niceeval 0.13.3 → 0.13.4-canary.39

package/dist/runner/ledger.d.cts

@@ -2,9 +2,7 @@ import type { DiffArtifact, Sandbox } from "../types.cjs";
 import type { AgentWorkspaceDiffPolicy } from "../assertions/workspace-diff.cjs";
 /**
  * ledger 的私有 git 目录:workdir 之外、runner 控制;agent 的工具默认不会去 /tmp 翻它。这是
- * 沙箱内 provider(docker/e2b/vercel)的默认值——每个实例都是全新隔离文件系统,固定路径不会
- * 跨实例踩踏。宿主本身即工作树的 provider(如 local)按 sandboxId 登记专属路径覆盖它
- * (见 sandbox/ledger-paths.ts),避免同机多次运行共享同一个 /tmp。
+ * 沙箱内 provider(docker/e2b/vercel)的固定值——每个实例都是全新隔离文件系统。
  */
 export declare const LEDGER_GIT_DIR = "/tmp/.niceeval-ledger";
 export interface ChangeLedger {

package/dist/runner/ledger.d.mts

@@ -2,9 +2,7 @@ import type { DiffArtifact, Sandbox } from "../types.mjs";
 import type { AgentWorkspaceDiffPolicy } from "../assertions/workspace-diff.mjs";
 /**
  * ledger 的私有 git 目录:workdir 之外、runner 控制;agent 的工具默认不会去 /tmp 翻它。这是
- * 沙箱内 provider(docker/e2b/vercel)的默认值——每个实例都是全新隔离文件系统,固定路径不会
- * 跨实例踩踏。宿主本身即工作树的 provider(如 local)按 sandboxId 登记专属路径覆盖它
- * (见 sandbox/ledger-paths.ts),避免同机多次运行共享同一个 /tmp。
+ * 沙箱内 provider(docker/e2b/vercel)的固定值——每个实例都是全新隔离文件系统。
  */
 export declare const LEDGER_GIT_DIR = "/tmp/.niceeval-ledger";
 export interface ChangeLedger {

package/dist/runner/ledger.d.ts

@@ -2,9 +2,7 @@ import type { DiffArtifact, Sandbox } from "../types.js";
 import type { AgentWorkspaceDiffPolicy } from "../assertions/workspace-diff.js";
 /**
  * ledger 的私有 git 目录:workdir 之外、runner 控制;agent 的工具默认不会去 /tmp 翻它。这是
- * 沙箱内 provider(docker/e2b/vercel)的默认值——每个实例都是全新隔离文件系统,固定路径不会
- * 跨实例踩踏。宿主本身即工作树的 provider(如 local)按 sandboxId 登记专属路径覆盖它
- * (见 sandbox/ledger-paths.ts),避免同机多次运行共享同一个 /tmp。
+ * 沙箱内 provider(docker/e2b/vercel)的固定值——每个实例都是全新隔离文件系统。
  */
 export declare const LEDGER_GIT_DIR = "/tmp/.niceeval-ledger";
 export interface ChangeLedger {

package/dist/runner/run.cjs

@@ -491,7 +491,6 @@ function runEvals(opts) {
         const runTiming = (0, timing_ts_1.createRunTimingRecorder)();
         let sandboxBuildRecords = [];
         const buildFailureByPair = new Map();
-        const buildLocatorsByPair = new Map();
         const collected = opts.buildPreparation === undefined
             ? yield* (0, build_preparation_ts_1.collectBuildPreparation)({
                 preparedPairs: [...preparedPairsByKey.values()],
@@ -502,6 +501,14 @@ function runEvals(opts) {
             ? effect_1.Option.flatMap(collected, build_preparation_ts_1.toBuildPreparation)
             : effect_1.Option.some(opts.buildPreparation);
         const buildPrep = effect_1.Option.getOrUndefined(buildPreparation);
+        const buildDependents = new Map();
+        if (buildPrep !== undefined) {
+            for (const attempt of attempts) {
+                const keys = buildPrep.pairBuildKeys[(0, fingerprint_ts_1.cacheKey)(attempt.run, attempt.evalDef.id)] ?? [];
+                for (const key of keys)
+                    buildDependents.set(key, (buildDependents.get(key) ?? 0) + 1);
+            }
+        }
         // 共享构建**不阻塞派发**:整批 key 同时开工,每条 attempt 只等自己引用的那几个 key
         // (case.md「Run 级构建协调」第 4 条的逐 key 放行)。全局 barrier 会让 10 个已就绪的镜像
         // 陪着最慢的那个构建干等(台账见 memory/shared-build-single-barrier-not-per-buildkey.md)。
@@ -515,10 +522,21 @@ function runEvals(opts) {
                 signal: opts.signal,
                 // 最小反馈钩子:共享构建投影为运行级 active 行 / 非 TTY 起止事件,不占 attempt 位。
                 onActivity: (event) => {
+                    const dependents = buildDependents.get(event.ref) ?? 0;
+                    const shared = `${dependents} attempt${dependents === 1 ? "" : "s"}`;
+                    const action = event.status === "started"
+                        ? "checking build cache"
+                        : event.outcome === "hit"
+                            ? "build cache hit"
+                            : event.outcome === "built"
+                                ? "built once"
+                                : event.outcome === "cancelled"
+                                    ? "build cancelled"
+                                    : "build failed";
                     (0, sink_ts_1.reportRunActivity)({
                         id: event.id,
                         key: event.key,
-                        label: event.label,
+                        label: `${action} · ${event.label} · ${shared}`,
                         status: event.status,
                         ...("durationMs" in event ? { durationMs: event.durationMs } : {}),
                     });
@@ -526,18 +544,26 @@ function runEvals(opts) {
             })
             : undefined;
         // 逐 pair 的放行闸:第一次问到就记下等待,之后同 pair 的其它 attempt 复用同一条。
+        const buildUseKey = (a) => `${(0, fingerprint_ts_1.cacheKey)(a.run, a.evalDef.id)}|${a.attempt}`;
         const buildWaits = new Map();
-        const awaitBuildsFor = (pairKey) => {
+        const buildUseHandles = new Map();
+        const buildLocatorsByAttempt = new Map();
+        const buildWorkByRef = new Map(buildPrep?.works.map((work) => [work.ref, work]) ?? []);
+        const awaitBuildsFor = (a) => {
+            const pairKey = (0, fingerprint_ts_1.cacheKey)(a.run, a.evalDef.id);
             const keys = buildPrep?.pairBuildKeys[pairKey];
             if (runningBuilds === undefined || keys === undefined || keys.length === 0)
                 return Promise.resolve();
-            let pending = buildWaits.get(pairKey);
+            const useKey = buildUseKey(a);
+            let pending = buildWaits.get(useKey);
             if (pending !== undefined)
                 return pending;
             pending = (async () => {
                 for (const key of keys)
                     await runningBuilds.settled(key);
                 const locators = new Map();
+                const handles = [];
+                buildUseHandles.set(useKey, handles);
                 for (const key of keys) {
                     const failure = runningBuilds.failures.get(key);
                     if (failure !== undefined) {
@@ -550,16 +576,28 @@ function runEvals(opts) {
                         });
                         return;
                     }
-                    const locator = runningBuilds.locators.get(key);
-                    if (locator !== undefined)
-                        locators.set(key, locator);
+                    const source = runningBuilds.sources.get(key);
+                    const work = buildWorkByRef.get(key);
+                    if (source !== undefined && work !== undefined) {
+                        const handle = await source.acquireUse(opts.signal ?? new AbortController().signal);
+                        handles.push(handle);
+                        locators.set(work.buildKey, handle.locator);
+                    }
                 }
                 if (locators.size > 0)
-                    buildLocatorsByPair.set(pairKey, locators);
+                    buildLocatorsByAttempt.set(useKey, locators);
             })();
-            buildWaits.set(pairKey, pending);
+            buildWaits.set(useKey, pending);
             return pending;
         };
+        const releaseBuildUsesFor = (a) => effect_1.Effect.tryPromise({
+            try: async () => {
+                const handles = buildUseHandles.get(buildUseKey(a)) ?? [];
+                buildUseHandles.delete(buildUseKey(a));
+                await Promise.all(handles.map((handle) => handle.release()));
+            },
+            catch: () => undefined,
+        }).pipe(effect_1.Effect.ignore);
         // Run 级 Agent artifact prepare:由 attempt 内探测到目标 Sandbox 平台后触发 single-flight。
         // 绝不能在这里按宿主平台 eager prepare：macOS 宿主跑 Linux Sandbox 会拿到错误制品。
         const artifactPrepare = opts.artifactPrepare ??
@@ -788,10 +826,10 @@ function runEvals(opts) {
             }
         }
         // provider 级独占串行闸(见 docs/runner.md「调度:有界并发」):声明了 exclusive 的 provider
-        // (如 local——同一棵真实工作树不允许并发写)按 provider 名共享一把 permit=1 的信号量,
+        // 按 provider 名共享一把 permit=1 的信号量,
         // --max-concurrency / 实验级 maxConcurrency 都不解除。核心不认 provider 名分支:这里只读
         // physical plan 的中性 admission/lane 字段；相同 lane 共用一把锁，表示它们竞争同一份
-        // 不可并发底层资源，不是 `provider === "local"` 的行为分支。
+        // 不可并发底层资源。
         const providerExclusiveSems = new Map();
         for (const attempt of attempts) {
             if (attempt.plan._tag === "Direct" ||
@@ -2022,7 +2060,7 @@ function runEvals(opts) {
                 ]);
                 // BuildKey / CaseKey 已在 Attempt.plan 的 physical completion state 中确定；
                 // 这里只把协调器执行结果作为必填运行输入传给 materializer，不回写 Attempt。
-                const buildLocators = buildLocatorsByPair.get((0, fingerprint_ts_1.cacheKey)(a.run, a.evalDef.id)) ?? new Map();
+                const buildLocators = buildLocatorsByAttempt.get(buildUseKey(a)) ?? new Map();
                 // 派发前的确定性失败(实验级 setup 失败 / 判分预检失败):不派发 agent、不建沙箱。
                 // 这类 Slot 没有 origin Attempt，因而会使 V1 draft 保持 incomplete；不能为它
                 // 伪造一个没有 sealed Assertions 的 Member。
@@ -2332,7 +2370,7 @@ function runEvals(opts) {
             });
             // ③ 全局并发位 → sharedState（如声明，先于 Eval lock）→ 派发时刻试锁 → preflight
             // → 实验级 setup → provider/Sandbox/body。
-            // 独占串行 provider(如 local):同一 provider 名的所有 attempt 共享一把 permit=1 的锁。
+            // 独占串行 provider:同一 provider 名的所有 attempt 共享一把 permit=1 的锁。
             // sharedState 获取与 Experiment setup 都是宿主协调，不能让等待者占着该 Provider lane；
             // permit 只包真正触及 provider、Sandbox 与 Attempt body 的执行段。
             const exclusiveSem = exclusiveSemFor(a.plan);
@@ -2404,9 +2442,8 @@ function runEvals(opts) {
                 }
                 // ⓪ 逐 BuildKey 放行:只等本 eval 引用的那几个 key,不引用任何 key 的 attempt
                 // 立刻进入许可链。等在这里不占全局并发位,慢构建因此不挡住同批别的 eval。
-                const pairKey = (0, fingerprint_ts_1.cacheKey)(a.run, a.evalDef.id);
                 yield* effect_1.Effect.tryPromise({
-                    try: () => awaitBuildsFor(pairKey),
+                    try: () => awaitBuildsFor(a),
                     catch: (error) => error,
                 });
                 for (;;) {
@@ -2449,7 +2486,7 @@ function runEvals(opts) {
             const withCaseLifecycle = !caseState
                 ? withExpLifecycle
                 : withExpLifecycle.pipe(effect_1.Effect.ensuring(releaseCaseLockIfDone(caseState, a.attempt)));
-            const withWaveLifecycle = withCaseLifecycle.pipe(effect_1.Effect.ensuring(arriveAtDispatchWave));
+            const withWaveLifecycle = withCaseLifecycle.pipe(effect_1.Effect.ensuring(releaseBuildUsesFor(a)), effect_1.Effect.ensuring(arriveAtDispatchWave));
             if (predecessor === undefined)
                 return withWaveLifecycle;
             const releaseSuccessor = groupedReleases.get(a);
@@ -2468,9 +2505,17 @@ function runEvals(opts) {
             }
             return effect_1.Effect.failCause(cause); // 非中断的意外缺陷:照常抛出
         }));
-        const exit = yield* effect_1.Effect.exit(opts.signal === undefined
+        const releaseBuildSources = effect_1.Effect.tryPromise({
+            try: async () => {
+                const sources = new Set(runningBuilds?.sources.values() ?? []);
+                await Promise.all([...sources].map((source) => source.release()));
+            },
+            catch: () => undefined,
+        }).pipe(effect_1.Effect.ignore);
+        const exit = yield* effect_1.Effect.exit((opts.signal === undefined
             ? dispatchEffect
-            : effect_1.Effect.raceFirst(dispatchEffect, interruptOnAbort(opts.signal)));
+            : effect_1.Effect.raceFirst(dispatchEffect, interruptOnAbort(opts.signal)))
+            .pipe(effect_1.Effect.ensuring(releaseBuildSources)));
         // A full-carry / zero-Attempt invocation has no dispatch fiber that could
         // await startup recovery. Seal its selected-Experiment obligation here; for
         // normal runs the per-setup gate above has already awaited the same Deferred.