niceeval 0.12.1 → 0.12.2-canary.31

package/src/runner/reporters/braintrust.ts

@@ -1,211 +0,0 @@
-// Braintrust 报告器:把一次 niceeval 运行作为一个 Braintrust experiment 上报,
-// 每个 attempt 一行(scores = 断言,metrics = 时长/token/成本),跨提交比较与团队共享。
-// `braintrust` 是可选依赖:动态 import,装了才用得上,没装在 onInvocationStart 报错
-// (reporter 错误按框架约定只记 diagnostic,不会让运行崩)。
-
-import type { EvalResult, JsonValue, Reporter } from "../../types.ts";
-import { reportActivity } from "../feedback/sink.ts";
-
-export interface BraintrustConfig {
-  /** Braintrust 项目名;省略时用 "niceeval"。 */
-  project?: string;
-  /** Braintrust 项目 id;与 project 给一个即可。 */
-  projectId?: string;
-  /** 实验名;省略时由 Braintrust 自动命名。 */
-  experiment?: string;
-  /** 作为对比基线(diff base)的既有实验名。 */
-  baseExperiment?: string;
-  /** 作为对比基线(diff base)的既有实验 id。 */
-  baseExperimentId?: string;
-  /** true = 更新同名既有实验,而不是新建一个。 */
-  update?: boolean;
-  /** 实验级附加 metadata;与 niceeval 自动写入的字段合并,同名以这里为准。 */
-  metadata?: globalThis.Record<string, JsonValue>;
-  /** API key;省略时 SDK 读 BRAINTRUST_API_KEY 环境变量。 */
-  apiKey?: string;
-}
-
-/**
- * Braintrust SDK 的最小类型面。本地声明是为了不把 `braintrust` 变成编译期依赖;
- * 动态 import 后按这个形状断言。
- */
-interface BraintrustSdk {
-  // SDK 里 init 同步返回(登录与建实验都是惰性的);统一 await,同步/异步都兼容。
-  init(options: {
-    project?: string;
-    projectId?: string;
-    experiment?: string;
-    baseExperiment?: string;
-    baseExperimentId?: string;
-    update?: boolean;
-    apiKey?: string;
-    metadata?: globalThis.Record<string, JsonValue>;
-    setCurrent?: boolean;
-  }): BraintrustExperiment | Promise<BraintrustExperiment>;
-  flush(): Promise<void>;
-}
-
-interface BraintrustExperiment {
-  log(event: BraintrustLogEvent): void;
-  summarize(): Promise<{ experimentUrl?: string }>;
-}
-
-export interface BraintrustLogEvent {
-  id?: string;
-  input?: string;
-  output?: string;
-  error?: EvalResult["error"];
-  scores?: globalThis.Record<string, number>;
-  metadata?: globalThis.Record<string, JsonValue>;
-  metrics?: globalThis.Record<string, number>;
-}
-
-/**
- * 创建 Braintrust 报告器。挂在 `defineConfig({ reporters })` 上观测整次运行,
- * 或挂在单个 eval 的 `reporters` 上只观测它(同一实例被多个 eval 引用时共享一个实验)。
- */
-export function Braintrust(config: BraintrustConfig = {}): Reporter {
-  let sdk: BraintrustSdk | undefined;
-  let experiment: BraintrustExperiment | undefined;
-
-  return {
-    async onInvocationStart(evals) {
-      sdk = await loadBraintrustSdk();
-      experiment = await sdk.init({
-        project: config.projectId ? undefined : (config.project ?? "niceeval"),
-        projectId: config.projectId,
-        experiment: config.experiment,
-        baseExperiment: config.baseExperiment,
-        baseExperimentId: config.baseExperimentId,
-        update: config.update,
-        apiKey: config.apiKey,
-        // 不再写顶层单一 agent:一次 Invocation 可能横跨多个 (agent, model, flags) 配置,
-        // 启动时还没有任何结果,写一个必然只代表其中一份配置的值就是撒谎(见
-        // docs/runner.md「Reporter 与运行器事件」)。每行自己的 agent 身份仍在
-        // toBraintrustEvent() 的 metadata.agent 里,逐 attempt 精确;跨行的 agent 集合可以
-        // 从 Braintrust 自己按 metadata.agent 分组得到,不需要实验级再存一份。
-        metadata: {
-          evals: evals.map((e) => e.id),
-          ...config.metadata,
-        },
-        // 不设为全局 current experiment,避免污染用户代码里的 braintrust 全局态。
-        setCurrent: false,
-      });
-    },
-
-    onEvalComplete(result) {
-      experiment?.log(toBraintrustEvent(result));
-    },
-
-    async onInvocationComplete() {
-      if (!experiment) return;
-      try {
-        await sdk?.flush();
-        const summary = await experiment.summarize();
-        if (summary.experimentUrl) {
-          reportActivity(`Braintrust experiment: ${summary.experimentUrl}`);
-        }
-      } finally {
-        experiment = undefined;
-        sdk = undefined;
-      }
-    },
-  };
-}
-
-/**
- * EvalResult → Braintrust 一行。导出仅为单测;映射口径:
- * - scores:soft 断言按名字记分,gate 断言记在 `gate:` 前缀下 —— 实验 diff 里
- *   gate 回归和 soft 分数回归用同一套机制看。重名断言追加 `#n` 消歧,不静默覆盖。
- * - metrics:start/end(Braintrust 由此算时长)+ token 用量 + 估算成本;缺就不写,不编 0。
- * - metadata:身份维度(agent / model / experiment / attempt / flags)+ 失败断言明细。
- */
-export function toBraintrustEvent(result: EvalResult): BraintrustLogEvent {
-  const scores: globalThis.Record<string, number> = {};
-  for (const a of result.assertions) {
-    // unavailable 是没有分数的独立态:不写 0 分(评不了 ≠ 0 分),缺口进 metadata。
-    if (a.outcome === "unavailable") continue;
-    const base = a.severity === "gate" ? `gate:${a.name}` : a.name;
-    let key = base;
-    for (let n = 2; key in scores; n++) key = `${base}#${n}`;
-    // Braintrust 要求 0..1
-    scores[key] = Math.min(1, Math.max(0, a.score));
-  }
-
-  const metrics: globalThis.Record<string, number> = {};
-  if (result.startedAt) {
-    const start = Date.parse(result.startedAt) / 1000;
-    if (Number.isFinite(start)) {
-      metrics.start = start;
-      metrics.end = start + result.durationMs / 1000;
-    }
-  }
-  if (result.usage) {
-    const { inputTokens, outputTokens, cacheReadTokens, cacheCreationTokens, reasoningTokens, requests } = result.usage;
-    if (inputTokens !== undefined) metrics.prompt_tokens = inputTokens;
-    if (outputTokens !== undefined) metrics.completion_tokens = outputTokens;
-    if (inputTokens !== undefined && outputTokens !== undefined) metrics.tokens = inputTokens + outputTokens;
-    if (cacheReadTokens !== undefined) metrics.cache_read_tokens = cacheReadTokens;
-    if (cacheCreationTokens !== undefined) metrics.cache_creation_tokens = cacheCreationTokens;
-    if (reasoningTokens !== undefined) metrics.reasoning_tokens = reasoningTokens;
-    if (requests !== undefined) metrics.requests = requests;
-  }
-  if (result.estimatedCostUSD !== undefined) metrics.estimated_cost_usd = result.estimatedCostUSD;
-
-  const metadata: globalThis.Record<string, JsonValue> = {
-    eval: result.id,
-    agent: result.agent,
-    attempt: result.attempt,
-    verdict: result.verdict,
-  };
-  if (result.model !== undefined) metadata.model = result.model;
-  if (result.experimentId !== undefined) metadata.experiment = result.experimentId;
-  if (result.experiment?.flags && Object.keys(result.experiment.flags).length > 0) {
-    metadata.flags = result.experiment.flags;
-  }
-  if (result.skipReason !== undefined) metadata.skipReason = result.skipReason;
-  const failed = result.assertions
-    .filter((a) => a.outcome === "failed")
-    .map((a) => ({ name: a.name, ...(a.detail === undefined ? {} : { detail: a.detail }) }));
-  if (failed.length > 0) metadata.failedAssertions = failed;
-  const unavailable = result.assertions
-    .filter((a) => a.outcome === "unavailable")
-    .map((a) => ({ name: a.name, reason: a.outcome === "unavailable" ? a.reason : "" }));
-  if (unavailable.length > 0) metadata.unavailableAssertions = unavailable;
-
-  // 一次运行内 (experiment, eval, agent, model, attempt) 唯一;Braintrust 按 id 合并重复行。
-  const id = [result.experimentId ?? "", result.id, result.agent, result.model ?? "", `a${result.attempt}`].join("|");
-
-  return {
-    id,
-    input: result.description ?? result.id,
-    output: lastAssistantText(result.events),
-    error: result.error,
-    scores,
-    metadata,
-    metrics,
-  };
-}
-
-/** agent 的最终回复文本(事件流里最后一条 assistant message);没有就不填。 */
-function lastAssistantText(events: EvalResult["events"]): string | undefined {
-  if (!events) return undefined;
-  for (let i = events.length - 1; i >= 0; i--) {
-    const e = events[i];
-    if (e.type === "message" && e.role === "assistant") return e.text;
-  }
-  return undefined;
-}
-
-/** 动态 import 说明:specifier 放变量里,`braintrust` 不进编译期依赖,没装也能 typecheck。 */
-const BRAINTRUST_PACKAGE = "braintrust";
-
-async function loadBraintrustSdk(): Promise<BraintrustSdk> {
-  try {
-    return (await import(BRAINTRUST_PACKAGE)) as unknown as BraintrustSdk;
-  } catch {
-    throw new Error(
-      "The 'braintrust' package is required for the Braintrust reporter but was not found. Install it with: npm install braintrust (and set BRAINTRUST_API_KEY).",
-    );
-  }
-}

