niceeval 0.6.0 → 0.6.2

package/dist/report/built-ins/experiment-comparison.js

@@ -0,0 +1,119 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// ExperimentComparison:裸 niceeval show / view 首页渲染的内置默认报告,同时是可整体引用的
+// 官方组合件(docs/feature/reports/library.md「ExperimentComparison」)。
+//
+// 名字描述整份报告回答的问题,不绑定其中某一张图。它是组合件而非新的数据源——每组的
+// GroupSummary、成本 × 端到端成功率散点、固定列 ExperimentList 都消费各自公开 .data() 的结果。
+// 两种用法共享同一份口径:
+//   · 默认报告:宿主把它当普通 ReportDefinition(build 面),没有 renderer 私有通道;
+//   · 报告组件:`<ExperimentComparison data={await ExperimentComparison.data(selection)} />`,
+//     在自定义报告或用户自己的 React 页面里整体引用。
+import { Col, Section, Table } from "../primitives.js";
+import { ExperimentList, GroupSummary, MetricScatter } from "../components.js";
+import { costUSD, endToEndPassRate } from "../metrics.js";
+import { defineReport } from "../report.js";
+import { defineComponent } from "../tree.js";
+import { localeText } from "../locale.js";
+import { resolveInput } from "../aggregate.js";
+import { ExperimentComparisonView } from "../react/ExperimentComparison.js";
+import { wrapDisplay } from "../text/layout.js";
+import { formatUSD } from "../format.js";
+// 每组散点的唯一口径：默认 definition 与公开 `.data()` 共用，不各写一份。
+const SCATTER_OPTIONS = {
+    points: "experiment",
+    series: "agent",
+    x: costUSD,
+    y: endToEndPassRate,
+};
+/** 完整父路径是组键；没有父路径的 experiment 不能互相比，自己形成单例组。 */
+export function experimentComparisonGroupKey(experimentId) {
+    const slash = experimentId.lastIndexOf("/");
+    return slash === -1 ? experimentId : experimentId.slice(0, slash);
+}
+/** 组合件的数据计算：先分区，再让三个官方子块在各组内并行计算。 */
+async function experimentComparisonData(input) {
+    const { snapshots } = resolveInput(input);
+    const snapshotsByGroup = new Map();
+    for (const snapshot of snapshots) {
+        const key = experimentComparisonGroupKey(snapshot.experimentId);
+        const group = snapshotsByGroup.get(key);
+        if (group)
+            group.push(snapshot);
+        else
+            snapshotsByGroup.set(key, [snapshot]);
+    }
+    const groups = await Promise.all([...snapshotsByGroup.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(async ([key, groupSnapshots]) => {
+        const [summary, scatter, experiments] = await Promise.all([
+            GroupSummary.data(groupSnapshots),
+            MetricScatter.data(groupSnapshots, SCATTER_OPTIONS),
+            ExperimentList.data(groupSnapshots),
+        ]);
+        return { key, summary, scatter, experiments };
+    }));
+    return { groups };
+}
+/** 单组详情：散点与实验列表全部来自同一个预分区结果。 */
+function groupComposition(group, locale, className) {
+    return (_jsxs(Col, { className: className, children: [_jsx(MetricScatter, { data: group.scatter, locale: locale }), _jsx(ExperimentList, { items: group.experiments, filter: true, locale: locale, relativeTo: group.key })] }));
+}
+function shellQuote(value) {
+    return /^[A-Za-z0-9._/-]+$/.test(value) ? value : `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function verdictsText(group, locale) {
+    const parts = [];
+    for (const verdict of ["passed", "failed", "errored", "skipped"]) {
+        const count = group.summary.verdicts[verdict];
+        if (count > 0)
+            parts.push(`${count} ${localeText(locale, `verdict.${verdict}`)}`);
+    }
+    return parts.length > 0 ? parts.join(" / ") : "—";
+}
+function textFace(data, className, ctx) {
+    if (data.groups.length === 0)
+        return localeText(ctx.locale, "experimentComparison.empty");
+    if (data.groups.length === 1) {
+        const group = data.groups[0];
+        return ctx.render(_jsx(Section, { title: group.key, className: className, children: groupComposition(group) }));
+    }
+    const table = ctx.render(_jsx(Table, { columns: [
+            { key: "group", header: localeText(ctx.locale, "experimentComparison.group") },
+            { key: "experiments", header: localeText(ctx.locale, "groupSummary.experiments"), align: "right" },
+            { key: "evals", header: localeText(ctx.locale, "overview.evals"), align: "right" },
+            { key: "passRate", header: localeText(ctx.locale, "overview.passRate"), align: "right" },
+            { key: "results", header: localeText(ctx.locale, "experimentComparison.results") },
+            { key: "cost", header: localeText(ctx.locale, "overview.totalCost"), align: "right" },
+            { key: "lastRun", header: localeText(ctx.locale, "experimentComparison.lastRun") },
+        ], rows: data.groups.map((group) => ({
+            key: group.key,
+            cells: {
+                group: group.key,
+                experiments: String(group.summary.experiments),
+                evals: String(group.summary.evals),
+                passRate: group.summary.passRate.display,
+                results: verdictsText(group, ctx.locale),
+                cost: group.summary.totalCostUSD === null ? null : formatUSD(group.summary.totalCostUSD),
+                lastRun: group.summary.lastRunAt ?? null,
+            },
+        })) }));
+    const commands = data.groups
+        .map((group) => {
+        const command = `niceeval show --experiment ${shellQuote(group.key)}`;
+        return wrapDisplay(localeText(ctx.locale, "experimentComparison.command", { command }), ctx.width).join("\n");
+    })
+        .join("\n");
+    return `${localeText(ctx.locale, "experimentComparison.groups")}\n\n${table}\n\n${commands}`;
+}
+/**
+ * 内置默认报告兼官方组合件:作为组件时收 `data`(`.data()` 的产物),两个渲染面直接摆
+ * 数据形态的子组件;作为默认报告时经 build 面走与用户 `--report` 完全相同的管线。
+ */
+export const ExperimentComparison = Object.assign(defineComponent({
+    web: (props, ctx) => (_jsx(ExperimentComparisonView, { data: props.data, locale: props.locale ?? ctx.locale, className: props.className })),
+    text: ({ data, className }, ctx) => textFace(data, className, ctx),
+}), defineReport(async ({ selection }) => {
+    const data = await experimentComparisonData(selection);
+    return _jsx(ExperimentComparison, { data: data });
+}), { data: experimentComparisonData });
+ExperimentComparison.displayName = "ExperimentComparison";

package/dist/report/built-ins/index.d.ts

@@ -1 +1,2 @@
-export { CostPassRateComparison } from "./cost-pass-rate-comparison.tsx";
+export { ExperimentComparison } from "./experiment-comparison.tsx";
+export type { ExperimentComparisonData, ExperimentComparisonGroupData, ExperimentComparisonProps, } from "./experiment-comparison.tsx";

package/dist/report/built-ins/index.js

@@ -1,2 +1,2 @@
-// 内置报告目录:一个文件一个按展示内容命名的普通 ReportDefinition,显式导出值,不建字符串 registry。
-export { CostPassRateComparison } from "./cost-pass-rate-comparison.js";
+// 内置报告目录:一个文件一个按展示内容命名的组合件(组件兼默认报告),显式导出值,不建字符串 registry。
+export { ExperimentComparison } from "./experiment-comparison.js";

package/dist/report/components.d.ts

@@ -24,6 +24,14 @@ export interface GroupSummaryProps {
  */
 export interface ExperimentListProps {
     items: ExperimentListItem[];
+    /** web 面在比较表前显示实验过滤框；text 面忽略。 */
+    filter?: boolean;
+    /**
+     * 可选父路径:两面的行标签去掉与它相同的前缀,只显示 experiment id 末段,避免在已经以组为
+     * 标题的上下文里重复文件夹名(默认 `ExperimentComparison` 给每组传组键)。完整 id 仍是排序 /
+     * 着色 / 过滤 / 折叠的键;不传或它不是前缀(如根目录单例组)时显示完整 id。
+     */
+    relativeTo?: string;
     /** chrome 文案 locale;省略时随宿主上下文(宿主外默认 "en")。 */
     locale?: ReportLocale;
     className?: string;
@@ -140,8 +148,8 @@ export declare const EvalList: ReportComponent<EvalListProps> & {
     data: typeof evalListData;
 };
 /**
- * Attempt 列表:实体列表的叶子层,每项一个 Attempt,固定展示判定、断言、error、Judge 评语
- * (assertions 的 detail/evidence)与证据引用(locator + 证据能力标记)。它不预设只看失败;
+ * Attempt 列表:实体列表的叶子层,每项一个 Attempt,固定展示判定、一条主失败断言摘要或
+ * error 一层摘要与证据引用(locator)。完整 assertions / evidence 经 locator 下钻。它不预设只看失败;
  * 报告作者过滤 `AttemptListItem[]`、用 `.slice()` 限量,`total` 让渲染面如实报告剩余数量。
  */
 export declare const AttemptList: ReportComponent<AttemptListProps> & {

package/dist/report/components.js

@@ -57,7 +57,7 @@ GroupSummary.displayName = "GroupSummary";
  */
 export const ExperimentList = Object.assign(defineComponent({
     web: (props, ctx) => _jsx(ExperimentListWeb, { ...props, locale: props.locale ?? ctx.locale, attemptHref: ctx.attemptHref }),
-    text: ({ items }, ctx) => experimentListText(items, ctx),
+    text: ({ items, relativeTo }, ctx) => experimentListText(items, ctx, relativeTo),
 }), { data: experimentListData });
 ExperimentList.displayName = "ExperimentList";
 /**
@@ -70,8 +70,8 @@ export const EvalList = Object.assign(defineComponent({
 }), { data: evalListData });
 EvalList.displayName = "EvalList";
 /**
- * Attempt 列表:实体列表的叶子层,每项一个 Attempt,固定展示判定、断言、error、Judge 评语
- * (assertions 的 detail/evidence)与证据引用(locator + 证据能力标记)。它不预设只看失败;
+ * Attempt 列表:实体列表的叶子层,每项一个 Attempt,固定展示判定、一条主失败断言摘要或
+ * error 一层摘要与证据引用(locator)。完整 assertions / evidence 经 locator 下钻。它不预设只看失败;
  * 报告作者过滤 `AttemptListItem[]`、用 `.slice()` 限量,`total` 让渲染面如实报告剩余数量。
  */
 export const AttemptList = Object.assign(defineComponent({

package/dist/report/compute.d.ts

@@ -1,5 +1,5 @@
-import type { AttemptListItem, DeltaData, DimensionInput, EvalListItem, ExperimentListItem, GroupSummaryData, LineData, MatrixData, Metric, OverviewData, FlagRef, ScatterData, ScoreboardData, TableData } from "./types.ts";
-import type { AssertionResult, EvalResult } from "../types.ts";
+import type { AttemptListItem, AxisInput, DeltaData, DimensionInput, EvalListItem, ExperimentListItem, GroupSummaryData, LineData, MatrixData, Metric, OverviewData, ScatterData, ScoreboardData, TableData } from "./types.ts";
+import type { EvalResult } from "../types.ts";
 import { type SnapshotsInput } from "./aggregate.ts";
 export interface TableDataOptions<M extends readonly Metric[]> {
     /** 行维度(内置 / 自定义 / flag())。 */
@@ -11,22 +11,15 @@ export interface TableDataOptions<M extends readonly Metric[]> {
     /** eval id 前缀过滤,同 CLI 位置参数语义。 */
     evals?: string | string[];
 }
-/**
- * 一次 attempt 未通过的 gate 断言,原始声明顺序不变;soft 断言不参与判定,不算「失败原因」,
- * 只影响得分,永不出现在这份列表里。`EvalList` / `ExperimentList` 的失败诊断与 `AttemptList`
- * 的断言列表共用这同一份材料,保证同一个 attempt 在各处给出同一个原因。
- */
-export declare function failingGateAssertions(result: EvalResult): AssertionResult[];
-/**
- * 一次 attempt 的失败原因文案,按优先级取第一个在场的:
- * `error` → `skipReason` → 未通过的 gate 断言(原始声明顺序,`name`,detail 在场则
- * `"name: detail"`,多条用「, 」连接)→ 都缺席则无原因(如某道题恰好没有失败信号)。
- * soft 断言永不进入这份原因文案,soft 得分是独立概念,不与 reason 混用同一个字段。
- */
+/** 一次 attempt 的有界结果摘要：error → skipReason → 一条主失败断言 + 其余失败计数。 */
 export declare function reasonFor(result: EvalResult): string | undefined;
 export declare function tableData<const M extends readonly Metric[]>(input: SnapshotsInput, opts: TableDataOptions<M>): Promise<TableData<M[number]["name"]>>;
 export interface AttemptListDataOptions {
-    /** 发布消毒:error / 断言 detail / evidence 经这个钩子;身份字段(experimentId/evalId/locator…)不经它。 */
+    /**
+     * 展示层遮蔽:error 的 message/cause/stack、diagnostic 的 message/data、断言 detail 与
+     * evidence 经这个钩子;experimentId、evalId、locator、error/diagnostic code 与 lifecycle
+     * operation 等身份和分类字段不经它。只作用于这次计算产出的组件数据,不改盘上 artifact。
+     */
     redact?: (text: string) => string;
 }
 /** `AttemptList.data(selection)`:每个 Attempt 一项,顺序取自 Selection 展平顺序(不重排)。 */
@@ -74,10 +67,10 @@ export interface ScatterDataOptions {
 }
 export declare function scatterData(input: SnapshotsInput, opts: ScatterDataOptions): Promise<ScatterData>;
 export interface LineDataOptions {
-    /** x 轴:experiment 声明的 flag(数值),不解析 experiment 命名。 */
-    x: FlagRef;
+    /** x 轴:experiment 声明的 flag 或顶层运行配置 config()(要求数值),不解析 experiment 命名。 */
+    x: AxisInput;
     y: Metric;
-    /** 可选:每个系列一条线(flag 或普通维度);省略 = 单系列。 */
+    /** 可选:每个系列一条线(flag / config 或普通维度);省略 = 单系列。 */
     series?: DimensionInput;
 }
 /** 每个点 = 一个 experiment 的聚合;同系列的点按 x 排序连线(排序在组件面,数据保持分组序)。 */

package/dist/report/compute.js

@@ -10,9 +10,10 @@
 // - null ≠ 0:缺数据不编数,覆盖率经 samples/total 如实暴露;
 // - core 中立:只认 Metric / Dimension 接口,不出现具体 agent 名的分支。
 import { evalLevelStats, foldEvalVerdict } from "../shared/verdict.js";
-import { applyAggregator, assertUniqueMetricNames, collectItems, computeCell, dimensionKey, dimensionName, displayValue, evalGroupOf, evalIdOf, evalPrefixPredicate, evaluateMetric, experimentIdOf, filterItems, groupItems, flagAxisValue, locatorOf, resolveInput, snapshotKeyOf, toColumn, } from "./aggregate.js";
-import { attemptCostUSD, costUSD, durationMs, examScore, passRate, tokens } from "./metrics.js";
+import { applyAggregator, assertUniqueMetricNames, axisValue, collectItems, computeCell, dimensionKey, dimensionName, displayValue, evalGroupOf, evalIdOf, evalPrefixPredicate, evaluateMetric, experimentIdOf, filterItems, groupItems, locatorOf, resolveInput, snapshotKeyOf, toColumn, } from "./aggregate.js";
+import { attemptCostUSD, costUSD, durationMs, endToEndPassRate, examScore, tokens } from "./metrics.js";
 import { formatMetricValue, formatPlainNumber } from "./format.js";
+import { compactAssertionSummary, primaryAssertionSummary } from "../scoring/display.js";
 // 一组 Item 的 eval 全身份键:experimentId + eval id。单 experiment 场景(如 experimentRowMeta,
 // 一组本就只有一个 experimentId)下退化为只按 eval id 折叠,与旧行为一致;多 experiment 场景
 // (GroupSummary 的组可能跨多个 experiment)下避免两个 experiment 里同名 eval 被误合并成一道题。
@@ -102,29 +103,14 @@ function experimentRowMeta(group) {
         ...(stats.lastRunAt !== undefined ? { lastRunAt: stats.lastRunAt } : {}),
     };
 }
-/**
- * 一次 attempt 未通过的 gate 断言,原始声明顺序不变;soft 断言不参与判定,不算「失败原因」,
- * 只影响得分,永不出现在这份列表里。`EvalList` / `ExperimentList` 的失败诊断与 `AttemptList`
- * 的断言列表共用这同一份材料,保证同一个 attempt 在各处给出同一个原因。
- */
-export function failingGateAssertions(result) {
-    return result.assertions.filter((a) => !a.passed && a.severity === "gate");
-}
-/**
- * 一次 attempt 的失败原因文案,按优先级取第一个在场的:
- * `error` → `skipReason` → 未通过的 gate 断言(原始声明顺序,`name`,detail 在场则
- * `"name: detail"`,多条用「, 」连接)→ 都缺席则无原因(如某道题恰好没有失败信号)。
- * soft 断言永不进入这份原因文案,soft 得分是独立概念,不与 reason 混用同一个字段。
- */
+/** 一次 attempt 的有界结果摘要：error → skipReason → 一条主失败断言 + 其余失败计数。 */
 export function reasonFor(result) {
     if (result.error !== undefined)
-        return result.error;
+        return result.error.message;
     if (result.skipReason !== undefined)
         return result.skipReason;
-    const gates = failingGateAssertions(result);
-    if (gates.length === 0)
-        return undefined;
-    return gates.map((a) => (a.detail ? `${a.name}: ${a.detail}` : a.name)).join(", ");
+    const summary = primaryAssertionSummary(result.assertions, result.verdict);
+    return summary === undefined ? undefined : compactAssertionSummary(summary);
 }
 export async function tableData(input, opts) {
     assertUniqueMetricNames(opts.columns, "MetricTable.data columns");
@@ -174,45 +160,52 @@ export async function tableData(input, opts) {
 // 没有列配置;过滤是报告作者对返回数组调用 .filter()/.slice() 的事,不进这里
 // (docs/feature/reports/library.md「实体列表」)。AttemptListItem 是三者共用的叶子形状——
 // ExperimentList / EvalList 的下钻数组直接复用它,不各自精简一份。
-/**
- * 一个 attempt 的证据能力标记,只读已有的瘦身摘要位(`hasSources` / `hasEvents` / `hasTrace`)
- * 加一次 `diff()` 懒加载——不调用完整的 `loadAttemptEvidence`(那还会额外装配 Eval 源码标注
- * 与 ExecutionTree,这里只要四个布尔位)。三位定义与 `AttemptEvidence.capabilities` 完全一致:
- *
- * - `eval`:`hasSources` 为真。真正的门槛是 `AnnotatedEvalSource` 非空且有内容(源码行或断言
- *   非空),但 sources 存在时 `buildAnnotatedEvalSource` 恒产出至少一行源码,断言又永远来自
- *   `result.assertions`(不需要 IO)——`hasSources` 是这个条件的精确瘦身版,不是近似。
- * - `execution`:`hasEvents` 为真,与 `loadAttemptEvidence` 的 `events !== null && events.length > 0`
- *   同一个判定,写入面按同一条规则算的 `hasEvents` 就是它的瘦身镜像。
- * - `timing`:`hasEvents && hasTrace` 为真——`execution` 成立且这次运行接入过 OTel
- *   (`ExecutionTree.timingAvailable` = `spans.length > 0`,`hasTrace` 正是这个判定的瘦身镜像)。
- * - `diff`:唯一需要 IO 的一位,`attempt.diff()` 非空且至少改动/删除了一个文件——落盘没有
- *   与 `hasEvents` 对应的瘦身摘要位,只能懒加载判定;成本是每个 item 一次 `diff()` 读取,
- *   不是完整证据装配的四路 Promise.all。
- */
-async function attemptCapabilities(attempt) {
-    const result = attempt.result;
-    const diff = await attempt.diff();
-    const diffCapable = diff !== null && (Object.keys(diff.generatedFiles).length > 0 || diff.deletedFiles.length > 0);
-    return {
-        eval: result.hasSources === true,
-        execution: result.hasEvents === true,
-        timing: result.hasEvents === true && result.hasTrace === true,
-        diff: diffCapable,
-    };
-}
-/** 自由文本(error / 断言 detail / evidence)的发布消毒钩子;身份字段(name/severity/loc)不经它。 */
+/** 自由文本(断言 detail / evidence)的展示层遮蔽钩子;身份字段(name/severity/loc)不经它。 */
 function redactAssertions(assertions, redact) {
     if (assertions.length === 0)
         return assertions;
     return assertions.map((a) => ({
         ...a,
         ...(a.detail !== undefined ? { detail: redact(a.detail) } : {}),
-        ...(a.evidence !== undefined ? { evidence: redact(a.evidence) } : {}),
+        ...(a.outcome !== "unavailable" && a.evidence !== undefined ? { evidence: redact(a.evidence) } : {}),
+        ...(a.outcome !== "unavailable" && a.expected !== undefined ? { expected: redact(a.expected) } : {}),
+        ...(a.outcome !== "unavailable" && a.received !== undefined ? { received: redact(a.received) } : {}),
+    }));
+}
+/**
+ * 结构化 error 的遮蔽:message / stack / cause.message 是自由文本,经钩子;
+ * code / operation / cause.name / cause.code 是分类与身份字段,原样保留
+ * (与 copySnapshots({ redact }) 的改写范围约定一致)。
+ */
+function redactError(error, redact) {
+    return {
+        ...error,
+        message: redact(error.message),
+        ...(error.stack !== undefined ? { stack: redact(error.stack) } : {}),
+        ...(error.cause !== undefined ? { cause: { ...error.cause, message: redact(error.cause.message) } } : {}),
+    };
+}
+/** JsonValue 树里逐个字符串值经钩子;结构与非字符串标量原样。 */
+function redactJsonValue(value, redact) {
+    if (typeof value === "string")
+        return redact(value);
+    if (Array.isArray(value))
+        return value.map((v) => redactJsonValue(v, redact));
+    if (typeof value === "object" && value !== null) {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, redactJsonValue(v, redact)]));
+    }
+    return value;
+}
+/** diagnostics 的遮蔽:message 与 data(自由内容)经钩子;code / operation / level / count 原样。 */
+function redactDiagnostics(diagnostics, redact) {
+    return diagnostics.map((d) => ({
+        ...d,
+        message: redact(d.message),
+        ...(d.data !== undefined ? { data: redactJsonValue(d.data, redact) } : {}),
     }));
 }
 /** AttemptList / ExperimentList / EvalList 共用的叶子构造:一个 Item → 一个 AttemptListItem。 */
-async function attemptListItemOf(item, redact) {
+function attemptListItemOf(item, redact) {
     const result = item.attempt.result;
     const cost = attemptCostUSD(result);
     return {
@@ -221,12 +214,14 @@ async function attemptListItemOf(item, redact) {
         attempt: result.attempt,
         agent: result.agent,
         verdict: result.verdict,
-        ...(result.error !== undefined ? { error: redact(result.error) } : {}),
+        ...(result.error !== undefined ? { error: redactError(result.error, redact) } : {}),
+        ...(result.diagnostics !== undefined && result.diagnostics.length > 0
+            ? { diagnostics: redactDiagnostics(result.diagnostics, redact) }
+            : {}),
         assertions: redactAssertions(result.assertions, redact),
         durationMs: result.durationMs,
         ...(cost !== null ? { costUSD: cost } : {}),
         locator: locatorOf(item),
-        capabilities: await attemptCapabilities(item.attempt),
     };
 }
 const identityRedact = (text) => text;
@@ -235,7 +230,7 @@ export async function attemptListData(input, opts) {
     const { snapshots } = resolveInput(input);
     const redact = opts?.redact ?? identityRedact;
     const items = collectItems(snapshots);
-    return Promise.all(items.map((item) => attemptListItemOf(item, redact)));
+    return items.map((item) => attemptListItemOf(item, redact));
 }
 /** `EvalList.data(selection)`:每个 `experimentId + evalId` 一项,按 evalId 再按 experimentId 升序。 */
 export async function evalListData(input) {
@@ -254,13 +249,11 @@ export async function evalListData(input) {
     for (const group of groups.values()) {
         const sorted = [...group].sort((a, b) => a.attempt.result.attempt - b.attempt.result.attempt);
         const verdict = foldEvalVerdict(sorted.map((item) => item.attempt.result));
-        const representative = sorted.find((item) => item.attempt.result.verdict === verdict) ?? sorted[0];
-        const attempts = await Promise.all(sorted.map((item) => attemptListItemOf(item, identityRedact)));
+        const attempts = sorted.map((item) => attemptListItemOf(item, identityRedact));
         out.push({
             evalId: evalIdOf(sorted[0]),
             experimentId: experimentIdOf(sorted[0]),
             verdict,
-            reason: reasonFor(representative.attempt.result),
             score: await computeCell(examScore, sorted),
             duration: await computeCell(durationMs, sorted),
             cost: await computeCell(costUSD, sorted),
@@ -284,12 +277,10 @@ export async function experimentListData(input) {
         for (const [evalId, evalItems] of evalGroups) {
             const sorted = [...evalItems].sort((a, b) => a.attempt.result.attempt - b.attempt.result.attempt);
             const verdict = foldEvalVerdict(sorted.map((item) => item.attempt.result));
-            const representative = sorted.find((item) => item.attempt.result.verdict === verdict) ?? sorted[0];
-            const attempts = await Promise.all(sorted.map((item) => attemptListItemOf(item, identityRedact)));
+            const attempts = sorted.map((item) => attemptListItemOf(item, identityRedact));
             evalRows.push({
                 evalId,
                 verdict,
-                reason: reasonFor(representative.attempt.result),
                 duration: await computeCell(durationMs, sorted),
                 cost: await computeCell(costUSD, sorted),
                 attempts,
@@ -305,7 +296,7 @@ export async function experimentListData(input) {
                 : {}),
             ...(experiment?.flags ? { flags: experiment.flags } : {}),
             verdicts: stats.verdicts,
-            passRate: await computeCell(passRate, group),
+            passRate: await computeCell(endToEndPassRate, group),
             cost: await computeCell(costUSD, group),
             duration: await computeCell(durationMs, group),
             tokens: await computeCell(tokens, group),
@@ -315,7 +306,17 @@ export async function experimentListData(input) {
             evalRows,
         });
     }
-    out.sort((a, b) => a.experimentId.localeCompare(b.experimentId));
+    // ExperimentList 是默认实验比较表:初始态按端到端成功率(endToEndPassRate)从高到低,缺数据沉底;
+    // 同分时按 experiment id 稳定排序。web 增强可临时重排,text 面沿用同一基准顺序。
+    out.sort((a, b) => {
+        if (a.passRate.value === null && b.passRate.value === null)
+            return a.experimentId.localeCompare(b.experimentId);
+        if (a.passRate.value === null)
+            return 1;
+        if (b.passRate.value === null)
+            return -1;
+        return b.passRate.value - a.passRate.value || a.experimentId.localeCompare(b.experimentId);
+    });
     return out;
 }
 export async function matrixData(input, opts) {
@@ -475,7 +476,7 @@ export async function lineData(input, opts) {
     const groups = groupItems(items, "experiment");
     const rows = [];
     for (const [key, group] of groups) {
-        const x = flagAxisValue(opts.x, group[0]); // flag 是 experiment 级声明,组内一致
+        const x = axisValue(opts.x, group[0]); // flag / config 都是 experiment 级声明,组内一致
         rows.push({
             key,
             series: opts.series ? dimensionKey(opts.series, group[0]) : undefined,
@@ -529,9 +530,10 @@ export async function overviewData(input) {
         if (cost !== null)
             costUSD = (costUSD ?? 0) + cost;
     }
-    // 通过率的唯一官方口径:两级聚合(computeCell),不是从上面四个 verdict 计票现场重算——
-    // 一道题内 attempt 部分通过要算部分 credit,不是二元投票。
-    const passRateCell = await computeCell(passRate, items);
+    // 默认成功率的唯一官方口径:endToEndPassRate 的两级聚合(computeCell),不是从上面四个
+    // verdict 计票现场重算——一道题内 attempt 部分通过要算部分 credit,不是二元投票;
+    // failed / errored 都记 0,只有 skipped 不进聚合。
+    const passRateCell = await computeCell(endToEndPassRate, items);
     return {
         snapshots: snapshots.map((s) => ({
             experimentId: s.experimentId,

package/dist/report/flag.d.ts

@@ -1,6 +1,21 @@
-import type { FlagRef } from "./types.ts";
+import type { ConfigRef, FlagRef } from "./types.ts";
+/**
+ * 把 experiment 声明的一个 flag 当分组维度(series / rows / columns / points 槽)或数值轴
+ * (MetricLine 的 x 槽)。只读 `ExperimentDef.flags` 里显式声明的 KV;未声明的 experiment
+ * 分组归 `(unset)`,作轴不画点并报告缺失。
+ */
 export declare function flag(name: string, opts?: {
     /** 组标签 / 轴标签;函数形态把声明值折成组名(如 `(v) => \`${v} agents\``)。 */
     label?: string | ((value: string | number | boolean) => string);
     unit?: string;
 }): FlagRef;
