@tangle-network/agent-eval 0.115.3 → 0.117.0

package/dist/{chunk-FAOEFFRT.js → chunk-IDZTTFRR.js}

@@ -2,11 +2,16 @@ import {
   confidenceInterval
 } from "./chunk-PJQFMIOX.js";
 import {
-  AgentEvalError
+  CostAccountingIncompleteError,
+  CostLedger
+} from "./chunk-VCTY3W6J.js";
+import {
+  AgentEvalError,
+  ValidationError
 } from "./chunk-ONWEPEDO.js";
 
 // src/campaign/run-campaign.ts
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 
 // src/integrity/backend-integrity.ts
 var BackendIntegrityError = class extends AgentEvalError {
@@ -215,6 +220,7 @@ function cachedJudge(judge, store, options) {
   const wrapped = {
     name: judge.name,
     dimensions: judge.dimensions,
+    judgeVersion: options.judgeVersion,
     async score(input) {
       const key = contentHash({
         artifact: canonicalJson(input.artifact),
@@ -246,34 +252,209 @@ function tangleTracesRoot() {
   return join(homedir(), ".tangle", "traces");
 }
 function resolveRunDir(runDir, repo) {
-  if (isAbsolute(runDir)) return runDir;
+  if (isAbsolute(runDir) || runDir.startsWith("mem://")) return runDir;
   const r = repo && repo.trim().length > 0 ? repo : basename(process.cwd());
   return join(tangleTracesRoot(), r, "runs", runDir);
 }
 
 // src/campaign/storage.ts
 import { createRequire } from "module";
+import { join as join2 } from "path";
+
+// src/campaign/search-ledger-file.ts
+import { randomUUID } from "crypto";
+import {
+  closeSync,
+  constants,
+  existsSync as existsSync2,
+  fsyncSync,
+  linkSync,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  unlinkSync,
+  writeSync
+} from "fs";
+import { hostname } from "os";
+import { dirname } from "path";
+import { z } from "zod";
+
+// src/campaign/search-ledger-errors.ts
+var SearchLedgerError = class extends ValidationError {
+};
+var SearchLedgerIntegrityError = class extends SearchLedgerError {
+};
+var SearchLedgerConflictError = class extends SearchLedgerError {
+};
+
+// src/campaign/search-ledger-file.ts
+function appendSearchLedgerLine(path, line) {
+  mkdirSync(dirname(path), { recursive: true });
+  const fd = openSync(path, constants.O_CREAT | constants.O_WRONLY | constants.O_APPEND, 384);
+  try {
+    writeAll(fd, Buffer.from(line, "utf8"));
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  fsyncDirectory(dirname(path));
+}
+function withSearchLedgerFileLock(ledgerPath, run) {
+  const result = tryWithSearchLedgerFileLock(ledgerPath, run);
+  if (!result.acquired) {
+    throw new SearchLedgerIntegrityError(`search ledger lock is held (${ledgerPath})`);
+  }
+  return result.value;
+}
+function tryWithSearchLedgerFileLock(ledgerPath, run) {
+  mkdirSync(dirname(ledgerPath), { recursive: true });
+  const lockPath = `${ledgerPath}.lock`;
+  const owner = acquireLock(lockPath);
+  if (!owner) return { acquired: false };
+  try {
+    return { acquired: true, value: run() };
+  } finally {
+    releaseLock(lockPath, owner);
+  }
+}
+function writeAll(fd, bytes) {
+  let offset = 0;
+  while (offset < bytes.byteLength) {
+    const written = writeSync(fd, bytes, offset, bytes.byteLength - offset);
+    if (written <= 0) throw new SearchLedgerIntegrityError("filesystem wrote zero bytes");
+    offset += written;
+  }
+}
+function fsyncDirectory(path) {
+  const fd = openSync(path, constants.O_RDONLY);
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function acquireLock(lockPath) {
+  const owner = { pid: process.pid, host: hostname(), nonce: randomUUID() };
+  const ownerBytes = `${canonicalOwner(owner)}
+`;
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const ownerPath = `${lockPath}.${owner.pid}.${owner.nonce}.${attempt}.owner`;
+    const fd = openSync(ownerPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+    try {
+      writeAll(fd, Buffer.from(ownerBytes, "utf8"));
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    try {
+      linkSync(ownerPath, lockPath);
+      unlinkSync(ownerPath);
+      return owner;
+    } catch (error) {
+      unlinkIfExists(ownerPath);
+      if (error.code !== "EEXIST") throw error;
+    }
+    const holder = readOwner(lockPath);
+    if (holder.host !== owner.host || isProcessAlive(holder.pid)) {
+      return void 0;
+    }
+    const tombstone = `${lockPath}.stale.${owner.nonce}.${attempt}`;
+    try {
+      renameSync(lockPath, tombstone);
+      unlinkSync(tombstone);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  throw new SearchLedgerIntegrityError(`could not acquire search ledger lock ${lockPath}`);
+}
+function releaseLock(lockPath, owner) {
+  if (!existsSync2(lockPath)) return;
+  const holder = readOwner(lockPath);
+  if (canonicalOwner(holder) !== canonicalOwner(owner)) {
+    throw new SearchLedgerIntegrityError(
+      `search ledger lock owner changed before release (${lockPath})`
+    );
+  }
+  unlinkSync(lockPath);
+}
+function readOwner(lockPath) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync2(lockPath, "utf8"));
+  } catch (error) {
+    throw new SearchLedgerIntegrityError(`search ledger lock ${lockPath} is malformed`, {
+      cause: error
+    });
+  }
+  const parsed = z.object({
+    pid: z.number().int().positive().safe(),
+    host: z.string().trim().min(1),
+    nonce: z.string().trim().min(1)
+  }).strict().safeParse(raw);
+  if (!parsed.success) {
+    throw new SearchLedgerIntegrityError(
+      `search ledger lock ${lockPath} is malformed: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`
+    );
+  }
+  return parsed.data;
+}
+function canonicalOwner(owner) {
+  return JSON.stringify({ host: owner.host, nonce: owner.nonce, pid: owner.pid });
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function unlinkIfExists(path) {
+  try {
+    unlinkSync(path);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+
+// src/campaign/storage.ts
 function fsCampaignStorage() {
   const nodeRequire = createRequire(import.meta.url);
-  const { existsSync: existsSync2, mkdirSync, readFileSync: readFileSync2, writeFileSync } = nodeRequire(
+  const { existsSync: existsSync3, mkdirSync: mkdirSync2, readFileSync: readFileSync3, statSync, writeFileSync } = nodeRequire(
     "node:fs"
   );
   return {
     ensureDir(dir) {
-      if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+      if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
     },
     exists(path) {
-      return existsSync2(path);
+      return existsSync3(path);
     },
     read(path) {
       try {
-        return readFileSync2(path, "utf8");
+        return readFileSync3(path, "utf8");
       } catch {
         return void 0;
       }
     },
     write(path, content) {
       writeFileSync(path, content);
+    },
+    append(path, content, expectedBytes) {
+      const result = tryWithSearchLedgerFileLock(path, () => {
+        let actualBytes = 0;
+        try {
+          actualBytes = statSync(path).size;
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+        if (actualBytes !== expectedBytes) return void 0;
+        appendSearchLedgerLine(path, content);
+        return expectedBytes + Buffer.byteLength(content);
+      });
+      return result.acquired ? result.value : void 0;
     }
   };
 }
@@ -294,24 +475,72 @@ function inMemoryCampaignStorage() {
     },
     write(path, content) {
       files.set(path, content);
+    },
+    append(path, content, expectedBytes) {
+      const current = files.get(path);
+      const currentText = current === void 0 ? "" : typeof current === "string" ? current : new TextDecoder().decode(current);
+      const currentBytes = new TextEncoder().encode(currentText).byteLength;
+      if (currentBytes !== expectedBytes) return void 0;
+      files.set(path, `${currentText}${content}`);
+      return currentBytes + new TextEncoder().encode(content).byteLength;
     }
   };
 }
+function createRunCostLedger(input) {
+  const path = join2(input.runDir, "cost-ledger.jsonl");
+  input.storage.ensureDir(input.runDir);
+  return new CostLedger({
+    costCeilingUsd: input.costCeilingUsd,
+    persistence: {
+      read: () => {
+        const stored = input.storage.read(path);
+        if (stored === void 0 && input.storage.exists(path)) {
+          throw new Error(`CostLedger: cannot read existing event log '${path}'`);
+        }
+        const events = stored ?? "";
+        return {
+          revision: String(new TextEncoder().encode(events).byteLength),
+          events
+        };
+      },
+      append: (expectedRevision, event) => {
+        const expectedBytes = Number(expectedRevision);
+        if (!Number.isSafeInteger(expectedBytes) || expectedBytes < 0) {
+          throw new Error(`CostLedger: invalid storage revision '${expectedRevision}'`);
+        }
+        if (!input.storage.append) {
+          throw new Error("CostLedger: CampaignStorage.append is required for paid calls");
+        }
+        const next = input.storage.append(path, event, expectedBytes);
+        return next === void 0 ? void 0 : String(next);
+      }
+    }
+  });
+}
 
 // src/campaign/run-campaign.ts
 async function runCampaign(opts) {
   const seed = opts.seed ?? 42;
   const reps = opts.reps ?? 1;
   const resumable = opts.resumable ?? true;
-  const maxConcurrency = opts.maxConcurrency ?? 2;
   const now = opts.now ?? (() => /* @__PURE__ */ new Date());
   const judges = opts.judges ?? [];
   const storage = opts.storage ?? fsCampaignStorage();
+  const costPhase = opts.costPhase ?? "campaign";
   if (typeof opts.runDir !== "string" || opts.runDir.trim().length === 0) {
     throw new Error("runCampaign: runDir is required and must be a non-empty string");
   }
   opts.runDir = resolveRunDir(opts.runDir, opts.repo);
   storage.ensureDir(opts.runDir);
+  const costLedger = opts.costLedger ?? createRunCostLedger({
+    storage,
+    runDir: opts.runDir,
+    costCeilingUsd: opts.costCeiling
+  });
+  if (opts.costCeiling !== void 0 && costLedger.costCeilingUsd !== opts.costCeiling) {
+    throw new Error("runCampaign: costCeiling must match the shared CostLedger ceiling");
+  }
+  const maxConcurrency = opts.maxConcurrency ?? 2;
   const manifestHash = computeManifestHash({
     scenarios: opts.scenarios,
     judges,
@@ -320,11 +549,10 @@ async function runCampaign(opts) {
     reps
   });
   const startedAt = now();
+  const runAttemptId = globalThis.crypto.randomUUID();
   const cells = [];
   const artifactsByPath = {};
   const schedule = buildCellSchedule(opts.scenarios, seed, reps);
-  let totalCostUsd = 0;
-  let costCeilingReached = false;
   const abortController = new AbortController();
   const lanes = [];
   let nextIdx = 0;
@@ -336,10 +564,6 @@ async function runCampaign(opts) {
           const myIdx = nextIdx++;
           if (myIdx >= schedule.length) return;
           const slot = schedule[myIdx];
-          if (costCeilingReached) {
-            cellsRef.push(skippedCell(slot, "cost_ceiling_reached"));
-            continue;
-          }
           const result = await executeCell({
             slot,
             opts,
@@ -349,15 +573,13 @@ async function runCampaign(opts) {
             storage,
             buildTraceWriter: opts.buildTraceWriter ?? defaultBuildTraceWriter(storage),
             signal: abortController.signal,
-            dispatchTimeoutMs: opts.dispatchTimeoutMs
+            dispatchTimeoutMs: opts.dispatchTimeoutMs,
+            costLedger,
+            costPhase,
+            runAttemptId
           });
           cellsRef.push(result.cell);
-          enforceCellUsage(result.cell, opts.expectUsage ?? "warn");
-          totalCostUsd += result.cell.costUsd;
           Object.assign(artifactsByPath, result.artifactsByPath);
-          if (opts.costCeiling !== void 0 && totalCostUsd >= opts.costCeiling) {
-            costCeilingReached = true;
-          }
           if (opts.labeledStore && opts.labeledStore !== "off" && !result.cell.error) {
             await captureToStore({
               store: opts.labeledStore,
@@ -378,10 +600,12 @@ async function runCampaign(opts) {
   await Promise.all(lanes);
   const endedAt = now();
   cellsRef.sort((a, b) => a.cellId.localeCompare(b.cellId));
+  const campaignCost = costLedger.summary({ tags: { runDir: opts.runDir } });
   const aggregates = computeAggregates(
     cellsRef,
     judges,
-    seed
+    seed,
+    campaignCost
   );
   return {
     manifestHash,
@@ -398,9 +622,16 @@ async function runCampaign(opts) {
 }
 async function executeCell(args) {
   const storage = args.storage;
-  const cellDir = join2(args.opts.runDir, args.slot.cellId.replace(/[^a-zA-Z0-9_-]/g, "_"));
+  const cellDir = join3(args.opts.runDir, args.slot.cellId.replace(/[^a-zA-Z0-9_-]/g, "_"));
   storage.ensureDir(cellDir);
-  const cachePath = join2(cellDir, "cached-result.json");
+  const stableCostTags = {
+    runDir: args.opts.runDir,
+    cellId: args.slot.cellId,
+    scenarioId: args.slot.scenario.id,
+    rep: String(args.slot.rep)
+  };
+  const costTags = { ...stableCostTags, runAttemptId: args.runAttemptId };
+  const cachePath = join3(cellDir, "cached-result.json");
   if (args.resumable) {
     const cached = readCachedCell({
       storage,
@@ -409,6 +640,33 @@ async function executeCell(args) {
       manifestHash: args.manifestHash
     });
     if (cached.status === "hit") {
+      enforceDispatchUsage(cached.cell, args.opts.expectUsage ?? "warn");
+      const cachedHasUsage = cached.cell.costUsd > 0 || cached.cell.tokenUsage.input > 0 || cached.cell.tokenUsage.output > 0;
+      if (cached.cell.costCallIds === void 0) {
+        if (cachedHasUsage || Object.keys(cached.cell.judgeScores).length > 0) {
+          throw new CostAccountingIncompleteError(
+            `runCampaign: cached cell '${args.slot.cellId}' does not identify its ledger receipts`
+          );
+        }
+      } else if (!Array.isArray(cached.cell.costCallIds) || cached.cell.costCallIds.some(
+        (callId) => typeof callId !== "string" || callId.trim().length === 0
+      ) || new Set(cached.cell.costCallIds).size !== cached.cell.costCallIds.length) {
+        throw new CostAccountingIncompleteError(
+          `runCampaign: cached cell '${args.slot.cellId}' has invalid ledger receipt IDs`
+        );
+      } else {
+        const restoredCallIds = new Set(
+          args.costLedger.list({ tags: stableCostTags }).map((receipt) => receipt.callId)
+        );
+        const missingCallIds = cached.cell.costCallIds.filter(
+          (callId) => !restoredCallIds.has(callId)
+        );
+        if (missingCallIds.length > 0) {
+          throw new CostAccountingIncompleteError(
+            `runCampaign: cached cell '${args.slot.cellId}' is missing ledger receipt(s): ${missingCallIds.join(", ")}`
+          );
+        }
+      }
       return { cell: { ...cached.cell, cached: true }, artifactsByPath: {} };
     }
   }
@@ -417,8 +675,8 @@ async function executeCell(args) {
   const artifactsByPath = {};
   const artifacts = {
     async write(path, content) {
-      const fullPath = join2(cellDir, path);
-      storage.ensureDir(join2(fullPath, ".."));
+      const fullPath = join3(cellDir, path);
+      storage.ensureDir(join3(fullPath, ".."));
       storage.write(fullPath, content);
       artifactsByPath[`${args.slot.cellId}/${path}`] = fullPath;
       return fullPath;
@@ -427,31 +685,20 @@ async function executeCell(args) {
       return artifacts.write(path, JSON.stringify(value, null, 2));
     }
   };
-  let costSoFar = 0;
-  const tokensSoFar = { input: 0, output: 0 };
-  let resolvedModel;
   const cost = {
-    observe(amount, source) {
-      costSoFar += amount;
-      trace.span(`cost.${source}`, { amountUsd: amount }).end();
-    },
-    observeTokens(usage) {
-      tokensSoFar.input += usage.input;
-      tokensSoFar.output += usage.output;
-      if (usage.cached) tokensSoFar.cached = (tokensSoFar.cached ?? 0) + usage.cached;
-    },
-    observeModel(model) {
-      const trimmed = model?.trim();
-      if (trimmed) resolvedModel = trimmed;
-    },
-    current() {
-      return costSoFar;
-    },
-    tokens() {
-      return { ...tokensSoFar };
-    },
-    resolvedModel() {
-      return resolvedModel;
+    async runPaidCall(input) {
+      const result = await args.costLedger.runPaidCall({
+        ...input,
+        channel: input.channel ?? "agent",
+        phase: args.costPhase,
+        actor: input.actor,
+        tags: costTags,
+        signal: cellAbort.signal
+      });
+      if (result.receipt) {
+        trace.span(`cost.${result.receipt.actor}`, { amountUsd: result.receipt.costUsd }).end();
+      }
+      return result;
     }
   };
   const placement = args.opts.cellPlacement?.({
@@ -503,23 +750,53 @@ async function executeCell(args) {
     if (timeoutTimer) clearTimeout(timeoutTimer);
     args.signal.removeEventListener("abort", onCampaignAbort);
   }
+  const agentReceipts = args.costLedger.list({ channel: "agent", tags: costTags });
+  const agentCost = args.costLedger.summary({ channel: "agent", tags: costTags });
+  const tokenUsage = {
+    input: agentCost.inputTokens,
+    output: agentCost.outputTokens,
+    ...agentCost.cachedTokens > 0 ? { cached: agentCost.cachedTokens } : {}
+  };
+  const resolvedModel = agentReceipts.at(-1)?.model;
+  const dispatchResult = {
+    cellId: args.slot.cellId,
+    artifact,
+    error: errorMessage,
+    costUsd: agentCost.totalCostUsd,
+    tokenUsage
+  };
+  try {
+    enforceDispatchUsage(dispatchResult, args.opts.expectUsage ?? "warn");
+  } catch (error) {
+    await trace.flush();
+    throw error;
+  }
   const judgeScores = {};
   if (artifact !== void 0) {
     for (const judge of args.opts.judges ?? []) {
       if (judge.appliesTo && !judge.appliesTo(args.slot.scenario)) continue;
       try {
-        judgeScores[judge.name] = await runJudgeCell(judge, {
+        const score = await runJudgeCell(judge, {
           artifact,
           scenario: args.slot.scenario,
-          signal: args.signal
+          signal: args.signal,
+          costLedger: args.costLedger,
+          costPhase: args.costPhase,
+          costTags
         });
+        judgeScores[judge.name] = score;
       } catch (err) {
+        if (err instanceof CostAccountingIncompleteError) {
+          await trace.flush();
+          throw err;
+        }
         errorMessage = `judge '${judge.name}' failed: ${err instanceof Error ? err.message : String(err)}`;
         break;
       }
     }
   }
   await trace.flush();
+  const costCallIds = args.costLedger.list({ tags: costTags }).map((receipt) => receipt.callId).sort();
   const cell = {
     manifestHash: args.manifestHash,
     cellId: args.slot.cellId,
@@ -527,8 +804,12 @@ async function executeCell(args) {
     rep: args.slot.rep,
     artifact: artifact ?? null,
     judgeScores,
-    costUsd: costSoFar,
-    tokenUsage: { ...tokensSoFar },
+    costUsd: agentCost.totalCostUsd,
+    costEstimated: agentReceipts.some(
+      (receipt) => receipt.actualCostUsd === void 0 && !receipt.costUnknown
+    ),
+    costCallIds,
+    tokenUsage,
     ...resolvedModel ? { resolvedModel } : {},
     durationMs: Date.now() - startMs,
     seed: args.slot.cellSeed,
@@ -557,7 +838,7 @@ function planCampaignRun(opts) {
     reps
   });
   const cells = buildCellSchedule(opts.scenarios, seed, reps).map((slot) => {
-    const cachePath = join2(
+    const cachePath = join3(
       opts.runDir,
       slot.cellId.replace(/[^a-zA-Z0-9_-]/g, "_"),
       "cached-result.json"
@@ -608,12 +889,12 @@ function planCampaignRun(opts) {
     cells
   };
 }
-function enforceCellUsage(cell, mode) {
-  if (mode === "off" || cell.error) return;
+function enforceDispatchUsage(cell, mode) {
+  if (mode === "off") return;
   if (cell.artifact === null || cell.artifact === void 0) return;
   const zeroTokens = cell.tokenUsage.input === 0 && cell.tokenUsage.output === 0;
   if (cell.costUsd !== 0 || !zeroTokens) return;
-  const msg = `cell '${cell.cellId}' produced an artifact but reported zero cost and zero tokens \u2014 the dispatch never reported LLM usage via ctx.cost.observe/observeTokens (a stub cell)`;
+  const msg = `cell '${cell.cellId}' produced an artifact but reported zero cost and zero tokens \u2014 the dispatch made no paid call through ctx.cost.runPaidCall (a stub cell)`;
   if (mode === "assert") {
     const report = {
       totalRecords: 1,
@@ -631,7 +912,29 @@ function enforceCellUsage(cell, mode) {
   console.warn(`[runCampaign] expectUsage: ${msg}`);
 }
 async function runJudgeCell(judge, input) {
-  return judge.score(input);
+  const previousJudgeCalls = new Set(
+    input.costLedger?.list({ channel: "judge", tags: input.costTags }).map((receipt) => receipt.callId) ?? []
+  );
+  try {
+    const score = await judge.score(input);
+    assertReportedJudgeCallRecorded(judge.name, score, input, previousJudgeCalls);
+    return score;
+  } catch (error) {
+    assertReportedJudgeCallRecorded(judge.name, error, input, previousJudgeCalls, error);
+    throw error;
+  }
+}
+function assertReportedJudgeCallRecorded(judgeName, value, input, previousCallIds, cause) {
+  if (!hasLlmCall(value)) return;
+  const recorded = input.costLedger?.list({ channel: "judge", tags: input.costTags }).some((receipt) => !previousCallIds.has(receipt.callId));
+  if (recorded) return;
+  throw new CostAccountingIncompleteError(
+    `runCampaign: judge '${judgeName}' reported a paid LLM call without a CostLedger receipt`,
+    cause === void 0 ? void 0 : { cause }
+  );
+}
+function hasLlmCall(value) {
+  return typeof value === "object" && value !== null && "llmCall" in value && value.llmCall !== void 0;
 }
 function defaultBuildTraceWriter(storage) {
   return (cellId, dir) => {
@@ -653,26 +956,11 @@ function defaultBuildTraceWriter(storage) {
         return finish;
       },
       async flush() {
-        storage.write(join2(dir, "spans.jsonl"), spans.map((s) => JSON.stringify(s)).join("\n"));
+        storage.write(join3(dir, "spans.jsonl"), spans.map((s) => JSON.stringify(s)).join("\n"));
       }
     };
   };
 }
-function skippedCell(slot, reason) {
-  return {
-    cellId: slot.cellId,
-    scenarioId: slot.scenario.id,
-    rep: slot.rep,
-    artifact: null,
-    judgeScores: {},
-    costUsd: 0,
-    tokenUsage: { input: 0, output: 0 },
-    durationMs: 0,
-    seed: slot.cellSeed,
-    cached: false,
-    error: `skipped: ${reason}`
-  };
-}
 function buildCellSchedule(scenarios, seed, reps) {
   const schedule = [];
   let cellIndex = 0;
@@ -721,13 +1009,30 @@ async function captureToStore(args) {
 function computeManifestHash(input) {
   return contentHash({
     scenarios: input.scenarios,
-    judges: input.judges.map((j) => ({ name: j.name, dims: j.dimensions })),
+    judges: input.judges.map((judge) => ({
+      name: judge.name,
+      dims: judge.dimensions,
+      version: judgeVersionFor(judge)
+    })),
     dispatch: input.dispatchRef,
     seed: input.seed,
     reps: input.reps
   });
 }
-function computeAggregates(cells, judges, seed) {
+function judgeVersionFor(judge) {
+  if (judge.judgeVersion !== void 0) {
+    const version = judge.judgeVersion.trim();
+    if (version.length === 0) {
+      throw new Error(`runCampaign: judge '${judge.name}' has an empty judgeVersion`);
+    }
+    return version;
+  }
+  return contentHash({
+    score: judge.score.toString(),
+    appliesTo: judge.appliesTo?.toString() ?? null
+  });
+}
+function computeAggregates(cells, judges, seed, cost) {
   const byJudge = {};
   for (const judge of judges) {
     const scores = [];
@@ -754,7 +1059,8 @@ function computeAggregates(cells, judges, seed) {
   return {
     byJudge,
     byScenario,
-    totalCostUsd: cells.reduce((a, c) => a + c.costUsd, 0),
+    cost,
+    totalCostUsd: cost.totalCostUsd,
     cellsExecuted: cells.filter((c) => !c.error).length,
     cellsSkipped: cells.filter((c) => c.error?.startsWith("skipped:")).length,
     cellsCached: cells.filter((c) => c.cached).length,
@@ -782,9 +1088,15 @@ export {
   cachedJudge,
   tangleTracesRoot,
   resolveRunDir,
+  SearchLedgerError,
+  SearchLedgerIntegrityError,
+  SearchLedgerConflictError,
+  appendSearchLedgerLine,
+  withSearchLedgerFileLock,
   fsCampaignStorage,
   inMemoryCampaignStorage,
+  createRunCostLedger,
   runCampaign,
   planCampaignRun
 };
-//# sourceMappingURL=chunk-FAOEFFRT.js.map
+//# sourceMappingURL=chunk-IDZTTFRR.js.map