niceeval 0.15.1-canary.76 → 0.16.1

package/dist/runner/attempt.cjs

@@ -6,6 +6,7 @@ exports.scoreFactOutcomeForAttemptError = scoreFactOutcomeForAttemptError;
 exports.errorFromThrown = errorFromThrown;
 exports.executeSandboxAction = executeSandboxAction;
 exports.experimentRunInfo = experimentRunInfo;
+const attempt_cancellation_ts_1 = require("./attempt-cancellation.cjs");
 // 单个 attempt 的完整生命周期:资源(沙箱 / OTLP 接收器)经 Effect.Sample 的
 // acquireRelease 接管,无论 body 成功 / 抛错 / 被中断,stop() / close() 都保证执行。
 // 沙箱编排的固定段在 runAttemptBody(基线→setup→驱动 test→采 diff→评分→判定→收 trace),
@@ -19,6 +20,8 @@ const paths_ts_1 = require("../sandbox/paths.cjs");
 const request_executor_ts_1 = require("../sandbox/request-executor.cjs");
 const cleanup_timeout_ts_1 = require("./cleanup-timeout.cjs");
 const adapter_usage_ts_1 = require("./adapter-usage.cjs");
+const judge_usage_ts_1 = require("../o11y/judge-usage.cjs");
+const judge_usage_ts_2 = require("./judge-usage.cjs");
 const adapter_attachments_ts_1 = require("./adapter-attachments.cjs");
 const adapter_execution_trace_ts_1 = require("./adapter-execution-trace.cjs");
 const score_ts_1 = require("../eval/record/score.cjs");