+/**
+ * 把一项顶层运行配置当分组维度或数值轴,与 {@link flag} 同一套用法。读快照的
+ * `ExperimentRunInfo` 投影(可用键是那张接口的字段全集),外加桥接到快照顶层权威字段的
+ * `model` / `agent` 两个键。未投影的值分组归 `(unset)`,作轴不画点并报告缺失。
+ */
+export declare function config(name: string, opts?: {
+    /** 组标签 / 轴标签;函数形态把投影值折成组名(如 `(v) => \`effort ${v}\``)。 */
+    label?: string | ((value: string | number | boolean) => string);
+    unit?: string;
+}): ConfigRef;

package/dist/report/flag.js

@@ -1,8 +1,26 @@
-// flag():把 experiment 声明的 flags 当维度或轴(docs/feature/reports/library.md「维度与 flags」)。
+// flag() / config():把 experiment 声明的变量当维度或轴(docs/feature/reports/library.md「维度与 flags」)。
 // 变量来自配置,不来自命名 —— 报告不解析 experiment id 字符串抠变量。
+// flag() 只读 `ExperimentDef.flags` 里显式声明的 KV;model / reasoningEffort / budget / runs
+// 这类顶层运行配置不在 flags 里,用 config() 读快照的 ExperimentRunInfo 投影。
+/**
+ * 把 experiment 声明的一个 flag 当分组维度(series / rows / columns / points 槽)或数值轴
+ * (MetricLine 的 x 槽)。只读 `ExperimentDef.flags` 里显式声明的 KV;未声明的 experiment
+ * 分组归 `(unset)`,作轴不画点并报告缺失。
+ */
 export function flag(name, opts) {
     if (typeof name !== "string" || name.length === 0) {
         throw new Error("flag: name must be a non-empty string (the key declared in the experiment's flags).");
     }
     return { kind: "flag", name, label: opts?.label, unit: opts?.unit };
 }
