niceeval 0.5.3 → 0.6.0

package/src/runner/eval-source.ts

@@ -0,0 +1,45 @@
+// Eval 源码捕获:discovery 时读一次 eval 定义文件、归一化、算 SHA-256(定稿见
+// docs/concepts.md「标注 Eval 源码」、docs/feature/results/architecture.md「sources.json」)。
+//
+// 目标形态是"发现时捕获,同一快照内相同内容只存一份"——本函数只做捕获这一步(读 + 归一化 +
+// 哈希),不碰去重存储、不写 result.json、不改 discoverEvals()。它的产物形状是为了让后续
+// 集成把 `captureEvalSource(evalDef.sourcePath)` 直接插进 discoverEvals() 的每个文件循环里:
+// path/content 交给 writer 落盘(按 sha256 去重),sha256 也是 buildAnnotatedEvalSource()
+// 重建标注模型时用来核对"这就是同一份源码"的锚。
+//
+// 归一化 + 哈希算法住在 results/source-hash.ts,不在这里重新实现一遍——discovery 侧捕获的
+// 哈希与证据重建侧(annotated-source.ts)重算的哈希必须逐字节一致,唯一的办法是共用同一个
+// 函数。runner 已经单向依赖 results(reporters/artifacts.ts 用 createResultsWriter),这里
+// 反向引用不新增循环。
+
+import { readFile } from "node:fs/promises";
+import { relative, sep } from "node:path";
+import { hashEvalSource, normalizeEvalSource } from "../results/source-hash.ts";
+
+export interface CapturedEvalSource {
+  /** 项目相对路径(正斜杠),与 SourceArtifact.path / SourceLoc.file 同一约定。 */
+  path: string;
+  /** 归一化后的源码文本(去 BOM、CRLF/CR 统一成 LF)。 */
+  content: string;
+  /** 归一化文本的 SHA-256 十六进制摘要;同一份内容(哪怕跨平台不同换行符)恒相同。 */
+  sha256: string;
+}
+
+/**
+ * 读一个 eval 定义文件、归一化文本、算哈希。`filePath` 是绝对路径(discoverEvals() 里
+ * `DiscoveredEval.sourcePath` 的形状);`opts.root` 决定 `path` 字段相对谁计算,省略时
+ * 用 `process.cwd()`(与 src/source-loc.ts 的 captureLoc()、runner/attempt.ts 的
+ * collectSources() 同一约定——项目相对路径永远相对进程 cwd,不是相对 discoverEvals() 的
+ * `root` 参数,两者通常相同但不保证,显式传参让调用方按需要覆盖,也让单测不依赖真实 cwd)。
+ *
+ * 读不到文件(已删除 / 权限问题)如实抛错——发现阶段的源码文件应当总是可读,
+ * 与 collectSources() 运行后"读不到就跳过"的降级语义不同:那时源码可能已经在沙箱里、
+ * 已被清理;这里读的是刚刚 import 成功的同一个文件,读不到是需要暴露的异常。
+ */
+export async function captureEvalSource(filePath: string, opts?: { root?: string }): Promise<CapturedEvalSource> {
+  const root = opts?.root ?? process.cwd();
+  const raw = await readFile(filePath, "utf-8");
+  const content = normalizeEvalSource(raw);
+  const path = relative(root, filePath).split(sep).join("/");
+  return { path, content, sha256: hashEvalSource(content) };
+}

package/src/runner/fingerprint.ts

