niceeval 0.6.1 → 0.7.0

package/src/runner/run.ts

@@ -10,9 +10,28 @@ import { cacheKey, planCarry } from "./fingerprint.ts";
 import { OtelReceiverPool } from "../o11y/otlp/turn-otel.ts";
 import { runAttemptEffect } from "./attempt.ts";
 import { runReporter, emitReporterEvent, scopeReporter, summarize } from "./report.ts";
-import { writeStderrLine } from "../tty-line.ts";
-import type { Agent, EvalResult, JudgeConfig, Reporter, RunShape, RunSummary } from "../types.ts";
-import type { AgentRun, Attempt, RunOptions } from "./types.ts";
+import {
+  reportActivity,
+  reportAttemptLifecycle,
+  reportBudgetExhausted,
+  reportDiagnostic,
+  reportFailure,
+  reportInterrupted,
+} from "./feedback/sink.ts";
+import { failureDetailFromResult } from "./feedback/failure.ts";
+import { encodeAttemptLocator, type AttemptLocator } from "../results/locator.ts";
+import { runWho } from "./types.ts";
+import type { Agent, EvalResult, JudgeConfig, Reporter, ReporterRegistration, RunShape, RunSummary } from "../types.ts";
+import type { AgentRun, Attempt, LifecyclePhase, AttemptRef, RunOptions } from "./types.ts";
+
+/** 反馈层的 attempt 身份 + 展示 label,两个 sink.ts lifecycle 调用点共用,避免各自手写
+ *  同一组字段(见 memory 的 live-who-key-mismatch-freezes-rows —— 手写副本漏改是真实事故源)。 */
+function feedbackIdentity(a: Attempt): AttemptRef {
+  return { experimentId: a.run.experimentId, evalId: a.evalDef.id, attempt: a.attempt };
+}
+function feedbackWho(a: Attempt): string {
+  return runWho({ agentName: a.run.agent.name, model: a.run.model, experimentId: a.run.experimentId });
+}
 
 export type { AgentRun, RunOptions } from "./types.ts";
 