+/**
+ * 把一项顶层运行配置当分组维度或数值轴,与 {@link flag} 同一套用法。读快照的
+ * `ExperimentRunInfo` 投影(可用键是那张接口的字段全集),外加桥接到快照顶层权威字段的
+ * `model` / `agent` 两个键。未投影的值分组归 `(unset)`,作轴不画点并报告缺失。
+ */
+export function config(name, opts) {
+    if (typeof name !== "string" || name.length === 0) {
+        throw new Error("config: name must be a non-empty string (an ExperimentRunInfo field, or the bridged \"model\" / \"agent\" keys).");
+    }
+    return { kind: "config", name, label: opts?.label, unit: opts?.unit };
+}

package/dist/report/format.d.ts

@@ -1,5 +1,12 @@
-import type { AttemptEvidenceCapabilities } from "../results/attempt-evidence.ts";
 import type { AssertionResult, Verdict } from "../types.ts";
+/**
+ * experiment 行的显示名：给了父路径 `relativeTo` 且它确是前缀，就去掉 `relativeTo + "/"`，
+ * 只留 id 末段——用在已经以组为标题的上下文（如默认 `ExperimentComparison` 的每组面板）里，
+ * 避免每行重复文件夹名。组键就是 experiment id 的父目录，因此这里的末段与 `MetricScatter`
+ * 点标签取的末段同源。不给 `relativeTo`、或它不是前缀（如根目录单例组）时原样返回完整 id。
+ * 完整 id 仍是排序 / 着色 / 折叠的键，调用方不要拿这个显示名当身份用。
+ */
+export declare function experimentDisplayName(experimentId: string, relativeTo?: string): string;
 export declare function formatMetricValue(value: number, unit?: string): string;
 /** 无单位纯数字(scoreboard 总分等):一位小数,去尾零。 */
 export declare function formatPlainNumber(value: number): string;