@@ -140,765 +143,791 @@ function attemptFailureDeclaration(classify, phase, e) {
     return { class: cls, phase, text: info.text };
 }
 function runAttemptEffect(a, opts, sandboxSem, { attachmentScope, buildLocators, preparedSetupPrefix, runTiming, parentSignal, invocationSignal, onPhase, concurrencySlot, providerAdmission, onFailureClass, onEnvironmentIncomplete, onSandboxCleanupFailure, onSealedEvaluation: publishSealedEvaluation, onInterruptedResult, reusedSandbox, }) {
-    let assistanceReported = false;
-    const onSealedEvaluation = (sealed) => effect_1.Effect.suspend(() => {
-        if (!assistanceReported) {
-            assistanceReported = true;
-            reportJudgeErrorAssistance(a, sealed);
-        }
-        return publishSealedEvaluation?.(sealed) ?? effect_1.Effect.void;
-    });
-    const config = opts.config;
-    const { evalDef, run, attempt } = a;
-    const adapter = run.adapter;
-    const agent = run.agent;
-    const coordinationRoot = opts.coordinationRoot ?? `${process.cwd()}/.niceeval`;
-    const t0 = Date.now();
-    // Source bytes are snapshotted at the author action, then held only through
-    // an internal capability until the Record producer seals its own Attachments.
-    const sourceRegistry = (0, source_loc_ts_1.createSourceRegistry)(process.cwd());
-    const sourceCapture = (0, source_producer_ts_1.createRunnerAttemptSourceCapture)(sourceRegistry);
-    const attemptResources = new attempt_resources_ts_1.ManagedAttemptResources();
-    let attemptResourceReleaseFailureReported = false;
-    const reportAttemptResourceReleaseFailure = (error) => {
-        if (attemptResourceReleaseFailureReported)
-            return;
-        attemptResourceReleaseFailureReported = true;
-        declareFailure("agent.teardown", error);
-        diagnostics.push(teardownDiagnostic("agent.teardown", error));
-    };
-    const base = {
-        id: evalDef.id,
-        description: evalDef.description,
-        experimentId: run.experimentId,
-        experiment: experimentRunInfo(run, a.plan, a.sandboxPlansByEval, config, a.judge),
-        adapter: (0, adapter_ts_1.adapterIdentity)(adapter),
-        model: run.model,
-        verdict: "errored",
-        fingerprint: a.fingerprint,
-        evaluationAlgorithm: types_ts_1.EVALUATION_ALGORITHM,
-        configHash: a.configHash,
-        attempt,
-        startedAt: new Date(t0).toISOString(),
-        durationMs: 0,
-        factResults: [],
-        factUses: [],
-        evidenceCoverage: agent?.evidenceCoverage ?? attempt_resources_ts_1.adapterEvidenceUnavailable,
-        evaluationKind: evalDef.evaluationKind ?? "pass",
-    };
-    /**
-     * 调度事实:Sandbox 租借给这条 Attempt 的那一刻定死(复用池借出的实例在进入本函数时就已经
-     * 借定,一次性沙箱在 create 返回那一刻借定)。Attempt 在任何阶段终结——Eval `setup` 失败、
-     * 超时、资源获取失败——记录里都要带全 provider / sandboxId / reused / 编号与承接序号,
-     * 只有 `kept` 在收尾时点决定(见 docs/feature/record/architecture.md 的 `sandbox` 字段)。
-     * 所以它挂在唯一出口(下方 Effect.map)上,而不是分散在各条返回路径里。
-     */
-    let sandboxFacts;
-    let currentSandbox;
-    /** 留存提交成功(`--keep-sandbox`)——唯一一个在收尾时点才知道的 sandbox 记录键。 */
-    let kept = false;
-    if (reusedSandbox && agent?.kind === "sandbox") {
-        if (a.plan._tag !== "Sandbox") {
-            throw new Error(`sandbox agent ${JSON.stringify(agent.name)} received a Direct plan`);
-        }
-        sandboxFacts = {
-            provider: a.plan.providerPlan.provider,
-            sandboxId: reusedSandbox.sandbox.sandboxId,
-            reused: true,
-            reuseSandbox: reusedSandbox.reuseSandbox,
-            reuseOrdinal: reusedSandbox.reuseOrdinal,
+    return effect_1.Effect.clockWith((clock) => effect_1.Effect.suspend(() => {
+        let assistanceReported = false;
+        const onSealedEvaluation = (sealed) => effect_1.Effect.suspend(() => {
+            if (!assistanceReported) {
+                assistanceReported = true;
+                reportJudgeErrorAssistance(a, sealed);
+            }
+            return publishSealedEvaluation?.(sealed) ?? effect_1.Effect.void;
+        });
+        const config = opts.config;
+        const { evalDef, run, attempt } = a;
+        const adapter = run.adapter;
+        const agent = run.agent;
+        const coordinationRoot = opts.coordinationRoot ?? `${process.cwd()}/.niceeval`;
+        const t0 = Date.now();
+        // Source bytes are snapshotted at the author action, then held only through
+        // an internal capability until the Record producer seals its own Attachments.
+        const sourceRegistry = (0, source_loc_ts_1.createSourceRegistry)(process.cwd());
+        const sourceCapture = (0, source_producer_ts_1.createRunnerAttemptSourceCapture)(sourceRegistry);
+        const attemptResources = new attempt_resources_ts_1.ManagedAttemptResources();
+        let attemptResourceReleaseFailureReported = false;
+        const reportAttemptResourceReleaseFailure = (error) => {
+            if (attemptResourceReleaseFailureReported)
+                return;
+            attemptResourceReleaseFailureReported = true;
+            declareFailure("agent.teardown", error);
+            diagnostics.push(teardownDiagnostic("agent.teardown", error));
         };
-    }
-    // 四层解析链的最后两层(eval → config)在这里接上,并把赢家那一层带出来:超时消息要说得出
-    // 「这个上限是哪一层给的」,否则撞线时得回头逐层对照四个声明点(契约见
-    // docs/feature/experiments/cli.md「timeout、budget 与基础设施错误」)。
-    // 四层都没声明 = 无上限:不挂 deadline、不发软截止信号,也不给 provider 递命令超时,
-    // 链末端不发明一条隐藏的线。
-    const attemptTimeout = (0, timeout_ts_1.resolveAttemptTimeout)(run, evalDef, config);
-    // deadline 的截止**时刻**:沙箱内一切时限从它派生(单条命令未显式传 timeout 时上限 =
-    // 剩余量,见 sandbox/deadline.ts)。与 Effect.timeoutTo 同一个锚点,不各取各的 now()。
-    const deadlineAt = attemptTimeout ? Date.now() + attemptTimeout.timeoutMs : undefined;
-    // Adapter 的协作式 deadline 由专用 controller 承载。它绝不能自己设 timer：Effect.timeoutTo
-    // 是唯一的 deadline owner，并会在 onTimeout 同步 abort 这个 controller；否则独立 timer
-    // 可能让 adapter 先 reject，把 deadline 错分成外部 interrupt。
-    const deadlineAbort = new AbortController();
-    const parentAbort = new AbortController();
-    const signal = AbortSignal.any([parentAbort.signal, deadlineAbort.signal]);
-    // Attempt 阶段的正式生命周期投影(见 docs/feature/experiments/cli.md「Attempt 阶段」)。
-    // Direct / reused Attempt 由 run.ts 在进入本函数前发 start；fresh Sandbox 则由下面的 provider
-    // admission 在 granted 后发 start，再于同一边界进入 sandbox.create。没有对应 hook/配置的步骤
-    // 直接不调用，不产生空阶段。没有活跃 feedback coordinator 时 lifecycle 投影静默 no-op。
-    const identity = { experimentId: run.experimentId, evalId: evalDef.id, attempt };
-    // 最近跨入的正式 phase:errored 结果的 `error.phase` 从它取(见下方 timeout / scope
-    // 兜底与 runAttemptBody 的 body catch)。body 与本函数共用同一个 enterPhase 闭包(经 res 传下去),
-    // 所以 body 内部的阶段推进也会更新它,不需要 body 再单独维护一份。
-    // 阶段计时:live 展示、error.phase、落盘 phases[].name 用同一套 LifecyclePhase 闭集,
-    // 一次 enterPhase 同时推进三者(词表全仓只有一套,见 runner/types.ts 的 LifecyclePhase)。
-    let lastPhase;
-    const recorder = (0, timing_ts_1.createTimingRecorder)();
-    // adapter send 在飞时,错误/诊断归因到嵌套的 `agent.run`(eval.run 内打开,不单列计时条目)。
-    let sendActive = false;
-    // 超时证据保全的外层句柄:与 recorder 同一模式,runAttemptBody 内部一建好 SessionManager /
-    // ChangeLedger 就经 AttemptResources.registerEvidence/registerLedger 登记回这里——中断后由
-    // Sample 外层直接读它们组装结果,不随被 Effect 中断放弃的 body fiber 一起消失(见
-    // docs/runner.md「超时:双层保护」超时不丢证据)。
-    let liveEvents;
-    let liveUsage;
-    let liveRetryAttempts;
-    let liveLedger;
-    // Assert-first state becomes visible only after the real TestContext has
-    // been constructed. Scope finalization owns the interruption seal so an
-    // aborted Attempt cannot leave declared entries unsealed.
-    let liveAssertions;
-    let liveAssertionState;
-    let adapterResources;
-    let adapterUsage;
-    let adapterUsageSnapshot;
-    let adapterAttachments;
-    let adapterExecutionTraces;
-    let adapterSealedAssertions;
-    let adapterCleanupError;
-    let invocationInterrupted = false;
-    let assertionsSealed = false;
-    let resolveExecutionTerminal;
-    const executionTerminal = new Promise((resolve) => {
-        resolveExecutionTerminal = resolve;
-    });
-    const markExecutionTerminal = () => {
-        if (assertionsSealed)
-            return;
-        assertionsSealed = true;
-        resolveExecutionTerminal();
-    };
-    let timeoutSealedAssertions;
-    // Effect.timeoutTo 的 onTimeout 是同步回调,在中断真正下发给 body fiber(从而触发下面的
-    // finalizer 链)之前就已经跑完并同步置位这个标记——下面新增的 finalizer 靠它判断本次 Sample
-    // release 是不是超时触发的,只在超时路径补折叠证据,正常收尾路径不重复做(见文件顶部
-    // Effect.timeoutTo 调用点的注释)。
-    let timedOut = false;
-    let deadlineError;
-    let timeoutDiff;
-    let fileChangesCapture;
-    let timeoutFileChangesCapture;
-    let timeoutSources;
-    const closeAuthoring = (reason) => {
-        adapterResources?.closeAuthoring();
-        liveAssertions?.closeAuthoring(reason);
-    };
-    const forwardParentAbort = () => {
-        closeAuthoring("attempt-interrupted");
-        parentAbort.abort(parentSignal?.reason);
-    };
-    if (parentSignal?.aborted === true)
-        forwardParentAbort();
-    else
-        parentSignal?.addEventListener("abort", forwardParentAbort, { once: true });
-    const enterPhase = (phase) => {
-        lastPhase = phase;
-        recorder.enter(phase);
-        onPhase?.(phase);
-        (0, sink_ts_1.reportAttemptLifecycle)({ type: "attempt:phase", at: Date.now(), identity, phase });
-    };
-    /**
-     * 终局失败的分类与回执 —— **必须在把错误折成纯数据 `AttemptError` 之前调**:折完之后原错误
-     * 对象(连同它携带的 `_tag`/`class` 与 cause 链)就不再是任何人的引用,空间轴声明再也读不出来。
-     * 走生命周期链的三道决议(抛出点声明 → 实验分类器 → 缺省不可重试,见
-     * src/shared/failure-class.ts 的 `resolveAttemptFailureClass`);send 失败的时间轴已由 send 重试
-     * 执行体在 context 层消费完,浮出到这里的一定是终局失败,这里只读空间轴。
-     * 缺省档(`scope` 省略或 `"attempt"`)不回执:那是「死因只属于本次执行」,没有闸可落。
-     */
-    const declareFailure = (phase, e) => {
-        if (!onFailureClass)
-            return;
-        const declaration = attemptFailureDeclaration(run.classifyFailure, phase, e);
-        if (declaration) {
-            // 空间轴回执会先于 Attempt 结果封口进入 run.ts，并立即生成运行期反馈与 run.json 的
-            // dispatch-halted 诊断。它不能依赖下面的 EvalResult 最终扫描补救，否则同一条错误在
-            // result.json 已脱敏、Run 级诊断却仍保留原值。分类决策只消费原始错误；对外回执单独
-            // 复制并脱敏正文，scope / phase 等路由事实保持原样。
-            onFailureClass({
-                ...declaration,
-                text: (0, redaction_ts_1.redactSensitiveText)(declaration.text, sensitiveValues),
-            });
+        const base = {
+            id: evalDef.id,
+            description: evalDef.description,
+            experimentId: run.experimentId,
+            experiment: experimentRunInfo(run, a.plan, a.sandboxPlansByEval, config, a.judge),
+            adapter: (0, adapter_ts_1.adapterIdentity)(adapter),
+            model: run.model,
+            verdict: "errored",
+            fingerprint: a.fingerprint,
+            evaluationAlgorithm: types_ts_1.EVALUATION_ALGORITHM,
+            configHash: a.configHash,
+            attempt,
+            startedAt: new Date(t0).toISOString(),
+            durationMs: 0,
+            factResults: [],
+            factUses: [],
+            evidenceCoverage: agent?.evidenceCoverage ?? attempt_resources_ts_1.adapterEvidenceUnavailable,
+            evaluationKind: evalDef.evaluationKind ?? "pass",
+        };
+        /**
+         * 调度事实:Sandbox 租借给这条 Attempt 的那一刻定死(复用池借出的实例在进入本函数时就已经
+         * 借定,一次性沙箱在 create 返回那一刻借定)。Attempt 在任何阶段终结——Eval `setup` 失败、
+         * 超时、资源获取失败——记录里都要带全 provider / sandboxId / reused / 编号与承接序号,
+         * 只有 `kept` 在收尾时点决定(见 docs/feature/record/architecture.md 的 `sandbox` 字段)。
+         * 所以它挂在唯一出口(下方 Effect.map)上,而不是分散在各条返回路径里。
+         */
+        let sandboxFacts;
+        let currentSandbox;
+        /** 留存提交成功(`--keep-sandbox`)——唯一一个在收尾时点才知道的 sandbox 记录键。 */
+        let kept = false;
+        if (reusedSandbox && agent?.kind === "sandbox") {
+            if (a.plan._tag !== "Sandbox") {
+                throw new Error(`sandbox agent ${JSON.stringify(agent.name)} received a Direct plan`);
+            }
+            sandboxFacts = {
+                provider: a.plan.providerPlan.provider,
+                sandboxId: reusedSandbox.sandbox.sandboxId,
+                reused: true,
+                reuseSandbox: reusedSandbox.reuseSandbox,
+                reuseOrdinal: reusedSandbox.reuseOrdinal,
+            };
         }
-    };
-    // 本 attempt 累计的诊断(与 verdict 独立):ScopedFeedback.diagnostic 与 teardown 失败都落这里,
-    // 收尾时并入结果;dedupeKey 相同的并发诊断折叠成一条并累计 count。
-    const diagnostics = [];
-    const dedupeIndex = new Map();
-    // Sandbox 命令证据的累加器(与 diagnostics 同一种「共享容器」模式):
-    // withCommandTiming 在 CommandResult 交还调用方之前把每条命令(成功与非零退出都算)push 进来,
-    // runAttemptBody 的 finally 与本函数的超时/中断兜底分支都读同一个数组引用
-    // (见 docs/feature/record/architecture.md「commandsjson」「证据在 CommandResult 返回
-    // 调用方之前写入内存」)。
-    const commands = [];
-    // CommandOptions.sensitiveValues 的 Attempt 级内存集合。值只供记录边界精确替换；最终
-    // result 封口后集合随本次调用释放，不进入任何 artifact、指纹或 provider identity。
-    const sensitiveValues = new Set();
-    // Package-internal only: the final EvalResult is weakly associated with this
-    // capture after all Runner evidence is sealed. No public result field or
-    // legacy artifact is used as a transport.
-    const observabilityRuntime = (0, runtime_ts_3.createRunnerAttemptObservabilityRuntime)({
-        providerName: adapter.name,
-        sensitiveValues,
-    });
-    const recordDiagnostic = (input) => {
-        const phase = (sendActive ? "agent.run" : lastPhase) ?? "eval.run";
-        if (input.dedupeKey !== undefined) {
-            const existing = dedupeIndex.get(input.dedupeKey);
-            if (existing) {
-                existing.count = (existing.count ?? 1) + 1;
+        // 四层解析链的最后两层(eval → config)在这里接上,并把赢家那一层带出来:超时消息要说得出
+        // 「这个上限是哪一层给的」,否则撞线时得回头逐层对照四个声明点(契约见
+        // docs/feature/experiments/cli.md「timeout、budget 与基础设施错误」)。
+        // 四层都没声明 = 无上限:不挂 deadline、不发软截止信号,也不给 provider 递命令超时,
+        // 链末端不发明一条隐藏的线。
+        const attemptTimeout = (0, timeout_ts_1.resolveAttemptTimeout)(run, evalDef, config);
+        // deadline 的截止**时刻**:沙箱内一切时限从它派生(单条命令未显式传 timeout 时上限 =
+        // 剩余量,见 sandbox/deadline.ts)。与 Effect.timeoutTo 同一个锚点,不各取各的 now()。
+        const deadlineAt = attemptTimeout ? clock.currentTimeMillisUnsafe() + attemptTimeout.timeoutMs : undefined;
+        const executionStartedAt = clock.monotonicTimeNanosUnsafe();
+        // Adapter 的协作式 deadline 由专用 controller 承载。它绝不能自己设 timer：Effect.timeoutTo
+        // 是唯一的 deadline owner，并会在 onTimeout 同步 abort 这个 controller；否则独立 timer
+        // 可能让 adapter 先 reject，把 deadline 错分成外部 interrupt。
+        const cancellation = new attempt_cancellation_ts_1.AttemptCancellationController();
+        const signal = cancellation.signal;
+        // Attempt 阶段的正式生命周期投影(见 docs/feature/experiments/cli.md「Attempt 阶段」)。
+        // Direct / reused Attempt 由 run.ts 在进入本函数前发 start；fresh Sandbox 则由下面的 provider
+        // admission 在 granted 后发 start，再于同一边界进入 sandbox.create。没有对应 hook/配置的步骤
+        // 直接不调用，不产生空阶段。没有活跃 feedback coordinator 时 lifecycle 投影静默 no-op。
+        const identity = { experimentId: run.experimentId, evalId: evalDef.id, attempt };
+        // 最近跨入的正式 phase:errored 结果的 `error.phase` 从它取(见下方 timeout / scope
+        // 兜底与 runAttemptBody 的 body catch)。body 与本函数共用同一个 enterPhase 闭包(经 res 传下去),
+        // 所以 body 内部的阶段推进也会更新它,不需要 body 再单独维护一份。
+        // 阶段计时:live 展示、error.phase、落盘 phases[].name 用同一套 LifecyclePhase 闭集,
+        // 一次 enterPhase 同时推进三者(词表全仓只有一套,见 runner/types.ts 的 LifecyclePhase)。
+        let lastPhase;
+        const recorder = (0, timing_ts_1.createTimingRecorder)();
+        // adapter send 在飞时,错误/诊断归因到嵌套的 `agent.run`(eval.run 内打开,不单列计时条目)。
+        let sendActive = false;
+        // 超时证据保全的外层句柄:与 recorder 同一模式,runAttemptBody 内部一建好 SessionManager /
+        // ChangeLedger 就经 AttemptResources.registerEvidence/registerLedger 登记回这里——中断后由
+        // Sample 外层直接读它们组装结果,不随被 Effect 中断放弃的 body fiber 一起消失(见
+        // docs/runner.md「超时:双层保护」超时不丢证据)。
+        let liveEvents;
+        let liveUsage;
+        let liveRetryAttempts;
+        let liveLedger;
+        // Assert-first state becomes visible only after the real TestContext has
+        // been constructed. Scope finalization owns the interruption seal so an
+        // aborted Attempt cannot leave declared entries unsealed.
+        let liveAssertions;
+        let liveAssertionState;
+        let adapterResources;
+        let adapterUsage;
+        let adapterUsageSnapshot;
+        let adapterAttachments;
+        let adapterExecutionTraces;
+        let adapterSealedAssertions;
+        let adapterCleanupError;
+        let invocationInterrupted = false;
+        let assertionsSealed = false;
+        let resolveExecutionTerminal;
+        const executionTerminal = new Promise((resolve) => {
+            resolveExecutionTerminal = resolve;
+        });
+        const markExecutionTerminal = () => {
+            if (assertionsSealed)
+                return;
+            assertionsSealed = true;
+            resolveExecutionTerminal();
+        };
+        let timeoutSealedAssertions;
+        // Effect.timeoutTo 的 onTimeout 是同步回调,在中断真正下发给 body fiber(从而触发下面的
+        // finalizer 链)之前就已经跑完并同步置位这个标记——下面新增的 finalizer 靠它判断本次 Sample
+        // release 是不是超时触发的,只在超时路径补折叠证据,正常收尾路径不重复做(见文件顶部
+        // Effect.timeoutTo 调用点的注释)。
+        let timedOut = false;
+        let deadlineError;
+        let timeoutDiff;
+        let fileChangesCapture;
+        let timeoutFileChangesCapture;
+        let timeoutSources;
+        const closeAuthoring = (reason) => {
+            adapterResources?.closeAuthoring();
+            liveAssertions?.closeAuthoring(reason);
+        };
+        const forwardParentAbort = () => {
+            closeAuthoring("attempt-interrupted");
+            cancellation.abort({ kind: "cancelled" });
+        };
+        if (parentSignal?.aborted === true)
+            forwardParentAbort();
+        else
+            parentSignal?.addEventListener("abort", forwardParentAbort, { once: true });
+        const enterPhase = (phase) => {
+            lastPhase = phase;
+            recorder.enter(phase);
+            onPhase?.(phase);
+            (0, sink_ts_1.reportAttemptLifecycle)({ type: "attempt:phase", at: Date.now(), identity, phase });
+        };
+        /**
+         * 终局失败的分类与回执 —— **必须在把错误折成纯数据 `AttemptError` 之前调**:折完之后原错误
+         * 对象(连同它携带的 `_tag`/`class` 与 cause 链)就不再是任何人的引用,空间轴声明再也读不出来。
+         * 走生命周期链的三道决议(抛出点声明 → 实验分类器 → 缺省不可重试,见
+         * src/shared/failure-class.ts 的 `resolveAttemptFailureClass`);send 失败的时间轴已由 send 重试
+         * 执行体在 context 层消费完,浮出到这里的一定是终局失败,这里只读空间轴。
+         * 缺省档(`scope` 省略或 `"attempt"`)不回执:那是「死因只属于本次执行」,没有闸可落。
+         */
+        const declareFailure = (phase, e) => {
+            if (!onFailureClass)
                 return;
+            const declaration = attemptFailureDeclaration(run.classifyFailure, phase, e);
+            if (declaration) {
+                // 空间轴回执会先于 Attempt 结果封口进入 run.ts，并立即生成运行期反馈与 run.json 的
+                // dispatch-halted 诊断。它不能依赖下面的 EvalResult 最终扫描补救，否则同一条错误在
+                // result.json 已脱敏、Run 级诊断却仍保留原值。分类决策只消费原始错误；对外回执单独
+                // 复制并脱敏正文，scope / phase 等路由事实保持原样。
+                onFailureClass({
+                    ...declaration,
+                    text: (0, redaction_ts_1.redactSensitiveText)(declaration.text, sensitiveValues),
+                });
             }
-        }
-        const message = (0, redaction_ts_1.redactSensitiveText)(input.message, sensitiveValues);
-        const context = input.data === undefined
-            ? undefined
-            : (0, redaction_ts_1.redactSensitiveEvidence)(input.data, sensitiveValues);
-        const record = {
-            code: input.code,
-            level: input.level,
-            detail: message,
-            origin: (0, timing_ts_1.attemptOrigin)(phase),
-            ...(context !== undefined ? { context } : {}),
         };
-        if (input.dedupeKey !== undefined)
-            dedupeIndex.set(input.dedupeKey, record);
-        diagnostics.push(record);
-        // 同时进运行级永久事件流(human 撤下 dashboard 后追加、JSON stdout 追加 warning,去重按 key)。
-        // `key` 只管折叠到多细(作者没给 dedupeKey 时折到「这一条 attempt 的这种诊断」,身份因此
-        // 编进去);对外稳定词法始终单独给 `code`,不让消费方从 key 反推(见 sink.ts 的
-        // DiagnosticInput.code、docs/feature/experiments/cli.md 的 WarningEvent)。
-        const { origin: _authorOrigin, phase: _authorPhase, ...diagnosticData } = context ?? {};
-        (0, sink_ts_1.reportDiagnostic)({
-            key: input.dedupeKey ?? `${input.code}:${(0, types_ts_1.encodeAttemptKey)(identity)}`,
-            code: input.code,
-            severity: input.level,
-            message,
-            identity,
-            // phase 由运行器给,且**压过**作者 `data` 里的同名字段:`WarningEvent.phase` 是
-            // `LifecyclePhase` 闭集,取值只能由「这条诊断报上来时运行器正处在哪一步」决定。
-            // 作者的 `data` 是开放词表,让它盖住这个字段等于允许从 eval / adapter 代码里冒充一个
-            // 别的(甚至不在闭集里的)阶段,消费方按 phase 分支就此失效——与 ScopedFeedback
-            // 「两个方法都不接受 phase」是同一条纪律(见 src/shared/types.ts 的接口注释)。
-            data: { ...diagnosticData, phase, origin: (0, timing_ts_1.attemptOrigin)(phase) },
+        // 本 attempt 累计的诊断(与 verdict 独立):ScopedFeedback.diagnostic 与 teardown 失败都落这里,
+        // 收尾时并入结果;dedupeKey 相同的并发诊断折叠成一条并累计 count。
+        const diagnostics = [];
+        const dedupeIndex = new Map();
+        // Sandbox 命令证据的累加器(与 diagnostics 同一种「共享容器」模式):
+        // withCommandTiming 在 CommandResult 交还调用方之前把每条命令(成功与非零退出都算)push 进来,
+        // runAttemptBody 的 finally 与本函数的超时/中断兜底分支都读同一个数组引用
+        // (见 docs/feature/record/architecture.md「commandsjson」「证据在 CommandResult 返回
+        // 调用方之前写入内存」)。
+        const commands = [];
+        // CommandOptions.sensitiveValues 的 Attempt 级内存集合。值只供记录边界精确替换；最终
+        // result 封口后集合随本次调用释放，不进入任何 artifact、指纹或 provider identity。
+        const sensitiveValues = new Set();
+        // Package-internal only: the final EvalResult is weakly associated with this
+        // capture after all Runner evidence is sealed. No public result field or
+        // legacy artifact is used as a transport.
+        const observabilityRuntime = (0, runtime_ts_3.createRunnerAttemptObservabilityRuntime)({
+            providerName: adapter.name,
+            sensitiveValues,
         });
-    };
-    // 作用域反馈:progress 只走 attempt:progress(短命状态,归因由 runner 的当前阶段决定),
-    // 不进入 recentLogs / timeout stack；diagnostic 落 attempt diagnostics + 运行级永久事件。
-    // 绑定见 docs/feature/experiments/library.md。
-    const scopedFeedback = {
-        progress: (u) => {
-            const suffix = u.current !== undefined && u.total !== undefined ? ` (${u.current}/${u.total})` : "";
+        const recordDiagnostic = (input) => {
+            const phase = (sendActive ? "agent.run" : lastPhase) ?? "eval.run";
+            if (input.dedupeKey !== undefined) {
+                const existing = dedupeIndex.get(input.dedupeKey);
+                if (existing) {
+                    existing.count = (existing.count ?? 1) + 1;
+                    return;
+                }
+            }
+            const message = (0, redaction_ts_1.redactSensitiveText)(input.message, sensitiveValues);
+            const context = input.data === undefined
+                ? undefined
+                : (0, redaction_ts_1.redactSensitiveEvidence)(input.data, sensitiveValues);
+            const record = {
+                code: input.code,
+                level: input.level,
+                detail: message,
+                origin: (0, timing_ts_1.attemptOrigin)(phase),
+                ...(context !== undefined ? { context } : {}),
+            };
+            if (input.dedupeKey !== undefined)
+                dedupeIndex.set(input.dedupeKey, record);
+            diagnostics.push(record);
+            // 同时进运行级永久事件流(human 撤下 dashboard 后追加、JSON stdout 追加 warning,去重按 key)。
+            // `key` 只管折叠到多细(作者没给 dedupeKey 时折到「这一条 attempt 的这种诊断」,身份因此
+            // 编进去);对外稳定词法始终单独给 `code`,不让消费方从 key 反推(见 sink.ts 的
+            // DiagnosticInput.code、docs/feature/experiments/cli.md 的 WarningEvent)。
+            const { origin: _authorOrigin, phase: _authorPhase, ...diagnosticData } = context ?? {};
+            (0, sink_ts_1.reportDiagnostic)({
+                key: input.dedupeKey ?? `${input.code}:${(0, types_ts_1.encodeAttemptKey)(identity)}`,
+                code: input.code,
+                severity: input.level,
+                message,
+                identity,
+                // phase 由运行器给,且**压过**作者 `data` 里的同名字段:`WarningEvent.phase` 是
+                // `LifecyclePhase` 闭集,取值只能由「这条诊断报上来时运行器正处在哪一步」决定。
+                // 作者的 `data` 是开放词表,让它盖住这个字段等于允许从 eval / adapter 代码里冒充一个
+                // 别的(甚至不在闭集里的)阶段,消费方按 phase 分支就此失效——与 ScopedFeedback
+                // 「两个方法都不接受 phase」是同一条纪律(见 src/shared/types.ts 的接口注释)。
+                data: { ...diagnosticData, phase, origin: (0, timing_ts_1.attemptOrigin)(phase) },
+            });
+        };
+        // 作用域反馈:progress 只走 attempt:progress(短命状态,归因由 runner 的当前阶段决定),
+        // 不进入 recentLogs / timeout stack；diagnostic 落 attempt diagnostics + 运行级永久事件。
+        // 绑定见 docs/feature/experiments/library.md。
+        const scopedFeedback = {
+            progress: (u) => {
+                const suffix = u.current !== undefined && u.total !== undefined ? ` (${u.current}/${u.total})` : "";
+                (0, sink_ts_1.reportAttemptLifecycle)({
+                    type: "attempt:progress",
+                    at: Date.now(),
+                    identity,
+                    detail: activeDetailText(`${u.message}${suffix}`, sensitiveValues),
+                });
+            },
+            diagnostic: recordDiagnostic,
+        };
+        const recordSandboxCleanupFailure = (stage, cause) => {
+            if (onSandboxCleanupFailure === undefined)
+                return;
+            const rawError = cause instanceof Error ? cause : new Error(String(cause));
+            // The ledger is later surfaced as an Experiment diagnostic, outside this
+            // Attempt's normal diagnostic sink. Preserve the real cleanup outcome, but
+            // cross that boundary only after applying this Attempt's evidence redaction.
+            const error = new Error((0, redaction_ts_1.redactSensitiveText)(rawError.message, sensitiveValues));
+            // This receiver runs inside the Scope finalizer path. It must not let a
+            // bookkeeping failure replace the provider or lifecycle cleanup outcome.
+            try {
+                onSandboxCleanupFailure({ stage, error });
+            }
+            catch {
+                // The owning Experiment will still receive the original cleanup result.
+            }
+        };
+        /**
+         * Sandbox runtime deliberately keeps lifecycle cleanup diagnostic-only so it
+         * can continue other finalizers. Only this fresh Sandbox wrapper
+         * observes those runtime-owned diagnostics; Eval/Agent diagnostics with the
+         * same public sink never enter the physical cleanup ledger.
+         */
+        const freshSandboxLifecycleFeedback = {
+            progress: scopedFeedback.progress,
+            diagnostic: (input) => {
+                scopedFeedback.diagnostic(input);
+                if (input.code === "sandbox-teardown-failed" ||
+                    input.code === "sandbox-stop-failed" ||
+                    input.code === "plugin-lifecycle-teardown-failed") {
+                    recordSandboxCleanupFailure("sandbox.lifecycle", new Error((0, redaction_ts_1.redactSensitiveText)(input.message, sensitiveValues)));
+                }
+            },
+        };
+        const judgeUsage = new judge_usage_ts_1.JudgeUsageCollector(config.pricing, signal, () => recordDiagnostic({
+            code: "judge-transport-cleanup-incomplete", level: "warning",
+            message: "Judge transport cleanup did not settle before its local deadline; remote completion is unknown.",
+        }));
+        const sealExecutionError = () => {
+            const runtime = liveAssertions ?? (evalDef.evaluationKind === "score"
+                ? (0, runtime_ts_2.createAssertionsRuntime)({ evaluationKind: "score", judgeUsage })
+                : (0, runtime_ts_2.createAssertionsRuntime)({ evaluationKind: "pass", judgeUsage }));
+            if (liveAssertions === undefined) {
+                // Sandbox acquire/prepare may fail before TestContext exists. It is still
+                // an executed Attempt, so seal its empty assertion set with the same
+                // execution-error terminal used by failures after Context construction.
+                liveAssertions = runtime;
+                sourceCapture.attachAssertions(runtime);
+            }
+            return (0, assertions_ts_1.sealAttemptAssertions)(runtime, { execution: "errored" }).pipe(effect_1.Effect.tap(() => effect_1.Effect.sync(() => {
+                markExecutionTerminal();
+            })), effect_1.Effect.tap((sealed) => adapter.kind === "custom"
+                ? effect_1.Effect.sync(() => { adapterSealedAssertions = sealed; })
+                : onSealedEvaluation?.(sealed) ?? effect_1.Effect.void));
+        };
+        // `log` 是显式 timeout breadcrumb；与短命 progress 分开，避免 user/tool ACTIVE 文本落盘。
+        const recentLogs = [];
+        const log = (m) => {
+            const detail = (0, redaction_ts_1.redactSensitiveText)(m, sensitiveValues);
+            recentLogs.push(detail);
+            if (recentLogs.length > 20)
+                recentLogs.shift();
+            // 附着在「当前阶段」上的次要文本(见 ActiveAttempt.detail)。所有调用点都晚于 Direct/reuse
+            // start，或 fresh provider 的 granted callback，active map 因而已经有这个 identity。这是唯一出口 ——
+            // 没有裸写 stderr 的兜底分支(那是给已删除的 Live reporter 用的旧接线,见
+            // docs/feature/experiments/cli.md「一个 run 内只有一个终端协调者」);由当前 renderer 决定
+            // 是否消费这条 detail（human 展示，JSON 不消费 lifecycle detail）。
             (0, sink_ts_1.reportAttemptLifecycle)({
                 type: "attempt:progress",
                 at: Date.now(),
                 identity,
-                detail: activeDetailText(`${u.message}${suffix}`, sensitiveValues),
+                detail: activeDetailText(m, sensitiveValues),
             });
-        },
-        diagnostic: recordDiagnostic,
-    };
-    const recordSandboxCleanupFailure = (stage, cause) => {
-        if (onSandboxCleanupFailure === undefined)
-            return;
-        const rawError = cause instanceof Error ? cause : new Error(String(cause));
-        // The ledger is later surfaced as an Experiment diagnostic, outside this
-        // Attempt's normal diagnostic sink. Preserve the real cleanup outcome, but
-        // cross that boundary only after applying this Attempt's evidence redaction.
-        const error = new Error((0, redaction_ts_1.redactSensitiveText)(rawError.message, sensitiveValues));
-        // This receiver runs inside the Scope finalizer path. It must not let a
-        // bookkeeping failure replace the provider or lifecycle cleanup outcome.
-        try {
-            onSandboxCleanupFailure({ stage, error });
-        }
-        catch {
-            // The owning Experiment will still receive the original cleanup result.
-        }
-    };
-    /**
-     * Sandbox runtime deliberately keeps lifecycle cleanup diagnostic-only so it
-     * can continue other finalizers. Only this fresh Sandbox wrapper
-     * observes those runtime-owned diagnostics; Eval/Agent diagnostics with the
-     * same public sink never enter the physical cleanup ledger.
-     */
-    const freshSandboxLifecycleFeedback = {
-        progress: scopedFeedback.progress,
-        diagnostic: (input) => {
-            scopedFeedback.diagnostic(input);
-            if (input.code === "sandbox-teardown-failed" ||
-                input.code === "sandbox-stop-failed" ||
-                input.code === "plugin-lifecycle-teardown-failed") {
-                recordSandboxCleanupFailure("sandbox.lifecycle", new Error((0, redaction_ts_1.redactSensitiveText)(input.message, sensitiveValues)));
-            }
-        },
-    };
-    const sealExecutionError = () => {
-        const runtime = liveAssertions ?? (evalDef.evaluationKind === "score"
-            ? (0, runtime_ts_2.createAssertionsRuntime)({ evaluationKind: "score" })
-            : (0, runtime_ts_2.createAssertionsRuntime)({ evaluationKind: "pass" }));
-        if (liveAssertions === undefined) {
-            // Sandbox acquire/prepare may fail before TestContext exists. It is still
-            // an executed Attempt, so seal its empty assertion set with the same
-            // execution-error terminal used by failures after Context construction.
-            liveAssertions = runtime;
-            sourceCapture.attachAssertions(runtime);
-        }
-        return (0, assertions_ts_1.sealAttemptAssertions)(runtime, { execution: "errored" }).pipe(effect_1.Effect.tap(() => effect_1.Effect.sync(() => {
-            markExecutionTerminal();
-        })), effect_1.Effect.tap((sealed) => adapter.kind === "custom"
-            ? effect_1.Effect.sync(() => { adapterSealedAssertions = sealed; })
-            : onSealedEvaluation?.(sealed) ?? effect_1.Effect.void));
-    };
-    // `log` 是显式 timeout breadcrumb；与短命 progress 分开，避免 user/tool ACTIVE 文本落盘。
-    const recentLogs = [];
-    const log = (m) => {
-        const detail = (0, redaction_ts_1.redactSensitiveText)(m, sensitiveValues);
-        recentLogs.push(detail);
-        if (recentLogs.length > 20)
-            recentLogs.shift();
-        // 附着在「当前阶段」上的次要文本(见 ActiveAttempt.detail)。所有调用点都晚于 Direct/reuse
-        // start，或 fresh provider 的 granted callback，active map 因而已经有这个 identity。这是唯一出口 ——
-        // 没有裸写 stderr 的兜底分支(那是给已删除的 Live reporter 用的旧接线,见
-        // docs/feature/experiments/cli.md「一个 run 内只有一个终端协调者」);由当前 renderer 决定
-        // 是否消费这条 detail（human 展示，JSON 不消费 lifecycle detail）。
-        (0, sink_ts_1.reportAttemptLifecycle)({
-            type: "attempt:progress",
-            at: Date.now(),
-            identity,
-            detail: activeDetailText(m, sensitiveValues),
-        });
-    };
-    /**
-     * ── attempt 总超时的硬边界(P1)──
-     * 上限是「整个 attempt(setup+agent+脚本+评分)」的,不是 docker 单条命令的。
-     * 到点 → 中断整段 body → Sample 跑 release(停容器、关接收器)→ 产出一条 errored 结果。
-     * 即便 adapter / test 完全无视 signal 挂死,这一层也能把它停下来并回收资源。
-     *
-     * 四层解析链都没声明上限时**这个算子整个不挂**——不是挂一条无穷大的 timer:没有线就没有
-     * deadline,attempt 跑到自己结束为止(与携带判据的 `Infinity` 同一个语义)。
-     */
-    const applyAttemptDeadline = (self) => {
-        if (attemptTimeout === undefined)
-            return self;
-        const { timeoutMs, source: timeoutSource } = attemptTimeout;
-        const deadline = effect_1.Effect.raceFirst(effect_1.Effect.sleep(effect_1.Duration.millis(timeoutMs)).pipe(effect_1.Effect.as("deadline")), effect_1.Effect.promise(() => executionTerminal).pipe(effect_1.Effect.as("terminal"))).pipe(effect_1.Effect.flatMap((winner) => {
-            // Assertion seal is the Attempt's terminal freeze. Once it wins, the
-            // deadline competitor is permanently retired while publication,
-            // source capture, and cleanup finish under their own ownership.
-            if (winner === "terminal")
-                return effect_1.Effect.never;
-            return effect_1.Effect.suspend(() => {
-                // Recheck in the same synchronous section that closes admission and
-                // flips `timedOut`; seal may have won after the race selected its
-                // timer but before this continuation was scheduled.
-                if (assertionsSealed)
+        };
+        /**
+         * ── attempt 总超时的硬边界(P1)──
+         * 上限是「整个 attempt(setup+agent+脚本+评分)」的,不是 docker 单条命令的。
+         * 到点 → 中断整段 body → Sample 跑 release(停容器、关接收器)→ 产出一条 errored 结果。
+         * 即便 adapter / test 完全无视 signal 挂死,这一层也能把它停下来并回收资源。
+         *
+         * 四层解析链都没声明上限时**这个算子整个不挂**——不是挂一条无穷大的 timer:没有线就没有
+         * deadline,attempt 跑到自己结束为止(与携带判据的 `Infinity` 同一个语义)。
+         */
+        const applyAttemptDeadline = (self) => {
+            if (attemptTimeout === undefined)
+                return self;
+            const { timeoutMs, source: timeoutSource } = attemptTimeout;
+            const waitForDeadline = effect_1.Effect.suspend(() => {
+                const remaining = timeoutMs - Number(clock.monotonicTimeNanosUnsafe() - executionStartedAt) / 1000000;
+                // Native timers truncate fractional milliseconds. Recheck the same
+                // monotonic deadline after waking rather than cancelling early.
+                return remaining <= 0 ? effect_1.Effect.void
+                    : effect_1.Effect.sleep(effect_1.Duration.millis(Math.ceil(remaining))).pipe(effect_1.Effect.andThen(waitForDeadline));
+            });
+            const deadline = effect_1.Effect.raceFirst(waitForDeadline.pipe(effect_1.Effect.as("deadline")), effect_1.Effect.promise(() => executionTerminal).pipe(effect_1.Effect.as("terminal"))).pipe(effect_1.Effect.flatMap((winner) => {
+                // Assertion seal is the Attempt's terminal freeze. Once it wins, the
+                // deadline competitor is permanently retired while publication,
+                // source capture, and cleanup finish under their own ownership.
+                if (winner === "terminal")
                     return effect_1.Effect.never;
-                // 超时:message 是一层原因(首行),recentLogs 明细放进 stack 供 show 展开「卡在哪一步」;
-                // operation 取超时那一刻打开的 lifecycle operation。code 稳定为 "timeout"。
-                const text = `attempt timed out (${timeoutMs}ms, from ${timeoutSource})
+                return effect_1.Effect.suspend(() => {
+                    // Recheck in the same synchronous section that closes admission and
+                    // flips `timedOut`; seal may have won after the race selected its
+                    // timer but before this continuation was scheduled.
+                    if (assertionsSealed || signal.aborted)
+                        return effect_1.Effect.never;
+                    // 超时:message 是一层原因(首行),recentLogs 明细放进 stack 供 show 展开「卡在哪一步」;
+                    // operation 取超时那一刻打开的 lifecycle operation。code 稳定为 "timeout"。
+                    const text = `attempt timed out (${timeoutMs}ms, from ${timeoutSource})
 Recent progress:
 ${recentLogs.map((l) => `  · ${l}`).join("\n")}`;
-                const message = (0, util_ts_1.firstLine)(text);
-                const rest = text.length > message.length ? text.slice(message.length + 1).replace(/\n+$/, "") : "";
-                const error = {
-                    code: "timeout",
-                    message,
-                    origin: (0, timing_ts_1.attemptOrigin)((sendActive ? "agent.run" : lastPhase) ?? "eval.run"),
-                    // 归属三样一起落盘:撞的是哪层时限、值多少、值从四层解析链的哪层来。
-                    // 不打一个没有归属说明的 ✗(见 docs/feature/sandbox/architecture.md「时限归属」)。
-                    timeout: { trigger: "attempt-deadline", limitMs: timeoutMs, source: timeoutSource },
-                    ...(rest.trim() !== "" ? { stack: rest } : {}),
-                };
-                deadlineError = error;
-                recorder.failCurrent();
-                // `timeoutTo` 已经赢得 deadline：先同步关闭所有作者/Core 修改入口，
-                // 再标记并 abort 协作式 adapter。同步 abort listener 因而也不能追加断言。
-                // Scope release below seals the Attempt-local Assertions runtime as
-                // producer-interrupted before resources are released.
-                // 这个 controller 没有独立 timer；它只把已经裁定的 timeout 传给观察 signal 的
-                // adapter。标记必须先于 abort，才能把本 fiber 的 timeout 中断与真正外层取消区分。
-                closeAuthoring("attempt-interrupted");
-                timedOut = true;
-                deadlineAbort.abort();
-                // 置位给下面的 finalizer 用(它在 Sample release 里跑,LIFO 早于 sandbox stop,
-                // 补折叠 workspace.diff / sources——见该 finalizer 的注释)。events/usage 不必等它:
-                // SessionManager 是外层已经登记过的活引用(见 liveEvents/liveUsage),截至这一刻已经
-                // 归一化的事件与已累计的用量此刻就能直接读出,不随放弃的 body fiber 一起消失。
-                const events = liveEvents?.();
-                const usage = liveUsage?.();
-                const retryAttempts = liveRetryAttempts?.();
-                return effect_1.Effect.succeed({
-                    ...base,
-                    durationMs: recorder.offsetNow(),
-                    error,
-                    ...(evalDef.evaluationKind === "score" ? { scoreResult: scoreFactOutcomeForAttemptError(error) } : {}),
-                    ...(events !== undefined ? { events: [...events], o11y: (0, derive_ts_1.buildO11ySummary)(events) } : {}),
-                    ...(usage !== undefined ? { usage: { ...usage } } : {}),
-                    ...(retryAttempts !== undefined && retryAttempts.length > 0
-                        ? { retryAttempts: retryAttempts.map((attempt) => ({ ...attempt })) }
-                        : {}),
-                    // 超时前已经登记的命令证据(见 withCommandTiming)不因中断而丢失——它们在
-                    // CommandResult 返回调用方那一刻就已经写进了这个共享数组。
-                    ...(commands.length > 0 ? { commands: [...commands] } : {}),
+                    const message = (0, util_ts_1.firstLine)(text);
+                    const rest = text.length > message.length ? text.slice(message.length + 1).replace(/\n+$/, "") : "";
+                    const error = {
+                        code: "timeout",
+                        message,
+                        origin: (0, timing_ts_1.attemptOrigin)((sendActive ? "agent.run" : lastPhase) ?? "eval.run"),
+                        // 归属三样一起落盘:撞的是哪层时限、值多少、值从四层解析链的哪层来。
+                        // 不打一个没有归属说明的 ✗(见 docs/feature/sandbox/architecture.md「时限归属」)。
+                        timeout: { trigger: "attempt-deadline", limitMs: timeoutMs, source: timeoutSource },
+                        ...(rest.trim() !== "" ? { stack: rest } : {}),
+                    };
+                    deadlineError = error;
+                    recorder.failCurrent();
+                    // `timeoutTo` 已经赢得 deadline：先同步关闭所有作者/Core 修改入口，
+                    // 再标记并 abort 协作式 adapter。同步 abort listener 因而也不能追加断言。
+                    // Scope release below seals the Attempt-local Assertions runtime as
+                    // producer-interrupted before resources are released.
+                    // 这个 controller 没有独立 timer；它只把已经裁定的 timeout 传给观察 signal 的
+                    // adapter。标记必须先于 abort，才能把本 fiber 的 timeout 中断与真正外层取消区分。
+                    closeAuthoring("attempt-interrupted");
+                    timedOut = true;
+                    cancellation.abort({ kind: "timeout", timeoutMs, source: timeoutSource, deadlineAt: deadlineAt });
+                    // 置位给下面的 finalizer 用(它在 Sample release 里跑,LIFO 早于 sandbox stop,
+                    // 补折叠 workspace.diff / sources——见该 finalizer 的注释)。events/usage 不必等它:
+                    // SessionManager 是外层已经登记过的活引用(见 liveEvents/liveUsage),截至这一刻已经
+                    // 归一化的事件与已累计的用量此刻就能直接读出,不随放弃的 body fiber 一起消失。
+                    const events = liveEvents?.();
+                    const usage = liveUsage?.();
+                    const retryAttempts = liveRetryAttempts?.();
+                    return effect_1.Effect.succeed({
+                        ...base,
+                        durationMs: recorder.offsetNow(),
+                        error,
+                        ...(evalDef.evaluationKind === "score" ? { scoreResult: scoreFactOutcomeForAttemptError(error) } : {}),
+                        ...(events !== undefined ? { events: [...events], o11y: (0, derive_ts_1.buildO11ySummary)(events) } : {}),
+                        ...(usage !== undefined ? { usage: { ...usage } } : {}),
+                        ...(retryAttempts !== undefined && retryAttempts.length > 0
+                            ? { retryAttempts: retryAttempts.map((attempt) => ({ ...attempt })) }
+                            : {}),
+                        // 超时前已经登记的命令证据(见 withCommandTiming)不因中断而丢失——它们在
+                        // CommandResult 返回调用方那一刻就已经写进了这个共享数组。
+                        ...(commands.length > 0 ? { commands: [...commands] } : {}),
+                    });
                 });
-            });
-        }));
-        return effect_1.Effect.raceFirst(self, deadline);
-    };
-    const layerCleanups = [];
-    return effect_1.Effect.uninterruptibleMask((restore) => restore(effect_1.Effect.scoped(effect_1.Effect.gen(function* () {
-        // Every Adapter kind enters through the same Attempt-owned bridge,
-        // execution deadline, Assertion seal, feedback sink, and publication
-        // callback. The driver below contributes only its own preparation,
-        // author context, and observations.
-        const assertFirst = yield* (0, assert_first_bridge_ts_1.makeAssertFirstAttemptBridge)();
-        if (adapter.kind === "custom") {
-            const resources = new attempt_resources_ts_1.AdapterAttemptResources(() => {
-                adapterUsageSnapshot = adapterUsage.close();
-                adapterAttachments.close();
-                adapterExecutionTraces.close();
-            });
-            adapterResources = resources;
-            adapterUsage = new adapter_usage_ts_1.AdapterUsageCollector(() => resources.assertCaptureOpen(), config.pricing);
-            adapterAttachments = (0, adapter_attachments_ts_1.createAdapterAttachmentCollector)(`${(0, root_ts_1.recordRootPaths)(opts.recordRoot).portableRoot}/attachment-staging`);
-            const ownedAttachments = adapterAttachments;
-            yield* effect_1.Scope.addFinalizer(attachmentScope, effect_1.Effect.promise(() => ownedAttachments.dispose()));
-            adapterExecutionTraces = (0, adapter_execution_trace_ts_1.createAdapterExecutionTraceCollector)(adapterAttachments.artifacts);
-            // Scope LIFO freezes Assertions before releasing author resources.
-            // The final execution outcome is handed off only after capture drains.
-            yield* effect_1.Effect.addFinalizer(() => cleanupAdapterResources(resources, {
-                enterPhase,
-                recorder,
-                feedback: scopedFeedback,
-                onTimeout: (error) => { adapterCleanupError = error; },
-            }));
-            yield* effect_1.Effect.addFinalizer((exit) => effect_1.Effect.suspend(() => {
-                const interrupted = timedOut || (effect_1.Exit.isFailure(exit) && effect_1.Cause.hasInterruptsOnly(exit.cause));
-                if (!interrupted || liveAssertions === undefined || assertionsSealed) {
-                    return effect_1.Effect.void;
-                }
-                closeAuthoring("attempt-interrupted");
-                sourceCapture.markInterrupted();
-                return (0, assertions_ts_1.sealAttemptAssertions)(liveAssertions, {
-                    execution: "errored",
-                    interrupted: true,
-                }).pipe(effect_1.Effect.tap((sealed) => effect_1.Effect.sync(() => {
-                    markExecutionTerminal();
-                    timeoutSealedAssertions = sealed;
-                    adapterSealedAssertions = sealed;
-                })), effect_1.Effect.catchCause(() => effect_1.Effect.void));
             }));
-            return yield* runAdapterAttemptBody({
-                a,
-                base,
-                adapter,
-                resources,
-                usage: adapterUsage,
-                attachments: adapterAttachments,
-                executionTraces: adapterExecutionTraces,
-                signal,
-                sourceCapture,
-                sourceRegistry,
-                assertFirst,
-                enterPhase,
-                recorder,
-                feedback: scopedFeedback,
-                log,
-                declareFailure,
-                registerAssertions: (runtime) => {
-                    if (liveAssertions !== undefined && liveAssertions !== runtime) {
-                        throw new Error("Attempt tried to register a second Assertions runtime");
-                    }
-                    liveAssertions = runtime;
-                },
-                closeAuthoring,
-                markAssertionsSealed: (sealed) => {
-                    markExecutionTerminal();
-                    adapterSealedAssertions = sealed;
-                    timeoutSealedAssertions = timedOut ? sealed : timeoutSealedAssertions;
-                },
-            });
-        }
-        if (agent === undefined) {
-            throw new Error(`Agent Adapter ${JSON.stringify(adapter.name)} is missing its Agent runtime`);
-        }
-        const projectStateDatabase = yield* project_state_database_ts_1.ProjectStateDatabase;
-        const sandboxPlan = a.plan._tag === "Sandbox" ? a.plan : undefined;
-        if (agent.kind === "sandbox" && sandboxPlan === undefined) {
-            throw new Error(`sandbox agent ${JSON.stringify(agent.name)} received a Direct plan`);
-        }
-        const runtimeCapabilities = sandboxPlan === undefined ? undefined : (0, runtime_ts_1.sandboxRuntimeCapabilities)(sandboxPlan);
-        // 留存 disposition:只在本 attempt 内可变,初始 stop;只有留存提交成功才改成 keep
-        // (Ctrl+C 中断外层 Sample 时仍是 stop,照常清理)。是否可留存只读 physical plan
-        // 的中性 retention 能力；不在 runner 里按 provider 名或旧声明结构分支。
-        let disposition = "stop";
-        // The bridge owns its Queue worker inside this Attempt Scope. Promise
-        // code only offers work; no internal module starts a second runtime.
-        // 退避重试(runtime.ts → retry.ts)期间临时归还这个名额:被限流的 provider 只是在
-        // setTimeout 里睡觉,不该攥着 sandboxSem 的槽位陪跑,不然一批 429 能把整体并发拖成个位数。
-        const provisioningPermit = (0, provisioning_permit_ts_1.makeProvisioningPermitOwner)(sandboxSem);
-        const provisionSlot = provisioningPermit;
-        const admissionSlot = {
-            // The ordinary provisioning permit is innermost and leaves first. The
-            // scheduler permits then leave through their stateful owner handle.
-            release: provisioningPermit.release.pipe(effect_1.Effect.andThen(concurrencySlot?.release ?? effect_1.Effect.void)),
-            // Re-enter the scheduler in its original order before taking the
-            // ordinary provisioning permit again. Each scheduler owner and the
-            // provisioning owner is stateful; cancellation cleans only permits
-            // actually reacquired and never issues a blind release.
-            reacquire: (concurrencySlot?.reacquire ?? effect_1.Effect.void).pipe(effect_1.Effect.andThen(provisioningPermit.reacquire)),
-        };
-        const runtimeAdmission = {
-            queued: (reason) => (providerAdmission?.queued(reason) ?? effect_1.Effect.void).pipe(effect_1.Effect.andThen(effect_1.Effect.sync(() => enterPhase("sandbox.queue")))),
-            granted: (providerAdmission?.granted ?? effect_1.Effect.void).pipe(effect_1.Effect.andThen(effect_1.Effect.sync(() => {
-                enterPhase("sandbox.create");
-                log(`starting sandbox...`);
-            }))),
-            slot: admissionSlot,
+            return effect_1.Effect.raceFirst(self, deadline);
         };
-        // Sample release(receiver close + provider stop)整段计成 sandbox.stop:先加的 finalizer
-        // 后跑(LIFO),所以「先加的」在 release 链末尾打终点戳、「后加的」在 release 开始前打起点戳;
-        // 结果封口(附 phases)发生在 Sample release 完成之后(见下方 Effect.map)。
-        let releaseStartedAt;
-        if (agent.kind === "sandbox" && !reusedSandbox) {
-            yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => {
-                // 留存路径的 phases 以 sandbox.suspend 结尾,没有 sandbox.stop 条目(见 release)。
-                if (releaseStartedAt !== undefined && disposition !== "keep") {
-                    recorder.record("sandbox.stop", recorder.offsetNow() - releaseStartedAt);
-                }
-            }));
-        }
-        let materializedCase;
-        const sandbox = reusedSandbox?.sandbox ??
-            (agent.kind === "sandbox"
-                ? yield* effect_1.Effect.gen(function* () {
-                    // ── 沙箱:acquire=起,release=整组 stop(成功 / 失败 / 中断都跑)──
-                    // sandboxSem 只覆盖「容器创建」阶段;容器起好后立即释放,后续 npm install / agent 不占位。
-                    // provider 固有的会话上限不能静默充当默认值:deadline 超出它时,attempt
-                    // 会跑到一半被平台截断。在派发前就报环境约束,点名 provider 与上限值。
-                    if (sandboxPlan === undefined || runtimeCapabilities === undefined) {
-                        throw new Error("sandbox plan invariant violated before materialization");
-                    }
-                    assertDeadlineFitsPlan(runtimeCapabilities, attemptTimeout?.timeoutMs);
-                    if (opts.keepSandbox !== undefined && runtimeCapabilities.retention._tag !== "Suspendable") {
-                        throw new Error(`--keep-sandbox is unsupported by provider ${JSON.stringify(runtimeCapabilities.provider)}`);
-                    }
-                    const runtimeDeadline = attemptTimeout === undefined || deadlineAt === undefined
-                        ? { _tag: "Unlimited" }
-                        : { _tag: "Bounded", timeoutMs: attemptTimeout.timeoutMs, deadlineAt };
-                    const runtimeInput = {
-                        plan: sandboxPlan,
-                        evalId: evalDef.id,
-                        deadline: runtimeDeadline,
-                        feedback: freshSandboxLifecycleFeedback,
-                        signal,
-                        hookContext: {
-                            experimentId: sandboxPlan.pair.experimentId,
-                            signal,
-                            progress: freshSandboxLifecycleFeedback.progress,
-                            diagnostic: freshSandboxLifecycleFeedback.diagnostic,
-                        },
-                        buildLocators,
-                        ...(preparedSetupPrefix === undefined
-                            ? {}
-                            : { setupPrefixArtifact: preparedSetupPrefix.artifact.locator }),
-                        agent: agent.kind === "sandbox" ? agent : undefined,
-                        ...(runTiming !== undefined ? { runTiming } : {}),
-                        provisionSlot: { _tag: "Bound", value: provisionSlot },
-                        admission: { _tag: "Bound", value: runtimeAdmission },
-                        services: runtime_ts_1.liveSandboxRuntimeServices,
-                        // Provider runtime 自己用 acquireRelease 持有 Case；Attempt 只提交显式
-                        // Managed disposition，避免外层再包一层 acquireRelease 造成 double-stop。
-                        release: {
-                            _tag: "Managed",
-                            run: (owned) => effect_1.Effect.gen(function* () {
-                                const sb = owned.sandbox;
-                                if (disposition !== "keep") {
-                                    return yield* tryPromiseAsDefect(() => owned.group.stop()).pipe(effect_1.Effect.onExit((exit) => effect_1.Exit.isFailure(exit)
-                                        ? effect_1.Effect.sync(() => {
-                                            recordSandboxCleanupFailure("sandbox.stop", effect_1.Cause.squash(exit.cause));
-                                        })
-                                        : effect_1.Effect.void));
-                                }
-                                yield* effect_1.Effect.sync(() => (0, registry_ts_1.unregisterSandbox)(sb));
-                                const providerName = runtimeCapabilities.provider;
-                                const suspendStart = recorder.offsetNow();
-                                return yield* tryPromiseAsDefect(() => (0, keep_ts_1.suspendSandbox)(sb)).pipe(effect_1.Effect.tap(() => effect_1.Effect.sync(() => {
-                                    recorder.record("sandbox.suspend", recorder.offsetNow() - suspendStart);
-                                })), effect_1.Effect.andThen((0, keep_registry_ts_1.updateKeptEntryEffect)(coordinationRoot, (0, keep_registry_ts_1.keptEntryId)(providerName, sb.sandboxId), {
-                                    state: "dormant",
-                                }).pipe(effect_1.Effect.provideService(project_state_database_ts_1.ProjectStateDatabase, projectStateDatabase), effect_1.Effect.ignore)), effect_1.Effect.catchCause((cause) => effect_1.Cause.hasInterruptsOnly(cause)
-                                    ? effect_1.Effect.failCause(cause)
-                                    : effect_1.Effect.sync(() => {
-                                        const error = effect_1.Cause.squash(cause);
-                                        recorder.record("sandbox.suspend", recorder.offsetNow() - suspendStart, true);
-                                        recordDiagnostic({
-                                            code: "sandbox-suspend-failed",
-                                            level: "warning",
-                                            message: `sandbox ${sb.sandboxId} kept but suspend failed; the instance is still running: ${error instanceof Error ? error.message : String(error)}`,
-                                            dedupeKey: `sandbox-suspend-failed:${sb.sandboxId}`,
-                                        });
-                                    })));
-                            }),
-                        },
-                    };
-                    const materialized = yield* effect_1.Effect.acquireUseRelease(provisioningPermit.acquire, () => (0, runtime_ts_1.acquireSandboxRunPlan)(runtimeInput), () => provisioningPermit.release);
-                    // Legacy layer/plugin setup is the earliest opaque barrier and runs after
-                    // provider admission has been returned, while the same Attempt Scope still owns release.
-                    if (sandboxPlan.pair.setupHooks.length > 0 || sandboxPlan.pair.pluginLifecycles.length > 0) {
-                        enterPhase("sandbox.prepare");
+        const layerCleanups = [];
+        return effect_1.Effect.uninterruptibleMask((restore) => restore(effect_1.Effect.scoped(effect_1.Effect.gen(function* () {
+            // Every Adapter kind enters through the same Attempt-owned bridge,
+            // execution deadline, Assertion seal, feedback sink, and publication
+            // callback. The driver below contributes only its own preparation,
+            // author context, and observations.
+            yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.promise(() => judgeUsage.closeAndDrain()));
+            const assertFirst = yield* (0, assert_first_bridge_ts_1.makeAssertFirstAttemptBridge)();
+            if (adapter.kind === "custom") {
+                const resources = new attempt_resources_ts_1.AdapterAttemptResources(() => {
+                    adapterUsageSnapshot = adapterUsage.close();
+                    adapterExecutionTraces.close();
+                    adapterAttachments.close();
+                });
+                adapterResources = resources;
+                adapterUsage = new adapter_usage_ts_1.AdapterUsageCollector(() => resources.assertCaptureOpen(), config.pricing, run.models ?? Object.freeze({}));
+                adapterAttachments = (0, adapter_attachments_ts_1.createAdapterAttachmentCollector)(`${(0, root_ts_1.recordRootPaths)(opts.recordRoot).portableRoot}/attachment-staging`);
+                const ownedAttachments = adapterAttachments;
+                yield* effect_1.Scope.addFinalizer(attachmentScope, effect_1.Effect.promise(() => ownedAttachments.dispose()));
+                adapterExecutionTraces = (0, adapter_execution_trace_ts_1.createAdapterExecutionTraceCollector)(adapterAttachments.artifacts);
+                // Scope LIFO freezes Assertions before releasing author resources.
+                // The final execution outcome is handed off only after capture drains.
+                yield* effect_1.Effect.addFinalizer(() => cleanupAdapterResources(resources, {
+                    timeoutMs: adapter.cleanupTimeoutMs,
+                    enterPhase,
+                    recorder,
+                    feedback: scopedFeedback,
+                    onTimeout: (error) => { adapterCleanupError = error; },
+                }));
+                yield* effect_1.Effect.addFinalizer((exit) => effect_1.Effect.suspend(() => {
+                    const interrupted = timedOut || (effect_1.Exit.isFailure(exit) && effect_1.Cause.hasInterruptsOnly(exit.cause));
+                    if (!interrupted || liveAssertions === undefined || assertionsSealed) {
+                        return effect_1.Effect.void;
                     }
-                    yield* (0, runtime_ts_1.prepareMaterializedSandboxRunPlan)(runtimeInput, materialized);
-                    materializedCase = materialized;
-                    // fresh Attempt:author facade 在当前 Attempt Scope 内构建。executor 捕获本
-                    // Scope 的 Runtime,Scope 关闭时统一中断在飞请求并拒绝新调用;release closure
-                    // 继续用 materialized.sandbox(资源面 facade),两者生命周期互不借用。
-                    const executor = yield* (0, request_executor_ts_1.makeSandboxRequestExecutor)();
-                    return (0, paths_ts_1.makeSandboxAuthorFacade)(materialized.authorBackend, executor, runtimeCapabilities.provider);
-                })
-                : (0, direct_agent_sandbox_ts_1.createDirectAgentSandbox)());
-        currentSandbox = sandbox;
-        // 一次性沙箱的租借时刻:实例到手就定归属,后面无论走到哪一步终结都带着它。
-        if (agent.kind === "sandbox" && !sandboxFacts) {
-            sandboxFacts = { provider: runtimeCapabilities.provider, sandboxId: sandbox.sandboxId };
-        }
-        if (agent.kind !== "sandbox")
-            log(`using Direct Agent (no Sandbox created)...`);
-        const commandTarget = (0, operations_ts_1.createSandboxCommandTarget)(sandbox);
-        // A fresh author facade forks requests into this Attempt Scope. Once Scope.close starts,
-        // forkIn() interrupts new children immediately even before the executor's own finalizer flips
-        // its closed flag. Cleanup therefore uses the provider-owned resource facade; before/Agent/test
-        // continue to use the interruptible author facade above.
-        const cleanupCommandTarget = (0, operations_ts_1.createSandboxCommandTarget)(reusedSandbox?.resourceSandbox ?? materializedCase?.sandbox ?? sandbox);
-        // ── tracing ──────────────────────────────────────────────────────────────────
-        // sandbox.otlpHost:
-        //   string → provider 承诺该 hostname 可访问宿主 receiver
-        //   null   → provider 不承诺宿主回连,改在沙箱内起 attempt-scope collector
-        // defineConfig({ telemetry: { host } }) 可强制覆盖(如配好 tunnel 时)。
-        //
-        // 非沙箱 agent(远程 / 进程内)不走 per-attempt receiver:被测应用是长驻进程,只有一条
-        // 全局 OTel 管线(OTEL_* env 进程启动时读一次)—— per-attempt 端口会在第一个 attempt
-        // 结束时关掉,后续 span 全丢。改走 run 级共享池,span 逐轮归属(traceparent / 窗口)。
-        let receiver;
-        let telemetry;
-        let otelChannel;
-        // 共享池仅限:config 配了 telemetry(固定端口,无侵入接入的长驻服务)或显式 tracing.scope === "run"。
-        // 只声明 tracing 的进程内 adapter(如 aiSdkAgent)保持 per-attempt receiver,attempt 全并发。
-        const wantsSharedOtel = config.telemetry !== undefined || agent.tracing?.scope === "run";
-        if (agent.kind !== "sandbox" && wantsSharedOtel && opts.otelPool) {
-            enterPhase("telemetry.configure");
-            try {
-                otelChannel = yield* opts.otelPool.channel(agent.name);
-                const endpoint = otelChannel.receiver.endpoint(config.telemetry?.host ?? "127.0.0.1");
-                const env = agent.tracing?.env?.(endpoint);
-                telemetry = env ? { endpoint, env } : { endpoint };
-                log(`OTLP shared receiver (run-scoped) -> ${endpoint}`);
-            }
-            catch (e) {
-                if (isAttemptAborted(parentSignal))
-                    throw e;
-                recordDiagnostic({
-                    code: "telemetry-configure-failed",
-                    level: "warning",
-                    message: `telemetry configure failed; continuing without OTLP trace: ${(0, util_ts_1.firstLine)((0, util_ts_1.formatThrown)(e))}`,
-                    data: evidenceDiagnosticData("configure", e),
+                    closeAuthoring("attempt-interrupted");
+                    sourceCapture.markInterrupted();
+                    return (0, assertions_ts_1.sealAttemptAssertions)(liveAssertions, {
+                        execution: "errored",
+                        interrupted: true,
+                    }).pipe(effect_1.Effect.tap((sealed) => effect_1.Effect.sync(() => {
+                        markExecutionTerminal();
+                        timeoutSealedAssertions = sealed;
+                        adapterSealedAssertions = sealed;
+                    })), effect_1.Effect.catchCause(() => effect_1.Effect.void));
+                }));
+                return yield* runAdapterAttemptBody({
+                    a,
+                    base,
+                    adapter,
+                    resources,
+                    usage: adapterUsage,
+                    judgeUsage,
+                    attachments: adapterAttachments,
+                    executionTraces: adapterExecutionTraces,
+                    signal,
+                    sourceCapture,
+                    sourceRegistry,
+                    assertFirst,
+                    enterPhase,
+                    recorder,
+                    feedback: scopedFeedback,
+                    log,
+                    declareFailure,
+                    registerAssertions: (runtime) => {
+                        if (liveAssertions !== undefined && liveAssertions !== runtime) {
+                            throw new Error("Attempt tried to register a second Assertions runtime");
+                        }
+                        liveAssertions = runtime;
+                    },
+                    closeAuthoring,
+                    markAssertionsSealed: (sealed) => {
+                        markExecutionTerminal();
+                        adapterSealedAssertions = sealed;
+                        timeoutSealedAssertions = timedOut ? sealed : timeoutSealedAssertions;
+                    },
                 });
-                otelChannel = undefined;
-                telemetry = undefined;
             }
-        }
-        else if (agent.tracing !== undefined) {
-            enterPhase("telemetry.configure");
-            try {
-                const forcedHost = config.telemetry?.host;
-                if (forcedHost) {
-                    // 显式覆盖:走本地接收器,把指定 host 交给 agent
-                    receiver = yield* (0, receiver_ts_1.createTraceReceiver)();
-                    const endpoint = receiver.endpoint(forcedHost);
+            if (agent === undefined) {
+                throw new Error(`Agent Adapter ${JSON.stringify(adapter.name)} is missing its Agent runtime`);
+            }
+            const projectStateDatabase = yield* project_state_database_ts_1.ProjectStateDatabase;
+            const sandboxPlan = a.plan._tag === "Sandbox" ? a.plan : undefined;
+            if (agent.kind === "sandbox" && sandboxPlan === undefined) {
+                throw new Error(`sandbox agent ${JSON.stringify(agent.name)} received a Direct plan`);
+            }
+            const runtimeCapabilities = sandboxPlan === undefined ? undefined : (0, runtime_ts_1.sandboxRuntimeCapabilities)(sandboxPlan);
+            // 留存 disposition:只在本 attempt 内可变,初始 stop;只有留存提交成功才改成 keep
+            // (Ctrl+C 中断外层 Sample 时仍是 stop,照常清理)。是否可留存只读 physical plan
+            // 的中性 retention 能力；不在 runner 里按 provider 名或旧声明结构分支。
+            let disposition = "stop";
+            // The bridge owns its Queue worker inside this Attempt Scope. Promise
+            // code only offers work; no internal module starts a second runtime.
+            // 退避重试(runtime.ts → retry.ts)期间临时归还这个名额:被限流的 provider 只是在
+            // setTimeout 里睡觉,不该攥着 sandboxSem 的槽位陪跑,不然一批 429 能把整体并发拖成个位数。
+            const provisioningPermit = (0, provisioning_permit_ts_1.makeProvisioningPermitOwner)(sandboxSem);
+            const provisionSlot = provisioningPermit;
+            const admissionSlot = {
+                // The ordinary provisioning permit is innermost and leaves first. The
+                // scheduler permits then leave through their stateful owner handle.
+                release: provisioningPermit.release.pipe(effect_1.Effect.andThen(concurrencySlot?.release ?? effect_1.Effect.void)),
+                // Re-enter the scheduler in its original order before taking the
+                // ordinary provisioning permit again. Each scheduler owner and the
+                // provisioning owner is stateful; cancellation cleans only permits
+                // actually reacquired and never issues a blind release.
+                reacquire: (concurrencySlot?.reacquire ?? effect_1.Effect.void).pipe(effect_1.Effect.andThen(provisioningPermit.reacquire)),
+            };
+            const runtimeAdmission = {
+                queued: (reason) => (providerAdmission?.queued(reason) ?? effect_1.Effect.void).pipe(effect_1.Effect.andThen(effect_1.Effect.sync(() => enterPhase("sandbox.queue")))),
+                granted: (providerAdmission?.granted ?? effect_1.Effect.void).pipe(effect_1.Effect.andThen(effect_1.Effect.sync(() => {
+                    enterPhase("sandbox.create");
+                    log(`starting sandbox...`);
+                }))),
+                slot: admissionSlot,
+            };
+            // Sample release(receiver close + provider stop)整段计成 sandbox.stop:先加的 finalizer
+            // 后跑(LIFO),所以「先加的」在 release 链末尾打终点戳、「后加的」在 release 开始前打起点戳;
+            // 结果封口(附 phases)发生在 Sample release 完成之后(见下方 Effect.map)。
+            let releaseStartedAt;
+            if (agent.kind === "sandbox" && !reusedSandbox) {
+                yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => {
+                    // 留存路径的 phases 以 sandbox.suspend 结尾,没有 sandbox.stop 条目(见 release)。
+                    if (releaseStartedAt !== undefined && disposition !== "keep") {
+                        recorder.record("sandbox.stop", recorder.offsetNow() - releaseStartedAt);
+                    }
+                }));
+            }
+            let materializedCase;
+            const sandbox = reusedSandbox?.sandbox ??
+                (agent.kind === "sandbox"
+                    ? yield* effect_1.Effect.gen(function* () {
+                        // ── 沙箱:acquire=起,release=整组 stop(成功 / 失败 / 中断都跑)──
+                        // sandboxSem 只覆盖「容器创建」阶段;容器起好后立即释放,后续 npm install / agent 不占位。
+                        // provider 固有的会话上限不能静默充当默认值:deadline 超出它时,attempt
+                        // 会跑到一半被平台截断。在派发前就报环境约束,点名 provider 与上限值。
+                        if (sandboxPlan === undefined || runtimeCapabilities === undefined) {
+                            throw new Error("sandbox plan invariant violated before materialization");
+                        }
+                        assertDeadlineFitsPlan(runtimeCapabilities, attemptTimeout?.timeoutMs);
+                        if (opts.keepSandbox !== undefined && runtimeCapabilities.retention._tag !== "Suspendable") {
+                            throw new Error(`--keep-sandbox is unsupported by provider ${JSON.stringify(runtimeCapabilities.provider)}`);
+                        }
+                        const runtimeDeadline = attemptTimeout === undefined || deadlineAt === undefined
+                            ? { _tag: "Unlimited" }
+                            : { _tag: "Bounded", timeoutMs: attemptTimeout.timeoutMs, deadlineAt };
+                        const runtimeInput = {
+                            plan: sandboxPlan,
+                            evalId: evalDef.id,
+                            deadline: runtimeDeadline,
+                            feedback: freshSandboxLifecycleFeedback,
+                            signal,
+                            hookContext: {
+                                experimentId: sandboxPlan.pair.experimentId,
+                                signal,
+                                progress: freshSandboxLifecycleFeedback.progress,
+                                diagnostic: freshSandboxLifecycleFeedback.diagnostic,
+                            },
+                            buildLocators,
+                            ...(preparedSetupPrefix === undefined
+                                ? {}
+                                : { setupPrefixArtifact: preparedSetupPrefix.artifact.locator }),
+                            agent: agent.kind === "sandbox" ? agent : undefined,
+                            ...(runTiming !== undefined ? { runTiming } : {}),
+                            provisionSlot: { _tag: "Bound", value: provisionSlot },
+                            admission: { _tag: "Bound", value: runtimeAdmission },
+                            services: runtime_ts_1.liveSandboxRuntimeServices,
+                            // Provider runtime 自己用 acquireRelease 持有 Case；Attempt 只提交显式
+                            // Managed disposition，避免外层再包一层 acquireRelease 造成 double-stop。
+                            release: {
+                                _tag: "Managed",
+                                run: (owned) => effect_1.Effect.gen(function* () {
+                                    const sb = owned.sandbox;
+                                    if (disposition !== "keep") {
+                                        return yield* tryPromiseAsDefect(() => owned.group.stop()).pipe(effect_1.Effect.onExit((exit) => effect_1.Exit.isFailure(exit)
+                                            ? effect_1.Effect.sync(() => {
+                                                recordSandboxCleanupFailure("sandbox.stop", effect_1.Cause.squash(exit.cause));
+                                            })
+                                            : effect_1.Effect.void));
+                                    }
+                                    yield* effect_1.Effect.sync(() => (0, registry_ts_1.unregisterSandbox)(sb));
+                                    const providerName = runtimeCapabilities.provider;
+                                    const suspendStart = recorder.offsetNow();
+                                    return yield* tryPromiseAsDefect(() => (0, keep_ts_1.suspendSandbox)(sb)).pipe(effect_1.Effect.tap(() => effect_1.Effect.sync(() => {
+                                        recorder.record("sandbox.suspend", recorder.offsetNow() - suspendStart);
+                                    })), effect_1.Effect.andThen((0, keep_registry_ts_1.updateKeptEntryEffect)(coordinationRoot, (0, keep_registry_ts_1.keptEntryId)(providerName, sb.sandboxId), {
+                                        state: "dormant",
+                                    }).pipe(effect_1.Effect.provideService(project_state_database_ts_1.ProjectStateDatabase, projectStateDatabase), effect_1.Effect.ignore)), effect_1.Effect.catchCause((cause) => effect_1.Cause.hasInterruptsOnly(cause)
+                                        ? effect_1.Effect.failCause(cause)
+                                        : effect_1.Effect.sync(() => {
+                                            const error = effect_1.Cause.squash(cause);
+                                            recorder.record("sandbox.suspend", recorder.offsetNow() - suspendStart, true);
+                                            recordDiagnostic({
+                                                code: "sandbox-suspend-failed",
+                                                level: "warning",
+                                                message: `sandbox ${sb.sandboxId} kept but suspend failed; the instance is still running: ${error instanceof Error ? error.message : String(error)}`,
+                                                dedupeKey: `sandbox-suspend-failed:${sb.sandboxId}`,
+                                            });
+                                        })));
+                                }),
+                            },
+                        };
+                        const materialized = yield* effect_1.Effect.acquireUseRelease(provisioningPermit.acquire, () => (0, runtime_ts_1.acquireSandboxRunPlan)(runtimeInput), () => provisioningPermit.release);
+                        // Legacy layer/plugin setup is the earliest opaque barrier and runs after
+                        // provider admission has been returned, while the same Attempt Scope still owns release.
+                        if (sandboxPlan.pair.setupHooks.length > 0 || sandboxPlan.pair.pluginLifecycles.length > 0) {
+                            enterPhase("sandbox.prepare");
+                        }
+                        yield* (0, runtime_ts_1.prepareMaterializedSandboxRunPlan)(runtimeInput, materialized);
+                        materializedCase = materialized;
+                        // fresh Attempt:author facade 在当前 Attempt Scope 内构建。executor 捕获本
+                        // Scope 的 Runtime,Scope 关闭时统一中断在飞请求并拒绝新调用;release closure
+                        // 继续用 materialized.sandbox(资源面 facade),两者生命周期互不借用。
+                        const executor = yield* (0, request_executor_ts_1.makeSandboxRequestExecutor)();
+                        return (0, paths_ts_1.makeSandboxAuthorFacade)(materialized.authorBackend, executor, runtimeCapabilities.provider);
+                    })
+                    : (0, direct_agent_sandbox_ts_1.createDirectAgentSandbox)());
+            currentSandbox = sandbox;
+            // 一次性沙箱的租借时刻:实例到手就定归属,后面无论走到哪一步终结都带着它。
+            if (agent.kind === "sandbox" && !sandboxFacts) {
+                sandboxFacts = { provider: runtimeCapabilities.provider, sandboxId: sandbox.sandboxId };
+            }
+            if (agent.kind !== "sandbox")
+                log(`using Direct Agent (no Sandbox created)...`);
+            const commandTarget = (0, operations_ts_1.createSandboxCommandTarget)(sandbox);
+            // A fresh author facade forks requests into this Attempt Scope. Once Scope.close starts,
+            // forkIn() interrupts new children immediately even before the executor's own finalizer flips
+            // its closed flag. Cleanup therefore uses the provider-owned resource facade; before/Agent/test
+            // continue to use the interruptible author facade above.
+            const cleanupCommandTarget = (0, operations_ts_1.createSandboxCommandTarget)(reusedSandbox?.resourceSandbox ?? materializedCase?.sandbox ?? sandbox);
+            // ── tracing ──────────────────────────────────────────────────────────────────
+            // sandbox.otlpHost:
+            //   string → provider 承诺该 hostname 可访问宿主 receiver
+            //   null   → provider 不承诺宿主回连,改在沙箱内起 attempt-scope collector
+            // defineConfig({ telemetry: { host } }) 可强制覆盖(如配好 tunnel 时)。
+            //
+            // 非沙箱 agent(远程 / 进程内)不走 per-attempt receiver:被测应用是长驻进程,只有一条
+            // 全局 OTel 管线(OTEL_* env 进程启动时读一次)—— per-attempt 端口会在第一个 attempt
+            // 结束时关掉,后续 span 全丢。改走 run 级共享池,span 逐轮归属(traceparent / 窗口)。
+            let receiver;
+            let telemetry;
+            let otelChannel;
+            // 共享池仅限:config 配了 telemetry(固定端口,无侵入接入的长驻服务)或显式 tracing.scope === "run"。
+            // 只声明 tracing 的进程内 adapter(如 aiSdkAgent)保持 per-attempt receiver,attempt 全并发。
+            const wantsSharedOtel = config.telemetry !== undefined || agent.tracing?.scope === "run";
+            if (agent.kind !== "sandbox" && wantsSharedOtel && opts.otelPool) {
+                enterPhase("telemetry.configure");
+                try {
+                    otelChannel = yield* opts.otelPool.channel(agent.name);
+                    const endpoint = otelChannel.receiver.endpoint(config.telemetry?.host ?? "127.0.0.1");
                     const env = agent.tracing?.env?.(endpoint);
                     telemetry = env ? { endpoint, env } : { endpoint };
-                    log(`OTLP receiver (host override) -> ${endpoint}`);
+                    log(`OTLP shared receiver (run-scoped) -> ${endpoint}`);
                 }
-                else if (sandbox.otlpHost !== null) {
-                    // provider 明确承诺宿主回连:宿主开接收器
-                    receiver = yield* (0, receiver_ts_1.createTraceReceiver)();
-                    const endpoint = receiver.endpoint(sandbox.otlpHost);
-                    const env = agent.tracing?.env?.(endpoint);
-                    telemetry = env ? { endpoint, env } : { endpoint };
-                    const proto = agent.tracing?.protocol;
-                    log(`OTLP receiver -> ${endpoint}${proto ? ` (${proto})` : ""}`);
+                catch (e) {
+                    if (isAttemptAborted(parentSignal))
+                        throw e;
+                    recordDiagnostic({
+                        code: "telemetry-configure-failed",
+                        level: "warning",
+                        message: `telemetry configure failed; continuing without OTLP trace: ${(0, util_ts_1.firstLine)((0, util_ts_1.formatThrown)(e))}`,
+                        data: evidenceDiagnosticData("configure", e),
+                    });
+                    otelChannel = undefined;
+                    telemetry = undefined;
                 }
-                else {
-                    // provider 不承诺宿主回连:在沙箱内起 collector,agent 往 localhost 端口发。
-                    receiver = yield* (0, sandbox_receiver_ts_1.createInSandboxTraceReceiver)(sandbox);
-                    const endpoint = receiver.endpoint("");
-                    const env = agent.tracing?.env?.(endpoint);
-                    telemetry = env ? { endpoint, env } : { endpoint };
-                    const proto = agent.tracing?.protocol;
-                    log(`OTLP in-sandbox collector -> ${endpoint}${proto ? ` (${proto})` : ""}`);
+            }
+            else if (agent.tracing !== undefined) {
+                enterPhase("telemetry.configure");
+                try {
+                    const forcedHost = config.telemetry?.host;
+                    if (forcedHost) {
+                        // 显式覆盖:走本地接收器,把指定 host 交给 agent
+                        receiver = yield* (0, receiver_ts_1.createTraceReceiver)();
+                        const endpoint = receiver.endpoint(forcedHost);
+                        const env = agent.tracing?.env?.(endpoint);
+                        telemetry = env ? { endpoint, env } : { endpoint };
+                        log(`OTLP receiver (host override) -> ${endpoint}`);
+                    }
+                    else if (sandbox.otlpHost !== null) {
+                        // provider 明确承诺宿主回连:宿主开接收器
+                        receiver = yield* (0, receiver_ts_1.createTraceReceiver)();
+                        const endpoint = receiver.endpoint(sandbox.otlpHost);
+                        const env = agent.tracing?.env?.(endpoint);
+                        telemetry = env ? { endpoint, env } : { endpoint };
+                        const proto = agent.tracing?.protocol;
+                        log(`OTLP receiver -> ${endpoint}${proto ? ` (${proto})` : ""}`);
+                    }
+                    else {
+                        // provider 不承诺宿主回连:在沙箱内起 collector,agent 往 localhost 端口发。
+                        receiver = yield* (0, sandbox_receiver_ts_1.createInSandboxTraceReceiver)(sandbox);
+                        const endpoint = receiver.endpoint("");
+                        const env = agent.tracing?.env?.(endpoint);
+                        telemetry = env ? { endpoint, env } : { endpoint };
+                        const proto = agent.tracing?.protocol;
+                        log(`OTLP in-sandbox collector -> ${endpoint}${proto ? ` (${proto})` : ""}`);
+                    }
+                }
+                catch (e) {
+                    if (isAttemptAborted(parentSignal))
+                        throw e;
+                    recordDiagnostic({
+                        code: "telemetry-configure-failed",
+                        level: "warning",
+                        message: `telemetry configure failed; continuing without OTLP trace: ${(0, util_ts_1.firstLine)((0, util_ts_1.formatThrown)(e))}`,
+                        data: evidenceDiagnosticData("configure", e, runtimeCapabilities?.provider),
+                    });
+                    receiver = undefined;
+                    telemetry = undefined;
                 }
             }
-            catch (e) {
-                if (isAttemptAborted(parentSignal))
-                    throw e;
-                recordDiagnostic({
-                    code: "telemetry-configure-failed",
-                    level: "warning",
-                    message: `telemetry configure failed; continuing without OTLP trace: ${(0, util_ts_1.firstLine)((0, util_ts_1.formatThrown)(e))}`,
-                    data: evidenceDiagnosticData("configure", e, runtimeCapabilities?.provider),
-                });
-                receiver = undefined;
-                telemetry = undefined;
+            // attempt-scope 的进程内 adapter（如 aiSdkAgent + aiSdkOtel）虽然拥有独立 receiver，
+            // 仍需要逐轮窗口归属来给 TimingActivity 写入真实 traceId。独立 receiver 不会与其它
+            // attempt 混流，因此直接复用同一个 AgentOtelChannel 算法，不必升级成 run 级共享池。
+            if (agent.kind !== "sandbox" && receiver !== undefined && otelChannel === undefined) {
+                otelChannel = new turn_otel_ts_1.AgentOtelChannel(receiver);
             }
-        }
-        // attempt-scope 的进程内 adapter（如 aiSdkAgent + aiSdkOtel）虽然拥有独立 receiver，
-        // 仍需要逐轮窗口归属来给 TimingActivity 写入真实 traceId。独立 receiver 不会与其它
-        // attempt 混流，因此直接复用同一个 AgentOtelChannel 算法，不必升级成 run 级共享池。
-        if (agent.kind !== "sandbox" && receiver !== undefined && otelChannel === undefined) {
-            otelChannel = new turn_otel_ts_1.AgentOtelChannel(receiver);
-        }
-        if (agent.kind === "sandbox" && !reusedSandbox) {
-            // 后加先跑:release 链开始时打起点戳(与上面的终点戳配对,测出整段 sandbox.stop)。
-            yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => {
-                releaseStartedAt = recorder.offsetNow();
-            }));
-        }
-        // 超时收尾段的证据保全(docs/runner.md「超时:双层保护」超时不丢证据)。注册在这里,
-        // LIFO 意味着 release 时它先于上面已注册的 sandbox stop/suspend finalizer 跑——此刻沙箱
-        // (若有)仍然存活,赶在停之前抢一次 workspace.diff 折叠;`timedOut` 由 Effect.timeoutTo
-        // 的 onTimeout 同步置位,正常收尾(body 走完)时这里直接跳过,不重复采一次已经采过的证据。
-        // 沙箱此刻可能已经被 agent 搞挂——withCleanupTimeout 有界执行,导出挂起也不能拖住收尾,
-        // 到点如实缺失。计时单独记一条 phases 条目,不入 durationMs(durationMs 已在 onTimeout
-        // 按中断时刻定格)。sources 折叠是本地文件读取,与沙箱是否存活无关,一并在这里补。
-        yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.gen(function* () {
-            if (!timedOut)
-                return;
-            if (agent.kind === "sandbox" && liveLedger) {
-                const startedAt = recorder.offsetNow();
-                const diff = yield* effect_1.Effect.result((0, cleanup_timeout_ts_1.cleanupCallback)(() => liveLedger.exportWindows()));
-                if (effect_1.Result.isSuccess(diff)) {
-                    timeoutDiff = diff.success;
-                    let document;
-                    try {
-                        document = (0, workspace_diff_ts_1.createAgentWorkspaceDiff)({
-                            windows: diff.success,
-                            policy: liveLedger.attribution,
-                        });
+            if (agent.kind === "sandbox" && !reusedSandbox) {
+                // 后加先跑:release 链开始时打起点戳(与上面的终点戳配对,测出整段 sandbox.stop)。
+                yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => {
+                    releaseStartedAt = recorder.offsetNow();
+                }));
+            }
+            // 超时收尾段的证据保全(docs/runner.md「超时:双层保护」超时不丢证据)。注册在这里,
+            // LIFO 意味着 release 时它先于上面已注册的 sandbox stop/suspend finalizer 跑——此刻沙箱
+            // (若有)仍然存活,赶在停之前抢一次 workspace.diff 折叠;`timedOut` 由 Effect.timeoutTo
+            // 的 onTimeout 同步置位,正常收尾(body 走完)时这里直接跳过,不重复采一次已经采过的证据。
+            // 沙箱此刻可能已经被 agent 搞挂——withCleanupTimeout 有界执行,导出挂起也不能拖住收尾,
+            // 到点如实缺失。计时单独记一条 phases 条目,不入 durationMs(durationMs 已在 onTimeout
+            // 按中断时刻定格)。sources 折叠是本地文件读取,与沙箱是否存活无关,一并在这里补。
+            yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.gen(function* () {
+                if (!timedOut)
+                    return;
+                if (agent.kind === "sandbox" && liveLedger) {
+                    const startedAt = recorder.offsetNow();
+                    const diff = yield* effect_1.Effect.result((0, cleanup_timeout_ts_1.cleanupCallback)(() => liveLedger.exportWindows()));
+                    if (effect_1.Result.isSuccess(diff)) {
+                        timeoutDiff = diff.success;
+                        let document;
+                        try {
+                            document = (0, workspace_diff_ts_1.createAgentWorkspaceDiff)({
+                                windows: diff.success,
+                                policy: liveLedger.attribution,
+                            });
+                        }
+                        catch {
+                            timeoutFileChangesCapture = (0, diff_ts_2.createEmptyFileChangesCapture)({
+                                policy: liveLedger.attribution,
+                                limitations: [Object.freeze({
+                                        code: "capture-failed",
+                                        stage: "normalize",
+                                        atWindowId: null,
+                                    })],
+                            });
+                        }
+                        if (document !== undefined) {
+                            timeoutFileChangesCapture = (0, diff_ts_2.createFileChangesCapture)({
+                                document,
+                                limitations: [Object.freeze({
+                                        code: "capture-interrupted",
+                                        stage: "finalizer-export",
+                                        atWindowId: null,
+                                    })],
+                            });
+                        }
                     }
-                    catch {
+                    else {
                         timeoutFileChangesCapture = (0, diff_ts_2.createEmptyFileChangesCapture)({
                             policy: liveLedger.attribution,
-                            limitations: [Object.freeze({
-                                    code: "capture-failed",
-                                    stage: "normalize",
-                                    atWindowId: null,
-                                })],
-                        });
-                    }
-                    if (document !== undefined) {
-                        timeoutFileChangesCapture = (0, diff_ts_2.createFileChangesCapture)({
-                            document,
                             limitations: [Object.freeze({
                                     code: "capture-interrupted",
                                     stage: "finalizer-export",
@@ -906,427 +935,425 @@ ${recentLogs.map((l) => `  · ${l}`).join("\n")}`;
                                 })],
                         });
                     }
+                    if (timeoutFileChangesCapture !== undefined) {
+                        (0, diff_ts_2.assertFileChangesCaptureRecordable)(timeoutFileChangesCapture);
+                    }
+                    // 沙箱不可用 / 导出挂起到点:如实缺失,不阻塞收尾。
+                    recorder.record("workspace.diff", recorder.offsetNow() - startedAt);
                 }
-                else {
-                    timeoutFileChangesCapture = (0, diff_ts_2.createEmptyFileChangesCapture)({
-                        policy: liveLedger.attribution,
-                        limitations: [Object.freeze({
-                                code: "capture-interrupted",
-                                stage: "finalizer-export",
-                                atWindowId: null,
-                            })],
-                    });
+                const sources = yield* effect_1.Effect.result((0, cleanup_timeout_ts_1.cleanupCallback)(() => collectSources(evalDef.source, sourceRegistry)));
+                if (effect_1.Result.isSuccess(sources))
+                    timeoutSources = sources.success;
+                // 源码读不到:如实缺失,不阻塞收尾。
+            }));
+            // Matcher-only source material must not outlive the Attempt. Register
+            // this before the interruption seal so LIFO runs that seal first, then
+            // clears the sidecar immediately afterwards.
+            yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => liveAssertionState?.manager.releaseObservedEvaluationSegments()));
+            // Scope release owns the interruption seal. It runs before resource
+            // release, so entries already declared by the real Context survive a
+            // timeout or external cancellation in declaration order.
+            yield* effect_1.Effect.addFinalizer((exit) => effect_1.Effect.suspend(() => {
+                const interrupted = timedOut || (effect_1.Exit.isFailure(exit) && effect_1.Cause.hasInterruptsOnly(exit.cause));
+                if (interrupted)
+                    sourceCapture.markInterrupted();
+                if (!interrupted || liveAssertions === undefined || assertionsSealed) {
+                    return effect_1.Effect.void;
                 }
-                if (timeoutFileChangesCapture !== undefined) {
-                    (0, diff_ts_2.assertFileChangesCaptureRecordable)(timeoutFileChangesCapture);
+                if (liveAssertionState?.late.diff.state === "pending") {
+                    liveAssertionState.late.diff = Object.freeze({
+                        state: "unavailable",
+                        reason: "producer-interrupted",
+                    });
                 }
-                // 沙箱不可用 / 导出挂起到点:如实缺失,不阻塞收尾。
-                recorder.record("workspace.diff", recorder.offsetNow() - startedAt);
-            }
-            const sources = yield* effect_1.Effect.result((0, cleanup_timeout_ts_1.cleanupCallback)(() => collectSources(evalDef.source, sourceRegistry)));
-            if (effect_1.Result.isSuccess(sources))
-                timeoutSources = sources.success;
-            // 源码读不到:如实缺失,不阻塞收尾。
-        }));
-        // Matcher-only source material must not outlive the Attempt. Register
-        // this before the interruption seal so LIFO runs that seal first, then
-        // clears the sidecar immediately afterwards.
-        yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => liveAssertionState?.manager.releaseObservedEvaluationSegments()));
-        // Scope release owns the interruption seal. It runs before resource
-        // release, so entries already declared by the real Context survive a
-        // timeout or external cancellation in declaration order.
-        yield* effect_1.Effect.addFinalizer((exit) => effect_1.Effect.suspend(() => {
-            const interrupted = timedOut || (effect_1.Exit.isFailure(exit) && effect_1.Cause.hasInterruptsOnly(exit.cause));
-            if (interrupted)
-                sourceCapture.markInterrupted();
-            if (!interrupted || liveAssertions === undefined || assertionsSealed) {
-                return effect_1.Effect.void;
-            }
-            if (liveAssertionState?.late.diff.state === "pending") {
-                liveAssertionState.late.diff = Object.freeze({
-                    state: "unavailable",
-                    reason: "producer-interrupted",
-                });
-            }
-            return (0, assertions_ts_1.sealAttemptAssertions)(liveAssertions, {
-                execution: "errored",
-                interrupted: true,
-            }).pipe(effect_1.Effect.tap((sealed) => effect_1.Effect.sync(() => {
-                markExecutionTerminal();
-                timeoutSealedAssertions = sealed;
-            })), effect_1.Effect.tap((sealed) => onSealedEvaluation?.(sealed) ?? effect_1.Effect.void), 
-            // Release must preserve the original interruption/failure. A
-            // malformed attachment is still reflected by the sealed runtime,
-            // but cannot mask the owning Attempt's terminal cause.
-            effect_1.Effect.catchCause(() => effect_1.Effect.void));
-        }));
-        // Scope 的 LIFO 让作者 cleanup 在 agent teardown 后、Provider Case finalizer 前执行。
-        // Cleanup must not fork back into this already-closing Attempt Scope, so it uses the resource
-        // facade captured above while retaining the same physical Sandbox and provider release owner.
-        if (agent.kind === "sandbox") {
-            yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.suspend(() => {
-                if (layerCleanups.length === 0)
-                    return effect_1.Effect.void;
-                enterPhase("sandbox.cleanup");
-                const phaseStartedAt = recorder.offsetNow();
-                const before = diagnostics.length;
-                return effect_1.Effect.forEach([...layerCleanups].reverse(), (cleanup) => {
-                    const startedAt = recorder.offsetNow();
-                    const node = recorder.child((0, timing_ts_1.sandboxPrepareActivity)({
-                        label: `${cleanup.label} cleanup`,
-                        startOffsetMs: startedAt,
-                    }));
-                    if (node)
-                        recorder.pushParent(node);
-                    return (0, cleanup_timeout_ts_1.cleanupCallback)((cleanupSignal) => cleanup.command(cleanupCommandTarget, {
-                        ...cleanup.context,
-                        signal: cleanupSignal,
-                    })).pipe(effect_1.Effect.catch((error) => effect_1.Effect.sync(() => {
+                return (0, assertions_ts_1.sealAttemptAssertions)(liveAssertions, {
+                    execution: "errored",
+                    interrupted: true,
+                }).pipe(effect_1.Effect.tap((sealed) => effect_1.Effect.sync(() => {
+                    markExecutionTerminal();
+                    timeoutSealedAssertions = sealed;
+                })), effect_1.Effect.tap((sealed) => onSealedEvaluation?.(sealed) ?? effect_1.Effect.void), 
+                // Release must preserve the original interruption/failure. A
+                // malformed attachment is still reflected by the sealed runtime,
+                // but cannot mask the owning Attempt's terminal cause.
+                effect_1.Effect.catchCause(() => effect_1.Effect.void));
+            }));
+            // Scope 的 LIFO 让作者 cleanup 在 agent teardown 后、Provider Case finalizer 前执行。
+            // Cleanup must not fork back into this already-closing Attempt Scope, so it uses the resource
+            // facade captured above while retaining the same physical Sandbox and provider release owner.
+            if (agent.kind === "sandbox") {
+                yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.suspend(() => {
+                    if (layerCleanups.length === 0)
+                        return effect_1.Effect.void;
+                    enterPhase("sandbox.cleanup");
+                    const phaseStartedAt = recorder.offsetNow();
+                    const before = diagnostics.length;
+                    return effect_1.Effect.forEach([...layerCleanups].reverse(), (cleanup) => {
+                        const startedAt = recorder.offsetNow();
+                        const node = recorder.child((0, timing_ts_1.sandboxPrepareActivity)({
+                            label: `${cleanup.label} cleanup`,
+                            startOffsetMs: startedAt,
+                        }));
                         if (node)
-                            node.failed = true;
-                        declareFailure("sandbox.cleanup", error);
-                        diagnostics.push(teardownDiagnostic("sandbox.cleanup", error));
-                        recordSandboxCleanupFailure("sandbox.cleanup", error);
-                    })), effect_1.Effect.ensuring(effect_1.Effect.sync(() => {
-                        if (node) {
-                            node.durationMs = Math.max(0, recorder.offsetNow() - startedAt);
-                            recorder.popParent();
-                        }
+                            recorder.pushParent(node);
+                        return (0, cleanup_timeout_ts_1.cleanupCallback)((cleanupSignal) => cleanup.command(cleanupCommandTarget, {
+                            ...cleanup.context,
+                            signal: cleanupSignal,
+                        })).pipe(effect_1.Effect.catch((error) => effect_1.Effect.sync(() => {
+                            if (node)
+                                node.failed = true;
+                            declareFailure("sandbox.cleanup", error);
+                            diagnostics.push(teardownDiagnostic("sandbox.cleanup", error));
+                            recordSandboxCleanupFailure("sandbox.cleanup", error);
+                        })), effect_1.Effect.ensuring(effect_1.Effect.sync(() => {
+                            if (node) {
+                                node.durationMs = Math.max(0, recorder.offsetNow() - startedAt);
+                                recorder.popParent();
+                            }
+                        })));
+                    }, { discard: true }).pipe(effect_1.Effect.ensuring(effect_1.Effect.sync(() => {
+                        recorder.record("sandbox.cleanup", Math.max(0, recorder.offsetNow() - phaseStartedAt), diagnostics.length > before);
                     })));
-                }, { discard: true }).pipe(effect_1.Effect.ensuring(effect_1.Effect.sync(() => {
-                    recorder.record("sandbox.cleanup", Math.max(0, recorder.offsetNow() - phaseStartedAt), diagnostics.length > before);
-                })));
+                }));
+            }
+            // Cross-send adapter processes belong to the Attempt Scope, not to the
+            // Promise-shaped body. On timeout the bridge is intentionally sealed
+            // before that Promise's finally continuation can submit more work, so a
+            // scope finalizer must remain the unconditional release owner.
+            yield* effect_1.Effect.addFinalizer(() => (0, cleanup_timeout_ts_1.cleanupCallback)((cleanupSignal) => attemptResources.releaseAll(cleanupSignal)).pipe(effect_1.Effect.catch((error) => effect_1.Effect.sync(() => {
+                reportAttemptResourceReleaseFailure(error);
+            }))));
+            // Register the cleanup join after every outer resource finalizer, then
+            // register the forward close last. Scope LIFO therefore first rejects
+            // outstanding Promise work, then lets the body finish Agent teardown →
+            // managed Attempt release → Eval Plugin teardown, and only afterwards
+            // releases the enclosing Sandbox / Provider owners. The join abandons
+            // only a body that never enters cleanup; each cleanup callback owns its
+            // deadline without sharing an aggregate deadline with later callbacks.
+            yield* effect_1.Effect.addFinalizer(() => assertFirst.awaitCleanup());
+            yield* effect_1.Effect.addFinalizer((exit) => effect_1.Effect.suspend(() => {
+                const interrupted = timedOut || (effect_1.Exit.isFailure(exit) && effect_1.Cause.hasInterruptsOnly(exit.cause));
+                return assertFirst.closeEffectRequests(new api_ts_1.AssertionAuthoringClosedError(interrupted ? "attempt-interrupted" : "attempt-sealed"));
             }));
-        }
-        // Cross-send adapter processes belong to the Attempt Scope, not to the
-        // Promise-shaped body. On timeout the bridge is intentionally sealed
-        // before that Promise's finally continuation can submit more work, so a
-        // scope finalizer must remain the unconditional release owner.
-        yield* effect_1.Effect.addFinalizer(() => (0, cleanup_timeout_ts_1.cleanupCallback)((cleanupSignal) => attemptResources.releaseAll(cleanupSignal)).pipe(effect_1.Effect.catch((error) => effect_1.Effect.sync(() => {
-            reportAttemptResourceReleaseFailure(error);
-        }))));
-        // Register the cleanup join after every outer resource finalizer, then
-        // register the forward close last. Scope LIFO therefore first rejects
-        // outstanding Promise work, then lets the body finish Agent teardown →
-        // managed Attempt release → Eval Plugin teardown, and only afterwards
-        // releases the enclosing Sandbox / Provider owners. The join abandons
-        // only a body that never enters cleanup; each cleanup callback owns its
-        // deadline without sharing an aggregate deadline with later callbacks.
-        yield* effect_1.Effect.addFinalizer(() => assertFirst.awaitCleanup());
-        yield* effect_1.Effect.addFinalizer((exit) => effect_1.Effect.suspend(() => {
-            const interrupted = timedOut || (effect_1.Exit.isFailure(exit) && effect_1.Cause.hasInterruptsOnly(exit.cause));
-            return assertFirst.closeEffectRequests(new api_ts_1.AssertionAuthoringClosedError(interrupted ? "attempt-interrupted" : "attempt-sealed"));
-        }));
-        // The legacy setup/diff body remains Promise-shaped, while OTLP waits,
-        // author execution, and sealing run in this Attempt's Effect scope. No
-        // nested runtime is introduced.
-        const bodyFiber = yield* effect_1.Effect.forkChild(tryPromiseAsDefect((interruptSignal) => runAttemptBody(a, config, t0, base, {
-            sandbox,
-            sourceRegistry,
-            sourceCapture,
-            receiver,
-            telemetry,
-            otel: otelChannel,
-            signal: AbortSignal.any([signal, interruptSignal]),
-            log,
-            enterPhase,
-            // send 在飞时归因到嵌套的 agent.run(不切换顶层阶段,见 LifecyclePhase 注释)。
-            getPhase: () => (sendActive ? "agent.run" : lastPhase),
-            setSendActive: (active) => {
-                sendActive = active;
-            },
-            recorder,
-            ...(attemptTimeout ? { attemptTimeout } : {}),
-            ...(deadlineAt !== undefined ? { deadlineAt } : {}),
-            feedback: scopedFeedback,
-            diagnostics,
-            commands,
-            sensitiveValues,
-            observabilityRuntime,
-            ...(materializedCase === undefined ? {} : { materializedCase }),
-            ...(preparedSetupPrefix === undefined ? {} : { preparedSetupPrefix }),
-            concurrencySlot,
-            declareFailure,
-            onEnvironmentIncomplete,
-            isDeadlineTimedOut: () => timedOut,
-            layerCleanups,
-            attemptResources,
-            reportAttemptResourceReleaseFailure,
-            registerEvidence: (getEvents, getUsage, getRetryAttempts) => {
-                liveEvents = getEvents;
-                liveUsage = getUsage;
-                liveRetryAttempts = getRetryAttempts;
-            },
-            registerLedger: (ledger) => {
-                liveLedger = ledger;
-            },
-            retainFileChangesCapture: (capture) => {
-                fileChangesCapture = capture;
-            },
-            assertFirst,
-            registerAssertions: (runtime, state) => {
-                if (liveAssertions !== undefined && liveAssertions !== runtime) {
-                    throw new Error("Attempt tried to register a second Assertions runtime");
-                }
-                if (liveAssertionState !== undefined && liveAssertionState !== state) {
-                    throw new Error("Attempt tried to register a second Assertions state");
+            // The legacy setup/diff body remains Promise-shaped, while OTLP waits,
+            // author execution, and sealing run in this Attempt's Effect scope. No
+            // nested runtime is introduced.
+            const bodyFiber = yield* effect_1.Effect.forkChild(tryPromiseAsDefect((interruptSignal) => runAttemptBody(a, config, t0, base, {
+                judgeUsage,
+                sandbox,
+                sourceRegistry,
+                sourceCapture,
+                receiver,
+                telemetry,
+                otel: otelChannel,
+                signal: AbortSignal.any([signal, interruptSignal]),
+                log,
+                enterPhase,
+                // send 在飞时归因到嵌套的 agent.run(不切换顶层阶段,见 LifecyclePhase 注释)。
+                getPhase: () => (sendActive ? "agent.run" : lastPhase),
+                setSendActive: (active) => {
+                    sendActive = active;
+                },
+                recorder,
+                ...(attemptTimeout ? { attemptTimeout } : {}),
+                ...(deadlineAt !== undefined ? { deadlineAt } : {}),
+                feedback: scopedFeedback,
+                diagnostics,
+                commands,
+                sensitiveValues,
+                observabilityRuntime,
+                ...(materializedCase === undefined ? {} : { materializedCase }),
+                ...(preparedSetupPrefix === undefined ? {} : { preparedSetupPrefix }),
+                concurrencySlot,
+                declareFailure,
+                onEnvironmentIncomplete,
+                isDeadlineTimedOut: () => timedOut,
+                layerCleanups,
+                attemptResources,
+                reportAttemptResourceReleaseFailure,
+                registerEvidence: (getEvents, getUsage, getRetryAttempts) => {
+                    liveEvents = getEvents;
+                    liveUsage = getUsage;
+                    liveRetryAttempts = getRetryAttempts;
+                },
+                registerLedger: (ledger) => {
+                    liveLedger = ledger;
+                },
+                retainFileChangesCapture: (capture) => {
+                    fileChangesCapture = capture;
+                },
+                assertFirst,
+                registerAssertions: (runtime, state) => {
+                    if (liveAssertions !== undefined && liveAssertions !== runtime) {
+                        throw new Error("Attempt tried to register a second Assertions runtime");
+                    }
+                    if (liveAssertionState !== undefined && liveAssertionState !== state) {
+                        throw new Error("Attempt tried to register a second Assertions state");
+                    }
+                    liveAssertions = runtime;
+                    liveAssertionState = state;
+                },
+                ...(opts.artifactPrepare !== undefined ? { prepareCoordinator: opts.artifactPrepare } : {}),
+            }, parentSignal)));
+            const contextExit = yield* effect_1.Effect.exit(assertFirst.awaitContext());
+            if (effect_1.Exit.isFailure(contextExit)) {
+                if (effect_1.Cause.hasInterruptsOnly(contextExit.cause))
+                    return yield* effect_1.Effect.interrupt;
+                // Context construction failed before the Agent body could register its
+                // runtime. Seal the single empty execution-error result now so the
+                // execution deadline retires before the Promise body's existing
+                // Agent/Plugin cleanup chain is joined.
+                const sealed = yield* sealExecutionError();
+                const bodyResult = yield* effect_1.Fiber.join(bodyFiber);
+                return withSealedAssertions(bodyResult, sealed);
+            }
+            const author = effect_1.Effect.suspend(() => {
+                // This is the original frozen author Context; the assertion only
+                // resolves Eval-kind overloads and never substitutes a wrapper.
+                // Both Promise and deferred Effect calls capture through explicit
+                // Attempt-owned dependencies, never fiber-local ALS.
+                const returned = evalDef.test(contextExit.value);
+                if (effect_1.Effect.isEffect(returned)) {
+                    return returned;
                 }
-                liveAssertions = runtime;
-                liveAssertionState = state;
-            },
-            ...(opts.artifactPrepare !== undefined ? { prepareCoordinator: opts.artifactPrepare } : {}),
-        }, parentSignal)));
-        const contextExit = yield* effect_1.Effect.exit(assertFirst.awaitContext());
-        if (effect_1.Exit.isFailure(contextExit)) {
-            if (effect_1.Cause.hasInterruptsOnly(contextExit.cause))
-                return yield* effect_1.Effect.interrupt;
-            // Context construction failed before the Agent body could register its
-            // runtime. Seal the single empty execution-error result now so the
-            // execution deadline retires before the Promise body's existing
-            // Agent/Plugin cleanup chain is joined.
-            const sealed = yield* sealExecutionError();
-            const bodyResult = yield* effect_1.Fiber.join(bodyFiber);
-            return withSealedAssertions(bodyResult, sealed);
-        }
-        const author = effect_1.Effect.suspend(() => {
-            // This is the original frozen author Context; the assertion only
-            // resolves Eval-kind overloads and never substitutes a wrapper.
-            // Both Promise and deferred Effect calls capture through explicit
-            // Attempt-owned dependencies, never fiber-local ALS.
-            const returned = evalDef.test(contextExit.value);
-            if (effect_1.Effect.isEffect(returned)) {
-                return returned;
-            }
-            return effect_1.Effect.tryPromise({
-                try: () => Promise.resolve(returned),
-                catch: (error) => error,
+                return effect_1.Effect.tryPromise({
+                    try: () => Promise.resolve(returned),
+                    catch: (error) => error,
+                });
             });
-        });
-        const authorExit = yield* effect_1.Effect.exit(author);
-        if (effect_1.Exit.isSuccess(authorExit)) {
-            yield* assertFirst.completeAuthor({ _tag: "succeeded" });
-        }
-        else {
-            if (effect_1.Cause.hasInterruptsOnly(authorExit.cause))
-                return yield* effect_1.Effect.interrupt;
-            const failure = effect_1.Cause.findErrorOption(authorExit.cause);
-            const defect = effect_1.Cause.findDefect(authorExit.cause);
-            const completion = effect_1.Option.isSome(failure)
-                ? isAssertionStopError(failure.value)
-                    ? { _tag: "stopped" }
-                    : { _tag: "failed", error: failure.value }
-                : { _tag: "defect", cause: effect_1.Result.isSuccess(defect) ? defect.success : authorExit.cause };
-            yield* assertFirst.completeAuthor(completion);
-        }
-        // The declared author callback has returned. A detached continuation may
-        // still hold a handle, but it cannot enqueue a new control barrier while
-        // this Attempt moves to its single ordered seal.
-        yield* assertFirst.closeAssertionRequests(new api_ts_1.AssertionAuthoringClosedError("attempt-sealing"));
-        const sealRequestExit = yield* effect_1.Effect.exit(assertFirst.awaitSealRequest());
-        if (effect_1.Exit.isFailure(sealRequestExit)) {
-            if (effect_1.Cause.hasInterruptsOnly(sealRequestExit.cause))
-                return yield* effect_1.Effect.interrupt;
-            return yield* effect_1.Fiber.join(bodyFiber);
-        }
-        const sealExit = yield* effect_1.Effect.exit((0, assertions_ts_1.sealAttemptAssertions)(sealRequestExit.value.runtime, sealRequestExit.value.options, sealRequestExit.value.workspaceDiff).pipe(effect_1.Effect.tap(() => effect_1.Effect.sync(() => {
-            markExecutionTerminal();
-        })), effect_1.Effect.tap((sealed) => onSealedEvaluation?.(sealed) ?? effect_1.Effect.void)));
-        liveAssertionState?.manager.releaseObservedEvaluationSegments();
-        if (effect_1.Exit.isSuccess(sealExit)) {
-            yield* assertFirst.completeSeal(sealExit.value);
-        }
-        else {
-            if (effect_1.Cause.hasInterruptsOnly(sealExit.cause))
-                return yield* effect_1.Effect.interrupt;
-            const failure = effect_1.Cause.findErrorOption(sealExit.cause);
-            const defect = effect_1.Cause.findDefect(sealExit.cause);
-            yield* assertFirst.failSeal(effect_1.Option.isSome(failure)
-                ? failure.value
-                : effect_1.Result.isSuccess(defect)
-                    ? defect.success
-                    : effect_1.Cause.squash(sealExit.cause));
-        }
-        const bodyResult = yield* effect_1.Fiber.join(bodyFiber);
-        // 留存提交:verdict 定稿、其余收尾(teardown 链、diff 采集)已在 body 内完成后,按档位
-        // 提交——failed 档留 failed/errored,all 档全部;顺序不可调换:先原子写登记项,写入成功
-        // 才把 disposition 改成 keep;写入失败保持 stop、记 diagnostic,`sandbox.kept` 不得为 true。
-        const keepMode = opts.keepSandbox;
-        if (agent.kind === "sandbox" &&
-            keepMode !== undefined &&
-            a.locator !== undefined &&
-            (keepMode === "all" || bodyResult.verdict === "failed" || bodyResult.verdict === "errored")) {
-            const providerName = runtimeCapabilities.provider;
-            if (runtimeCapabilities.retention._tag === "Suspendable") {
-                const enter = (0, keep_ts_1.nativeEnterCommand)(providerName, sandbox.sandboxId);
-                const keptAt = new Date().toISOString();
-                const expiresAt = (0, keep_ts_1.computeExpiresAt)(providerName, keptAt);
-                const registered = yield* effect_1.Effect.result((0, keep_registry_ts_1.writeKeptEntryEffect)(coordinationRoot, {
-                    sandboxId: sandbox.sandboxId,
-                    provider: providerName,
-                    evalId: evalDef.id,
-                    attempt,
-                    ...(run.experimentId !== undefined ? { experimentId: run.experimentId } : {}),
-                    locator: String(a.locator),
-                    verdict: bodyResult.verdict,
-                    keptAt,
-                    workdir: sandbox.workdir,
-                    ...(enter !== undefined ? { enter } : {}),
-                    ...(expiresAt !== undefined ? { expiresAt } : {}),
-                    state: "alive",
-                }));
-                if (effect_1.Result.isSuccess(registered)) {
-                    disposition = "keep";
-                    (0, sink_ts_1.reportKept)({
-                        locator: a.locator,
-                        identity,
-                        who: (0, types_ts_1.runWho)({ agentName: agent.name, model: run.model, experimentId: run.experimentId }),
-                        verdict: bodyResult.verdict,
-                        provider: providerName,
+            const authorExit = yield* effect_1.Effect.exit(author);
+            if (effect_1.Exit.isSuccess(authorExit)) {
+                yield* assertFirst.completeAuthor({ _tag: "succeeded" });
+            }
+            else {
+                if (effect_1.Cause.hasInterruptsOnly(authorExit.cause))
+                    return yield* effect_1.Effect.interrupt;
+                const failure = effect_1.Cause.findErrorOption(authorExit.cause);
+                const defect = effect_1.Cause.findDefect(authorExit.cause);
+                const completion = effect_1.Option.isSome(failure)
+                    ? isAssertionStopError(failure.value)
+                        ? { _tag: "stopped" }
+                        : { _tag: "failed", error: failure.value }
+                    : { _tag: "defect", cause: effect_1.Result.isSuccess(defect) ? defect.success : authorExit.cause };
+                yield* assertFirst.completeAuthor(completion);
+            }
+            // The declared author callback has returned. A detached continuation may
+            // still hold a handle, but it cannot enqueue a new control barrier while
+            // this Attempt moves to its single ordered seal.
+            yield* assertFirst.closeAssertionRequests(new api_ts_1.AssertionAuthoringClosedError("attempt-sealing"));
+            const sealRequestExit = yield* effect_1.Effect.exit(assertFirst.awaitSealRequest());
+            if (effect_1.Exit.isFailure(sealRequestExit)) {
+                if (effect_1.Cause.hasInterruptsOnly(sealRequestExit.cause))
+                    return yield* effect_1.Effect.interrupt;
+                return yield* effect_1.Fiber.join(bodyFiber);
+            }
+            const sealExit = yield* effect_1.Effect.exit((0, assertions_ts_1.sealAttemptAssertions)(sealRequestExit.value.runtime, sealRequestExit.value.options, sealRequestExit.value.workspaceDiff).pipe(effect_1.Effect.tap(() => effect_1.Effect.sync(() => {
+                markExecutionTerminal();
+            })), effect_1.Effect.tap((sealed) => onSealedEvaluation?.(sealed) ?? effect_1.Effect.void)));
+            liveAssertionState?.manager.releaseObservedEvaluationSegments();
+            if (effect_1.Exit.isSuccess(sealExit)) {
+                yield* assertFirst.completeSeal(sealExit.value);
+            }
+            else {
+                if (effect_1.Cause.hasInterruptsOnly(sealExit.cause))
+                    return yield* effect_1.Effect.interrupt;
+                const failure = effect_1.Cause.findErrorOption(sealExit.cause);
+                const defect = effect_1.Cause.findDefect(sealExit.cause);
+                yield* assertFirst.failSeal(effect_1.Option.isSome(failure)
+                    ? failure.value
+                    : effect_1.Result.isSuccess(defect)
+                        ? defect.success
+                        : effect_1.Cause.squash(sealExit.cause));
+            }
+            const bodyResult = yield* effect_1.Fiber.join(bodyFiber);
+            // 留存提交:verdict 定稿、其余收尾(teardown 链、diff 采集)已在 body 内完成后,按档位
+            // 提交——failed 档留 failed/errored,all 档全部;顺序不可调换:先原子写登记项,写入成功
+            // 才把 disposition 改成 keep;写入失败保持 stop、记 diagnostic,`sandbox.kept` 不得为 true。
+            const keepMode = opts.keepSandbox;
+            if (agent.kind === "sandbox" &&
+                keepMode !== undefined &&
+                a.locator !== undefined &&
+                (keepMode === "all" || bodyResult.verdict === "failed" || bodyResult.verdict === "errored")) {
+                const providerName = runtimeCapabilities.provider;
+                if (runtimeCapabilities.retention._tag === "Suspendable") {
+                    const enter = (0, keep_ts_1.nativeEnterCommand)(providerName, sandbox.sandboxId);
+                    const keptAt = new Date().toISOString();
+                    const expiresAt = (0, keep_ts_1.computeExpiresAt)(providerName, keptAt);
+                    const registered = yield* effect_1.Effect.result((0, keep_registry_ts_1.writeKeptEntryEffect)(coordinationRoot, {
                         sandboxId: sandbox.sandboxId,
+                        provider: providerName,
+                        evalId: evalDef.id,
+                        attempt,
+                        ...(run.experimentId !== undefined ? { experimentId: run.experimentId } : {}),
+                        locator: String(a.locator),
+                        verdict: bodyResult.verdict,
+                        keptAt,
+                        workdir: sandbox.workdir,
                         ...(enter !== undefined ? { enter } : {}),
+                        ...(expiresAt !== undefined ? { expiresAt } : {}),
+                        state: "alive",
+                    }));
+                    if (effect_1.Result.isSuccess(registered)) {
+                        disposition = "keep";
+                        (0, sink_ts_1.reportKept)({
+                            locator: a.locator,
+                            identity,
+                            who: (0, types_ts_1.runWho)({ agentName: agent.name, model: run.model, experimentId: run.experimentId }),
+                            verdict: bodyResult.verdict,
+                            provider: providerName,
+                            sandboxId: sandbox.sandboxId,
+                            ...(enter !== undefined ? { enter } : {}),
+                        });
+                        // 只有 `kept` 在收尾时点决定;provider / sandboxId 等归属键仍由租借时刻的
+                        // sandboxFacts 统一挂上(见下方 Effect.map)。
+                        kept = true;
+                        return bodyResult;
+                    }
+                    const error = registered.failure;
+                    recordDiagnostic({
+                        code: "sandbox-keep-failed",
+                        level: "warning",
+                        message: `failed to register kept sandbox ${sandbox.sandboxId}; it will be destroyed normally: ${error instanceof Error ? error.message : String(error)}`,
+                        dedupeKey: `sandbox-keep-failed:${sandbox.sandboxId}`,
                     });
-                    // 只有 `kept` 在收尾时点决定;provider / sandboxId 等归属键仍由租借时刻的
-                    // sandboxFacts 统一挂上(见下方 Effect.map)。
-                    kept = true;
-                    return bodyResult;
                 }
-                const error = registered.failure;
-                recordDiagnostic({
-                    code: "sandbox-keep-failed",
-                    level: "warning",
-                    message: `failed to register kept sandbox ${sandbox.sandboxId}; it will be destroyed normally: ${error instanceof Error ? error.message : String(error)}`,
-                    dedupeKey: `sandbox-keep-failed:${sandbox.sandboxId}`,
+            }
+            return bodyResult;
+        }).pipe(applyAttemptDeadline, 
+        // Observe only interruption of the complete Attempt execution, never a
+        // losing internal race fiber. The original Cause continues unchanged.
+        effect_1.Effect.onInterrupt(() => effect_1.Effect.sync(() => {
+            if (!assertionsSealed)
+                forwardParentAbort();
+        }))))).pipe(
+        // The execution race ends before Scope finalizers start. Cleanup retains
+        // its own budgets; custom capture failure participates in the final fold.
+        // body 自己已兜了 agent 执行错;这里兜的是资源获取 / Sample 层的意外(起沙箱失败等)。
+        // 中断【不】吞:此时 Sample 已跑完 release(容器已停),把中断继续上抛,让 forEach 整体停掉,
+        // 否则会把中断「恢复」成一条 errored 结果、并让后续 attempt 继续起 —— 那就停不下来了。
+        // `timeoutTo` 已在内层把自己的中断消费成 onTimeout 的成功值。这里不能仅凭 Cause 中含
+        // interrupt 就升级成整批取消：earlyExit 也会中断 losing attempt 的 fiber。整个 Invocation
+        // 是否取消只由 invocationSignal 裁决；其它中断在本 attempt 内封成 errored，随后由调度器
+        // 的 earlyExit 去重分支丢弃。兄弟 fiber 的真实 defect 仍由它自己的 Cause 向外传播。
+        effect_1.Effect.catchCause((cause) => isAttemptAborted(invocationSignal) && adapter.kind !== "custom"
+            ? effect_1.Effect.interrupt
+            : effect_1.Effect.suspend(() => {
+                invocationInterrupted = isAttemptAborted(invocationSignal) && effect_1.Cause.hasInterruptsOnly(cause);
+                // 资源获取 / Sample 层的意外(起沙箱失败、provisioning 的确定性配置死因)同样是终局
+                // 失败:先读空间轴回执,再折成纯数据 AttemptError(顺序不可换,见 declareFailure)。
+                const raw = effect_1.Cause.squash(cause);
+                const phase = (sendActive ? "agent.run" : lastPhase) ?? "eval.run";
+                declareFailure(phase, raw);
+                const error = timedOut && deadlineError !== undefined
+                    ? deadlineError
+                    : errorFromThrown(raw, sendActive ? "agent.run" : lastPhase, attemptTimeout);
+                const fallback = {
+                    ...base,
+                    durationMs: recorder.offsetNow(),
+                    error,
+                    ...(evalDef.evaluationKind === "score" ? { scoreResult: scoreFactOutcomeForAttemptError(error) } : {}),
+                    ...(commands.length > 0 ? { commands: [...commands] } : {}),
+                };
+                return effect_1.Effect.succeed(fallback);
+            })), 
+        // A prepare/setup failure can be caught by runAttemptBody before a real
+        // TestContext exists. In that case the scoped body returns an errored
+        // value successfully, so catchAllCause above never runs. Enforce the
+        // Record boundary as an output postcondition: every executed errored
+        // Attempt owns one sealed (possibly empty) assertion result.
+        effect_1.Effect.flatMap((result) => assertionsSealed || result.verdict !== "errored"
+            ? effect_1.Effect.succeed(result)
+            : sealExecutionError().pipe(effect_1.Effect.map((sealed) => withSealedAssertions(result, sealed)), effect_1.Effect.catch(() => effect_1.Effect.succeed(result)))), effect_1.Effect.map((result) => !timedOut || timeoutSealedAssertions === undefined
+            ? result
+            : withSealedAssertions(result, timeoutSealedAssertions)), effect_1.Effect.flatMap((result) => effect_1.Effect.gen(function* () {
+            if (adapter.kind !== "custom")
+                return result;
+            const captureFailure = adapterUsage?.failure ?? adapterAttachments?.failure() ?? adapterExecutionTraces?.failure();
+            // Cleanup must not erase the original execution failure or timeout attribution.
+            // Its own timeout remains independently recorded as a teardown diagnostic.
+            const error = result.error ?? adapterCleanupError ?? (captureFailure === undefined
+                ? undefined
+                : errorFromThrown(captureFailure, "attempt.teardown"));
+            let sealed = adapterSealedAssertions;
+            if (sealed === undefined)
+                return result;
+            if (error !== undefined || invocationInterrupted) {
+                // Assertions were evaluated once before cleanup. Only the execution
+                // outcome changes; the existing domain folds retain every earned point.
+                const evaluation = Object.freeze({ ...sealed.evaluation, execution: "errored" });
+                const score = evalDef.evaluationKind === "score" ? (0, score_ts_1.buildScorePayload)(evaluation) : undefined;
+                if (score !== undefined && effect_1.Result.isFailure(score))
+                    return yield* effect_1.Effect.fail(score.failure);
+                sealed = Object.freeze({
+                    ...sealed,
+                    evaluation,
+                    verdict: Object.freeze({ state: (0, verdict_ts_1.foldVerdict)(evaluation) }),
+                    ...(score === undefined ? {} : { score: score.success }),
                 });
             }
-        }
-        return bodyResult;
-    }).pipe(applyAttemptDeadline))).pipe(
-    // The execution race ends before Scope finalizers start. Cleanup retains
-    // its own budgets; custom capture failure participates in the final fold.
-    // body 自己已兜了 agent 执行错;这里兜的是资源获取 / Sample 层的意外(起沙箱失败等)。
-    // 中断【不】吞:此时 Sample 已跑完 release(容器已停),把中断继续上抛,让 forEach 整体停掉,
-    // 否则会把中断「恢复」成一条 errored 结果、并让后续 attempt 继续起 —— 那就停不下来了。
-    // `timeoutTo` 已在内层把自己的中断消费成 onTimeout 的成功值。这里不能仅凭 Cause 中含
-    // interrupt 就升级成整批取消：earlyExit 也会中断 losing attempt 的 fiber。整个 Invocation
-    // 是否取消只由 invocationSignal 裁决；其它中断在本 attempt 内封成 errored，随后由调度器
-    // 的 earlyExit 去重分支丢弃。兄弟 fiber 的真实 defect 仍由它自己的 Cause 向外传播。
-    effect_1.Effect.catchCause((cause) => isAttemptAborted(invocationSignal) && adapter.kind !== "custom"
-        ? effect_1.Effect.interrupt
-        : effect_1.Effect.suspend(() => {
-            invocationInterrupted = isAttemptAborted(invocationSignal) && effect_1.Cause.hasInterruptsOnly(cause);
-            // 资源获取 / Sample 层的意外(起沙箱失败、provisioning 的确定性配置死因)同样是终局
-            // 失败:先读空间轴回执,再折成纯数据 AttemptError(顺序不可换,见 declareFailure)。
-            const raw = effect_1.Cause.squash(cause);
-            const phase = (sendActive ? "agent.run" : lastPhase) ?? "eval.run";
-            declareFailure(phase, raw);
-            const error = timedOut && deadlineError !== undefined
-                ? deadlineError
-                : errorFromThrown(raw, sendActive ? "agent.run" : lastPhase, attemptTimeout);
-            const fallback = {
-                ...base,
-                durationMs: recorder.offsetNow(),
-                error,
-                ...(evalDef.evaluationKind === "score" ? { scoreResult: scoreFactOutcomeForAttemptError(error) } : {}),
+            yield* onSealedEvaluation?.(sealed) ?? effect_1.Effect.void;
+            return withSealedAssertions({ ...result, ...(error === undefined ? {} : { error }) }, sealed);
+        })), 
+        // 结果封口在 Sample release 完成之后:sandbox.stop 已由 finalizer 写进 recorder,
+        // 这里把完整的阶段计时挂到即将交还的结果上(timeout / scope 兜底分支同样带上)。超时路径
+        // 额外把上面那个 finalizer 折叠出的 workspace.diff / sources 并进来——它俩是异步产出,
+        // 必须等 Sample release(本 map 之前的所有 finalizer)跑完才有值,不能在 onTimeout 的同步
+        // 回调里就地给,原理与 phases 完全一致(见该 finalizer 与 onTimeout 的注释)。
+        effect_1.Effect.map((r) => {
+            const withEvidence = {
+                ...r,
+                ...(diagnostics.length > 0 ? { diagnostics: [...diagnostics] } : {}),
                 ...(commands.length > 0 ? { commands: [...commands] } : {}),
             };
-            return effect_1.Effect.succeed(fallback);
-        })), 
-    // A prepare/setup failure can be caught by runAttemptBody before a real
-    // TestContext exists. In that case the scoped body returns an errored
-    // value successfully, so catchAllCause above never runs. Enforce the
-    // Record boundary as an output postcondition: every executed errored
-    // Attempt owns one sealed (possibly empty) assertion result.
-    effect_1.Effect.flatMap((result) => assertionsSealed || result.verdict !== "errored"
-        ? effect_1.Effect.succeed(result)
-        : sealExecutionError().pipe(effect_1.Effect.map((sealed) => withSealedAssertions(result, sealed)), effect_1.Effect.catch(() => effect_1.Effect.succeed(result)))), effect_1.Effect.map((result) => !timedOut || timeoutSealedAssertions === undefined
-        ? result
-        : withSealedAssertions(result, timeoutSealedAssertions)), effect_1.Effect.flatMap((result) => effect_1.Effect.gen(function* () {
-        if (adapter.kind !== "custom")
-            return result;
-        const captureFailure = adapterUsage?.failure ?? adapterAttachments?.failure() ?? adapterExecutionTraces?.failure();
-        // Cleanup must not erase the original execution failure or timeout attribution.
-        // Its own timeout remains independently recorded as a teardown diagnostic.
-        const error = result.error ?? adapterCleanupError ?? (captureFailure === undefined
-            ? undefined
-            : errorFromThrown(captureFailure, "attempt.teardown"));
-        let sealed = adapterSealedAssertions;
-        if (sealed === undefined)
-            return result;
-        if (error !== undefined || invocationInterrupted) {
-            // Assertions were evaluated once before cleanup. Only the execution
-            // outcome changes; the existing domain folds retain every earned point.
-            const evaluation = Object.freeze({ ...sealed.evaluation, execution: "errored" });
-            const score = evalDef.evaluationKind === "score" ? (0, score_ts_1.buildScorePayload)(evaluation) : undefined;
-            if (score !== undefined && effect_1.Result.isFailure(score))
-                return yield* effect_1.Effect.fail(score.failure);
-            sealed = Object.freeze({
-                ...sealed,
-                evaluation,
-                verdict: Object.freeze({ state: (0, verdict_ts_1.foldVerdict)(evaluation) }),
-                ...(score === undefined ? {} : { score: score.success }),
-            });
-        }
-        yield* onSealedEvaluation?.(sealed) ?? effect_1.Effect.void;
-        return withSealedAssertions({ ...result, ...(error === undefined ? {} : { error }) }, sealed);
-    })), 
-    // 结果封口在 Sample release 完成之后:sandbox.stop 已由 finalizer 写进 recorder,
-    // 这里把完整的阶段计时挂到即将交还的结果上(timeout / scope 兜底分支同样带上)。超时路径
-    // 额外把上面那个 finalizer 折叠出的 workspace.diff / sources 并进来——它俩是异步产出,
-    // 必须等 Sample release(本 map 之前的所有 finalizer)跑完才有值,不能在 onTimeout 的同步
-    // 回调里就地给,原理与 phases 完全一致(见该 finalizer 与 onTimeout 的注释)。
-    effect_1.Effect.map((r) => {
-        const withEvidence = {
-            ...r,
-            ...(diagnostics.length > 0 ? { diagnostics: [...diagnostics] } : {}),
-            ...(commands.length > 0 ? { commands: [...commands] } : {}),
-        };
-        const phases = recorder.finalize();
-        // 现有阶段计时尚未把 sandbox.create 起点单独持久化；在它可用前落同口径的保守值，
-        // 读取旧记录也按 durationMs 回退，绝不因缺值错误携带。
-        const withPhases = {
-            ...(phases ? { ...withEvidence, phases } : withEvidence),
-            executionMs: withEvidence.executionMs ?? withEvidence.durationMs,
-        };
-        // 调度事实统一在这里挂:每条出口(正常、body 抛错、超时、Sample 层失败)都经过本 map,
-        // 归属因此不随「走到了哪一步」丢失(见 sandboxFacts 的声明)。
-        const withSandbox = sandboxFacts
-            ? {
-                ...withPhases,
-                sandbox: {
-                    ...sandboxFacts,
-                    // SetupPrefix restore/capture rebases the stable backend onto a new private clone.
-                    // Read the final dynamic facade here instead of retaining the acquisition id.
-                    sandboxId: currentSandbox?.sandboxId ?? sandboxFacts.sandboxId,
-                    ...(kept ? { kept: true } : {}),
-                },
-            }
-            : withPhases;
-        const completed = timedOut
-            ? {
-                ...withSandbox,
-                ...(timeoutDiff !== undefined ? { diff: timeoutDiff } : {}),
-                sources: timeoutSources ?? [],
-            }
-            : withSandbox;
-        const finalResult = (0, source_producer_ts_1.retainRunnerAttemptSourceCapture)(redactEvalResultEvidence(completed, sensitiveValues), sourceCapture.snapshot());
-        const capture = timedOut
-            ? timeoutFileChangesCapture ?? fileChangesCapture
-            : fileChangesCapture;
-        if (capture !== undefined) {
-            (0, sandbox_record_producer_ts_1.retainRunnerAttemptFileChangesCapture)(finalResult, capture);
-        }
-        if (adapterUsageSnapshot !== undefined)
-            (0, adapter_usage_ts_1.retainAdapterUsage)(finalResult, adapterUsageSnapshot);
-        if (adapterAttachments !== undefined)
-            (0, adapter_attachments_ts_1.retainAdapterAttachments)(finalResult, adapterAttachments.snapshot());
-        if (adapterExecutionTraces !== undefined)
-            (0, adapter_execution_trace_ts_1.retainAdapterExecutionTraces)(finalResult, adapterExecutionTraces.snapshot());
-        return finalResult;
-    }), effect_1.Effect.tap((finalResult) => (0, runtime_ts_3.bindRunnerAttemptObservabilityCapture)(finalResult, observabilityRuntime)), effect_1.Effect.flatMap((finalResult) => invocationInterrupted
-        ? (onInterruptedResult?.(finalResult) ?? effect_1.Effect.void).pipe(effect_1.Effect.andThen(effect_1.Effect.interrupt))
-        : effect_1.Effect.succeed(finalResult)), effect_1.Effect.ensuring(effect_1.Effect.sync(() => {
-        parentSignal?.removeEventListener("abort", forwardParentAbort);
-    }))));
+            const phases = recorder.finalize();
+            // 现有阶段计时尚未把 sandbox.create 起点单独持久化；在它可用前落同口径的保守值，
+            // 读取旧记录也按 durationMs 回退，绝不因缺值错误携带。
+            const withPhases = {
+                ...(phases ? { ...withEvidence, phases } : withEvidence),
+                executionMs: withEvidence.executionMs ?? withEvidence.durationMs,
+            };
+            // 调度事实统一在这里挂:每条出口(正常、body 抛错、超时、Sample 层失败)都经过本 map,
+            // 归属因此不随「走到了哪一步」丢失(见 sandboxFacts 的声明)。
+            const withSandbox = sandboxFacts
+                ? {
+                    ...withPhases,
+                    sandbox: {
+                        ...sandboxFacts,
+                        // SetupPrefix restore/capture rebases the stable backend onto a new private clone.
+                        // Read the final dynamic facade here instead of retaining the acquisition id.
+                        sandboxId: currentSandbox?.sandboxId ?? sandboxFacts.sandboxId,
+                        ...(kept ? { kept: true } : {}),
+                    },
+                }
+                : withPhases;
+            const completed = timedOut
+                ? {
+                    ...withSandbox,
+                    ...(timeoutDiff !== undefined ? { diff: timeoutDiff } : {}),
+                    sources: timeoutSources ?? [],
+                }
+                : withSandbox;
+            const finalResult = (0, source_producer_ts_1.retainRunnerAttemptSourceCapture)(redactEvalResultEvidence(completed, sensitiveValues), sourceCapture.snapshot());
+            const capture = timedOut
+                ? timeoutFileChangesCapture ?? fileChangesCapture
+                : fileChangesCapture;
+            if (capture !== undefined) {
+                (0, sandbox_record_producer_ts_1.retainRunnerAttemptFileChangesCapture)(finalResult, capture);
+            }
+            (0, judge_usage_ts_2.retainJudgeUsage)(finalResult, judgeUsage.snapshot());
+            if (adapterUsageSnapshot !== undefined)
+                (0, adapter_usage_ts_1.retainAdapterUsage)(finalResult, adapterUsageSnapshot);
+            if (adapterAttachments !== undefined)
+                (0, adapter_attachments_ts_1.retainAdapterAttachments)(finalResult, adapterAttachments.snapshot());
+            if (adapterExecutionTraces !== undefined)
+                (0, adapter_execution_trace_ts_1.retainAdapterExecutionTraces)(finalResult, adapterExecutionTraces.snapshot());
+            return finalResult;
+        }), effect_1.Effect.tap((finalResult) => (0, runtime_ts_3.bindRunnerAttemptObservabilityCapture)(finalResult, observabilityRuntime)), effect_1.Effect.flatMap((finalResult) => invocationInterrupted
+            ? (onInterruptedResult?.(finalResult) ?? effect_1.Effect.void).pipe(effect_1.Effect.andThen(effect_1.Effect.interrupt))
+            : effect_1.Effect.succeed(finalResult)), effect_1.Effect.ensuring(effect_1.Effect.sync(() => {
+            parentSignal?.removeEventListener("abort", forwardParentAbort);
+        }))));
+    }));
 }
 function adapterAuthorCallbackEffect(resources, signal, callback) {
     const author = effect_1.Effect.tryPromise({
@@ -1349,6 +1376,9 @@ function runAdapterAttemptBody(input) {
     const { a, base, adapter, resources, usage, attachments, executionTraces, signal, sourceCapture, sourceRegistry, assertFirst, enterPhase, recorder, feedback, log, declareFailure, registerAssertions, closeAuthoring, markAssertionsSealed, } = input;
     return effect_1.Effect.gen(function* () {
         const { context: core, state } = (0, assert_first_ts_1.createAssertFirstCoreContext)({
+            readUsage: () => usage.snapshot(),
+            judgeUsage: input.judgeUsage,
+            elapsedMs: recorder.offsetNow,
             evaluationKind: a.evalDef.evaluationKind ?? "pass",
             model: a.run.model,
             reasoningEffort: a.run.reasoningEffort,
@@ -1372,6 +1402,7 @@ function runAdapterAttemptBody(input) {
                 experimentId: a.run.experimentId,
                 attempt: a.attempt,
                 signal,
+                models: a.run.models ?? Object.freeze({}),
                 model: a.run.model,
                 reasoningEffort: a.run.reasoningEffort,
                 flags: a.run.flags,
@@ -1380,6 +1411,7 @@ function runAdapterAttemptBody(input) {
                 log,
                 onCleanup: (cleanup) => resources.onCleanup(cleanup),
                 recordUsage: usage.record,
+                sealUsage: usage.seal,
                 attach: (input) => resources.trackHandoff(attachments.attach(input)),
                 recordTrace: executionTraces.recordTrace,
             });
@@ -1457,12 +1489,15 @@ function runAdapterAttemptBody(input) {
     });
 }
 function cleanupAdapterResources(resources, input) {
-    return effect_1.Effect.suspend(() => {
+    return effect_1.Effect.clockWith((clock) => effect_1.Effect.suspend(() => {
+        const timeoutMs = input.timeoutMs;
+        const deadlineAt = clock.currentTimeMillisUnsafe() + timeoutMs;
+        const cleanupStartedAt = clock.monotonicTimeNanosUnsafe();
         resources.beginCleanup();
         input.enterPhase("attempt.teardown");
         const startedAt = input.recorder.offsetNow();
         let failed = false;
-        return (0, cleanup_timeout_ts_1.cleanupCallback)((signal) => resources.cleanup(signal), cleanup_timeout_ts_1.CLEANUP_TIMEOUT_MS).pipe(effect_1.Effect.tap((result) => effect_1.Effect.sync(() => {
+        return (0, cleanup_timeout_ts_1.cleanupCallback)((signal) => resources.cleanup(Object.freeze({ signal, timeoutMs, deadlineAt })), Math.max(0, Math.ceil(timeoutMs - Number(clock.monotonicTimeNanosUnsafe() - cleanupStartedAt) / 1000000))).pipe(effect_1.Effect.tap((result) => effect_1.Effect.sync(() => {
             for (const failure of result.failures) {
                 failed = true;
                 input.feedback.diagnostic({
@@ -1475,13 +1510,13 @@ function cleanupAdapterResources(resources, input) {
                 failed = true;
                 input.onTimeout({
                     code: "adapter-cleanup-timeout",
-                    message: `Adapter cleanup timed out after ${cleanup_timeout_ts_1.CLEANUP_TIMEOUT_MS}ms`,
+                    message: `Adapter cleanup timed out after ${timeoutMs}ms`,
                     origin: (0, timing_ts_1.attemptOrigin)("attempt.teardown"),
                 });
                 input.feedback.diagnostic({
                     code: "adapter-cleanup-timeout",
                     level: "warning",
-                    message: `Adapter cleanup timed out after ${cleanup_timeout_ts_1.CLEANUP_TIMEOUT_MS}ms`,
+                    message: `Adapter cleanup timed out after ${timeoutMs}ms`,
                 });
             }
         })), effect_1.Effect.catch((failure) => effect_1.Effect.sync(() => {
@@ -1496,7 +1531,7 @@ function cleanupAdapterResources(resources, input) {
             resources.close();
             input.recorder.record("attempt.teardown", input.recorder.offsetNow() - startedAt, failed || undefined);
         })));
-    });
+    }));
 }
 /**
  * `EvalResult` still has historical renderer fields while its replacement
@@ -2470,6 +2505,7 @@ async function runAttemptBody(a, config, t0, base, res, parentSignal) {
                 } }),
             model: run.model,
             reasoningEffort: run.reasoningEffort,
+            judgeUsage: res.judgeUsage,
             // maxCost 断言的估算价目表;与 observed usage.costUSD 互不兜底。
             pricing: config.pricing,
             flags: run.flags,
@@ -2503,6 +2539,7 @@ async function runAttemptBody(a, config, t0, base, res, parentSignal) {
                 }
                 : undefined,
             onSendActive: setSendActive,
+            elapsedMs: recorder.offsetNow,
             timingNow: recorder.offsetNow,
             // 每次 send 一个 turn 节点:本地单调时钟测得的端到端包络 + 与 diff/source 共用的
             // session/turn 身份 token;
@@ -3263,6 +3300,7 @@ async function collectSources(evalSource, registry) {
 function experimentRunInfo(run, plan, sandboxPlansByEval, config, judge) {
     const runLevelTimeoutMs = run.timeoutMs ?? config?.timeoutMs;
     return {
+        ...(run.models === undefined ? {} : { models: run.models }),
         ...(run.description !== undefined ? { description: run.description } : {}),
         ...(run.reasoningEffort !== undefined ? { reasoningEffort: run.reasoningEffort } : {}),
         ...(Object.keys(run.flags).length > 0 ? { flags: run.flags } : {}),