@@ -41,6 +60,13 @@ export function judgeProbeTargets(
 
 export async function runEvals(opts: RunOptions): Promise<RunSummary> {
   const startedAt = new Date().toISOString();
+  // 本次 invocation 的快照身份锚点:在展开/调度任何 attempt 之前确定一次,不同 experiment
+  // 共享它(locator 身份还含 experimentId,不会碰撞)。fresh EvalResult 的 locator(见下方
+  // attempt 完成处)与 Artifacts writer 写进 snapshot.json 的 startedAt 必须用同一个值——
+  // 复用刚建立的 startedAt,不是另起一次 new Date(),避免两者出现毫秒级漂移
+  // (docs/feature/experiments/cli.md「Locator 必须在 result 发布前确定」)。经 RunShape
+  // 传给 reporter(见下方 shape 构造),run.ts 之外没有第二个入口能改这份身份。
+  const snapshotStartedAt = startedAt;
   const t0 = Date.now();
 
   // 按 sourcePath 缓存文件内容,fingerprint 与 judge 预检共用:
@@ -64,6 +90,19 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
   const { plannedFingerprints, priorRunKeys, carriedResults } =
     opts.carryPlan ?? (await planCarry(opts.evals, opts.agentRuns, opts.priorResults));
 
+  // 携入覆盖计数:priorRunKeys 只回答「这个 (experimentId, evalId) 组合有没有可携入的终态
+  // 结果」,不回答「携入了几条」。runs 被调大(或实验改成更大的 runs)时,上次可能只留下比
+  // 这次请求更少的终态结果(如上次 runs:1、这次改成 runs:5),不能因为"有过携入"就把这次
+  // 请求的差额序号也整段跳过——那会让 pass@N 里的 N 被携入悄悄砍短,运行还照样报 PASSED/exit 0
+  // (见 docs/runner.md「不能在 CI 里伪装成全绿」)。下面按序号只跳过携入能覆盖到的前
+  // carriedCount 个,差额必须真正进 attempts 数组、走正常调度(含 earlyExit/budget 判断)。
+  const carriedCountByKey = new Map<string, number>();
+  for (const r of carriedResults) {
+    if (!r.experimentId) continue;
+    const key = `${r.experimentId}|${r.id}`;
+    carriedCountByKey.set(key, (carriedCountByKey.get(key) ?? 0) + 1);
+  }
+
   // 展开 attempts
   // 外层按「round」(run index)迭代,内层按 eval 迭代:同一 key 的第 i+1 次 attempt 排在
   // 所有 eval 的第 i 次之后,earlyExit 开启时第 0 轮通过的 eval,其后续轮大多还没入池就被跳过。
@@ -72,9 +111,15 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
   const attempts: Attempt[] = [];
   for (const run of opts.agentRuns) {
     const evals = opts.evals.filter((e) => run.evalFilter(e.id));
+    // 解析后实际选中的 eval id 全集(evals 过滤器的求值结果)进 ExperimentRunInfo.selectedEvalIds,
+    // 与 evalFilterFingerprint 一起取代过滤器本身落盘(见 docs/feature/results/architecture.md)。
+    run.selectedEvalIds = evals.map((e) => e.id);
     for (let i = 0; i < run.runs; i++) {
       for (const evalDef of evals) {
-        if (run.experimentId && priorRunKeys.has(`${run.experimentId}|${evalDef.id}`)) continue;
+        const carryKey = `${run.experimentId ?? ""}|${evalDef.id}`;
+        // 只跳过携入能覆盖到的前 carriedCount 个序号(见上面 carriedCountByKey 的注释);
+        // i 超出携入数量的部分必须真正调度,不能因为同一组合"有过携入"就整段跳过。
+        if (run.experimentId && priorRunKeys.has(carryKey) && i < (carriedCountByKey.get(carryKey) ?? 0)) continue;
         // key 标识「同一个运行配置下的同一条 eval」,earlyExit 的跳过/abort 只应作用于
         // 同 key 的重试轮。experimentId 必须进 key:两个实验可以同 agent 同 model、只差
         // flags(feature A/B 正是这种形状),漏掉它会让先过的实验把其它实验的同名 eval
@@ -86,6 +131,16 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
           attempt: i,
           key,
           fingerprint: plannedFingerprints.get(cacheKey(run, evalDef.id)) ?? "",
+          // locator 在构造 fresh attempt plan 时即算好并作为身份贯穿执行、留存登记与落盘
+          // (不是完成后写回,见 docs/cli.md);裸 run(无 experimentId)不产出。
+          locator: run.experimentId
+            ? encodeAttemptLocator({
+                experimentId: run.experimentId,
+                snapshotStartedAt,
+                evalId: evalDef.id,
+                attempt: i,
+              })
+            : undefined,
         });
       }
     }
@@ -102,7 +157,7 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
       opts.config.judge,
     );
     if (toProbe.length > 0) {
-      process.stderr.write(t("runner.judgePrecheck"));
+      reportActivity(t("runner.judgePrecheck").trimEnd());
       for (const jc of toProbe) {
         const err = await probeJudge(jc, opts.signal);
         if (err) throw new Error(err);
@@ -112,7 +167,7 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
 
   if (carriedResults.length > 0) {
     const retryCount = new Set(attempts.map((a) => `${a.run.experimentId ?? ""}|${a.evalDef.id}`)).size;
-    process.stderr.write(t("runner.resumeCarry", { carried: carriedResults.length, retry: retryCount }));
+    reportActivity(t("runner.resumeCarry", { carried: carriedResults.length, retry: retryCount }).trimEnd());
     // 按 experiment 分组列出被复用(跳过)的 eval:不列清单的话,用户只看到数量,
     // 无法核对「跳过的是不是我以为已经过了的那些」。同一 key 多个 run 去重。
     const carriedByExperiment = new Map<string, Set<string>>();
@@ -122,7 +177,7 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
       carriedByExperiment.set(r.experimentId!, ids);
     }
     for (const [experiment, ids] of [...carriedByExperiment].sort(([a], [b]) => a.localeCompare(b))) {
-      process.stderr.write(t("runner.resumeCarryDetail", { experiment, evals: [...ids].sort().join(", ") }));
+      reportActivity(t("runner.resumeCarryDetail", { experiment, evals: [...ids].sort().join(", ") }).trimEnd());
     }
   }
 
@@ -135,6 +190,7 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
     configs: opts.agentRuns.length,
     totalRuns: attempts.length,
     maxConcurrency: opts.maxConcurrency,
+    snapshotStartedAt,
   };
   // eval 级 reporters:实例只观测引用它的 eval(经 scopeReporter 过滤转发)。
   // 已经挂在全局 reporters 里的同一实例不重复挂;同一实例被多个 eval 引用时合并观测集