@@ -14,19 +21,14 @@ export declare function formatPercent(ratio: number): string;
 /** passed / failed / errored / skipped 的判定符。 */
 export declare function verdictMark(verdict: Verdict): string;
 /**
- * 证据能力标记:`[E,X,⏱]` 式方括号列表,固定顺序 eval → execution → timing → diff,
- * 缺哪个不列哪个;四位全无时返回空串(没有证据可看,不画空 `[]`)。
- */
-export declare function capabilityBadge(capabilities: AttemptEvidenceCapabilities): string;
-/**
- * 一个 AttemptListItem 的失败原因摘要,按优先级取第一个在场的:`error` → 未通过的 gate 断言
- * (原始声明顺序,`name`,detail 在场则 `"name: detail"`,多条用「, 」连接)→ 缺席。与
- * compute.ts 的 `reasonFor(EvalResult)` 同一口径,只是输入换成瘦身后的 AttemptListItem——
- * 没有 `skipReason` 字段(AttemptListItem 不携带),skipped 的 attempt 因此没有原因摘要,
- * 这与它们本来就不该出现在「为什么失败」列表里的事实一致。EvalList / ExperimentList 的
- * 逐 attempt 徽标行用它给每个 attempt 自己的原因(而不是复用整道题的代表原因)。
+ * Attempt 比较项的一层结果摘要；完整 assertions 只在 locator 详情里展开。
+ * maxChars(可选)是渲染面的宽度收口预算(如两行单元格 = 2 × 列宽):断言摘要按
+ * fitCompactAssertionSummary 的优先级让位,error 摘要折单行后尾截。
  */
 export declare function attemptItemReason(item: {
-    error?: string;
+    verdict: Verdict;
+    error?: {
+        message: string;
+    };
     assertions: AssertionResult[];
-}): string | undefined;
+}, maxChars?: number): string | undefined;

