niceeval 0.12.2-canary.31 → 0.13.0

package/dist/runner/run.cjs

@@ -18,7 +18,6 @@ const build_coordinator_ts_1 = require("../sandbox/build-coordinator.cjs");
 const provisioner_ts_1 = require("../agents/provisioner.cjs");
 const build_preparation_ts_1 = require("./build-preparation.cjs");
 const util_ts_1 = require("../util.cjs");
-const facts_ts_1 = require("../shared/facts.cjs");
 const report_ts_1 = require("./report.cjs");
 const sink_ts_1 = require("./feedback/sink.cjs");
 const failure_ts_1 = require("./feedback/failure.cjs");
@@ -113,7 +112,11 @@ function runEvals(opts) {
         const startedAtMs = Date.now();
         const startedAt = new Date(startedAtMs).toISOString();
         const t0 = startedAtMs;
-        const niceevalRoot = opts.niceevalRoot ?? `${process.cwd()}/.niceeval`;
+        // These roots have deliberately different ownership. `coordinationRoot`
+        // contains only local Runner state; `recordRoot` is the portable fact root
+        // passed unchanged to the Record reader/writer coordinator.
+        const coordinationRoot = opts.coordinationRoot ?? `${process.cwd()}/.niceeval`;
+        const recordRoot = opts.recordRoot;
         // `--keep-sandbox` 要把单条 Attempt 的最终现场转交给用户，
         // `sandboxReuse` 则让整个 Invocation 的 pool 继续拥有并在收尾时销毁同一个 Case。
         // 两种 ownership 不能同时成立；在 carry planning/build/provider 等任何资源动作之前
@@ -179,14 +182,11 @@ function runEvals(opts) {
         // Coordinator creates draft Runs first, then uses their real `draft.runId`
         // values and the frozen Record view to partition every Slot into reuse/gap.
         const recordCoordinator = yield* (0, record_ts_1.openRunnerRecordCoordinator)({
-            niceevalRoot,
+            recordRoot,
             startedAt: t0,
             evals: opts.evals,
             runs: opts.agentRuns,
             reuse,
-            ...(opts.recordAttachments === undefined
-                ? {}
-                : { attachments: opts.recordAttachments }),
         });
         // The draft is the only authority for a Run identity. Session, shape and
         // reporters all observe this same mapping; no caller can replace it with a
@@ -239,6 +239,8 @@ function runEvals(opts) {
         // attempt-major lane。先按 lane 深度铺成全 Invocation 的 wave，保证任一 lane 的下一槽位
         // 都不会排到其它 lane 的首槽位之前。carried 槽位先从 lane 删除，不占 wave 也不触发 Sandbox。
         const attempts = [];
+        // Group 串行链与 wave 闸都是 Effect Deferred 协调:等待是 Deferred.await 的 Effect,
+        // 释放是 Deferred 结算 Effect,不再经过裸 Promise resolve。
         const groupedPredecessors = new WeakMap();
         const groupedReleases = new WeakMap();
         const groupedTails = new Map();
@@ -345,43 +347,43 @@ function runEvals(opts) {
                 let tails = groupedTails.get(run);
                 if (tails === undefined)
                     groupedTails.set(run, (tails = new Map()));
-                const predecessor = tails.get(evalDef.evalGroup.id) ?? Promise.resolve();
-                let release;
-                const settled = new Promise((resolve) => { release = resolve; });
+                const predecessor = tails.get(evalDef.evalGroup.id) ?? effect_1.Effect.void;
+                const settled = yield* effect_1.Deferred.make();
                 groupedPredecessors.set(attempt, predecessor);
-                groupedReleases.set(attempt, release);
-                tails.set(evalDef.evalGroup.id, settled);
+                groupedReleases.set(attempt, effect_1.Deferred.succeed(settled, undefined).pipe(effect_1.Effect.asVoid));
+                tails.set(evalDef.evalGroup.id, effect_1.Deferred.await(settled));
             }
         }
-        // wave N+1 只有在 wave N 的每条槽位都至少拿到过一次全局并发位（或在此前确定不派发）
-        // 后才可排队。这样不依赖 Effect Semaphore 的内部唤醒顺序，也不会让同一 lane 的后续槽位
-        // 持续重排到其它 Group / 未分组 Eval 的首槽位之前。
+        // 公平闸只保护每条 lane 的首槽位：任一 lane 的后续槽位都要等所有 lane 的首槽位
+        // 至少拿到过一次全局并发位（或在此前确定不派发）。首波以后不再跨 lane 组 wave；
+        // Group 自己的 predecessor 已经保证 lane 内串行，继续要求第 N 波全部抵达会让慢 lane
+        // 尚未完成的当前槽挡住快 lane 的空闲后继，制造真实空闲和时间轴空白。
+        // arrive 同时挂在派发点与 ensuring，保持未派发/中断路径也能结算首波。
         const dispatchWaveReady = new WeakMap();
         const dispatchWaveArrive = new WeakMap();
-        const attemptsByWave = new Map();
+        const firstWave = attempts.filter((attempt) => dispatchWaveNumbers.get(attempt) === 0);
+        let firstWaveRemaining = firstWave.length;
+        const firstWaveSettled = yield* effect_1.Deferred.make();
+        const firstWaveReady = firstWaveRemaining === 0
+            ? effect_1.Effect.void
+            : effect_1.Deferred.await(firstWaveSettled);
         for (const attempt of attempts) {
-            const wave = dispatchWaveNumbers.get(attempt);
-            attemptsByWave.set(wave, [...(attemptsByWave.get(wave) ?? []), attempt]);
-        }
-        let previousWave = Promise.resolve();
-        for (const wave of [...attemptsByWave.keys()].sort((left, right) => left - right)) {
-            const members = attemptsByWave.get(wave);
-            let remaining = members.length;
-            let resolveWave;
-            const settled = new Promise((resolve) => { resolveWave = resolve; });
-            for (const attempt of members) {
-                dispatchWaveReady.set(attempt, previousWave);
-                let arrived = false;
-                dispatchWaveArrive.set(attempt, () => {
-                    if (arrived)
-                        return;
-                    arrived = true;
-                    remaining -= 1;
-                    if (remaining === 0)
-                        resolveWave();
-                });
+            const isFirst = dispatchWaveNumbers.get(attempt) === 0;
+            dispatchWaveReady.set(attempt, isFirst ? effect_1.Effect.void : firstWaveReady);
+            if (!isFirst) {
+                dispatchWaveArrive.set(attempt, effect_1.Effect.void);
+                continue;
             }
-            previousWave = settled;
+            let arrived = false;
+            dispatchWaveArrive.set(attempt, effect_1.Effect.gen(function* () {
+                if (arrived)
+                    return;
+                arrived = true;
+                firstWaveRemaining -= 1;
+                if (firstWaveRemaining === 0) {
+                    yield* effect_1.Deferred.succeed(firstWaveSettled, undefined);
+                }
+            }));
         }
         // 预检 judge:验证 API key + 端点可达,避免跑完 agent 才发现 judge 不通。
         // 放在 attempts 展开之后,fail fast 只对会真正触发 judge 的运行生效
@@ -509,6 +511,7 @@ function runEvals(opts) {
         // inputs remain immutable for the duration of this invocation.
         const attemptOptions = {
             ...opts,
+            coordinationRoot,
             artifactPrepare,
             otelPool,
         };
@@ -677,7 +680,6 @@ function runEvals(opts) {
                         signal: setupContext.signal,
                         progress: setupContext.progress,
                         diagnostic: setupContext.diagnostic,
-                        fact: (key, value) => recordExperimentFact(a.run.experimentId, key, value),
                     };
                 pool = new sandbox_pool_ts_1.ReusableSandboxPool(a.plan, capacity, {
                     progress: setupContext.progress,
@@ -776,18 +778,6 @@ function runEvals(opts) {
         const experimentDiagnostics = new Map();
         const experimentDedupeIndex = new Map();
         const experimentCompletedAt = new Map();
-        // experiment 作用域 ctx.fact() 的累加器(与 experimentDiagnostics 同一种「按 experimentId 分桶」
-        // 模式):同一实验内后写覆盖先写,与 completedAt 同批在快照封口补写进 RunMeta.facts
-        // (见 docs/feature/record/architecture.md#facts运行事实)。没有 experimentId 的裸 run 没有
-        // Run 可挂,调用直接丢弃(与 recordExperimentDiagnostic 同一条纪律)。
-        const experimentFacts = new Map();
-        const recordExperimentFact = (experimentId, key, value) => {
-            if (!experimentId)
-                return;
-            const facts = experimentFacts.get(experimentId) ?? {};
-            (0, facts_ts_1.recordFact)(facts, key, value);
-            experimentFacts.set(experimentId, facts);
-        };
         const recordExperimentDiagnostic = (input) => {
             if (!input.experimentId)
                 return;
@@ -829,8 +819,8 @@ function runEvals(opts) {
             experimentDiagnostics.set(input.experimentId, list);
         };
         // 强杀后的收尾兜底(docs/feature/experiments/architecture.md「强杀后的收尾兜底」)的磁盘登记
-        // 挂在结果根下,与留存注册表 `.niceeval/sandboxes/` 同一个根(省略时退回 cwd/.niceeval,
-        // 与 attempt.ts 的 niceevalRoot 兜底同一口径)。
+        // 挂在本地协调根下,与留存注册表 `.niceeval/sandboxes/` 同一个根（默认 cwd/.niceeval，
+        // 与 attempt.ts 的 `coordinationRoot` 兜底同一口径）。
         const currentHost = (0, node_os_1.hostname)();
         const makeExperimentHookContext = (run, phase) => {
             const experimentId = run.experimentId;
@@ -865,7 +855,6 @@ function runEvals(opts) {
                         ...(input.dedupeKey !== undefined ? { dedupeKey: input.dedupeKey } : {}),
                     });
                 },
-                fact: (key, value) => recordExperimentFact(run.experimentId, key, value),
             };
         };
         const replaceSetup = (cell, setup) => cell.mutex.withPermits(1)(effect_1.Effect.sync(() => {
@@ -955,7 +944,7 @@ function runEvals(opts) {
                 // settle 后才注销：drain 在执行体在飞时仍能看见本项。
                 yield* (0, experiment_cleanup_registry_ts_1.unregisterExperimentTeardown)(experimentId);
                 if (run.experimentId) {
-                    yield* (0, teardown_registry_ts_1.removeTeardownRegistrationIfPresentEffect)(niceevalRoot, (0, teardown_registry_ts_1.teardownEntryId)(run.experimentId, process.pid)).pipe(effect_1.Effect.ignore);
+                    yield* (0, teardown_registry_ts_1.removeTeardownRegistrationIfPresentEffect)(coordinationRoot, (0, teardown_registry_ts_1.teardownEntryId)(run.experimentId, process.pid)).pipe(effect_1.Effect.ignore);
                 }
             }))));
             const settle = effect_1.Effect.exit(restore(teardown)).pipe(effect_1.Effect.flatMap((exit) => effect_1.Deferred.done(completion, exit)), effect_1.Effect.asVoid);
@@ -973,11 +962,11 @@ function runEvals(opts) {
             if (!run.experimentId || !run.teardown)
                 return effect_1.Effect.void;
             return effect_1.Effect.gen(function* () {
-                const registrations = yield* (0, teardown_registry_ts_1.readTeardownRegistrationsEffect)(niceevalRoot).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed([])));
+                const registrations = yield* (0, teardown_registry_ts_1.readTeardownRegistrationsEffect)(coordinationRoot).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed([])));
                 for (const { id, entry } of registrations) {
                     if (entry.experimentId !== run.experimentId || !(0, teardown_registry_ts_1.isOrphanedTeardownRegistration)(entry, currentHost))
                         continue;
-                    const claimed = yield* (0, teardown_registry_ts_1.removeTeardownRegistrationIfPresentEffect)(niceevalRoot, id).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(false)));
+                    const claimed = yield* (0, teardown_registry_ts_1.removeTeardownRegistrationIfPresentEffect)(coordinationRoot, id).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(false)));
                     if (!claimed)
                         continue; // 已被另一个进程抢先删除，义务已被别处接手。
                     (0, sink_ts_1.reportExperimentHook)({ experimentId, hook: "teardown", status: "started", recovery: true });