package/src/runner/reporters/index.ts

@@ -1,7 +0,0 @@
-// 内置报告器:Artifacts(默认落盘)/ Json / JUnit / Braintrust。
-// 其它第三方实验跟踪平台也走同一条 Reporter 通道。
-// 终端反馈不是 Reporter——三种 --output profile 见 src/runner/feedback/。
-
-export { Artifacts } from "./artifacts.ts";
-export { Json, JUnit } from "./json.ts";
-export { Braintrust, type BraintrustConfig } from "./braintrust.ts";

package/src/runner/reporters/json.test.ts

@@ -1,163 +0,0 @@
-// cases: docs/engineering/testing/unit/experiments-runner.md
-// Json/JUnit 的同目录 temp → write → rename 原子替换契约(见 docs/feature/experiments/cli.md
-// 「输出流和落盘节奏」):成功后不留 temp;写入失败保留旧目标文件、不留半成品、不留 temp。
-//
-// `node:fs/promises` 的具名导出在这个 Vitest 环境下是不可配置的 ESM 绑定(`vi.spyOn` 直接
-// 报 "Module namespace is not configurable")——只能靠 `vi.mock` 在模块解析层整体替换,
-// 其余全部转发给真实实现(`importOriginal`),只在 `failureState` 显式设置时让 rename/
-// writeFile 失败一次(用后即清,不影响后续调用或其它测试)。
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { mkdtemp, readdir, readFile, rm, writeFile as realWriteFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Json, JUnit } from "./json.ts";
-import type { InvocationSummary } from "../../types.ts";
-import { completeEvidenceCoverage } from "../../assertions/coverage.ts";
-
-const failureState = vi.hoisted(() => ({
-  renameError: undefined as Error | undefined,
-  writeFileError: undefined as Error | undefined,
-}));
-
-vi.mock("node:fs/promises", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("node:fs/promises")>();
-  return {
-    ...actual,
-    rename: async (...args: Parameters<typeof actual.rename>) => {
-      if (failureState.renameError) {
-        const e = failureState.renameError;
-        failureState.renameError = undefined;
-        throw e;
-      }
-      return actual.rename(...args);
-    },
-    writeFile: async (...args: Parameters<typeof actual.writeFile>) => {
-      if (failureState.writeFileError) {
-        const e = failureState.writeFileError;
-        failureState.writeFileError = undefined;
-        throw e;
-      }
-      return actual.writeFile(...args);
-    },
-  };
-});
-
-function summary(overrides: Partial<InvocationSummary> = {}): InvocationSummary {
-  return {
-    startedAt: "2026-07-07T00:00:00.000Z",
-    completedAt: "2026-07-07T00:01:00.000Z",
-    passed: 1,
-    failed: 0,
-    skipped: 0,
-    errored: 0,
-    durationMs: 1000,
-    results: [],
-    ...overrides,
-  };
-}
-
-const roots: string[] = [];
-async function makeRoot(): Promise<string> {
-  const root = await mkdtemp(join(tmpdir(), "niceeval-json-atomic-"));
-  roots.push(root);
-  return root;
-}
-afterEach(async () => {
-  await Promise.all(roots.splice(0).map((r) => rm(r, { recursive: true, force: true })));
-  failureState.renameError = undefined;
-  failureState.writeFileError = undefined;
-});
-
-/** 目录里是否残留 `.tmp` 临时文件(atomicWriteFile 用 `.niceeval-<uuid>.tmp` 命名)。 */
-async function tmpFilesIn(dir: string): Promise<string[]> {
-  return (await readdir(dir)).filter((name) => name.endsWith(".tmp"));
-}
-
-describe("Json · 原子替换", () => {
-  it("成功写入合法 JSON,写完不留 temp 文件", async () => {
-    const root = await makeRoot();
-    const path = join(root, "out.json");
-
-    await Json(path).onInvocationComplete!(summary({ passed: 3 }));
-
-    const parsed = JSON.parse(await readFile(path, "utf-8"));
-    expect(parsed.passed).toBe(3);
-    expect(await tmpFilesIn(root)).toEqual([]);
-  });
-
-  it("rename 失败时保留旧目标文件原内容,不留截断 JSON,不留 temp 文件", async () => {
-    const root = await makeRoot();
-    const path = join(root, "out.json");
-    await realWriteFile(path, '{"old":"content"}', "utf-8"); // 上一轮已经成功写过一份
-
-    failureState.renameError = new Error("simulated rename failure");
-    await expect(Json(path).onInvocationComplete!(summary({ passed: 99 }))).rejects.toThrow("simulated rename failure");
-
-    // 旧内容原封不动——没有被替换成半成品,也没有被新内容(passed: 99)覆盖。
-    expect(await readFile(path, "utf-8")).toBe('{"old":"content"}');
-    expect(await tmpFilesIn(root)).toEqual([]);
-  });
-
-  it("写临时文件本身失败时不产生新目标文件,也不留 temp 文件", async () => {
-    const root = await makeRoot();
-    const path = join(root, "out.json"); // 目标此前不存在
-
-    failureState.writeFileError = new Error("simulated write failure");
-    await expect(Json(path).onInvocationComplete!(summary())).rejects.toThrow("simulated write failure");
-
-    expect(await readdir(root)).toEqual([]); // 没有凭空出现半成品目标文件
-  });
-
-  it("rename 目标是一个已存在目录时必然失败(POSIX 语义,不依赖权限/是否 root)——旧目录原样保留,不留 temp 文件", async () => {
-    const root = await makeRoot();
-    const path = join(root, "out.json");
-    const { mkdir } = await import("node:fs/promises");
-    await mkdir(path); // 占用目标路径的不是文件而是目录——rename 一个文件覆盖已存在目录恒失败
-
-    await expect(Json(path).onInvocationComplete!(summary())).rejects.toThrow();
-
-    const entries = await readdir(root);
-    expect(entries).toEqual(["out.json"]); // 目录还在,没有被替换、也没有多出 temp 文件残留
-  });
-});
-
-describe("JUnit · 原子替换", () => {
-  it("成功写入合法 XML,写完不留 temp 文件", async () => {
-    const root = await makeRoot();
-    const path = join(root, "out.xml");
-
-    await JUnit(path).onInvocationComplete!(
-      summary({
-        results: [
-          {
-            id: "a/1",
-            agent: "codex",
-            verdict: "passed",
-            attempt: 0,
-            durationMs: 10,
-            assertions: [],
-            evidenceCoverage: completeEvidenceCoverage,
-          },
-        ],
-      }),
-    );
-
-    const xml = await readFile(path, "utf-8");
-    expect(xml).toContain("<?xml");
-    expect(xml).toContain("<testsuite");
-    expect(await tmpFilesIn(root)).toEqual([]);
-  });
-
-  it("rename 失败时保留旧目标文件原内容,不留截断 XML,不留 temp 文件", async () => {
-    const root = await makeRoot();
-    const path = join(root, "out.xml");
-    await realWriteFile(path, "<old/>", "utf-8");
-
-    failureState.renameError = new Error("simulated rename failure");
-    await expect(JUnit(path).onInvocationComplete!(summary())).rejects.toThrow("simulated rename failure");
-
-    expect(await readFile(path, "utf-8")).toBe("<old/>");
-    expect(await tmpFilesIn(root)).toEqual([]);
-  });
-});

