niceeval 0.10.0 → 0.10.2

package/src/report/components/entity-lists/ExperimentList.tsx

@@ -6,7 +6,7 @@
 import type { ReactElement } from "react";
 import type { AttemptLocator } from "../../../results/locator.ts";
 import type { AttemptListItem, ExperimentListEvalRow, ExperimentListItem } from "../../model/types.ts";
-import { experimentDisplayName } from "../../model/format.ts";
+import { shortestUniqueLabels } from "../../model/format.ts";
 import { DEFAULT_REPORT_LOCALE, localeText, type ReportLocale } from "../../model/locale.ts";
 import { AttemptLocatorBadge, failureSummaryText } from "./AttemptList.tsx";
 import { MetricCellView } from "../cell.tsx";
@@ -122,23 +122,21 @@ function Flags({ flags, locale }: { flags: Record<string, unknown> | undefined;
 
 function ExperimentRow({
   item,
+  label,
   attemptHref,
   locale,
-  relativeTo,
 }: {
   item: ExperimentListItem;
+  label: string;
   attemptHref?: (locator: AttemptLocator) => string;
   locale: ReportLocale;
-  relativeTo?: string;
 }): ReactElement {
   return (
     <details className="nre-experiment-entry">
       <summary className="nre-experiment-summary">
-        {/* relativeTo 只影响显示末段;完整 id 仍是排序 / 过滤 / 折叠的键,系列色跟随 agent */}
+        {/* label 是当前列表里的最短唯一后缀;完整 id 仍是排序 / 过滤 / 折叠的键,系列色跟随 agent */}
         <span className="nre-experiment-name" data-sort-value={item.experimentId}>
-          <b className={cx("nre-experiment-id", "nre-key")}>
-            {experimentDisplayName(item.experimentId, relativeTo)}
-          </b>
+          <b className={cx("nre-experiment-id", "nre-key")}>{label}</b>
           <small>
             {localeText(locale, "overview.evalsCount", { n: item.evals })}
             {item.attempts > item.evals ? ` · ${localeText(locale, "overview.attemptsCount", { n: item.attempts })}` : ""}
@@ -184,15 +182,14 @@ export function ExperimentList({
   filter = false,
   className,
   locale = DEFAULT_REPORT_LOCALE,
-  relativeTo,
 }: {
   data: readonly ExperimentListItem[];
   attemptHref?: (locator: AttemptLocator) => string;
   filter?: boolean;
   className?: string;
   locale?: ReportLocale;
-  relativeTo?: string;
 }): ReactElement {
+  const experimentLabels = shortestUniqueLabels(data.map((item) => item.experimentId));
   const labels = [
     localeText(locale, "experimentList.experiment"),
     localeText(locale, "table.model"),
@@ -221,7 +218,13 @@ export function ExperimentList({
       </div>
       {data.length === 0 && <p className="nre-experiment-list-empty">{localeText(locale, "attemptList.empty")}</p>}
       {data.map((item) => (
-        <ExperimentRow key={item.experimentId} item={item} attemptHref={attemptHref} locale={locale} relativeTo={relativeTo} />
+        <ExperimentRow
+          key={item.experimentId}
+          item={item}
+          label={experimentLabels.get(item.experimentId) ?? item.experimentId}
+          attemptHref={attemptHref}
+          locale={locale}
+        />
       ))}
     </div>
   );

package/src/report/components/entity-lists/faces.ts

@@ -8,10 +8,10 @@ import type { AttemptListItem, EvalListItem, ExperimentListItem } from "../../mo
 import type { TextContext } from "../../definition/tree.ts";
 import type { TableColumn, TableRow } from "../../definition/primitives.tsx";
 import {
-  experimentDisplayName,
   fitFailureSummary,
   formatDurationMs,
   formatUSD,
+  shortestUniqueLabels,
   verdictMark,
 } from "../../model/format.ts";
 import { countText, localeText, type ReportLocale } from "../../model/locale.ts";
@@ -47,7 +47,7 @@ function attemptReasonText(item: AttemptListItem, locale: ReportLocale, maxChars
 function experimentSummaryTable(
   items: readonly ExperimentListItem[],
   ctx: TextContext,
-  relativeTo?: string,
+  labels: Map<string, string>,
 ): string {
   const locale = ctx.locale;
   const compact = ctx.width < 100;
@@ -64,7 +64,7 @@ function experimentSummaryTable(
   const rows: TableRow[] = items.map((item) => ({
     key: item.experimentId,
     cells: {
-      experiment: experimentDisplayName(item.experimentId, relativeTo),
+      experiment: labels.get(item.experimentId) ?? item.experimentId,
       model: item.model ?? localeText(locale, "experimentList.defaultModel"),
       agent: item.agent,
       duration: cellText(item.durationMs, locale),
@@ -76,14 +76,14 @@ function experimentSummaryTable(
   }));
   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}`,
+      `${labels.get(item.experimentId) ?? item.experimentId}: ${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: columns as unknown as [TableColumn, ...TableColumn[]], rows, locale }, ctx), metadata.join("\n")].join("\n");
 }
 
-function experimentDetailTable(item: ExperimentListItem, ctx: TextContext, relativeTo?: string): string {
+function experimentDetailTable(item: ExperimentListItem, ctx: TextContext, label: string): string {
   const locale = ctx.locale;
   const columns: TableColumn[] = [
     { key: "status", header: localeText(locale, "experimentList.status") },
@@ -135,7 +135,7 @@ function experimentDetailTable(item: ExperimentListItem, ctx: TextContext, relat
         .join(" · ")}`
     : undefined;
   return [
-    experimentDisplayName(item.experimentId, relativeTo),
+    label,
     flags,
     renderTableText({ columns: columns as unknown as [TableColumn, ...TableColumn[]], rows, locale }, ctx),
   ]
@@ -143,11 +143,12 @@ function experimentDetailTable(item: ExperimentListItem, ctx: TextContext, relat
     .join("\n");
 }
 
-export function experimentListText(items: readonly ExperimentListItem[], ctx: TextContext, relativeTo?: string): string {
+export function experimentListText(items: readonly ExperimentListItem[], ctx: TextContext): string {
   if (items.length === 0) return localeText(ctx.locale, "attemptList.empty");
+  const labels = shortestUniqueLabels(items.map((item) => item.experimentId));
   return [
-    experimentSummaryTable(items, ctx, relativeTo),
-    ...items.map((item) => experimentDetailTable(item, ctx, relativeTo)),
+    experimentSummaryTable(items, ctx, labels),
+    ...items.map((item) => experimentDetailTable(item, ctx, labels.get(item.experimentId) ?? item.experimentId)),
   ].join("\n\n");
 }
 

package/src/report/components/entity-lists/index.tsx

@@ -102,20 +102,18 @@ export type ExperimentListProps = DataProps<
   EntityListChrome & {
     /** web 面在比较表前显示实验过滤框;text 面忽略。 */
     filter?: boolean;
-    /**
-     * 可选父路径:两面的行标签去掉与它相同的前缀,只显示 experiment id 末段。自定义报告
-     * 显式传入使用;默认 `ExperimentComparison` 不传,完整 id 始终可见。完整 id 仍是
-     * 排序 / 着色 / 过滤 / 折叠的键。
-     */
-    relativeTo?: string;
   }
 >;
 
-/** 实验列表:每项一个 experiment,固定八列比较表 + 展开到 Eval / Attempt。 */
+/**
+ * 实验列表:每项一个 experiment,固定八列比较表 + 展开到 Eval / Attempt。行标签是
+ * experiment id 在当前列表里的最短唯一后缀(与 MetricScatter 点标签同一算法,重名逐步
+ * 加长到能区分为止);完整 id 不受影响,仍是排序 / 过滤 / 折叠的键。
+ */
 export const ExperimentList = makeDataComponent<
   readonly ExperimentListItem[],
   Record<never, never>,
-  EntityListChrome & { filter?: boolean; relativeTo?: string }
+  EntityListChrome & { filter?: boolean }
 >({
   name: "ExperimentList",
   dataFnName: "experimentListData",
@@ -127,13 +125,12 @@ export const ExperimentList = makeDataComponent<
     <ExperimentListWeb
       data={props.data}
       filter={props.filter}
-      relativeTo={props.relativeTo}
       locale={props.locale ?? ctx.locale}
       attemptHref={hrefOf(props, ctx)}
       className={props.className}
     />
   ),
-  text: (props, ctx) => experimentListText(props.data, ctx, props.relativeTo),
+  text: (props, ctx) => experimentListText(props.data, ctx),
 }) as unknown as ReportComponent<ExperimentListProps>;
 
 export type EvalListProps = DataProps<readonly EvalListItem[], Record<never, never>, EntityListChrome>;

package/src/report/components/metric-views/MetricScatter.tsx

@@ -12,7 +12,7 @@
 
 import type { ReactElement } from "react";
 import type { MetricColumn, ScatterData } from "../../model/types.ts";
-import { formatMetricValue } from "../../model/format.ts";
+import { formatMetricValue, shortestUniqueLabels } from "../../model/format.ts";
 import { DEFAULT_REPORT_LOCALE, countText, localeText, resolveLocalizedText, resolveMetricLabel, type ReportLocale } from "../../model/locale.ts";
 import { niceTicks, placePointLabels } from "./chart-math.ts";
 import { colorIndicesForKeys } from "../../assets/colors.ts";
@@ -36,42 +36,6 @@ interface DrawablePoint {
   py: number;
 }
 
-/**
- * 点的直接标签:末段在当前 data 中唯一才缩成末段;重名时逐步加长为能区分它们的最短
- * 路径后缀(完整 id 与两轴值仍进 <title>)。
- */
-function pointLabels(keys: readonly string[]): Map<string, string> {
-  const segsOf = (key: string) => key.split("/").filter(Boolean);
-  const depth = new Map<string, number>(keys.map((key) => [key, 1]));
-  for (;;) {
-    const byLabel = new Map<string, string[]>();
-    for (const key of keys) {
-      const segs = segsOf(key);
-      const label = segs.slice(-Math.min(depth.get(key)!, segs.length)).join("/") || key;
-      byLabel.set(label, [...(byLabel.get(label) ?? []), key]);
-    }
-    let grew = false;
-    for (const group of byLabel.values()) {
-      if (group.length < 2) continue;
-      for (const key of group) {
-        const segs = segsOf(key);
-        if (depth.get(key)! < segs.length) {
-          depth.set(key, depth.get(key)! + 1);
-          grew = true;
-        }
-      }
-    }
-    if (!grew) {
-      const out = new Map<string, string>();
-      for (const key of keys) {
-        const segs = segsOf(key);
-        out.set(key, segs.slice(-Math.min(depth.get(key)!, segs.length)).join("/") || key);
-      }
-      return out;
-    }
-  }
-}
-
 /**
  * 一根轴:niceTicks 撑出整齐的值域,值 → 像素做线性映射。轴方向跟随指标的 `better`:
  * `better: "lower"` 的轴反向渲染(值大的一端在左 / 下),「更好」因此恒指向右与上;
@@ -143,7 +107,7 @@ export function MetricScatter({
     MARGIN.top,
     data.y.better === "lower",
   );
-  const labelByKey = pointLabels(drawableRows.map((r) => r.key));
+  const labelByKey = shortestUniqueLabels(drawableRows.map((r) => r.key));
   // 方向提示恒为「越靠右上越好」,仅当两轴都声明 better 时显示——任一轴未声明,
   // 组件不猜「更好」朝哪边,整图无提示。
   const showBetterHint = data.x.better !== undefined && data.y.better !== undefined;

package/src/report/components/render.test.tsx

@@ -390,9 +390,11 @@ describe("ExperimentList", () => {
     expect(html).toContain("2 evals");
   });
 
-  it("主行:身份、agent/model、官方两级聚合指标与 eval 级判定构成", () => {
-    expect(html).toContain("compare/bub");
-    expect(html).toContain("compare/codex");
+  it("主行:身份(最短唯一后缀)、agent/model、官方两级聚合指标与 eval 级判定构成;完整 id 仍是排序键", () => {
+    expect(html).toContain(">bub</b>");
+    expect(html).toContain(">codex</b>");
+    expect(html).toContain('data-sort-value="compare/bub"');
+    expect(html).toContain('data-sort-value="compare/codex"');
     expect(html).toContain("gpt-5.4");
     expect(html).toContain("50%"); // endToEndPassRate.display
     expect(html).toContain("1 passed · 1 failed");
@@ -416,12 +418,20 @@ describe("ExperimentList", () => {
     expect(html.match(/gate: roots-correct/g)).toHaveLength(2);
   });
 
-  it("relativeTo 去掉组前缀只显示末段;data-sort-value 仍是完整 id", () => {
-    const relative = renderToStaticMarkup(<ExperimentList data={experimentListItems} relativeTo="compare" />);
-    expect(relative).toContain(">bub</b>");
-    expect(relative).toContain('data-sort-value="compare/bub"');
-    // 不传 relativeTo 显示完整 id
-    expect(html).toContain(">compare/bub</b>");
+  it("行标签默认缩成当前列表里的最短唯一后缀;末段重名时逐步加长到能区分,data-sort-value 仍是完整 id", () => {
+    // 两个不同 experiment 末段撞名(a/run 与 b/run 都叫 run)时,两行都要加长到能区分为止。
+    const dupes = renderToStaticMarkup(
+      <ExperimentList
+        data={[
+          { ...experimentListItems[0]!, experimentId: "compare/a/run" },
+          { ...experimentListItems[1]!, experimentId: "compare/b/run" },
+        ]}
+      />,
+    );
+    expect(dupes).toContain(">a/run</b>");
+    expect(dupes).toContain(">b/run</b>");
+    expect(dupes).toContain('data-sort-value="compare/a/run"');
+    expect(dupes).toContain('data-sort-value="compare/b/run"');
   });
 
   it("零 JS 靠原生 <details>,无 <script>", () => {

package/src/report/index.ts

@@ -271,6 +271,8 @@ export type {
   AttemptErrorData,
   AttemptFixPromptData,
   AttemptSourceData,
+  AttemptSourceLineData,
+  AttemptSourceTurn,
   AttemptSummaryData,
   AttemptTimelineData,
   AttemptTraceData,

package/src/report/model/format.ts

@@ -6,16 +6,41 @@ import type { Verdict } from "../../types.ts";
 import { DISPLAY_LOCALES, type LocalizedText, type ReportLocale } from "./locale.ts";
 
 /**
- * experiment 行的显示名：给了父路径 `relativeTo` 且它确是前缀，就去掉 `relativeTo + "/"`，
- * 只留 id 末段——供自定义报告在已知父路径的上下文里显式调用，避免每行重复文件夹名。默认
- * `ExperimentComparison` 不传 `relativeTo`，完整 id 始终可见。不给 `relativeTo`、或它不是
- * 前缀时原样返回完整 id。完整 id 仍是排序 / 着色 / 折叠的键，调用方不要拿这个显示名当身份用。
+ * 一组 id 的显示名：每个 id 缩成在这组里唯一的最短路径后缀，重名逐步加长到能区分为止
+ * （与 `MetricScatter` 点标签同一算法，两处共用本函数以保证同一份 experiment id 在散点和
+ * 列表里缩成同一个显示名）。单个 id、或所有 id 深度不同时也照常缩到各自的最短唯一后缀。
+ * 完整 id 不受影响，调用方仍用它做排序 / 过滤 / 折叠的身份键，这里只产出显示名。
  */
-export function experimentDisplayName(experimentId: string, relativeTo?: string): string {
-  if (relativeTo && experimentId.startsWith(`${relativeTo}/`)) {
-    return experimentId.slice(relativeTo.length + 1);
+export function shortestUniqueLabels(ids: readonly string[]): Map<string, string> {
+  const segsOf = (id: string) => id.split("/").filter(Boolean);
+  const depth = new Map<string, number>(ids.map((id) => [id, 1]));
+  for (;;) {
+    const byLabel = new Map<string, string[]>();
+    for (const id of ids) {
+      const segs = segsOf(id);
+      const label = segs.slice(-Math.min(depth.get(id)!, segs.length)).join("/") || id;
+      byLabel.set(label, [...(byLabel.get(label) ?? []), id]);
+    }
+    let grew = false;
+    for (const group of byLabel.values()) {
+      if (group.length < 2) continue;
+      for (const id of group) {
+        const segs = segsOf(id);
+        if (depth.get(id)! < segs.length) {
+          depth.set(id, depth.get(id)! + 1);
+          grew = true;
+        }
+      }
+    }
+    if (!grew) {
+      const out = new Map<string, string>();
+      for (const id of ids) {
+        const segs = segsOf(id);
+        out.set(id, segs.slice(-Math.min(depth.get(id)!, segs.length)).join("/") || id);
+      }
+      return out;
+    }
   }
-  return experimentId;
 }
 
 /** 一位小数、去掉无意义的 ".0" 尾巴。 */

package/src/report/model/types.ts

@@ -484,13 +484,29 @@ export interface AttemptAssertionsData {
   passedGroups: { group: string; items: AssertionResult[] }[];
 }
 
-/** `AttemptSource` 的 data:AnnotatedEvalSource 的展示投影;没有 source 时 null。 */
+/** `AttemptSource` 源码行内的一轮执行：send 头事实 + 标准事件流归并出的完整回复。 */
+export interface AttemptSourceTurn {
+  label: string;
+  status: "completed" | "failed" | "waiting";
+  durationMs?: number;
+  sentText: string;
+  replies: AttemptConversationReply[];
+}
+
+/** AnnotatedSourceLine 加上 web 源码视图需要的行内执行轮。 */
+export interface AttemptSourceLineData extends AnnotatedSourceLine {
+  turns: AttemptSourceTurn[];
+}
+
+/** `AttemptSource` 的 data:AnnotatedEvalSource + 按 loc 投影的标准事件流;没有 source 时 null。 */
 export interface AttemptSourceData {
   /** text 面拼 `niceeval show <locator> --source` 下钻命令用;web 面不需要。 */
   locator: AttemptLocator;
   sourcePath: string;
-  lines: AnnotatedSourceLine[];
+  lines: AttemptSourceLineData[];
   unmapped: AssertionResult[];
+  /** 没有 loc、指向其它文件或越界的轮次；不能静默丢弃，放在源码块末尾。 */
+  unlocatedTurns: AttemptSourceTurn[];
   summary: AnnotatedEvalSourceSummary;
 }
 

package/src/report/react/index.tsx

@@ -55,6 +55,8 @@ export type {
   AttemptListItem,
   AttemptLocator,
   AttemptSourceData,
+  AttemptSourceLineData,
+  AttemptSourceTurn,
   AttemptSummaryData,
   AttemptTimelineData,
   AttemptTraceData,

package/src/report/runtime/dual-render.test.tsx

@@ -521,13 +521,13 @@ describe("text/web 双面同源", () => {
         res("algebra/retry", "passed", { attempt: 1 }),
       ],
     });
-    const text = await renderTreeText(<ExperimentList relativeTo="grp" />, scopeOf([s]), 160);
+    const text = await renderTreeText(<ExperimentList />, scopeOf([s]), 160);
     expect(text.match(/algebra\/retry/g)).toHaveLength(1); // Eval 父行只出现一次
     expect(text).toContain("├─");
     expect(text).toContain("└─");
     // 失败摘要只在 Attempt 子行(父行不复述)
     expect(text.match(/equals\(42\)/g)).toHaveLength(1);
-    // relativeTo:行标签只显示末段
+    // 行标签默认缩成最短唯一后缀
     expect(text).toContain("exp-a");
   });
 });
@@ -1276,18 +1276,21 @@ describe("内建报告", () => {
     );
   });
 
-  it("首页 web/text 两面都展示完整 Scope,不同深度目录的 experiment 同屏且显示完整 id;无组选择器或组索引", async () => {
-    const g1 = snap({ experimentId: "compare/a", results: [res("q", "passed")] });
-    const g2 = snap({ experimentId: "dev/b", results: [res("q", "failed")] });
+  it("首页 web/text 两面都展示完整 Scope,不同深度目录的 experiment 同屏且行标签缩成最短唯一后缀;无组选择器或组索引", async () => {
+    const g1 = snap({ experimentId: "compare/alpha-exp", results: [res("q", "passed")] });
+    const g2 = snap({ experimentId: "dev/beta-exp", results: [res("q", "failed")] });
     const ctx = { scope: scopeOf([g1, g2]), results: resultsOf([g1, g2]) };
 
     const text = await renderReportToText(builtInReport, ctx, { width: 120 });
     // Hero text 面:标题行(回退链终点)+ 最后运行 meta 行在页首
     expect(text.split("\n")[0]).toBe("Eval Results");
     expect(text).toContain("Last run");
-    // 完整 Scope 直接展示:两个不同路径的 experiment 都可见,不是组索引 + 单组查看命令
-    expect(text).toContain("compare/a");
-    expect(text).toContain("dev/b");
+    // 完整 Scope 直接展示:两个不同路径的 experiment 都可见,不是组索引 + 单组查看命令;
+    // 行标签是各自末段(两个 id 互不撞名,不必加长),不带父路径。
+    expect(text).toContain("alpha-exp");
+    expect(text).toContain("beta-exp");
+    expect(text).not.toContain("compare/alpha-exp");
+    expect(text).not.toContain("dev/beta-exp");
     expect(text).not.toContain("niceeval show --exp compare");
     expect(text).not.toContain("niceeval show --exp dev");
     expect(text).not.toContain("niceeval exp compare");
@@ -1296,8 +1299,11 @@ describe("内建报告", () => {
     const html = await renderReportToStaticHtml(builtInReport, ctx);
     expect(html).not.toContain('role="tablist"');
     expect(html).not.toContain("data-nre-experiment-group");
-    expect(html).toContain("compare/a");
-    expect(html).toContain("dev/b");
+    expect(html).toContain(">alpha-exp</b>");
+    expect(html).toContain(">beta-exp</b>");
+    // 完整 id 仍是排序键,只是不再重复出现在显示文字里
+    expect(html).toContain('data-sort-value="compare/alpha-exp"');
+    expect(html).toContain('data-sort-value="dev/beta-exp"');
   });
 
   it("0/1/多 experiment 均可渲染;0 个时三个叶子组件各自显示自己的空态", async () => {
@@ -1431,6 +1437,33 @@ describe("ExperimentComparison(组合组件)", () => {
     const [, explicitScatterEl] = await resolveComparisonChildren(<ExperimentComparison series={label("memory")} />, all);
     expect((explicitScatterEl.props.data as { seriesDimension?: string }).seriesDimension).toBe("memory");
   });
+
+  it("ExperimentList 行标签默认缩成 Scope 内的最短唯一后缀,不改变 ScopeSummary / MetricScatter 输出或排序键", async () => {
+    const a = snap({ experimentId: "compare/a", agent: "bub", results: [res("q", "passed")] });
+    const b = snap({ experimentId: "compare/b", agent: "codex", results: [res("q", "failed")] });
+    const ctx = { scope: scopeOf([a, b]), results: resultsOf([a, b]) };
+
+    const definition = defineReport(<ExperimentComparison />);
+    const html = await renderReportToStaticHtml(definition, ctx);
+    expect(html).toContain(">a</b>");
+    expect(html).toContain(">b</b>");
+    expect(html).toContain('data-sort-value="compare/a"');
+    expect(html).toContain('data-sort-value="compare/b"');
+
+    // 换成末段撞名的一对(a/run、b/run 都叫 run)时两行都要加长到能区分为止,不是随口断言。
+    const dupeA = snap({ experimentId: "compare/x/run", agent: "bub", results: [res("q", "passed")] });
+    const dupeB = snap({ experimentId: "compare/y/run", agent: "codex", results: [res("q", "failed")] });
+    const dupeHtml = await renderReportToStaticHtml(definition, { scope: scopeOf([dupeA, dupeB]), results: resultsOf([dupeA, dupeB]) });
+    expect(dupeHtml).toContain(">x/run</b>");
+    expect(dupeHtml).toContain(">y/run</b>");
+
+    // ScopeSummary / MetricScatter 完全不受行标签缩短影响
+    const [summaryEl, scatterEl] = await resolveComparisonChildren(<ExperimentComparison />, [a, b]);
+    expect(summaryEl.props.data).toEqual(await scopeSummaryData([a, b]));
+    expect(scatterEl.props.data).toEqual(
+      await metricScatterData([a, b], { points: "experiment", series: "agent", x: costUSD, y: endToEndPassRate }),
+    );
+  });
 });
 
 // ───────────────────────── extends 与内建视图集合 ─────────────────────────

package/src/runner/types.ts

@@ -422,7 +422,8 @@ export interface ExperimentDef {
   labels?: Record<string, string | number>;
   /** 同一 eval 重复跑几次(结果各计一条 attempt);省略/CLI `--runs` 覆盖时默认 1。 */
   runs?: number;
-  /** 一次重复(runs > 1)里某次 attempt 失败后是否跳过剩余重复;省略默认 true(提前退出省钱)。 */
+  /** 一次重复(runs > 1)里某次 attempt 通过后是否跳过剩余重复;省略默认 false(`runs` 跑满、测完整通过率),
+   *  显式打开用于「只想知道能不能过」的省钱场景。 */
   earlyExit?: boolean;
   /**
    * 这个实验覆盖哪些 eval:`"*"` 全部、字符串数组按 id 前缀、或自定义谓词(逐条收到发现并扇出后的

package/src/sandbox/e2b-reconcile.test.ts

@@ -0,0 +1,125 @@
+// 覆盖 reconcileProvision 对账逻辑,不打真实 e2b API——mock "e2b" 整个模块。
+// 背景:线上跑分撞见过 nextItems() 之后 `for...of` 抛 "X is not iterable" 的一次,
+// 没能稳定复现出确切成因;这里补的是"对账这条路径本身撞上瞬时错误该怎么办"这层契约,
+// 不是去复现那次具体的 SDK 行为。
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+class FakeNotFoundError extends Error {}
+class FakeRateLimitError extends Error {}
+class FakeCommandExitError extends Error {}
+
+const listMock = vi.fn();
+const killMock = vi.fn();
+
+vi.mock("e2b", () => ({
+  Sandbox: { list: (...args: unknown[]) => listMock(...args), kill: (...args: unknown[]) => killMock(...args) },
+  NotFoundError: FakeNotFoundError,
+  RateLimitError: FakeRateLimitError,
+  CommandExitError: FakeCommandExitError,
+}));
+
+function fakePaginator(pages: Array<() => Promise<unknown[]>>) {
+  let i = 0;
+  return {
+    get hasNext() {
+      return i < pages.length;
+    },
+    nextItems: async () => {
+      const page = pages[i];
+      i += 1;
+      return page();
+    },
+  };
+}
+
+describe("reconcileProvision", () => {
+  beforeEach(() => {
+    listMock.mockReset();
+    killMock.mockReset();
+  });
+
+  it("kills every sandbox found under the provision token, across pages", async () => {
+    const { reconcileProvision } = await import("./e2b.ts");
+    listMock.mockReturnValue(
+      fakePaginator([
+        async () => [{ sandboxId: "a" }],
+        async () => [{ sandboxId: "b" }],
+      ]),
+    );
+    killMock.mockResolvedValue(undefined);
+
+    await reconcileProvision("tok");
+
+    expect(killMock).toHaveBeenCalledTimes(2);
+    expect(killMock.mock.calls.map((c) => c[0])).toEqual(["a", "b"]);
+  });
+
+  it("treats a NotFound on kill as already-reconciled, not an error", async () => {
+    const { reconcileProvision } = await import("./e2b.ts");
+    listMock.mockReturnValue(fakePaginator([async () => [{ sandboxId: "gone" }]]));
+    killMock.mockRejectedValue(new FakeNotFoundError("gone"));
+
+    await expect(reconcileProvision("tok")).resolves.toBeUndefined();
+  });
+
+  it("retries nextItems() on a transient (ambiguous) error and still succeeds", async () => {
+    vi.useFakeTimers();
+    try {
+      const { reconcileProvision } = await import("./e2b.ts");
+      let calls = 0;
+      let done = false;
+      listMock.mockReturnValue({
+        get hasNext() {
+          return !done;
+        },
+        nextItems: vi.fn(async () => {
+          calls += 1;
+          if (calls === 1) throw new Error("fetch failed");
+          done = true;
+          return [];
+        }),
+      });
+
+      const promise = reconcileProvision("tok");
+      await vi.runAllTimersAsync();
+      await promise;
+      expect(calls).toBe(2);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("does not swallow a nextItems() result that isn't an array", async () => {
+    const { reconcileProvision } = await import("./e2b.ts");
+    listMock.mockReturnValue({ hasNext: true, nextItems: vi.fn().mockResolvedValue(undefined) });
+
+    await expect(reconcileProvision("tok")).rejects.toThrow(/not an array|SandboxInfo/);
+  });
+
+  it("gives up after repeated transient nextItems() failures instead of retrying forever", async () => {
+    vi.useFakeTimers();
+    try {
+      const { reconcileProvision } = await import("./e2b.ts");
+      const err = new Error("fetch failed");
+      listMock.mockReturnValue({
+        hasNext: true,
+        nextItems: vi.fn().mockRejectedValue(err),
+      });
+
+      const assertion = expect(reconcileProvision("tok")).rejects.toBe(err);
+      await vi.runAllTimersAsync();
+      await assertion;
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("propagates a non-retryable kill error immediately", async () => {
+    const { reconcileProvision } = await import("./e2b.ts");
+    listMock.mockReturnValue(fakePaginator([async () => [{ sandboxId: "a" }]]));
+    const err = new Error("permission denied");
+    killMock.mockRejectedValue(err);
+
+    await expect(reconcileProvision("tok")).rejects.toBe(err);
+  });
+});