niceeval 0.10.3-canary.6 → 0.11.0

package/src/runner/feedback/human.ts

@@ -20,7 +20,7 @@ import { t } from "../../i18n/index.ts";
 import { verdictSymbol } from "../reporters/shared.ts";
 import { formatCost } from "../../shared/format.ts";
 import { assertionSummaryLines } from "../../scoring/display.ts";
-import { encodeAttemptKey } from "../types.ts";
+import { encodeAttemptKey, HALT_DIAGNOSTIC_CODE } from "../types.ts";
 import {
   panelCapabilityOf as panelCapability,
   panelContentWidth,
@@ -32,6 +32,7 @@ import { stringWidth } from "../../report/model/text-layout.ts";
 import type {
   ActiveAttempt,
   ActiveExperimentHook,
+  ActiveLockWait,
   ActivePrecheck,
   AttemptKey,
   ExperimentHookName,
@@ -140,6 +141,40 @@ export function renderDurableLines(
       const duration = event.durationMs !== undefined ? ` (${formatElapsed(event.durationMs)})` : "";
       return [`${t("feedback.human.precheckJudgeDone")}${duration}`];
     }
+    case "lock-wait": {
+      // 只服务非 TTY 退化流(TTY dashboard 的 appendDurable 对这个事件直接返回,运行级行由
+      // state.lockWaits 驱动,不进 scrollback,见 cli.md「等待并发 run 的显示」)。按实验聚合
+      // ——同一实验可能有多个用例先后撞锁,只在这个「有等待用例」窗口第一次打开(这是当前
+      // 唯一一条等待中的用例)与最后一次关闭(等待全部解决)各打印一行,中途加入/解决的用例
+      // 不逐条刷屏,与诊断按 dedupeKey 折叠同一种克制(state 已经是这条事件 reduce 之后的
+      // 快照,size 天然反映"这条事件之后"的计数)。
+      const agg = state.lockWaits.get(event.experimentId);
+      if (event.status === "started") {
+        if (!agg || agg.waiting.size !== 1) return []; // 不是这个窗口的第一条,静默
+        const holder = agg.waiting.get(event.evalId);
+        return [
+          t("feedback.human.lockWaitStarted", {
+            experimentId: event.experimentId,
+            count: agg.waiting.size,
+            pid: holder?.holderPid ?? "?",
+          }),
+        ];
+      }
+      if (!agg || agg.waiting.size !== 0) return []; // 窗口还没关闭,静默
+      const parts: string[] = [];
+      if (agg.resolvedCarried > 0) parts.push(t("feedback.human.lockWaitCarried", { count: agg.resolvedCarried }));
+      if (agg.resolvedDispatched > 0) {
+        parts.push(t("feedback.human.lockWaitDispatched", { count: agg.resolvedDispatched }));
+      }
+      const summary = parts.length > 0 ? parts.join(" · ") : t("feedback.human.lockWaitCarried", { count: 0 });
+      return [
+        t("feedback.human.lockWaitResolved", {
+          experimentId: event.experimentId,
+          summary,
+          elapsed: formatElapsed(event.waitedMs ?? 0),
+        }),
+      ];
+    }
     case "summary":
       return buildSummaryLines(event, state, panel);
     case "saved":
@@ -208,8 +243,27 @@ function buildDiagnosticLines(event: DurableFeedbackEvent & { type: "diagnostic"
   // count 从 state.diagnostics 读(reducer 已经按 key 去重累加),不在这里自己维护第二份计数。
   const count = state.diagnostics.find((d) => d.key === event.key)?.count ?? 1;
   const sym = event.severity === "error" ? "✗" : "!";
+  if (event.code === HALT_DIAGNOSTIC_CODE) {
+    // 止损闸落闸:一行 error 级通知,文案已经是完整的一句话(`experiment halted
+    // (dispatch-halted): <message>` / `eval halted: <message>`,见 docs/feature/
+    // error-classification/architecture.md「观察面」),不再加标题行、也不加 ×N 后缀——
+    // emitter 对每条未派发 attempt 都刷一次这条诊断以更新 data.unstarted,逐次打印就是
+    // 同一页文档明令禁止的「被中止的等待集 attempt 逐条刷屏」;未派发的数量由完成状态的
+    // `unstarted` 回答,不在这行重复。因此只在第一次出现时落一行(与 json profile 的
+    // isFirstOccurrence 同一条去重纪律)。
+    if (count > 1) return [];
+    return [`${sym} ${event.message}`];
+  }
+  // 标题用稳定词法(`code`),不是把折叠身份一起编进去的去重 key —— 人读的一行要能一眼认出
+  // 「这是哪一类诊断」,`compare/codex|memory/x` 那串身份属于 message 与机器面的具名字段。
   const suffix = count > 1 ? ` (${count} attempts)` : "";
-  return [`${sym} ${event.key}${suffix}`, `  ${event.message}`];
+  // 阶段标签走与失败行(`buildFailureLine`)同一个 `phaseLabel()` 投影:「在哪一步降级的」是
+  // 读者的第一个问题,message 里未必答得上。attempt 级诊断的 phase 由运行器写进 `data`
+  // (见 attempt.ts 的 recordDiagnostic);运行级诊断(止损闸、锁接管、budget)不属于任何
+  // 单条 attempt,天然没有 phase,标题退化成只有 code 一段。
+  const phase = typeof event.data?.phase === "string" ? (event.data.phase as LifecyclePhase) : undefined;
+  const heading = phase !== undefined ? `${phaseLabel(phase)} · ${event.code ?? event.key}` : (event.code ?? event.key);
+  return [`${sym} ${heading}${suffix}`, `  ${event.message}`];
 }
 
 /** 结束结论(`FAILED`/`PASSED`/…)+ `FAILURES`(有失败才出现)+ `KEPT SANDBOXES`(有留存才
@@ -418,14 +472,37 @@ function experimentHookLabel(hook: ExperimentHookName): string {
   return hook === "setup" ? t("feedback.phase.experimentSetup") : t("feedback.phase.experimentTeardown");
 }
 
+/** 首行守恒计数的文案(见 cli.md「运行中的 live 面板」)。四项结局恒显示、零值不省略——
+ *  「0 errored」是一句有价值的肯定;`elsewhere` 只在非零时出现,没有并发 run 的场景少一项。
+ *  行长不是压缩它的理由:首行跟随终端全宽,九项写满仍是一行。两个调用点(live dashboard
+ *  首行、非 TTY heartbeat)共用这一份,不各自维护一份键选择逻辑。 */
+function countsText(state: RunFeedbackState): string {
+  const outcomes = {
+    passed: state.passed,
+    failed: state.failed,
+    errored: state.errored,
+    skipped: state.skipped,
+  };
+  return state.elsewhere > 0
+    ? t("feedback.human.countsWithElsewhere", {
+        total: state.total,
+        reused: state.reused,
+        running: state.running,
+        elsewhere: state.elsewhere,
+        queued: state.queued,
+        ...outcomes,
+      })
+    : t("feedback.human.counts", {
+        total: state.total,
+        reused: state.reused,
+        running: state.running,
+        queued: state.queued,
+        ...outcomes,
+      });
+}
+
 function formatCounts(state: RunFeedbackState): string {
-  const counts = t("feedback.human.counts", {
-    total: state.total,
-    reused: state.reused,
-    running: state.running,
-    queued: state.queued,
-    completed: state.completed,
-  });
+  const counts = countsText(state);
   if (state.estimatedCostUSD === undefined || state.estimatedCostUSD <= 0) return counts;
   return `${counts}  ${formatCost(state.estimatedCostUSD)}`;
 }
@@ -479,30 +556,23 @@ function createDashboardRenderer(io: FeedbackIO, command: string): FeedbackRende
     // renderPanel 内部按另一个宽度钳制,行尾会被框吃掉——这正是 memory/
     // live-dashboard-active-row-width-clamp-mismatch.md 的根因类别。
     const contentWidth = panelContentWidth(capability.width, capability.mode, false);
-    const rows: PanelRow[] = [
-      {
-        kind: "line",
-        text: t("feedback.human.counts", {
-          total: state.total,
-          reused: state.reused,
-          running: state.running,
-          queued: state.queued,
-          completed: state.completed,
-        }),
-      },
-    ];
-    // 运行级行(judge 预检 + 实验钩子)排在 attempt 行前面(见 cli.md「judge 预检的显示」/
-    // 「实验级钩子的显示」):它们解释了为什么后面的 attempt 还停在 queued。预检又排在实验
-    // 钩子前面——它发生在最前(任何 attempt 派发之前)。Map 按插入序迭代,天然满足稳定 slot。
+    const rows: PanelRow[] = [{ kind: "line", text: countsText(state) }];
+    // 运行级行(judge 预检 + 实验钩子 + 用例锁等待)排在 attempt 行前面(见 cli.md「judge 预检
+    // 的显示」/「实验级钩子的显示」/「等待并发 run 的显示」):它们解释了为什么后面的 attempt
+    // 还停在 queued。预检排最前(发生在任何 attempt 派发之前),其次实验钩子,再是锁等待
+    // (排在实验钩子行之后、attempt 行之前)。Map 按插入序迭代,天然满足稳定 slot。
     const precheck = state.activePrecheck;
     const hookRows = [...state.experimentHooks.values()];
-    if (activeOrder.length > 0 || hookRows.length > 0 || precheck) {
+    // 只有仍在等待(waiting 非空)的实验才占运行级行;窗口已关闭(全部 resolved)的条目只是
+    // 给非 TTY 聚合收尾行留的历史计数,TTY 不展示。
+    const lockWaitRows = [...state.lockWaits.values()].filter((w) => w.waiting.size > 0);
+    if (activeOrder.length > 0 || hookRows.length > 0 || lockWaitRows.length > 0 || precheck) {
       rows.push({ kind: "divider", title: t("feedback.human.active") });
       // 固定开销:上边框 + counts 行 + ACTIVE 横隔 + 下边框(boxed);plain 时同样按 4 行估算,
       // 差一两行不影响「窄/矮终端先减 active slots」这条大方向。
       const rowBudget = Math.max(0, io.stderr.rows - 4 - DASHBOARD_ROW_RESERVE);
       const precheckCount = precheck ? 1 : 0;
-      const total = precheckCount + hookRows.length + activeOrder.length;
+      const total = precheckCount + hookRows.length + lockWaitRows.length + activeOrder.length;
       // 窄/矮终端先减 active slots(减少行数),而不是先压缩单行内容 ——
       // 单行内容的截断在 formatActiveRow 里按 contentWidth 单独处理。
       const showCount = total <= rowBudget ? total : Math.max(0, rowBudget - 1);
@@ -512,7 +582,11 @@ function createDashboardRenderer(io: FeedbackIO, command: string): FeedbackRende
       // 的行又观测到更长的值再推宽,导致同一帧内本该对齐的列错位。
       const shownPrecheck = precheck && showCount > 0 ? precheck : undefined;
       const shownHooks = hookRows.slice(0, Math.max(0, showCount - (shownPrecheck ? 1 : 0)));
-      const shownRunLevel = (shownPrecheck ? 1 : 0) + shownHooks.length;
+      const shownLockWaits = lockWaitRows.slice(
+        0,
+        Math.max(0, showCount - (shownPrecheck ? 1 : 0) - shownHooks.length),
+      );
+      const shownRunLevel = (shownPrecheck ? 1 : 0) + shownHooks.length + shownLockWaits.length;
       const shownActive: ActiveAttempt[] = [];
       for (const key of activeOrder) {
         if (shownRunLevel + shownActive.length >= showCount) break;
@@ -533,6 +607,9 @@ function createDashboardRenderer(io: FeedbackIO, command: string): FeedbackRende
       for (const hookRow of shownHooks) {
         activeLines.push(formatExperimentHookRow(hookRow, io, contentWidth, evalWidth, whoWidth));
       }
+      for (const lockWaitRow of shownLockWaits) {
+        activeLines.push(formatLockWaitRow(lockWaitRow, io, contentWidth));
+      }
       for (const active of shownActive) {
         activeLines.push(formatActiveRow(active, io, contentWidth, evalWidth, whoWidth));
       }
@@ -584,8 +661,9 @@ function createDashboardRenderer(io: FeedbackIO, command: string): FeedbackRende
       // 更新,coordinator 紧接着的 redrawDynamic 会画出来);成功钩子不写 scrollback 永久行
       // (见 cli.md「实验级钩子的显示」)。非 TTY 退化流才逐行追加(见 renderDurableLines)。
       // judge 预检同理:TTY 下只驱动 state.activePrecheck 的运行级 active 行(coordinator 紧接着的
-      // redrawDynamic 会画出来),不写 scrollback 永久行(见 cli.md「judge 预检的显示」)。
-      if (event.type === "experiment-hook" || event.type === "precheck") return;
+      // redrawDynamic 会画出来),不写 scrollback 永久行(见 cli.md「judge 预检的显示」)。用例锁
+      // 等待同理:TTY 下由 state.lockWaits 驱动运行级 active 行(见 cli.md「等待并发 run 的显示」)。
+      if (event.type === "experiment-hook" || event.type === "precheck" || event.type === "lock-wait") return;
       writeDurable(io, event, state, false);
     },
     activity(text) {
@@ -682,6 +760,26 @@ function formatExperimentHookRow(
   return prefix + (hook.detail ?? "").slice(0, budget);
 }
 
+/** 用例锁等待的运行级行:`● waiting on another run · <exp>   <elapsed>  <n> evals · pid <pid>`
+ *  (cli.md「等待并发 run 的显示」)。elapsed 从最早一条等待的 startedAt 算(存活性证明,
+ *  与其它运行级行同一约定);pid 取最早一条等待对应的持有方——一个实验可能同时撞上多把不同
+ *  持有方的锁,这里选一个稳定的代表值展示,不逐条列出(与 earlyExit 代表 attempt 的选法同一
+ *  种「挑一个确定性代表」思路)。不吃 evalWidth/whoWidth 身份列宽约束——与 `formatPrecheckRow`
+ *  同理:选中用例全在等锁时,本实验没有派发中的 attempt,那两个宽度还压在初始值 0,会把
+ *  label 截成 "w…"(与 memory/live-dashboard-active-row-width-clamp-mismatch.md 同一根因类别,
+ *  只是发生在锁等待场景);label 直接用整行宽度。 */
+function formatLockWaitRow(wait: ActiveLockWait, io: FeedbackIO, columns: number): string {
+  const entries = [...wait.waiting.values()].sort((a, b) => a.startedAt - b.startedAt);
+  const earliest = entries[0]!;
+  const elapsed = formatElapsed(io.clock.now() - earliest.startedAt).padStart(6);
+  const sym = "● ";
+  const label = `${t("feedback.human.waitingOnAnotherRun")} · ${wait.experimentId}`;
+  const prefix = `${sym}${label}  ${elapsed}  `;
+  const budget = Math.max(0, columns - prefix.length);
+  const detail = t("feedback.human.lockWaitDetail", { count: entries.length, pid: earliest.holderPid ?? "?" });
+  return padTrunc(prefix + detail.slice(0, budget), columns);
+}
+
 // ───────────────────────── 非 TTY:human 文案的纯追加流 ─────────────────────────
 //
 // 单一 stdout 有序流(见 memory/exp-output-two-forms-ruling.md 的补充裁决):从 start 到结束
@@ -730,6 +828,9 @@ function createPlainRenderer(io: FeedbackIO): FeedbackRenderer {
 export interface HumanDryPlanRow {
   experimentId: string;
   evalId: string;
+  /** 该用例正被另一条并行 Invocation 持锁运行(见 docs/feature/experiments/architecture.md
+   *  「并发 Invocation:用例锁」);计划行尾如实标注,`--dry` 本身不取锁、不等待。 */
+  locked?: boolean;
 }
 
 export interface HumanDryPlanInput {
@@ -772,7 +873,8 @@ export function renderHumanDryPlan(input: HumanDryPlanInput): string {
   }
   const idWidth = Math.max(0, ...input.rows.map((row) => stringWidth(row.experimentId)));
   for (const row of input.rows) {
-    lines.push(`${row.experimentId}${" ".repeat(idWidth - stringWidth(row.experimentId) + 2)}${row.evalId}`);
+    const base = `${row.experimentId}${" ".repeat(idWidth - stringWidth(row.experimentId) + 2)}${row.evalId}`;
+    lines.push(row.locked ? `${base}  ${t("feedback.human.lockedRowSuffix")}` : base);
   }
   return `${lines.join("\n")}\n`;
 }

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

@@ -8,8 +8,10 @@
 // docs/engineering/testing/e2e/cli.md「反馈输出格式」在真实进程输出上验收。
 
 import { describe, expect, it } from "vitest";
-import { computeExitCode, renderJsonPlanDocument } from "./json.ts";
-import type { InvocationCompletion, InvocationSummary } from "../types.ts";
+import { computeExitCode, createJsonRenderer, renderJsonPlanDocument } from "./json.ts";
+import { createInitialRunFeedbackState, reduceRunFeedback } from "./reducer.ts";
+import { createFakeFeedbackIO } from "./testing.ts";
+import { HALT_DIAGNOSTIC_CODE, type DurableFeedbackEvent, type InvocationCompletion, type InvocationSummary } from "../types.ts";
 
 function summary(overrides: Partial<InvocationSummary> = {}): InvocationSummary {
   return {
@@ -77,6 +79,113 @@ describe("computeExitCode:CompletionStatus 驱动退出码,不只看 failed/erro
   });
 });
 
+/** 依次喂进 reducer 再交给 json renderer(与生产的 coordinator 同序:先 reduce 后 render),
+ *  返回逐行解析出的事件对象。 */
+function emitDurable(events: readonly DurableFeedbackEvent[]): Record<string, unknown>[] {
+  const { io, stdout } = createFakeFeedbackIO();
+  const renderer = createJsonRenderer({ io });
+  let state = createInitialRunFeedbackState();
+  for (const event of events) {
+    state = reduceRunFeedback(state, event);
+    renderer.appendDurable(event, state);
+  }
+  return stdout.writes
+    .join("")
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line) as Record<string, unknown>);
+}
+
+describe("warning 事件:code 是稳定词法,折叠身份走具名字段", () => {
+  it("code 用 DiagnosticInput.code 的干净字面量,不透传编了身份的去重 key", () => {
+    const [warning] = emitDurable([
+      {
+        type: "diagnostic",
+        at: 1,
+        key: "lock-taken-over:compare/codex|memory/retention",
+        code: "lock-taken-over",
+        severity: "warning",
+        message: "took over a stale lock",
+        data: { experimentId: "compare/codex", evalId: "memory/retention" },
+      },
+    ]);
+    expect(warning).toMatchObject({
+      event: "warning",
+      code: "lock-taken-over",
+      level: "warning",
+      experimentId: "compare/codex",
+      evalId: "memory/retention",
+    });
+  });
+
+  it("没给 code 的诊断回落到 key(折叠身份本就不进 key 的那些天生是干净字面量)", () => {
+    const [warning] = emitDurable([
+      { type: "diagnostic", at: 1, key: "memory-warmup-degraded", severity: "warning", message: "cold index" },
+    ]);
+    expect(warning).toMatchObject({ code: "memory-warmup-degraded" });
+    expect(warning).not.toHaveProperty("experimentId");
+    expect(warning).not.toHaveProperty("evalId");
+  });
+
+  it("eval 闸的 dispatch-halted:code 干净、evalId 与 phase 都在事件流里透得出", () => {
+    const [warning] = emitDurable([
+      {
+        type: "diagnostic",
+        at: 1,
+        key: "dispatch-halted:eval:compare/codex|memory/retention",
+        code: HALT_DIAGNOSTIC_CODE,
+        severity: "error",
+        message: "eval halted: fixture db is empty; run scripts/seed.ts",
+        data: {
+          experimentId: "compare/codex",
+          scope: "eval",
+          evalId: "memory/retention",
+          phase: "eval.run",
+          unstarted: 0,
+        },
+      },
+    ]);
+    expect(warning).toMatchObject({
+      event: "warning",
+      code: "dispatch-halted",
+      level: "error",
+      phase: "eval.run",
+      experimentId: "compare/codex",
+      evalId: "memory/retention",
+    });
+  });
+
+  it("身份从 data 取(闸不是 attempt 级、不伪造 identity);有 identity 时 identity 优先", () => {
+    const [fromIdentity] = emitDurable([
+      {
+        type: "diagnostic",
+        at: 1,
+        key: "fail-fast:x",
+        code: "fail-fast",
+        severity: "warning",
+        message: "deterministic failure",
+        identity: { experimentId: "compare/codex", evalId: "memory/a", attempt: 0 },
+        data: { experimentId: "other/exp", evalId: "memory/z" },
+      },
+    ]);
+    expect(fromIdentity).toMatchObject({ experimentId: "compare/codex", evalId: "memory/a" });
+  });
+
+  it("同一 dedupeKey 只追加一次:emitter 为刷新 data.unstarted 反复报同一条闸,事件流不重复", () => {
+    const halted = (at: number, unstarted: number): DurableFeedbackEvent => ({
+      type: "diagnostic",
+      at,
+      key: "dispatch-halted:experiment:compare/codex",
+      code: HALT_DIAGNOSTIC_CODE,
+      severity: "error",
+      message: "experiment halted (dispatch-halted): shared service is down",
+      data: { experimentId: "compare/codex", scope: "experiment", phase: "eval.run", unstarted },
+    });
+    const events = emitDurable([halted(1, 0), halted(2, 1), halted(3, 2)]);
+    expect(events.filter((e) => e.event === "warning")).toHaveLength(1);
+  });
+});
+
 describe("renderJsonPlanDocument:单个 ExpPlanDocument,不是事件流", () => {
   it("输出恰好一行 JSON,可解析为单个对象而不是逐行事件序列", () => {
     const text = renderJsonPlanDocument({
@@ -101,6 +210,22 @@ describe("renderJsonPlanDocument:单个 ExpPlanDocument,不是事件流", () =>
     expect(doc.matrix).toHaveLength(2);
   });
 
+  it("locked 为 true 的行原样透传;省略的行不出现 locked 字段(JSON.stringify 丢弃 undefined 属性)", () => {
+    const text = renderJsonPlanDocument({
+      total: 2,
+      evals: 2,
+      configs: 1,
+      runs: 1,
+      matrix: [
+        { experimentId: "compare/codex", evalId: "memory/a", reused: false, locked: true },
+        { experimentId: "compare/codex", evalId: "memory/b", reused: false },
+      ],
+    });
+    const doc = JSON.parse(text);
+    expect(doc.matrix[0]).toMatchObject({ evalId: "memory/a", locked: true });
+    expect(doc.matrix[1]).not.toHaveProperty("locked");
+  });
+
   it("reused 是 matrix 逐行 reused 之和(命中数量,不是 attempt 数)", () => {
     const text = renderJsonPlanDocument({
       total: 3,

package/src/runner/feedback/json.ts

@@ -104,13 +104,24 @@ export function createJsonRenderer(options: JsonRendererOptions): FeedbackRender
           noteCheckpoint(event.at);
           if (!isFirstOccurrence(state, event.key)) return; // 去重后只追加一次(cli.md)
           const phase = typeof event.data?.phase === "string" ? (event.data.phase as LifecyclePhase) : undefined;
+          // `code` 是 cli.md `WarningEvent` 里那个稳定词法(`lock-taken-over` / `dispatch-halted`),
+          // **不是**去重 key:去重 key 常把折叠身份编进去(`lock-taken-over:<exp>|<eval>`),原样
+          // 透出会让消费方拿到一个每次运行都不同的 code、没法按值分支。折叠到哪一条实验/用例
+          // 由下面的 experimentId/evalId 两个具名字段回答。
+          const code = event.code ?? event.key;
+          // 身份两字段:attempt 级诊断从 identity 取;运行级诊断(实验闸 / eval 闸这类不属于
+          // 任何单条 attempt 的事实)不许伪造 identity,从 `data` 的同名字段取(见 ../types.ts
+          // "diagnostic" 变体的 identity 注释)。
+          const experimentId = event.identity?.experimentId ?? stringField(event.data?.experimentId);
+          const evalId = event.identity?.evalId ?? stringField(event.data?.evalId);
           writeEvent(io, {
             event: "warning",
-            code: event.key,
+            code,
             level: event.severity,
             message: event.message,
             ...(phase !== undefined ? { phase } : {}),
-            ...(event.identity?.experimentId !== undefined ? { experimentId: event.identity.experimentId } : {}),
+            ...(experimentId !== undefined ? { experimentId } : {}),
+            ...(evalId !== undefined ? { evalId } : {}),
           });
           return;
         }
@@ -148,6 +159,26 @@ export function createJsonRenderer(options: JsonRendererOptions): FeedbackRender
           return;
         }
 
+        case "lock-wait": {
+          noteCheckpoint(event.at);
+          writeEvent(io, {
+            event: "lock_wait",
+            experimentId: event.experimentId,
+            evalId: event.evalId,
+            status: event.status,
+            ...(event.holderPid !== undefined ? { holderPid: event.holderPid } : {}),
+            ...(event.holderHost !== undefined ? { holderHost: event.holderHost } : {}),
+            // 折叠 carried/dispatched 两个内部计数为一个公开 resolution:仍有 attempt 需要真实
+            // 派发(dispatched > 0)记 "dispatched",全部由携带满足才记 "carried"
+            // (见 ../types.ts 里 DurableFeedbackEvent "lock-wait" 变体的字段注释)。
+            ...(event.status === "resolved"
+              ? { resolution: (event.dispatched ?? 0) > 0 ? "dispatched" : "carried" }
+              : {}),
+            ...(event.waitedMs !== undefined ? { waitedMs: event.waitedMs } : {}),
+          });
+          return;
+        }
+
         case "interrupted": {
           noteCheckpoint(event.at);
           if (!isFirstOccurrence(state, "interrupted")) return;
@@ -208,8 +239,14 @@ export function createJsonRenderer(options: JsonRendererOptions): FeedbackRender
         total: state.total,
         reused: state.reused,
         running: state.running,
+        elsewhere: state.elsewhere,
         queued: state.queued,
-        completed: state.completed,
+        // 与 human 首行同一份状态、同一套划分:已了结的 attempt 按 verdict 分项,消费方不必
+        // 自己从合计数里猜成败(契约见 docs/feature/experiments/cli.md 的 ProgressEvent)。
+        passed: state.passed,
+        failed: state.failed,
+        errored: state.errored,
+        skipped: state.skipped,
       });
     },
 
@@ -225,6 +262,12 @@ function isFirstOccurrence(state: RunFeedbackState, key: string): boolean {
   return (state.diagnostics.find((d) => d.key === key)?.count ?? 0) <= 1;
 }
 
+/** `data` 里的一个字符串字段;非字符串(或缺失)一律当没有,不把数字/对象硬塞进只接受
+ *  字符串的事件字段里。 */
+function stringField(value: JsonValue | undefined): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
 // ───────────────────────── failure / error 事件(不设上限) ─────────────────────────
 
 function writeFailureOrError(io: FeedbackIO, event: DurableFeedbackEvent & { type: "failure" }): void {
@@ -346,6 +389,11 @@ export interface JsonPlanRow {
   evalId: string;
   /** 命中缓存指纹,本次不会派发新 attempt。 */
   reused: boolean;
+  /** 该用例正被另一条并行 Invocation 持锁运行,真实运行时将等待后携带或补跑(见
+   *  docs/feature/experiments/architecture.md「并发 Invocation:用例锁」)。`--dry` 只读锁
+   *  目录,不取锁、不等待;省略等于 `false`(JSON.stringify 丢弃 `undefined` 属性,
+   *  天然满足这条省略语义,不需要显式写 `locked: false`)。 */
+  locked?: boolean;
 }
 
 export interface JsonPlanInput {