package/dist/report/format.js

@@ -1,6 +1,20 @@
 // unit 驱动的内置格式化(docs/feature/reports/library.md「指标」):
 //   "%" → 87%    "ms" → 1.2s    "$" → $0.31    其余 → 1.2k 缩写(带 unit 后缀)
 // metric.display 可整体覆盖;这里只负责默认。
+import { compactAssertionSummary, fitCompactAssertionSummary, primaryAssertionSummary } from "../scoring/display.js";
+/**
+ * experiment 行的显示名：给了父路径 `relativeTo` 且它确是前缀，就去掉 `relativeTo + "/"`，
+ * 只留 id 末段——用在已经以组为标题的上下文（如默认 `ExperimentComparison` 的每组面板）里，
+ * 避免每行重复文件夹名。组键就是 experiment id 的父目录，因此这里的末段与 `MetricScatter`
+ * 点标签取的末段同源。不给 `relativeTo`、或它不是前缀（如根目录单例组）时原样返回完整 id。
+ * 完整 id 仍是排序 / 着色 / 折叠的键，调用方不要拿这个显示名当身份用。
+ */
+export function experimentDisplayName(experimentId, relativeTo) {
+    if (relativeTo && experimentId.startsWith(`${relativeTo}/`)) {
+        return experimentId.slice(relativeTo.length + 1);
+    }
+    return experimentId;
+}
 /** 一位小数、去掉无意义的 ".0" 尾巴。 */
 function trimmed(n) {
     const s = n.toFixed(1);
@@ -77,8 +91,7 @@ export function formatUSD(usd) {
 export function formatPercent(ratio) {
     return `${Math.round(ratio * 100)}%`;
 }
-// ── 实体列表(ExperimentList / EvalList / AttemptList)共用的判定符与证据能力位 ──
-// web / text 两面对同一个 AttemptListItem 给出同一个标记(docs-site「终端输出形成反馈闭环」)。
+// ── 实体列表(ExperimentList / EvalList / AttemptList)共用的判定符 ──
 /** passed / failed / errored / skipped 的判定符。 */
 export function verdictMark(verdict) {
     switch (verdict) {
@@ -93,34 +106,19 @@ export function verdictMark(verdict) {
     }
 }
 /**
- * 证据能力标记:`[E,X,⏱]` 式方括号列表,固定顺序 eval → execution → timing → diff,
- * 缺哪个不列哪个;四位全无时返回空串(没有证据可看,不画空 `[]`)。
+ * Attempt 比较项的一层结果摘要；完整 assertions 只在 locator 详情里展开。
+ * maxChars(可选)是渲染面的宽度收口预算(如两行单元格 = 2 × 列宽):断言摘要按
+ * fitCompactAssertionSummary 的优先级让位,error 摘要折单行后尾截。
  */
-export function capabilityBadge(capabilities) {
-    const marks = [];
-    if (capabilities.eval)
-        marks.push("E");
-    if (capabilities.execution)
-        marks.push("X");
-    if (capabilities.timing)
-        marks.push("⏱");
-    if (capabilities.diff)
-        marks.push("D");
-    return marks.length > 0 ? `[${marks.join(",")}]` : "";
-}
-/**
- * 一个 AttemptListItem 的失败原因摘要,按优先级取第一个在场的:`error` → 未通过的 gate 断言
- * (原始声明顺序,`name`,detail 在场则 `"name: detail"`,多条用「, 」连接)→ 缺席。与
- * compute.ts 的 `reasonFor(EvalResult)` 同一口径,只是输入换成瘦身后的 AttemptListItem——
- * 没有 `skipReason` 字段(AttemptListItem 不携带),skipped 的 attempt 因此没有原因摘要,
- * 这与它们本来就不该出现在「为什么失败」列表里的事实一致。EvalList / ExperimentList 的
- * 逐 attempt 徽标行用它给每个 attempt 自己的原因(而不是复用整道题的代表原因)。
- */
-export function attemptItemReason(item) {
-    if (item.error !== undefined)
-        return item.error;
-    const gates = item.assertions.filter((a) => !a.passed && a.severity === "gate");
-    if (gates.length === 0)
+export function attemptItemReason(item, maxChars) {
+    if (item.error !== undefined) {
+        const message = item.error.message.replace(/\s+/g, " ").trim();
+        return maxChars !== undefined && message.length > maxChars
+            ? `${message.slice(0, Math.max(0, maxChars - 1))}…`
+            : message;
+    }
+    const summary = primaryAssertionSummary(item.assertions, item.verdict);
+    if (summary === undefined)
         return undefined;
-    return gates.map((a) => (a.detail ? `${a.name}: ${a.detail}` : a.name)).join(", ");
+    return maxChars === undefined ? compactAssertionSummary(summary) : fitCompactAssertionSummary(summary, maxChars);
 }