@@ -4,7 +4,7 @@
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { sandboxLabel } from "../sandbox/resolve.ts";
-import type { DiscoveredEval } from "../types.ts";
+import type { DiscoveredEval, EvalResult } from "../types.ts";
 import type { AgentRun } from "./types.ts";
 
 export function cacheKey(run: AgentRun, evalId: string): string {
@@ -47,6 +47,59 @@ export async function computeFingerprint(
   return createHash("sha256").update(stableJson(payload)).digest("hex");
 }
 
+export interface CarryPlan {
+  /** `cacheKey(run, evalId)` → 本次规划出的指纹,供调用方按同一口径判断"这条要不要携入"。 */
+  plannedFingerprints: Map<string, string>;
+  /** 命中携入条件(passed/failed 终态 + 指纹匹配)的 `${experimentId}|${evalId}` 集合。 */
+  priorRunKeys: Set<string>;
+  /** priorRunKeys 对应的完整结果对象,供 run.ts 直接并入 summary、cli.ts 直接取 verdict 展示。 */
+  carriedResults: EvalResult[];
+}
+
+/**
+ * 算出这一批 (agentRun × eval) 的指纹,并据此从 priorResults 里筛出可以携入(跳过重跑)的结果。
+ * run.ts 与 cli.ts(live 表格构建)必须共用这同一份计算 —— 否则两边一旦对"哪些携入"的判断
+ * 不一致,live 表格就会显示"还在等名额",而 run.ts 其实已经把它筛掉、根本不会调度这个 attempt
+ * (见 memory 的 live-carry-row-shows-waiting-forever)。
+ */
+export async function planCarry(
+  evals: DiscoveredEval[],
+  agentRuns: AgentRun[],
+  priorResults: EvalResult[] | undefined,
+): Promise<CarryPlan> {
+  const sourceCache = new Map<string, Promise<string>>();
+  const plannedFingerprints = new Map<string, string>();
+  const jobs: Promise<void>[] = [];
+  for (const run of agentRuns) {
+    for (const evalDef of evals.filter((e) => run.evalFilter(e.id))) {
+      jobs.push(
+        computeFingerprint(evalDef, run, sourceCache).then((fp) => {
+          plannedFingerprints.set(cacheKey(run, evalDef.id), fp);
+        }),
+      );
+    }
+  }
+  await Promise.all(jobs);
+
+  const priorRunKeys = new Set<string>();
+  const carriedResults: EvalResult[] = [];
+  if (priorResults?.length) {
+    for (const r of priorResults) {
+      if (!r.experimentId) continue;
+      const key = `${r.experimentId}|${r.id}`;
+      const isTerminalVerdict = r.verdict === "passed" || r.verdict === "failed";
+      if (isTerminalVerdict && r.fingerprint !== undefined && r.fingerprint === plannedFingerprints.get(key)) {
+        priorRunKeys.add(key);
+      }
+    }
+    for (const r of priorResults) {
+      if (!r.experimentId || !priorRunKeys.has(`${r.experimentId}|${r.id}`)) continue;
+      carriedResults.push(r);
+    }
+  }
+  return { plannedFingerprints, priorRunKeys, carriedResults };
+}
+
 /** 键序稳定的 JSON 序列化(对象键排序),保证同一 payload 永远同一指纹。 */
 function stableJson(value: unknown): string {
   if (value === null || typeof value !== "object") return JSON.stringify(value);

package/src/runner/remote-sandbox.ts

@@ -46,7 +46,7 @@ export function withEvalLocalPaths(sandbox: Sandbox, baseDir: string): Sandbox {
           target.uploadDirectory(resolveLocalPath(baseDir, localDir), targetDir, opts);
       }
       const value = Reflect.get(target, prop, receiver);
-      // 方法要 bind 回原对象:后端实现(class 实例)里的 this 不能指向 Proxy。
+      // 方法要 bind 回原对象:provider 实现(class 实例)里的 this 不能指向 Proxy。
       return typeof value === "function" ? value.bind(target) : value;
     },
   });

package/src/runner/report.test.ts