@@ -142,29 +198,39 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
   const scopedSets = new Map<Reporter, Set<string>>();
   for (const e of opts.evals) {
     for (const r of e.reporters ?? []) {
-      if (opts.reporters.includes(r)) continue;
+      if (opts.reporters.some((reg) => reg.reporter === r)) continue;
       let ids = scopedSets.get(r);
       if (!ids) scopedSets.set(r, (ids = new Set()));
       ids.add(e.id);
     }
   }
-  const reporters: Reporter[] = [...opts.reporters];
+  const reporters: ReporterRegistration[] = [...opts.reporters];
+  // EvalDef.reporters 是用户在单个 eval 上挂的补充观测(如「这个 eval 单独也发一份到某个
+  // dashboard」),不是 CLI 显式注册的默认/机器出口——与 Config.reporters 同样默认
+  // best-effort(见 ReporterRegistration 的字段注释:required 只留给 artifacts / --json /
+  // --junit)。name 用「scope 内第几个」编号,足以在诊断里区分「哪一个 eval 级 reporter」,
+  // 不需要用户自己起名字。
+  let evalReporterIndex = 0;
   for (const [r, ids] of scopedSets) {
     const scopedRuns = attempts.filter((a) => ids.has(a.evalDef.id)).length;
     if (scopedRuns === 0) continue;
-    reporters.push(
-      scopeReporter(r, ids, {
+    reporters.push({
+      reporter: scopeReporter(r, ids, {
         evals: [...ids].filter((id) => runningIds.has(id)).length,
         configs: opts.agentRuns.length,
         totalRuns: scopedRuns,
         maxConcurrency: opts.maxConcurrency,
+        snapshotStartedAt,
       }),
-    );
+      name: `eval-reporter-${evalReporterIndex++}`,
+      required: false,
+    });
   }
 
-  for (const r of reporters) {
-    // reporter 只是结果消费方:单个 reporter 抛错记 diagnostic,不能让整次调度崩(P2)。
-    await runReporter("onRunStart", () => r.onRunStart?.(runningEvals, firstAgent as Agent, shape));
+  for (const reg of reporters) {
+    // reporter 只是结果消费方:单个 reporter 抛错记 diagnostic,不能让整次调度崩,也不阻断
+    // 其它 reporter 的必要收尾(required/best-effort 的判定权重在 runReporter 内部处理)。
+    await runReporter(reg, "onRunStart", () => reg.reporter.onRunStart?.(runningEvals, firstAgent as Agent, shape));
   }
   await emitReporterEvent(reporters, {
     type: "run:start",
@@ -178,26 +244,47 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
   // errored = 框架/环境层面的意外(超时、adapter 崩、eval 脚本抛异常……),不是 agent 表现的信号。
   // 同 key 一旦 errored 就会确定性地重复 error,再跑 runs 里剩下的次数纯烧钱;只有 failed(断言
   // 真的没过)才代表 agent 行为的样本,值得跑满 runs 去测通过率。earlyExit 开时两者都提前收尾。
-  const erroredKeys = new Set<string>();
+  // run 级 fail-fast(见 docs/runner.md「首过即停」):同一错误 code 在同一 key 连续复现
+  // 即判定确定性错误,停止派发受同一配置影响的后续 attempt(如实报 errored 的结果保留;
+  // 这是止损,不是「首过即停」,两个机制互不混用)。
+  const lastErrorCode = new Map<string, { code: string; streak: number }>();
+  const failFastKeys = new Map<string, { code: string; skipped: number }>();
+  // 携入的 passed 结果预置进 passedKeys:上面按序号回填的差额 attempt(carriedCount < run.runs
+  // 那部分)如果不预置这个,会在明明已经拿到过 passed 结果的情况下真的再调度一次 agent——
+  // earlyExit 的语义是「已知会通过就不用再跑」,携入的 passed 同样是「已知会通过」,理应同等对待
+  // (下面 preflight/body 的 earlyExit 判断本来就只在 a.run.earlyExit 为真时读这两个 Set,所以
+  // 这里无条件预置对 --no-early-exit 场景没有副作用)。携入的 failed 故意不预置——failed 本来
+  // 就不触发 earlyExit,回填的差额必须真的重跑,才对得起用户调大 runs 的意图(想看这次是不是
+  // 还失败,或想凑够 pass@N 的样本量)。
+  for (const r of carriedResults) {
+    if (r.verdict === "passed" && r.experimentId) {
+      passedKeys.add(`${r.experimentId}|${r.agent}|${r.model ?? ""}|${r.id}`);
+    }
+  }
 
   // budget 护栏:只按「已完成 attempt 的实测花费」判断,不做预测性节流。之前的实现会按
   // 「平均成本 × 在飞数」预扣,快到顶就让还没起飞的 attempt 排队等——这在探测阶段(还没有任何
   // 成本样本时)等价于把同一 budgetKey 的并发摁到一个很小的数,且完全没有文档承诺过这个副作用
-  // (`docs-site/zh/guides/write-experiment.mdx` 对 `budget` 的描述只有一句「这一格配置的预算
+  // (`docs-site/zh/how-to/write-experiment.mdx` 对 `budget` 的描述只有一句「这一格配置的预算
   // 上限」)。新语义:已完成 attempt 的花费加总一旦到顶,就不再放新 attempt 起飞(已经在飞的
   // 照常跑完,不会被中途打断);到顶之前不做任何预测性限流,并发完全由 globalSem / runSem 决定。
   // 代价是「已花 + 在飞未结算」的总花费可能短暂超出 budget——这是有意识的取舍:budget 是防止
   // 无限烧钱的安全网,不是精确计费闸,不应该反过来限制吞吐。
   interface BudgetState {
     spent: number;
-    completedNoCost: number;
+    /** 已经真正发起过 agent turn、但仍拿不到成本的 attempt 数。provider/setup 在 agent
+     *  运行前失败不计入——这种结果没有可执行的计费事实,不能据此声称 adapter 不报成本。 */
+    completedAgentRunsNoCost: number;
     unenforceableWarned: boolean;
+    /** 因这个 budgetKey 预算到顶而未派发的 attempt 累计数——反馈层 "budget-exhausted" 事件
+     *  (见 sink.ts 的 `BudgetExhaustedInput`)要求 emitter 自己维护这个累计值,reducer 不推导。 */
+    unstartedCount: number;
   }
   const budgetStates = new Map<string, BudgetState>();
   const budgetState = (key: string): BudgetState => {
     let s = budgetStates.get(key);
     if (!s) {
-      s = { spent: 0, completedNoCost: 0, unenforceableWarned: false };
+      s = { spent: 0, completedAgentRunsNoCost: 0, unenforceableWarned: false, unstartedCount: 0 };
       budgetStates.set(key, s);
     }
     return s;
@@ -265,9 +352,9 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
         // maxConcurrency)例外:它是实验私有资源,preflight 占着不影响别的实验,且和 mempal
         // 那类「必须串行」的语义一致,所以仍然把 preflight 包在 runSem 里面(见下方)。
         const preflight = Effect.gen(function* () {
-            // 首过即停:同 key 已通过,或已 errored(重跑只会重复同一个框架错误)且开了 earlyExit
-            // → 跳过未启动的 attempt。
-            if (a.run.earlyExit && (passedKeys.has(a.key) || erroredKeys.has(a.key))) {
+            // 首过即停:只由 passed 触发(errored 不中止其余样本,见 docs/feature/experiments/
+            // architecture.md「调度接口」)。
+            if (a.run.earlyExit && passedKeys.has(a.key)) {
               yield* reportMutex.withPermits(1)(
                 Effect.promise(() =>
                   emitReporterEvent(reporters, {
@@ -277,6 +364,33 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
                   }),
                 ),
               );
+              reportAttemptLifecycle({
+                type: "attempt:early-exit",
+                at: Date.now(),
+                identity: feedbackIdentity(a),
+                who: feedbackWho(a),
+              });
+              return false;
+            }
+
+            // run 级 fail-fast:确定性错误(同一 code 在同一 key 连续复现)已识别 → 停止派发,
+            // 未派发计入 unstarted(结论落 incomplete,不伪装成全绿;与首过即停互不混用)。
+            const failFast = failFastKeys.get(a.key);
+            if (failFast !== undefined) {
+              failFast.skipped += 1;
+              reportAttemptLifecycle({
+                type: "attempt:early-exit",
+                at: Date.now(),
+                identity: feedbackIdentity(a),
+                who: feedbackWho(a),
+              });
+              reportDiagnostic({
+                key: `fail-fast:${a.key}`,
+                severity: "warning",
+                message: t("runner.failFast", { evalId: a.evalDef.id, code: failFast.code }).trimEnd(),
+                identity: feedbackIdentity(a),
+                data: { evalId: a.evalDef.id, code: failFast.code, ...(a.run.experimentId ? { experimentId: a.run.experimentId } : {}) },
+              });
               return false;
             }
 
@@ -294,6 +408,21 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
                     ),
                   );
                 }
+                // 反馈层:对每一个因预算到顶而不派发的 attempt 各发一次(与上面的
+                // attempt:early-exit 同构),让 RunFeedbackState 的 queued/completed 计数与
+                // cli.ts 的 assembleRunCompletion() 都能感知到「有 attempt 因预算未派发」——
+                // 上面 emitReporterEvent 的 run:budgetExceeded 只对旧版 Reporter 接口每
+                // budgetKey 报一次,不满足反馈层「每个未派发 attempt 各一条」的计数契约,两者
+                // 独立并存。只在挂靠 experiment 时报(budget-exhausted 事件要求真实
+                // experimentId;裸 run 不产出这类永久事件,与 locator 的省略规则一致)。
+                if (a.run.experimentId) {
+                  s.unstartedCount += 1;
+                  reportBudgetExhausted({
+                    experimentId: a.run.experimentId,
+                    spent: s.spent,
+                    unstarted: s.unstartedCount,
+                  });
+                }
                 return false;
               }
             }
@@ -321,42 +450,114 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
                 }),
               ),
             );