package/src/runner/reporters/json.ts

@@ -1,79 +0,0 @@
-// JSON / JUnit 报告器:把运行结果落成机器可读 artifact,接 CI 或下游 dashboard。
-// 两者都是「整次运行结束时写一份聚合文件」(不像 Artifacts 的逐 attempt 增量落盘),见
-// docs/feature/experiments/cli.md「输出流和落盘节奏」——一旦开始写就必须原子替换目标:
-// 半途失败(磁盘满、权限问题、进程被杀)不能把上一次成功的 JSON/JUnit 覆盖成截断文件,
-// 那会让 CI 读到一份看似存在、实际损坏的报告,比「文件不存在」更危险。
-
-import { mkdir, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { randomUUID } from "node:crypto";
-import type { InvocationSummary, Reporter } from "../../types.ts";
-
-/**
- * 同目录 temp → write → rename 的原子替换:内容先整体写进同目录下的临时文件,写完才
- * `rename()` 覆盖真正的目标路径——`rename()` 在同一文件系统内是单一原子操作,读者不可能
- * 观察到「文件存在但内容只写了一半」的中间态。同目录是必须的,跨目录/跨文件系统的
- * rename 不保证原子性(可能退化成先复制再删除)。
- *
- * 失败路径:临时文件写入或 rename 本身抛错时,`rename()` 还没被调用或没有成功,旧目标文件
- * (如果之前存在)完全没被触碰;没有旧目标文件时目录里也不会凭空出现一个新的。失败后立即
- * 清理临时文件(`rm force`,即便清理本身失败也吞掉——不能让「清理垃圾」的次要错误掩盖调用方
- * 真正需要看到的写入失败),成功路径下 `rename()` 之后临时文件已经不在原路径,同样不留残留。
- */
-async function atomicWriteFile(path: string, content: string): Promise<void> {
-  const dir = dirname(path);
-  await mkdir(dir, { recursive: true });
-  const tmpPath = join(dir, `.niceeval-${randomUUID()}.tmp`);
-  try {
-    await writeFile(tmpPath, content, "utf-8");
-    await rename(tmpPath, path);
-  } catch (e) {
-    await rm(tmpPath, { force: true }).catch(() => {});
-    throw e;
-  }
-}
-
-export function Json(path: string): Reporter {
-  return {
-    async onInvocationComplete(summary: InvocationSummary) {
-      await atomicWriteFile(path, JSON.stringify(summary, null, 2));
-    },
-  };
-}
-
-export function JUnit(path: string): Reporter {
-  return {
-    async onInvocationComplete(summary: InvocationSummary) {
-      const cases = summary.results
-        .map((r) => {
-          const name = xmlAttr(`${r.id} [${r.agent}${r.model ? "/" + r.model : ""}]`);
-          const time = (r.durationMs / 1000).toFixed(3);
-          if (r.verdict === "errored") {
-            return `    <testcase name="${name}" time="${time}"><error message="${xmlAttr(r.error?.message ?? "execution error")}"/></testcase>`;
-          }
-          if (r.verdict === "failed") {
-            const msg = xmlAttr(r.assertions.filter((a) => a.outcome === "failed").map((a) => a.name).join("; "));
-            return `    <testcase name="${name}" time="${time}"><failure message="${msg}"/></testcase>`;
-          }
-          if (r.verdict === "skipped") {
-            return `    <testcase name="${name}" time="${time}"><skipped message="${xmlAttr(r.skipReason ?? "")}"/></testcase>`;
-          }
-          return `    <testcase name="${name}" time="${time}"/>`;
-        })
-        .join("\n");
-      const xml =
-        `<?xml version="1.0" encoding="UTF-8"?>\n` +
-        `<testsuite name="niceeval" tests="${summary.results.length}" failures="${summary.failed}" errors="${summary.errored}" skipped="${summary.skipped}" time="${(summary.durationMs / 1000).toFixed(3)}">\n` +
-        `${cases}\n</testsuite>\n`;
-      await atomicWriteFile(path, xml);
-    },
-  };
-}
-
-function xmlAttr(s: string): string {
-  return s
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;");
-}

package/src/runner/reporters/shared.ts

@@ -1,14 +0,0 @@
-// verdict 符号表,当前唯一消费方是 src/runner/feedback/human.ts 的 dashboard/完成页。
-
-import type { Verdict } from "../../types.ts";
-
-export const VERDICT_SYM: globalThis.Record<Verdict, string> = {
-  passed: "✓",
-  failed: "✗",
-  errored: "!",
-  skipped: "○",
-};
-
-export function verdictSymbol(verdict: string): string {
-  return VERDICT_SYM[verdict as Verdict] ?? "?";
-}

package/src/runner/reuse-diagnostics.test.ts

@@ -1,114 +0,0 @@
-// cases: docs/engineering/testing/unit/sandbox.md
-// 覆盖类别「Sandbox 复用」的复用污染诊断。
-//
-// 只指路不改判定,所以这里只断言「发不发、点名了谁」:某实例承接序号 ≥ 2 的 Attempt 集中失败
-// 于同一阶段才发;首承接失败或失败不聚集时不发(不误报)。
-
-import { describe, expect, it } from "vitest";
-import { detectReuseContamination, reuseContaminationMessage } from "./reuse-diagnostics.ts";
-import type { EvalResult, LifecyclePhase } from "./types.ts";
-import { completeEvidenceCoverage } from "../assertions/coverage.ts";
-
-function attempt(opts: {
-  id: string;
-  verdict: EvalResult["verdict"];
-  reuseSandbox: number;
-  reuseOrdinal: number;
-  phase?: LifecyclePhase;
-  experimentId?: string;
-  reused?: boolean;
-}): EvalResult {
-  return {
-    id: opts.id,
-    experimentId: opts.experimentId ?? "reuse-exp",
-    agent: "fake",
-    verdict: opts.verdict,
-    attempt: 0,
-    startedAt: new Date().toISOString(),
-    durationMs: 1,
-    assertions: [],
-    evidenceCoverage: completeEvidenceCoverage,
-    ...(opts.phase !== undefined ? { error: { code: "unexpected-error", message: "boom", origin: { scope: "attempt" as const, phase: opts.phase } } } : {}),
-    sandbox: {
-      provider: "docker",
-      sandboxId: `sbx-${opts.reuseSandbox}`,
-      ...(opts.reused === false ? {} : { reused: true as const }),
-      reuseSandbox: opts.reuseSandbox,
-      reuseOrdinal: opts.reuseOrdinal,
-    },
-  } as EvalResult;
-}
-
-describe("detectReuseContamination", () => {
-  it("首承接正常、后续承接集中 errored 在同一阶段时,点名实例、序号区间与阶段", () => {
-    const notices = detectReuseContamination([
-      attempt({ id: "a", verdict: "passed", reuseSandbox: 1, reuseOrdinal: 1 }),
-      attempt({ id: "b", verdict: "errored", reuseSandbox: 1, reuseOrdinal: 2, phase: "sandbox.prepare.eval" }),
-      attempt({ id: "c", verdict: "errored", reuseSandbox: 1, reuseOrdinal: 4, phase: "sandbox.prepare.eval" }),
-    ]);
-
-    expect(notices).toEqual([
-      { experimentId: "reuse-exp", reuseSandbox: 1, phase: "sandbox.prepare.eval", fromOrdinal: 2, toOrdinal: 4, count: 2 },
-    ]);
-    const message = reuseContaminationMessage(notices[0]!);
-    expect(message).toContain("#1");
-    expect(message).toContain("2-4");
-    expect(message).toContain("sandbox.prepare.eval");
-  });
-
-  it("首承接自己就失败时不发:那种失败与上一条 Attempt 的残留无关", () => {
-    expect(
-      detectReuseContamination([
-        attempt({ id: "a", verdict: "errored", reuseSandbox: 1, reuseOrdinal: 1, phase: "sandbox.prepare.eval" }),
-        attempt({ id: "b", verdict: "errored", reuseSandbox: 1, reuseOrdinal: 2, phase: "sandbox.prepare.eval" }),
-        attempt({ id: "c", verdict: "errored", reuseSandbox: 1, reuseOrdinal: 3, phase: "sandbox.prepare.eval" }),
-      ]),
-    ).toEqual([]);
-  });
-
-  it("后续失败不聚集(散在不同阶段、或只有一条)时不发", () => {
-    expect(
-      detectReuseContamination([
-        attempt({ id: "a", verdict: "passed", reuseSandbox: 1, reuseOrdinal: 1 }),
-        attempt({ id: "b", verdict: "errored", reuseSandbox: 1, reuseOrdinal: 2, phase: "sandbox.prepare.eval" }),
-        attempt({ id: "c", verdict: "errored", reuseSandbox: 1, reuseOrdinal: 3, phase: "agent.setup" }),
-        attempt({ id: "d", verdict: "passed", reuseSandbox: 1, reuseOrdinal: 4 }),
-      ]),
-    ).toEqual([]);
-  });
-
-  it("同一实验的两台实例各自判定,互不串味", () => {
-    const notices = detectReuseContamination([
-      attempt({ id: "a", verdict: "passed", reuseSandbox: 1, reuseOrdinal: 1 }),
-      attempt({ id: "b", verdict: "errored", reuseSandbox: 1, reuseOrdinal: 2, phase: "sandbox.prepare.eval" }),
-      // 2 号实例首承接就失败:它的后续失败不算线索,不能被 1 号的证据带出来。
-      attempt({ id: "c", verdict: "errored", reuseSandbox: 2, reuseOrdinal: 1, phase: "sandbox.prepare.eval" }),
-      attempt({ id: "d", verdict: "errored", reuseSandbox: 2, reuseOrdinal: 2, phase: "sandbox.prepare.eval" }),
-      attempt({ id: "e", verdict: "errored", reuseSandbox: 1, reuseOrdinal: 3, phase: "sandbox.prepare.eval" }),
-    ]);
-
-    expect(notices.map((n) => n.reuseSandbox)).toEqual([1]);
-  });
-
-  it("断言失败(没有 error.phase)按判定发生地 eval.run 聚合", () => {
-    const notices = detectReuseContamination([
-      attempt({ id: "a", verdict: "passed", reuseSandbox: 1, reuseOrdinal: 1 }),
-      attempt({ id: "b", verdict: "failed", reuseSandbox: 1, reuseOrdinal: 2 }),
-      attempt({ id: "c", verdict: "failed", reuseSandbox: 1, reuseOrdinal: 3 }),
-    ]);
-
-    expect(notices).toEqual([
-      { experimentId: "reuse-exp", reuseSandbox: 1, phase: "eval.run", fromOrdinal: 2, toOrdinal: 3, count: 2 },
-    ]);
-  });
-
-  it("没有声明复用的结果不参与判定(一次性沙箱的失败与复用无关)", () => {
-    expect(
-      detectReuseContamination([
-        attempt({ id: "a", verdict: "passed", reuseSandbox: 1, reuseOrdinal: 1, reused: false }),
-        attempt({ id: "b", verdict: "errored", reuseSandbox: 1, reuseOrdinal: 2, reused: false, phase: "sandbox.prepare.eval" }),
-        attempt({ id: "c", verdict: "errored", reuseSandbox: 1, reuseOrdinal: 3, reused: false, phase: "sandbox.prepare.eval" }),
-      ]),
-    ).toEqual([]);
-  });
-});