@@ -6,7 +6,7 @@ function result(id: string, overrides: Partial<EvalResult> = {}): EvalResult {
   return {
     id,
     agent: "codex",
-    outcome: "passed",
+    verdict: "passed",
     attempt: 0,
     durationMs: 1000,
     assertions: [],
@@ -19,21 +19,20 @@ function summary(results: EvalResult[]): RunSummary {
     agent: "codex",
     startedAt: "2026-07-07T00:00:00.000Z",
     completedAt: "2026-07-07T00:01:00.000Z",
-    passed: results.filter((r) => r.outcome === "passed").length,
-    failed: results.filter((r) => r.outcome === "failed").length,
+    passed: results.filter((r) => r.verdict === "passed").length,
+    failed: results.filter((r) => r.verdict === "failed").length,
     skipped: 0,
     errored: 0,
     durationMs: 60_000,
     results,
-    outputDir: ".niceeval/x",
   };
 }
 
 describe("filterSummary", () => {
-  it("按 eval id 过滤结果并重新计数,保留原 completedAt / outputDir", () => {
+  it("按 eval id 过滤结果并重新计数,保留原 completedAt", () => {
     const s = summary([
       result("a/1", { usage: { inputTokens: 10, outputTokens: 5 }, estimatedCostUSD: 0.1 }),
-      result("a/1", { outcome: "failed", attempt: 1 }),
+      result("a/1", { verdict: "failed", attempt: 1 }),
       result("b/1", { usage: { inputTokens: 100, outputTokens: 50 }, estimatedCostUSD: 1 }),
     ]);
     const sub = filterSummary(s, new Set(["a/1"]));
@@ -43,7 +42,6 @@ describe("filterSummary", () => {
     expect(sub.usage).toEqual({ inputTokens: 10, outputTokens: 5 });
     expect(sub.estimatedCostUSD).toBe(0.1);
     expect(sub.completedAt).toBe("2026-07-07T00:01:00.000Z");
-    expect(sub.outputDir).toBe(".niceeval/x");
   });
 });
 
@@ -81,7 +79,7 @@ describe("scopeReporter", () => {
   it("onRunComplete 收到重新计数的子集汇总", async () => {
     const { calls, reporter } = recordingReporter();
     const scoped = scopeReporter(reporter, new Set(["a/1"]));
-    await scoped.onRunComplete?.(summary([result("a/1"), result("b/1", { outcome: "failed" })]));
+    await scoped.onRunComplete?.(summary([result("a/1"), result("b/1", { verdict: "failed" })]));
     const got = calls[0]?.args[0] as RunSummary;
     expect(got.results.map((r) => r.id)).toEqual(["a/1"]);
     expect(got.passed).toBe(1);

package/src/runner/report.ts

@@ -4,13 +4,14 @@
 import type { EvalResult, LocalizedText, Reporter, ReporterEvent, RunShape, RunSummary } from "../types.ts";
 import { t } from "../i18n/index.ts";
 import { formatThrown } from "../util.ts";
+import { writeStderrLine } from "../tty-line.ts";
 
 /** reporter 调用的统一兜错。返回 void,永不 reject(供 Promise.all 安全聚合)。 */
 export async function runReporter(stage: string, fn: () => unknown): Promise<void> {
   try {
     await fn();
   } catch (e) {
-    process.stderr.write(t("runner.reporterDiagnostic", { stage, message: formatThrown(e) }));
+    writeStderrLine(t("runner.reporterDiagnostic", { stage, message: formatThrown(e) }));
   }
 }
 
@@ -22,7 +23,7 @@ export async function emitReporterEvent(reporters: readonly Reporter[], event: R
 export function filterSummary(summary: RunSummary, ids: ReadonlySet<string>): RunSummary {
   const results = summary.results.filter((r) => ids.has(r.id));
   const sub = summarize(results, summary.agent, summary.startedAt, summary.durationMs, summary.name);
-  // completedAt 用原值(summarize 会重新取 now);format / producer / outputDir 等元数据原样保留。
+  // completedAt 用原值(summarize 会重新取 now);name 等其余字段原样保留。
   return { ...summary, ...sub, completedAt: summary.completedAt };
 }
 
@@ -69,7 +70,7 @@ export function scopeReporter(r: Reporter, ids: ReadonlySet<string>, shape?: Run
   return scoped;
 }
 
-/** 全局汇总:outcome 计数 + token / cost 折叠。按 attempt 计(eval 级折叠见 shared/outcome.ts)。 */
+/** 全局汇总:verdict 计数 + token / cost 折叠。按 attempt 计(eval 级折叠见 shared/verdict.ts)。 */
 export function summarize(
   results: EvalResult[],
   agent: string,
@@ -82,7 +83,7 @@ export function summarize(
   let outTok = 0;
   let cost = 0;
   for (const r of results) {
-    counts[r.outcome] += 1;
+    counts[r.verdict] += 1;
     inTok += r.usage?.inputTokens ?? 0;
     outTok += r.usage?.outputTokens ?? 0;
     cost += r.estimatedCostUSD ?? 0;

package/src/runner/reporters/artifacts.ts

@@ -1,13 +1,14 @@
-// 默认本地工件报告器:给 `niceeval view` 提供稳定的离线输入。
+// 默认本地 artifact 报告器:给 `niceeval view` 提供稳定的离线输入。
 //
-// 本文件是 niceeval/results 写入面(createRunWriter)的薄壳:订阅 reporter 事件转手调 writer,
-// 自己不持有任何布局知识(时间戳目录、attempt 路径、大字段拆分、瘦身、版本元数据都在库内)。
-// 落盘格式见 docs/results-format.md;每 eval-attempt 一个文件夹,重数据分文件,
-// summary.json 只留榜单元数据,view 展开某条 trace 时再按需 fetch 它的 trace.json。
+// 本文件是 niceeval/results 写入面(createResultsWriter)的薄壳:订阅 reporter 事件按
+// experimentId 路由转手调 writer,自己不持有任何布局知识(实验目录、快照目录、attempt
+// 路径清洗、大字段拆分、瘦身、版本元数据全在库内)。落盘格式见 docs/feature/results/architecture.md:
+// 每个 experiment 一个实验目录,目录下按时间戳开快照,快照内每 eval-attempt 一个文件夹,
+// 重数据分文件,snapshot.json 只留快照元数据,view 展开某条 trace 时再按需 fetch 它的 trace.json。
 
 import { readFile } from "node:fs/promises";
 import type { Reporter } from "../../types.ts";
-import { createRunWriter, type RunWriter } from "../../results/writer.ts";
+import { createResultsWriter, type ResultsWriter } from "../../results/writer.ts";
 
 /** niceeval 自身的 npm 版本,写进 producer.version;版本不匹配时读取器靠它拼 npx 提示。 */
 let producerVersionPromise: Promise<string | undefined> | undefined;
@@ -18,53 +19,38 @@ function producerVersion(): Promise<string | undefined> {
   return producerVersionPromise;
 }
 
-/** Artifacts 报告器额外暴露输出目录:CLI 在 run 结束时打出 summary.json 路径给 agent 直读。 */
-export type ArtifactsReporter = Reporter & { outputDir(): string };
+/** Artifacts 报告器额外暴露已创建的快照目录清单:CLI 在 run 结束时逐条打出给 agent 直读。 */
+export type ArtifactsReporter = Reporter & { outputDirs(): { experimentId: string; dir: string }[] };
 
 export function Artifacts(root = ".niceeval"): ArtifactsReporter {
-  let writer: Promise<RunWriter> | undefined;
-  let dir = "";
-  const ensureWriter = (): Promise<RunWriter> => {
-    writer ??= (async () => {
-      const w = await createRunWriter(root, {
-        producer: { name: "niceeval", version: await producerVersion() },
-      });
-      dir = w.dir;
-      return w;
-    })();
-    return writer;
-  };
+  let writer: ResultsWriter | undefined;
 
   return {
-    outputDir: () => dir,
+    outputDirs: () => writer?.snapshotDirs() ?? [],
 
     async onRunStart() {
-      // 每次 run 开一个新的时间戳目录(同一个 reporter 实例可能被复用)。
-      writer = undefined;
-      await ensureWriter();
+      // 每次 run 换一个新 writer(同一个 reporter 实例可能被复用):writer 内部按
+      // experimentId 懒建各自的快照目录,这里只重置引用。
+      writer = createResultsWriter(root, {
+        producer: { name: "niceeval", version: await producerVersion() },
+      });
     },
 
-    // 每条结果一出来就把它的重数据落到自己的文件夹(增量、互不影响)。
-    // runner 的条目自带 agent / model / experimentId / startedAt(且存在无 experiment 的
-    // 普通 run),不经 snapshot() 声明,走 writer 的内部增量入口。
+    // 每条结果一出来就按它的 experimentId 路由落盘(增量、互不影响)。fresh 条目在这里
+    // 一次写成;--resume 携带合入的条目(带 artifactBase)不经这里,onRunComplete 补写。
     async onEvalComplete(result) {
-      await (await ensureWriter()).writeAttemptArtifacts(result);
+      await writer?.writeAttemptFor(result);
     },
 
-    // run 结束写瘦身 summary.json:携带条目(--resume 合入)与最终排序只有调度器知道,
-    // 权威 results 经 overrides 交给 writer,瘦身与版本元数据注入都在库内发生。
+    // run 结束:先把携带条目(--resume 合入,summary.results 里带 artifactBase 的那些)
+    // 逐条落盘——它们没有触发过 onEvalComplete,只会原样写 result.json,不写 artifact
+    // (artifact 仍在原快照里,靠 artifactBase 懒加载回退)。再给每个快照补 completedAt。
     async onRunComplete(summary) {
-      await (await ensureWriter()).finish({
-        ...(summary.name !== undefined ? { name: summary.name } : {}),
-        agent: summary.agent,
-        ...(summary.model !== undefined ? { model: summary.model } : {}),
-        startedAt: summary.startedAt,
-        completedAt: summary.completedAt,
-        durationMs: summary.durationMs,
-        ...(summary.usage !== undefined ? { usage: summary.usage } : {}),
-        ...(summary.estimatedCostUSD !== undefined ? { estimatedCostUSD: summary.estimatedCostUSD } : {}),
-        results: summary.results,
-      });
+      if (!writer) return;
+      for (const result of summary.results) {
+        if (result.artifactBase !== undefined) await writer.writeAttemptFor(result);
+      }
+      await writer.finish({ name: summary.name });
     },
   };
 }

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

@@ -6,7 +6,7 @@ function baseResult(overrides: Partial<EvalResult> = {}): EvalResult {
   return {
     id: "algebra/quadratic",
     agent: "codex",
-    outcome: "passed",
+    verdict: "passed",
     attempt: 0,
     durationMs: 42_000,
     assertions: [],
@@ -84,7 +84,7 @@ describe("toBraintrustEvent", () => {
         experimentId: "compare/codex",
         model: "gpt-5.2",
         attempt: 1,
-        outcome: "failed",
+        verdict: "failed",
         experiment: { id: "compare/codex", flags: { tape: true } },
         assertions: [{ name: "compiles", severity: "gate", score: 0, passed: false, detail: "tsc failed" }],
       }),
@@ -93,7 +93,7 @@ describe("toBraintrustEvent", () => {
       eval: "algebra/quadratic",
       agent: "codex",
       attempt: 1,
-      outcome: "failed",
+      verdict: "failed",
       model: "gpt-5.2",
       experiment: "compare/codex",
       flags: { tape: true },

package/src/runner/reporters/braintrust.ts

@@ -146,7 +146,7 @@ export function toBraintrustEvent(result: EvalResult): BraintrustLogEvent {
     eval: result.id,
     agent: result.agent,
     attempt: result.attempt,
-    outcome: result.outcome,
+    verdict: result.verdict,
   };
   if (result.model !== undefined) metadata.model = result.model;
   if (result.experimentId !== undefined) metadata.experiment = result.experimentId;

package/src/runner/reporters/console.ts

@@ -3,7 +3,7 @@
 import type { EvalResult, Reporter, RunSummary } from "../../types.ts";
 import { t } from "../../i18n/index.ts";
 import { formatCost, formatDuration, formatTokens, renderRunReport } from "./table.ts";
-import { outcomeSymbol } from "./shared.ts";
+import { verdictSymbol } from "./shared.ts";
 
 export function Console(): Reporter {
   return {
@@ -18,14 +18,14 @@ export function Console(): Reporter {
       process.stdout.write(t("report.runStart", { count: n, extra, concurrency: shape?.maxConcurrency ?? "?" }));
     },
     onEvalComplete(result: EvalResult) {
-      const sym = outcomeSymbol(result.outcome);
+      const sym = verdictSymbol(result.verdict);
       const tok = (result.usage?.inputTokens ?? 0) + (result.usage?.outputTokens ?? 0);
       // requests > 0 但 tokens = 0 → agent 跑了但不上报用量(如 bub);显示 — 而非误导性的 0
       const tokStr = tok > 0 ? `${formatTokens(tok)} tok` : (result.usage?.requests ?? 0) > 0 ? `— tok` : `0 tok`;
       const cost = result.estimatedCostUSD !== undefined ? `  ${formatCost(result.estimatedCostUSD)}` : "";
       const who = result.model ? `${result.agent}/${result.model}` : result.agent;
       const meta = `(${formatDuration(result.durationMs)}  ${tokStr}${cost})`;
-      const label = result.outcome === "passed" ? "" : ` ${formatOutcome(result.outcome)}`;
+      const label = result.verdict === "passed" ? "" : ` ${formatVerdict(result.verdict)}`;
       process.stdout.write(`  ${sym} ${result.id}${label}  [${who}]  ${meta}\n`);
 
       if (result.skipReason) {
@@ -55,13 +55,13 @@ export function Console(): Reporter {
   };
 }
 
-function formatOutcome(outcome: string): string {
-  switch (outcome) {
+function formatVerdict(verdict: string): string {
+  switch (verdict) {
     case "passed": return t("report.passed");
     case "failed": return t("report.failed");
     case "errored": return t("report.errored");
     case "skipped": return t("report.skipped");
-    default: return outcome;
+    default: return verdict;
   }
 }
 

package/src/runner/reporters/json.ts

@@ -1,4 +1,4 @@
-// JSON / JUnit 报告器:把运行结果落成机器可读工件,接 CI 或下游 dashboard。
+// JSON / JUnit 报告器:把运行结果落成机器可读 artifact,接 CI 或下游 dashboard。
 
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
@@ -21,14 +21,14 @@ export function JUnit(path: string): Reporter {
         .map((r) => {
           const name = xmlAttr(`${r.id} [${r.agent}${r.model ? "/" + r.model : ""}]`);
           const time = (r.durationMs / 1000).toFixed(3);
-          if (r.outcome === "errored") {
+          if (r.verdict === "errored") {
             return `    <testcase name="${name}" time="${time}"><error message="${xmlAttr(r.error ?? "execution error")}"/></testcase>`;
           }
-          if (r.outcome === "failed") {
+          if (r.verdict === "failed") {
             const msg = xmlAttr(r.assertions.filter((a) => !a.passed).map((a) => a.name).join("; "));
             return `    <testcase name="${name}" time="${time}"><failure message="${msg}"/></testcase>`;
           }
-          if (r.outcome === "skipped") {
+          if (r.verdict === "skipped") {
             return `    <testcase name="${name}" time="${time}"><skipped message="${xmlAttr(r.skipReason ?? "")}"/></testcase>`;
           }
           return `    <testcase name="${name}" time="${time}"/>`;

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

@@ -0,0 +1,56 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { Live, type LiveRow } from "./live.ts";
+
+function withMockTty<T>(fn: () => T): { writes: string[]; result: T } {
+  const writes: string[] = [];
+  vi.spyOn(process.stderr, "write").mockImplementation((chunk: unknown) => {
+    writes.push(String(chunk));
+    return true;
+  });
+  Object.defineProperty(process.stderr, "isTTY", { value: true, configurable: true });
+  Object.defineProperty(process.stderr, "columns", { value: 120, configurable: true });
+  Object.defineProperty(process.stderr, "rows", { value: 40, configurable: true });
+  return { writes, result: fn() };
+}
+
+describe("Live carried rows", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("renders a carried row as already-done from the first frame, not waiting for a slot", () => {
+    const rows: LiveRow[] = [
+      { evalId: "memory/carried-fail", who: "codex-e2b", total: 1, carriedVerdict: "failed" },
+      { evalId: "memory/fresh", who: "codex-e2b", total: 1 },
+    ];
+    const live = Live(rows, 2);
+
+    const { writes } = withMockTty(() => {
+      live.onRunStart?.([], { name: "codex", kind: "sandbox" } as never, {
+        evals: 2,
+        configs: 1,
+        totalRuns: 1,
+        maxConcurrency: 5,
+      });
+    });
+    vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+    live.onRunComplete?.({
+      startedAt: "",
+      finishedAt: "",
+      durationMs: 0,
+      results: [],
+      totalRuns: 1,
+    } as never);
+
+    const out = writes.join("");
+    const carriedLine = out.split("\n").find((l) => l.includes("memory/carried-fail"));
+    const freshLine = out.split("\n").find((l) => l.includes("memory/fresh"));
+
+    expect(carriedLine).toBeDefined();
+    expect(carriedLine).toContain("✗");
+    expect(carriedLine).not.toContain("waiting");
+
+    expect(freshLine).toBeDefined();
+    expect(freshLine).toContain("waiting");
+  });
+});

package/src/runner/reporters/live.ts

@@ -5,7 +5,9 @@
 import type { Reporter, ReporterEvent, RunShape, RunSummary } from "../../types.ts";
 import { t } from "../../i18n/index.ts";
 import { renderRunReport } from "./table.ts";
-import { outcomeSymbol, WAITING_SYM } from "./shared.ts";
+import { verdictSymbol, WAITING_SYM } from "./shared.ts";
+import { runWho } from "../types.ts";
+import { onBeforeExternalTerminalWrite } from "../../tty-line.ts";
 
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
@@ -31,6 +33,13 @@ export interface LiveRow {
   who: string;
   /** 该 (evalId, who) 对的总 attempt 数(含 earlyExit 估算值)。 */
   total: number;
+  /**
+   * 设置时表示这一行从第一帧起就是携入(carry)的结果,不会真的调度 attempt——直接按这个
+   * verdict 渲染成已完成,不经过 waiting → spinner 的过程。没有它,carry 掉的行会卡在
+   * "waiting for a slot"直到进程退出:它永远等不到 eval:start,因为 run.ts 压根不会为
+   * 它派发 attempt。
+   */
+  carriedVerdict?: string;
 }
 
 export interface LiveReporter extends Reporter {
@@ -41,7 +50,7 @@ export interface LiveReporter extends Reporter {
 interface RowState extends LiveRow {
   completed: number;
   lastMsg: string;
-  dominantOutcome: string | undefined;
+  dominantVerdict: string | undefined;
   /** true 一旦拿到并发名额、attempt effect 真正开始跑;之前是排队等待,不该转圈误导。 */
   started: boolean;
 }
@@ -49,12 +58,21 @@ interface RowState extends LiveRow {
 export function Live(rows: LiveRow[], totalAttempts: number): LiveReporter {
   const stateMap = new Map<string, RowState>();
   const keyOrder: string[] = [];
+  let totalCompleted = 0;
 
   for (const r of rows) {
     const k = `${r.evalId}|${r.who}`;
     if (!stateMap.has(k)) {
-      stateMap.set(k, { ...r, completed: 0, lastMsg: "", dominantOutcome: undefined, started: false });
+      const carried = r.carriedVerdict !== undefined;
+      stateMap.set(k, {
+        ...r,
+        completed: carried ? r.total : 0,
+        lastMsg: "",
+        dominantVerdict: r.carriedVerdict,
+        started: carried,
+      });
       keyOrder.push(k);
+      if (carried) totalCompleted += r.total;
     } else {
       // 同一 (evalId, who) 可能在多个 agentRun 里出现(不应发生,但做防御)
       stateMap.get(k)!.total += r.total;
@@ -62,17 +80,17 @@ export function Live(rows: LiveRow[], totalAttempts: number): LiveReporter {
   }
 
   let spinFrame = 0;
-  let totalCompleted = 0;
   let drawnLines = 0; // 上次 draw() 写了多少行,用于 \x1B[nA 回跳
   let intervalId: ReturnType<typeof setInterval> | undefined;
   let shape: RunShape | undefined;
+  let unsubscribeExternalWrite: (() => void) | undefined;
 
   const cols = () => process.stderr.columns || 100;
 
   function renderRow(state: RowState, frame: number): string {
     const done = state.completed >= state.total;
     const sym = done
-      ? outcomeSymbol(state.dominantOutcome ?? "")
+      ? verdictSymbol(state.dominantVerdict ?? "")
       : state.started
         ? SPINNER[frame % SPINNER.length]
         : WAITING_SYM;
@@ -176,13 +194,17 @@ export function Live(rows: LiveRow[], totalAttempts: number): LiveReporter {
 
     onEvent(event: ReporterEvent) {
       if (event.type !== "eval:start") return;
-      const who = event.model ? `${event.agent.name}/${event.model}` : event.agent.name;
+      const who = runWho({ agentName: event.agent.name, model: event.model, experimentId: event.experimentId });
       const state = stateMap.get(`${event.eval.id}|${who}`);
       if (state) state.started = true;
     },
 
     onRunStart(_evals, _agent, s) {
       shape = s;
+      // sandbox teardown 失败、budget 不可执行这类独立诊断行可能绕开 progress()/onEvalComplete
+      // 直接落地(见 tty-line.ts)。订阅后先把已画的表格清掉、drawnLines 归零,下一帧从新起点
+      // 重画,不然回跳量和实际光标错位,越滚越多。
+      unsubscribeExternalWrite = onBeforeExternalTerminalWrite(() => clearDisplay());
       // 初始渲染:让用户看到行表
       draw(0);
       intervalId = setInterval(() => {
@@ -192,14 +214,14 @@ export function Live(rows: LiveRow[], totalAttempts: number): LiveReporter {
     },
 
     onEvalComplete(result) {
-      const who = result.model ? `${result.agent}/${result.model}` : result.agent;
+      const who = runWho({ agentName: result.agent, model: result.model, experimentId: result.experimentId });
       const state = stateMap.get(`${result.id}|${who}`);
       if (state) {
         state.completed += 1;
         totalCompleted += 1;
-        const prev = state.dominantOutcome;
-        if (!prev || (prev === "passed" && result.outcome !== "passed")) {
-          state.dominantOutcome = result.outcome;
+        const prev = state.dominantVerdict;
+        if (!prev || (prev === "passed" && result.verdict !== "passed")) {
+          state.dominantVerdict = result.verdict;
         }
       } else {
         totalCompleted += 1;
@@ -211,6 +233,10 @@ export function Live(rows: LiveRow[], totalAttempts: number): LiveReporter {
         clearInterval(intervalId);
         intervalId = undefined;
       }
+      if (unsubscribeExternalWrite) {
+        unsubscribeExternalWrite();
+        unsubscribeExternalWrite = undefined;
+      }
       // 最后刷一帧(所有行都 done)
       draw(spinFrame);
       clearDisplay();