@@ -1008,7 +997,6 @@ function runEvals(opts) {
                                 ...(input.dedupeKey !== undefined ? { dedupeKey: input.dedupeKey } : {}),
                             });
                         },
-                        fact: (key, value) => recordExperimentFact(run.experimentId, key, value),
                     };
                     yield* (0, cleanup_timeout_ts_1.cleanupCallback)(() => run.teardown(recoveryCtx)).pipe(effect_1.Effect.matchEffect({
                         onSuccess: () => effect_1.Effect.sync(() => {
@@ -1079,7 +1067,7 @@ function runEvals(opts) {
                     // 上一进程的遗留收尾先补做，再原子写入本次登记；两步都先于 setup。
                     if (run.teardown && run.experimentId) {
                         yield* recoverOrphanedTeardownRegistration(run, experimentId);
-                        yield* (0, teardown_registry_ts_1.writeTeardownRegistrationEffect)(niceevalRoot, {
+                        yield* (0, teardown_registry_ts_1.writeTeardownRegistrationEffect)(coordinationRoot, {
                             experimentId: run.experimentId,
                             selectedEvalIds: run.selectedEvalIds,
                             pid: process.pid,
@@ -1416,6 +1404,7 @@ function runEvals(opts) {
         };
         const lockIdentity = { pid: process.pid, host: currentHost };
         const caseLocks = new Map();
+        const caseClaimsAwaitingPublication = [];
         for (const a of attempts) {
             if (!a.run.experimentId)
                 continue;
@@ -1488,27 +1477,23 @@ function runEvals(opts) {
                 holderHost: holder.host,
                 attempts: st.inElsewhere,
             });
-            const completion = yield* effect_1.Deferred.make();
-            const window = effect_1.Deferred.await(completion);
-            st.suspension = window;
             const poll = effect_1.Effect.gen(function* () {
                 for (;;) {
                     const stopped = yield* effect_1.Effect.raceFirst(effect_1.Effect.sleep(lock_ts_1.CASE_LOCK_HEARTBEAT_INTERVAL_MS).pipe(effect_1.Effect.as(false)), stopWaiting.pipe(effect_1.Effect.as(true)));
                     if (stopped)
                         return;
-                    const record = yield* (0, lock_ts_1.readCaseLockEffect)(niceevalRoot, st.experimentId, st.evalId).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(undefined)));
+                    const record = yield* (0, lock_ts_1.readCaseLockEffect)(coordinationRoot, st.experimentId, st.evalId).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(undefined)));
                     if (record === undefined || (0, lock_ts_1.isCaseLockExpired)(record, Date.now()))
                         return;
                 }
             }).pipe(effect_1.Effect.ensuring(effect_1.Effect.sync(() => resolveCaseWaitWithoutCarry(st, startedAt))));
-            // 登记窗口、启动唯一 poller、返回给许可链三步处在同一个 mask 内。poller 本身恢复为可中断，
-            // 结算则重新进入 mask：无论用户中断、兄弟 defect 还是 Scope 收尾，所有 follower 都收到原始 Exit，
-            // 且 `lock_wait resolved` 与 suspension 清理一定发生。
-            const settle = effect_1.Effect.uninterruptibleMask((restorePoll) => effect_1.Effect.exit(restorePoll(poll)).pipe(effect_1.Effect.flatMap((exit) => effect_1.Deferred.done(completion, exit)), effect_1.Effect.ensuring(effect_1.Effect.sync(() => {
+            // 等待本身就是挂起窗口。它不绑定刚归还的全局位 Scope；同组后到者拿到同一 Effect，
+            // 每个等待者都可被取消，而任一一次完成都会清掉下一轮重新试锁所读的窗口。
+            const window = poll.pipe(effect_1.Effect.ensuring(effect_1.Effect.sync(() => {
                 if (st.suspension === window)
                     st.suspension = undefined;
-            }))));
-            yield* effect_1.Effect.forkScoped(restore(settle));
+            })));
+            st.suspension = window;
             return window;
         }));
         /**
@@ -1528,10 +1513,10 @@ function runEvals(opts) {
                 // 接管诊断要报"原持有者是谁",但 acquireCaseLockEffect 只回传 takenOver 布尔值——取锁前先
                 // 无副作用地读一眼当前记录(纯尽力而为:极端时序下这份快照可能已经不是真正被接管的
                 // 那条记录,但诊断本来就是人读提示,不是判定依据)。
-                const priorHolder = yield* (0, lock_ts_1.readCaseLockEffect)(niceevalRoot, experimentId, evalId).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(undefined)));
+                const priorHolder = yield* (0, lock_ts_1.readCaseLockEffect)(coordinationRoot, experimentId, evalId).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(undefined)));
                 const giveUp = new AbortController();
                 let busyWith;
-                return yield* effect_1.Effect.uninterruptibleMask((restore) => restore((0, lock_ts_1.acquireCaseLockEffect)(niceevalRoot, experimentId, evalId, lockIdentity, {
+                return yield* effect_1.Effect.uninterruptibleMask((restore) => restore((0, lock_ts_1.acquireCaseLockEffect)(coordinationRoot, experimentId, evalId, lockIdentity, {
                     signal: giveUp.signal,
                     onWaitStart: (holder) => {
                         busyWith = holder;
@@ -1549,27 +1534,18 @@ function runEvals(opts) {
                         // 会让 heartbeat/held 已启动、CaseLockState 却没有 release 句柄。
                         st.claim = claim;
                         if (takenOver) {
-                            const message = (0, index_ts_1.t)("runner.lockTakenOver", {
-                                experimentId,
-                                evalId,
-                                pid: priorHolder?.pid ?? "?",
-                                host: priorHolder?.host ?? "?",
-                            }).trimEnd();
+                            const message = (0, index_ts_1.t)("runner.coordinationRecovered", { experimentId }).trimEnd();
                             (0, sink_ts_1.reportDiagnostic)({
-                                key: `lock-taken-over:${experimentId}|${evalId}`,
-                                code: "lock-taken-over",
-                                severity: "warning",
+                                key: `${types_ts_1.COORDINATION_RECOVERED_CODE}:case-lock:${experimentId}|${evalId}`,
+                                code: types_ts_1.COORDINATION_RECOVERED_CODE,
+                                severity: "info",
                                 message,
-                                data: { experimentId, evalId },
-                            });
-                            recordExperimentDiagnostic({
-                                experimentId,
-                                code: "lock-taken-over",
-                                level: "warning",
-                                message,
-                                phase: "eval.run",
-                                dedupeKey: `lock-taken-over:${experimentId}|${evalId}`,
-                                data: { experimentId, evalId },
+                                data: {
+                                    experimentId,
+                                    evalId,
+                                    resource: "case-lock",
+                                    ...(priorHolder !== undefined ? { previousPid: priorHolder.pid, previousHost: priorHolder.host } : {}),
+                                },
                             });
                         }
                         // V1 does not convert late legacy rows into carried Members. The frozen writer view is
@@ -1589,14 +1565,17 @@ function runEvals(opts) {
             const claim = st.claim;
             st.claim = undefined;
             return claim;
-        }).pipe(effect_1.Effect.flatMap((claim) => claim === undefined ? effect_1.Effect.void : claim.release.pipe(effect_1.Effect.ignore)));
+        }).pipe(effect_1.Effect.tap((claim) => effect_1.Effect.sync(() => {
+            if (claim !== undefined)
+                caseClaimsAwaitingPublication.push(claim);
+        })));
         /**
          * 实验闸的取位:声明了 `maxConcurrency` 的实验从**跨 Invocation 共用**的逐槽租约取名额
          * (gate-lease.ts);未声明的实验不走租约、不产生任何跨进程协调。取位在全局位之前——等名额
          * 的 attempt 不占别的实验的并发位。返回 undefined 表示等待期间被中断,这条 attempt 就此放弃。
          */
         /**
-         * 撞满实验闸名额时报一条 warning:名额域跨 Invocation,所以「等」的对象是别的进程,用户无从
+         * 撞满实验闸名额时报一条 info:名额域跨 Invocation,所以「等」的对象是别的进程,用户无从
          * 从本进程的面板推断。生效名额与本次声明分开报——两者不等就是 min-N 夹低了(别的运行声明了
          * 更小的 maxConcurrency),这是「我明明写了 3 却只跑 1 条」的唯一解释,不说清就只能去翻锁目录。
          * 按实验折叠:同一实验的一堆 attempt 会前后脚撞上同一批持有者,不该刷屏。
@@ -1607,34 +1586,32 @@ function runEvals(opts) {
             (0, sink_ts_1.reportDiagnostic)({
                 key: `gate-lease-waiting:${experimentId}`,
                 code: "gate-lease-waiting",
-                severity: "warning",
+                severity: "info",
                 message: (0, index_ts_1.t)("runner.gateLeaseWaiting", { experimentId, effectiveN, declaredN, holders: who }).trimEnd(),
                 data: { experimentId, effectiveN, declaredN },
             });
         };
-        const acquireGateLease = (experimentId, maxConcurrency) => effect_1.Effect.uninterruptibleMask((restore) => restore((0, gate_lease_ts_1.acquireGateSlotEffect)(niceevalRoot, experimentId, maxConcurrency, lockIdentity, {
+        const acquireGateLease = (experimentId, maxConcurrency) => effect_1.Effect.uninterruptibleMask((restore) => restore((0, gate_lease_ts_1.acquireGateSlotEffect)(coordinationRoot, experimentId, maxConcurrency, lockIdentity, {
             // 撞满名额只发生在「别的 Invocation 正占着这个实验的位子」——本进程自己的并发早被
             // gateLocalSems 挡在这一层之前了。不报的话面板就只剩 `0 running · N queued` 干等,
             // 看不出在等什么、等谁,也看不出生效名额被对方更小的声明夹低了(min-N)。
             onWaitStart: (holders) => reportGateLeaseWait(experimentId, maxConcurrency, holders),
         })).pipe(effect_1.Effect.map(({ claim, takenOver, takenOverFrom }) => {
             if (takenOver) {
-                const message = (0, index_ts_1.t)("runner.gateLeaseTakenOver", {
-                    experimentId,
-                    slot: claim.slot,
-                    pid: takenOverFrom?.pid ?? "?",
-                    host: takenOverFrom?.host ?? "?",
-                }).trimEnd();
-                const dedupeKey = `gate-lease-taken-over:${experimentId}`;
-                (0, sink_ts_1.reportDiagnostic)({ key: dedupeKey, code: "gate-lease-taken-over", severity: "warning", message, data: { experimentId } });
-                recordExperimentDiagnostic({
-                    experimentId,
-                    code: "gate-lease-taken-over",
-                    level: "warning",
+                const message = (0, index_ts_1.t)("runner.coordinationRecovered", { experimentId }).trimEnd();
+                (0, sink_ts_1.reportDiagnostic)({
+                    key: `${types_ts_1.COORDINATION_RECOVERED_CODE}:concurrency-slot:${experimentId}|${claim.slot}`,
+                    code: types_ts_1.COORDINATION_RECOVERED_CODE,
+                    severity: "info",
                     message,
-                    phase: "eval.run",
-                    dedupeKey,
-                    data: { experimentId, slot: claim.slot },
+                    data: {
+                        experimentId,
+                        resource: "concurrency-slot",
+                        slot: claim.slot,
+                        ...(takenOverFrom !== undefined
+                            ? { previousPid: takenOverFrom.pid, previousHost: takenOverFrom.host }
+                            : {}),
+                    },
                 });
             }
             return claim;
@@ -1968,7 +1945,6 @@ function runEvals(opts) {
                     }
                     return Object.freeze({
                         result: evaluated,
-                        executed: failedBeforeDispatch === undefined,
                     });
                 }));
                 // Reset/finalizer failures belong to the physical Group instance and
@@ -1978,19 +1954,18 @@ function runEvals(opts) {
                         recordEvalGroupPhysicalFailure(a, failure.stage, failure.error);
                     }
                 }
-                const { result, executed } = completed;
+                const { result } = completed;
                 // A never-started blocked Slot has no origin Attempt. A reserved
-                // but unsealed failure keeps its ID in the incomplete draft.
+                // setup/lease failure still closes its origin Attempt with the
+                // errored result, without inventing unavailable rich families.
                 let locator;
                 if (reservedRecordAttempt !== undefined) {
                     locator = reservedRecordAttempt.locator;
                     result.locator = locator;
-                    if (executed) {
-                        const recordAttempt = yield* recordCoordinator.completeAttemptOrMarkIncomplete(a, result);
-                        if (recordAttempt !== undefined) {
-                            locator = recordAttempt.locator;
-                            result.locator = locator;
-                        }
+                    const recordAttempt = yield* recordCoordinator.completeAttemptOrMarkIncomplete(a, result);
+                    if (recordAttempt !== undefined) {
+                        locator = recordAttempt.locator;
+                        result.locator = locator;
                     }
                 }
                 else if (!reservationAttempted) {
@@ -2093,7 +2068,7 @@ function runEvals(opts) {
             const exclusiveSem = exclusiveSemFor(a.plan);
             const arriveAtDispatchWave = dispatchWaveArrive.get(a);
             const dispatch = withGlobalSlot(haltAwait(a), (slot) => effect_1.Effect.gen(function* () {
-                arriveAtDispatchWave();
+                yield* arriveAtDispatchWave;
                 // 拿到位子的这一刻再问一次闸:排在独占 provider 锁 / 实验闸本地信号量上的那段等待
                 // 不在上面的竞速覆盖范围里(竞速只包全局位),闸可能正是在那段时间落下的。
                 if (checkDispatchHalt(a).halted)
@@ -2105,6 +2080,9 @@ function runEvals(opts) {
                     const outcome = yield* tryAcquireCase(caseState);
                     if (outcome.kind === "busy")
                         return { kind: "suspend", window: outcome.window };
+                    if (yield* recordCoordinator.adoptLatePublishedAttempt(a)) {
+                        return { kind: "done" };
+                    }
                 }
                 const proceed = yield* preflight;
                 if (!proceed)
@@ -2161,12 +2139,12 @@ function runEvals(opts) {
                     yield* outcome.window;
                 }
             });
-            const waveReady = dispatchWaveReady.get(a) ?? Promise.resolve();
-            const wavePipeline = effect_1.Effect.promise(() => waveReady).pipe(effect_1.Effect.flatMap(() => pipeline));
+            const waveReady = dispatchWaveReady.get(a) ?? effect_1.Effect.void;
+            const wavePipeline = waveReady.pipe(effect_1.Effect.flatMap(() => pipeline));
             const predecessor = groupedPredecessors.get(a);
             const orderedPipeline = predecessor === undefined
                 ? wavePipeline
-                : effect_1.Effect.promise(() => predecessor).pipe(effect_1.Effect.flatMap(() => wavePipeline));
+                : predecessor.pipe(effect_1.Effect.flatMap(() => wavePipeline));
             // 实验级 teardown 结算:每个 attempt 收尾(含被 preflight 跳过、被中断的、被用例锁
             // 被 preflight 跳过、被中断的)都从身份集合移除；最后一个触发 ExperimentDef.teardown。ensuring
             // 在中断路径同样执行，重复 finalizer 也不会让状态下溢。
@@ -2180,11 +2158,11 @@ function runEvals(opts) {
             const withCaseLifecycle = !caseState
                 ? withExpLifecycle
                 : withExpLifecycle.pipe(effect_1.Effect.ensuring(releaseCaseLockIfDone(caseState, a.attempt)));
-            const withWaveLifecycle = withCaseLifecycle.pipe(effect_1.Effect.ensuring(effect_1.Effect.sync(arriveAtDispatchWave)));
+            const withWaveLifecycle = withCaseLifecycle.pipe(effect_1.Effect.ensuring(arriveAtDispatchWave));
             if (predecessor === undefined)
                 return withWaveLifecycle;
             const releaseSuccessor = groupedReleases.get(a);
-            return withWaveLifecycle.pipe(effect_1.Effect.ensuring(effect_1.Effect.sync(releaseSuccessor)));
+            return withWaveLifecycle.pipe(effect_1.Effect.ensuring(releaseSuccessor));
         }, { concurrency: opts.maxConcurrency, discard: true }).pipe(
         // 中断(用户 Ctrl+C):finalizer 已在中断过程中跑完(容器已停),这里只是把它咽下,
         // 好让流程走到 summarize / onInvocationComplete,用已完成的 results 出一份部分汇总,而不是抛栈。
@@ -2288,28 +2266,23 @@ function runEvals(opts) {
         yield* sweepExperimentTeardowns();
         // Record publication is the intentionally narrow interruption mask. By this
         // point dispatch has stopped and its Scope/finalizers plus experiment
-        // teardown have settled; only the durable interrupted state, publish marker,
-        // and receipt remain. `uninterruptibleMask` preserves typed failures and
-        // defects from the writer, while preventing a pending cancellation from
-        // splitting that atomic hand-off after some Runs have become readable.
+        // teardown have settled; only durable Run publication and the receipt remain.
+        // The mask preserves typed writer failures, but this is not an Invocation
+        // transaction: SIGINT publication freezes each Run independently, leaving
+        // Runs with unsettled real Attempts incomplete while siblings may seal.
         const receipt = yield* effect_1.Effect.uninterruptibleMask(() => effect_1.Effect.gen(function* () {
-            // Missing Members remain missing, while membership-provenance records why
-            // each pending gap was interrupted. This never manufactures an Attempt
-            // for budget/early-exit/unstarted Slots.
-            if (interrupted)
-                recordCoordinator.markInterrupted();
             // These diagnostics are already settled and keyed by exact Experiment /
             // AgentRun identity. Bind them only at the final Runner → Record
             // boundary; the invocation-wide Run timing tree deliberately remains
             // unbound because it cannot be safely attributed to individual Runs.
             for (const run of opts.agentRuns) {
-                (0, runner_producer_ts_1.bindRunnerRunObservabilityDiagnosticsV1)({
+                (0, runner_producer_ts_1.bindRunnerRunObservabilityDiagnostics)({
                     run,
                     diagnostics: experimentDiagnostics.get(run.experimentId) ?? [],
                 });
             }
             const receiptCompletedAtMs = Date.now();
-            const publishedRuns = yield* recordCoordinator.publish(receiptCompletedAtMs);
+            const publishedRuns = yield* recordCoordinator.publish(receiptCompletedAtMs, interrupted ? "interrupted" : "normal");
             return Object.freeze({
                 invocationId: recordCoordinator.reusePlan.target.invocationId,
                 runIds: Object.freeze(publishedRuns.map(({ runId }) => String(runId))),
@@ -2317,7 +2290,10 @@ function runEvals(opts) {
                 completedAt: new Date(receiptCompletedAtMs).toISOString(),
                 completion: interrupted ? "interrupted" : "completed",
             });
-        }));
+        })).pipe(effect_1.Effect.ensuring(effect_1.Effect.forEach(caseClaimsAwaitingPublication, (claim) => claim.release.pipe(effect_1.Effect.ignore), {
+            concurrency: 1,
+            discard: true,
+        })));
         // Experiment 收尾协议(docs/runner.md):每个真正出现在这次 Invocation 里的 experimentId
         // 各发一次 experiment:complete,携带它自己的 completedAt(真实 teardown 完成时刻,没有
         // teardown 或未触发时退回当前时刻)与实验域诊断累积器里attribute 给它的记录。全部
@@ -2333,7 +2309,6 @@ function runEvals(opts) {
                 // Only exact current Record readbacks appear in the invocation snapshot.
                 reusedAttempts: reusedAttempts.filter((attempt) => attempt.target.experimentId === experimentId),
                 diagnostics: experimentDiagnostics.get(experimentId) ?? [],
-                ...(experimentFacts.has(experimentId) ? { facts: experimentFacts.get(experimentId) } : {}),
                 // Run 级共享构建时间与 provenance:属于产出它们的 Run;携带条目不继承。
                 ...(runTimings !== undefined ? { timings: runTimings } : {}),
                 ...(sandboxBuildRecords.length > 0 ? { sandboxBuilds: sandboxBuildRecords } : {}),