niceeval 0.10.3-canary.7 → 0.11.0

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

@@ -5,10 +5,10 @@
 // boxed 能力下产生可识别的框线字符与正确的面板顺序/分隔,plain/非 TTY 下不产生任何框字符。
 
 import { afterEach, describe, expect, it } from "vitest";
-import { createHumanRenderer, renderDurableLines } from "./human.ts";
+import { createHumanRenderer, renderDurableLines, renderHumanDryPlan } from "./human.ts";
 import { createFakeFeedbackIO } from "./testing.ts";
-import { createInitialRunFeedbackState } from "./reducer.ts";
-import { encodeAttemptKey } from "../types.ts";
+import { createInitialRunFeedbackState, reduceRunFeedback } from "./reducer.ts";
+import { encodeAttemptKey, HALT_DIAGNOSTIC_CODE } from "../types.ts";
 import { stringWidth } from "../../report/model/text-layout.ts";
 import type { DurableFeedbackEvent, InvocationCompletion, InvocationSummary, RunFeedbackPlan, RunFeedbackState } from "../types.ts";
 import type { AttemptLocator } from "../../results/locator.ts";
@@ -182,7 +182,8 @@ describe("live dashboard — 接线到 panel.ts", () => {
       reused: 6,
       running: 19,
       queued: 12,
-      completed: 8,
+      passed: 6,
+      failed: 2,
       elapsedMs: 134_000,
       estimatedCostUSD: 0.84,
       active: new Map([[key, { identity, who: "compare/bub-e2b", phase: "eval.run", phaseStartedAt: 0 }]]),
@@ -260,7 +261,8 @@ describe("live dashboard — 宽终端下 ACTIVE 行与身份列分配", () => {
       reused: 6,
       running: 19,
       queued: 12,
-      completed: 8,
+      passed: 6,
+      failed: 2,
       elapsedMs: 134_000,
       active: new Map([
         [key, { identity, who: "compare/bub-e2b", phase: "eval.run", phaseStartedAt: 0, detail: longDetail }],
@@ -358,7 +360,7 @@ describe("live dashboard — 宽终端下 ACTIVE 行与身份列分配", () => {
       ...createInitialRunFeedbackState(),
       total: 2,
       running: 1,
-      completed: 1,
+      passed: 1,
       active: new Map([[shortKey, { identity: shortIdentity, who, phase: "eval.run", phaseStartedAt: 1 }]]),
     };
     renderer.onLifecycle?.(
@@ -418,3 +420,295 @@ describe("live dashboard — 宽终端下 ACTIVE 行与身份列分配", () => {
     for (const l of framedLines) expect(stringWidth(l)).toBe(100);
   });
 });
+
+// cases: docs/engineering/testing/unit/experiments-runner.md「用例锁与并发 Invocation」——
+// 字节级精确渲染归 E2E · CLI「反馈输出格式」;这里只做与 precheck/experiment-hook 同等级别
+// 的最小 smoke 断言(行是否出现、关键子串是否存在),不断言列宽算术。
+describe("用例锁等待(elsewhere)的显示", () => {
+  it("TTY:等待期间显示运行级行,面板首行的 elsewhere 计数非零", () => {
+    const { io, stderr } = createFakeFeedbackIO({ stderr: { isTTY: true, columns: 100, rows: 30 } });
+    const renderer = createHumanRenderer({ io, command: "niceeval exp compare/codex" });
+    const state: RunFeedbackState = {
+      ...createInitialRunFeedbackState(),
+      total: 3,
+      elsewhere: 2,
+      queued: 1,
+      lockWaits: new Map([
+        [
+          "compare/codex",
+          {
+            experimentId: "compare/codex",
+            waiting: new Map([
+              ["memory/a", { startedAt: 0, holderPid: 41267, holderHost: "mba.local" }],
+              ["memory/b", { startedAt: 5, holderPid: 41267, holderHost: "mba.local" }],
+            ]),
+            resolvedCarried: 0,
+            resolvedDispatched: 0,
+          },
+        ],
+      ]),
+    };
+    renderer.redrawDynamic?.(state);
+
+    const plain = stripAnsi(stderr.writes.join(""));
+    expect(plain).toMatch(/├─ ACTIVE ─+┤/);
+    expect(plain).toContain("waiting on another run");
+    expect(plain).toContain("compare/codex");
+    expect(plain).toContain("2 evals");
+    expect(plain).toContain("pid 41267");
+    expect(plain).toContain("2 elsewhere");
+  });
+
+  it("TTY appendDurable 对 lock-wait 直接返回,不写 scrollback 永久行(运行级行由 state.lockWaits 驱动)", () => {
+    const { io, stdout, stderr } = createFakeFeedbackIO({ stderr: { isTTY: true, columns: 100, rows: 30 } });
+    const renderer = createHumanRenderer({ io, command: "niceeval exp compare/codex" });
+    const state: RunFeedbackState = { ...createInitialRunFeedbackState(), total: 1, elsewhere: 1 };
+    renderer.appendDurable(
+      { type: "lock-wait", at: 0, experimentId: "compare/codex", evalId: "memory/a", status: "started", attempts: 1, holderPid: 1, holderHost: "h" },
+      state,
+    );
+    expect(stdout.writes.join("") + stderr.writes.join("")).toBe("");
+  });
+
+  it("非 TTY:started 只在窗口第一次打开(唯一等待用例)时追加一行,中途加入的用例不逐条刷屏", () => {
+    const { io, stdout } = createFakeFeedbackIO({ stderr: { isTTY: false } });
+    const renderer = createHumanRenderer({ io, command: "niceeval exp compare/codex" });
+    const firstState: RunFeedbackState = {
+      ...createInitialRunFeedbackState(),
+      total: 2,
+      elsewhere: 1,
+      lockWaits: new Map([
+        [
+          "compare/codex",
+          {
+            experimentId: "compare/codex",
+            waiting: new Map([["memory/a", { startedAt: 0, holderPid: 41267 }]]),
+            resolvedCarried: 0,
+            resolvedDispatched: 0,
+          },
+        ],
+      ]),
+    };
+    renderer.appendDurable(
+      { type: "lock-wait", at: 0, experimentId: "compare/codex", evalId: "memory/a", status: "started", attempts: 1, holderPid: 41267, holderHost: "h" },
+      firstState,
+    );
+    const secondState: RunFeedbackState = {
+      ...firstState,
+      elsewhere: 2,
+      lockWaits: new Map([
+        [
+          "compare/codex",
+          {
+            ...firstState.lockWaits.get("compare/codex")!,
+            waiting: new Map([
+              ["memory/a", { startedAt: 0, holderPid: 41267 }],
+              ["memory/b", { startedAt: 1, holderPid: 41267 }],
+            ]),
+          },
+        ],
+      ]),
+    };
+    renderer.appendDurable(
+      { type: "lock-wait", at: 1, experimentId: "compare/codex", evalId: "memory/b", status: "started", attempts: 1, holderPid: 41267, holderHost: "h" },
+      secondState,
+    );
+
+    const out = stdout.writes.join("");
+    expect(out).toContain("waiting on another run · compare/codex");
+    // 只出现一次:第二条(memory/b 加入)是同一窗口内的非首条,静默不刷屏。
+    expect(out.split("waiting on another run").length - 1).toBe(1);
+  });
+
+  it("非 TTY:resolved 只在窗口最后一次关闭(全部等待用例都已解决)时追加聚合收尾行", () => {
+    const { io, stdout } = createFakeFeedbackIO({ stderr: { isTTY: false } });
+    const renderer = createHumanRenderer({ io, command: "niceeval exp compare/codex" });
+    // 还剩一个用例没解决:窗口未关闭,静默。
+    const stillWaitingState: RunFeedbackState = {
+      ...createInitialRunFeedbackState(),
+      lockWaits: new Map([
+        [
+          "compare/codex",
+          {
+            experimentId: "compare/codex",
+            waiting: new Map([["memory/b", { startedAt: 1, holderPid: 1 }]]),
+            resolvedCarried: 2,
+            resolvedDispatched: 0,
+          },
+        ],
+      ]),
+    };
+    renderer.appendDurable(
+      { type: "lock-wait", at: 5, experimentId: "compare/codex", evalId: "memory/a", status: "resolved", carried: 2, dispatched: 0, waitedMs: 5_000 },
+      stillWaitingState,
+    );
+    expect(stdout.writes.join("")).toBe("");
+
+    // 最后一个也解决了:窗口关闭,打印聚合收尾行(carried + dispatched 混合的措辞两面都要覆盖)。
+    const closedState: RunFeedbackState = {
+      ...createInitialRunFeedbackState(),
+      lockWaits: new Map([
+        [
+          "compare/codex",
+          {
+            experimentId: "compare/codex",
+            waiting: new Map(),
+            resolvedCarried: 2,
+            resolvedDispatched: 1,
+          },
+        ],
+      ]),
+    };
+    renderer.appendDurable(
+      { type: "lock-wait", at: 94_000, experimentId: "compare/codex", evalId: "memory/b", status: "resolved", carried: 0, dispatched: 1, waitedMs: 94_000 },
+      closedState,
+    );
+    const out = stdout.writes.join("");
+    expect(out).toContain("lock wait resolved · compare/codex");
+    expect(out).toContain("2 carried");
+    expect(out).toContain("1 to run");
+  });
+});
+
+describe("诊断行:标题是「阶段标签 · code」,止损闸落闸是一行 error 级通知", () => {
+  /** 把同一条诊断喂 N 次(emitter 刷新 data.unstarted 时就是这个形状),返回每一次的渲染行。 */
+  function replayDiagnostic(event: DurableFeedbackEvent & { type: "diagnostic" }, times: number): string[][] {
+    let state = createInitialRunFeedbackState();
+    const out: string[][] = [];
+    for (let i = 0; i < times; i++) {
+      state = reduceRunFeedback(state, event);
+      out.push(renderDurableLines(event, state, { mode: "plain", width: 100 }));
+    }
+    return out;
+  }
+
+  it("普通诊断的标题用 code,不把编了身份的去重 key 甩进人读的一行", () => {
+    const [lines] = replayDiagnostic(
+      {
+        type: "diagnostic",
+        at: 0,
+        key: "lock-taken-over:compare/codex|memory/retention",
+        code: "lock-taken-over",
+        severity: "warning",
+        message: "took over a stale lock from pid 41267",
+      },
+      1,
+    );
+    expect(lines![0]).toBe("! lock-taken-over");
+    expect(lines![1]).toContain("took over a stale lock");
+  });
+
+  it("同一 key 再次出现时标题带 ×N 折叠计数(非止损闸诊断保持既有形态)", () => {
+    const rounds = replayDiagnostic(
+      { type: "diagnostic", at: 0, key: "memory-warmup-degraded", severity: "warning", message: "cold index" },
+      3,
+    );
+    expect(rounds[0]![0]).toBe("! memory-warmup-degraded");
+    expect(rounds[2]![0]).toBe("! memory-warmup-degraded (3 attempts)");
+  });
+
+  it("attempt 级诊断的标题是「阶段标签 · code」,阶段标签与失败行同一投影", () => {
+    // 失败行已有的 ` · <阶段标签>` 段是同一个投影的既有出口:拿它当参照,断言诊断行没有
+    // 另写一份阶段词表(不硬编码语言,en/zh-CN 两种 locale 下都成立)。
+    const failureLines = renderDurableLines(
+      {
+        type: "failure",
+        at: 0,
+        locator: locator("@1bwcxxiy"),
+        identity: { experimentId: "compare/codex", evalId: "memory/x", attempt: 1 },
+        who: "codex",
+        verdict: "errored",
+        reason: "boom",
+        phase: "sandbox.setup",
+      },
+      createInitialRunFeedbackState(),
+      { mode: "plain", width: 100 },
+    );
+    const label = failureLines[0]!.split("\n")[0]!.split(" · ")[1]!;
+
+    const rounds = replayDiagnostic(
+      {
+        type: "diagnostic",
+        at: 0,
+        // 作者没传 dedupeKey 时 attempt.ts 折出来的 key —— 编了身份,不能出现在人读标题里。
+        key: "memory-warmup-degraded:compare/codex|memory/x|1",
+        code: "memory-warmup-degraded",
+        severity: "warning",
+        message: "Memory warmup failed; continuing with a cold index",
+        identity: { experimentId: "compare/codex", evalId: "memory/x", attempt: 1 },
+        data: { phase: "sandbox.setup" },
+      },
+      12,
+    );
+    expect(rounds[0]![0]).toBe(`! ${label} · memory-warmup-degraded`);
+    expect(rounds[11]![0]).toBe(`! ${label} · memory-warmup-degraded (12 attempts)`);
+    expect(rounds[11]![1]).toBe("  Memory warmup failed; continuing with a cold index");
+  });
+
+  it("运行级诊断没有 phase:标题只有 code,不留空的 · 分隔符", () => {
+    const [lines] = replayDiagnostic(
+      {
+        type: "diagnostic",
+        at: 0,
+        key: "budget-unenforceable:compare/codex",
+        code: "budget-unenforceable",
+        severity: "warning",
+        message: "no cost data; budget cannot be enforced",
+        data: { experimentId: "compare/codex" },
+      },
+      1,
+    );
+    expect(lines![0]).toBe("! budget-unenforceable");
+  });
+
+  it("实验闸落闸:一行 error 级通知,文案就是契约字面,不再多一行标题", () => {
+    const [lines] = replayDiagnostic(
+      {
+        type: "diagnostic",
+        at: 0,
+        key: "dispatch-halted:experiment:compare/codex",
+        code: HALT_DIAGNOSTIC_CODE,
+        severity: "error",
+        message: "experiment halted (dispatch-halted): shared service is down; restart the tunnel",
+        data: { experimentId: "compare/codex", scope: "experiment", phase: "eval.run", unstarted: 0 },
+      },
+      1,
+    );
+    expect(lines).toEqual(["✗ experiment halted (dispatch-halted): shared service is down; restart the tunnel"]);
+  });
+
+  it("每条未派发 attempt 刷一次的后续声明零输出:被中止的等待集不逐条刷屏,数量归完成状态的 unstarted", () => {
+    const rounds = replayDiagnostic(
+      {
+        type: "diagnostic",
+        at: 0,
+        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: 4 },
+      },
+      5,
+    );
+    expect(rounds[0]).toEqual(["✗ eval halted: fixture db is empty; run scripts/seed.ts"]);
+    expect(rounds.slice(1).flat()).toEqual([]);
+  });
+});
+
+describe("renderHumanDryPlan: locked 标注", () => {
+  it("locked 为 true 的行尾标注 locked;false/省略的行不受影响", () => {
+    const text = renderHumanDryPlan({
+      totalAttempts: 2,
+      evals: 2,
+      configs: 1,
+      runs: 1,
+      rows: [
+        { experimentId: "compare/codex", evalId: "memory/a", locked: true },
+        { experimentId: "compare/codex", evalId: "memory/b" },
+      ],
+    });
+    const lines = text.trim().split("\n");
+    expect(lines.find((l) => l.includes("memory/a"))).toContain("locked");
+    expect(lines.find((l) => l.includes("memory/b"))).not.toContain("locked");
+  });
+});

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`;
 }