+            // attempt:start 是这个 attempt 从 queued 移进 running 的唯一时刻(见
+            // src/runner/feedback/reducer.ts 的 attempt:start 分支),必须与 eval:start 同一
+            // 调用点、恰好发生一次 —— 否则 RunFeedbackState 的守恒计数会被破坏。phase 只是粗粒度
+            // 占位(sandbox 型 attempt 恒为 sandbox.queue,一定正确;非 sandbox 型给
+            // eval.run,attempt.ts 内部一旦跑到第一个真实边界会用 attempt:phase 立即纠正,见
+            // attempt.ts 的 enterPhase)——attempt.ts 自己不再发 attempt:start,只发
+            // attempt:phase,避免两处各发一次导致计数翻倍。
+            const initialPhase: LifecyclePhase = a.run.agent.kind === "sandbox" ? "sandbox.queue" : "eval.run";
+            reportAttemptLifecycle({
+              type: "attempt:start",
+              at: Date.now(),
+              identity: feedbackIdentity(a),
+              who: feedbackWho(a),
+              phase: initialPhase,
+            });
             const result = yield* runAttemptEffect(a, opts, sandboxSem, attemptSignal);
+            // locator 在这里确定 —— 早于本 attempt 触发的任何 reporter 回调 / 事件
+            // (onEvalComplete、eval:complete),所以每一个观察者看到的都已经是最终值,
+            // 和落盘 result.json 完全一致(writer.ts 的 entry.locator ?? 兜底分支因此
+            // 对 niceeval 自己的运行永不触发,只服务第三方直调 SnapshotWriter 的场景)。
+            // 没有 experimentId 的裸 run(非 exp 命令)不产出 locator,与
+            // writer.writeAttemptFor() 要求 experimentId 的既有约束一致 ——
+            // encodeAttemptLocator 本身也会在 experimentId 为空时直接抛错。
+            // 单独存一份本地变量(而不是只写 result.locator 再读回来):下面报 "failure" 永久
+            // 事件时需要一个已知是 AttemptLocator 品牌类型的值,result.locator 字段本身是
+            // 落盘/reporter 契约用的裸 string(见 EvalResult.locator 的类型注释)。
+            // locator 在 attempt plan 构造时已算好(见 attempts 构建处);这里只把同一个值写进
+            // 结果,早于本 attempt 触发的任何 reporter 回调 / 事件。
+            const locator: AttemptLocator | undefined = a.locator;
+            if (locator) result.locator = locator;
+            // attempt:complete 与上面的 attempt:start 严格一一配对(同一个 body Effect,唯一
+            // 出口),覆盖每一个真正跑过 runAttemptEffect 的 attempt(包括之后被下面的并发去重
+            // 分支丢弃、不计入 results 的那些)——reducer 的 attempt:complete 无条件
+            // running-1/completed+1,少配对一次就会让 running 计数漂移。
+            reportAttemptLifecycle({
+              type: "attempt:complete",
+              at: Date.now(),
+              identity: feedbackIdentity(a),
+              who: feedbackWho(a),
+              verdict: result.verdict,
+              tokenCount: result.usage
+                ? (result.usage.inputTokens ?? 0) + (result.usage.outputTokens ?? 0)
+                : undefined,
+              estimatedCostUSD: result.estimatedCostUSD,
+            });
             if (a.run.budget !== undefined) {
               const s = budgetState(budgetKey);
               if (result.estimatedCostUSD !== undefined) {
                 s.spent += result.estimatedCostUSD;
-              } else {
-                s.completedNoCost += 1;
-                if (s.spent === 0 && s.completedNoCost >= 3 && !s.unenforceableWarned) {
-                  // 连续几次完成都拿不到成本:budget 对这个 agent 不可执行,说清楚一次。
+              } else if (result.phases?.some((phase) => phase.children?.some((child) => child.kind === "turn"))) {
+                s.completedAgentRunsNoCost += 1;
+                if (s.spent === 0 && s.completedAgentRunsNoCost >= 3 && !s.unenforceableWarned) {
+                  // 连续几次真正跑过 agent 的 attempt 都拿不到成本:budget 对这个 agent
+                  // 不可执行,说清楚一次。sandbox.create/setup 等前置失败没有 turn,跳过这里:
+                  // 此时应由 attempt error 回答根因,不能再用计费 warning 抢走注意力。
+                  // s.unenforceableWarned 已经是 per-budgetKey 的一次性闸门;稳定 key 上的
+                  // reportDiagnostic 去重是双保险,不依赖它单独生效。
                   s.unenforceableWarned = true;
-                  writeStderrLine(t("runner.budgetUnenforceable", { budgetKey }));
+                  reportDiagnostic({
+                    key: `budget-unenforceable:${budgetKey}`,
+                    severity: "warning",
+                    message: t("runner.budgetUnenforceable", { budgetKey }).trimEnd(),
+                    data: { budgetKey },
+                  });
                 }
               }
             }
 
             if (result.verdict === "passed") {
               passedKeys.add(a.key);
+              lastErrorCode.delete(a.key);
               evalAc?.abort(); // 让同 key 并发 attempt 尽早退出
-            } else if (a.run.earlyExit && (passedKeys.has(a.key) || erroredKeys.has(a.key))) {
-              // 并发情况:同 key 另一个 attempt 已通过/已 errored 后本 attempt 才完成
-              // (被 abort 后产出 errored),不计入结果。
+            } else if (a.run.earlyExit && passedKeys.has(a.key)) {
+              // 并发情况:同 key 另一个 attempt 已通过后本 attempt 才完成(被 abort 后产出
+              // errored),不计入结果。
               return;
             } else if (result.verdict === "errored") {
-              erroredKeys.add(a.key);
-              evalAc?.abort(); // 框架层面的错误会确定性重复,让同 key 剩余 attempt 尽早退出
+              // errored 不中止其余样本(基建可能自愈);只有同一错误 code 连续复现才判定为
+              // 确定性错误,进 run 级 fail-fast 停止派发(不 abort 已在飞的 attempt)。
+              const code = result.error?.code ?? "unexpected-error";
+              const prev = lastErrorCode.get(a.key);
+              const streak = prev?.code === code ? prev.streak + 1 : 1;
+              lastErrorCode.set(a.key, { code, streak });
+              if (streak >= 2 && !failFastKeys.has(a.key)) {
+                failFastKeys.set(a.key, { code, skipped: 0 });
+              }
+            } else {
+              lastErrorCode.delete(a.key);
             }
 
             results.push(result);
+            // 反馈层的永久失败通知(见 sink.ts 的 FailureInput / docs/feature/experiments/
+            // cli.md「什么动态更新,什么逐条追加」表的「failed / errored + locator」行)——
+            // 只在拿到 locator 时报(裸 run 没有 locator,不产出这类事件,与上面 result.locator
+            // 的省略规则一致),且只报真正计入 results 的 attempt(上面的并发去重分支已经
+            // return 掉、不会走到这里,不会为一条被丢弃的重复 attempt 误报失败)。
+            if (locator) {
+              const failure = failureDetailFromResult(result);
+              if (failure) reportFailure(failure);
+            }
             yield* reportMutex.withPermits(1)(
               // 每个 reporter 单独兜错:一个写文件失败 / 自定义 reporter 抛错只记 diagnostic,
               // 不让 Promise.all 整体 reject —— 否则 Effect.promise 把它当 defect,fail 掉 forEach、
               // 停掉后续 attempt(P2)。
               Effect.promise(() =>
                 Promise.all(
-                  reporters.map((r) =>
-                    runReporter("onEvalComplete", () => r.onEvalComplete?.(result)),
+                  reporters.map((reg) =>
+                    runReporter(reg, "onEvalComplete", () => reg.reporter.onEvalComplete?.(result)),
                   ),
                 ),
               ),
@@ -399,7 +600,7 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
       throw Cause.squash(exit.cause);
     }
   }
-  if (interrupted) process.stderr.write(t("runner.interrupted"));
+  if (interrupted) reportInterrupted();
 
   // 稳定排序:按发现顺序 + attempt;携带结果并入后一起排
   const order = new Map(opts.evals.map((e, i) => [e.id, i]));
@@ -413,8 +614,13 @@ export async function runEvals(opts: RunOptions): Promise<RunSummary> {
 
   const summary = summarize(allResults, firstAgent?.name ?? "", startedAt, Date.now() - t0, opts.config.name);
   await emitReporterEvent(reporters, { type: "run:summary", summary });
-  for (const r of reporters) {
-    await runReporter("onRunComplete", () => r.onRunComplete?.(summary));
+  for (const reg of reporters) {
+    // required reporter(默认 artifacts、显式 --json/--junit)在这一步失败,不能中断其它
+    // reporter 的收尾——继续跑完剩下的循环,让每个 reporter 都拿到 onRunComplete 的机会;
+    // 失败本身经 runReporter → reportReporterError 折成诊断,由调用方(cli.ts)读取
+    // RunFeedbackState 组装成 RunCompletion,让最终 completion/退出码判红(见
+    // docs/feature/experiments/cli.md「运行完成状态不只看 verdict 计数」)。
+    await runReporter(reg, "onRunComplete", () => reg.reporter.onRunComplete?.(summary));
   }
   await emitReporterEvent(reporters, { type: "run:saved", summary });
   return summary;

package/src/runner/sandbox-prep.ts

@@ -1,9 +1,9 @@
-// 沙箱编排的固定段(对所有沙箱型 agent 一致):收集 workspace 文件、打 git 基线、
-// 跑完采 diff。adapter 只管中间「把 agent 跑起来」那一段。
+// 沙箱编排的固定段(对所有沙箱型 agent 一致):收集 workspace 文件。
+// 变更归因(私有 git ledger、send 窗口)见 ledger.ts;adapter 只管「把 agent 跑起来」那一段。
 
 import { readFile, readdir, stat } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
-import type { DiffData, Sandbox, SandboxFile } from "../types.ts";
+import type { SandboxFile } from "../types.ts";
 
 const IGNORE_DIRS = new Set([
   "node_modules",
@@ -50,42 +50,3 @@ export async function isDirectory(path: string): Promise<boolean> {
     return false;
   }
 }
-
-/** 打 git 基线:gitignore 掉依赖 / 构建产物,提交一版,供之后 diff HEAD 采改动。 */
-export async function initGitAndCommit(sandbox: Sandbox): Promise<void> {
-  await sandbox.writeFiles({
-    ".gitignore": "node_modules/\n.next/\ndist/\npackage-lock.json\n.niceeval/\n__niceeval__/\n",
-  });
-  await sandbox.runShell(
-    'git init -q && git config user.email "niceeval@localhost" && git config user.name "niceeval" && git add -A && git commit -q -m "baseline" || true',
-  );
-}
-
-/** git diff HEAD 采 agent 生成 / 删除的文件。 */
-export async function captureGeneratedFiles(sandbox: Sandbox): Promise<DiffData> {
-  const generatedFiles: Record<string, string> = {};
-  const deletedFiles: string[] = [];
-  try {
-    const res = await sandbox.runShell("git add -A && git diff HEAD --name-status");
-    const lines = res.stdout.trim().split("\n").filter(Boolean);
-    for (const line of lines) {
-      const tab = line.indexOf("\t");
-      if (tab === -1) continue;
-      const status = line.slice(0, tab).trim();
-      const path = line.slice(tab + 1).trim();
-      if (!path) continue;
-      if (status.startsWith("D")) {
-        deletedFiles.push(path);
-      } else {
-        try {
-          generatedFiles[path] = await sandbox.readFile(path);
-        } catch {
-          // 二进制 / 不可读跳过
-        }
-      }
-    }
-  } catch {
-    // 采集失败返回空
-  }
-  return { generatedFiles, deletedFiles };
-}