@remnic/bench 9.6.20 → 9.6.22

package/dist/index.js

@@ -5497,17 +5497,473 @@ var BENCHMARK_RESULT_SCHEMA = {
 
 // src/repro-manifest.ts
 import { execFileSync } from "child_process";
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { createReadStream } from "fs";
-import { lstat as lstat3, mkdir as mkdir3, readFile as readFile4, readdir as readdir4, readlink, realpath as realpath3, stat as stat2, writeFile as writeFile3 } from "fs/promises";
-import os2 from "os";
-import path4 from "path";
+import { lstat as lstat3, mkdir as mkdir4, readFile as readFile5, readdir as readdir4, readlink, realpath as realpath3, stat as stat2, writeFile as writeFile4 } from "fs/promises";
+import os3 from "os";
+import path5 from "path";
 
-// src/results-store.ts
-import { mkdir as mkdir2, readdir as readdir3, readFile as readFile3, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
-import fs from "fs";
+// src/providers/codex-credit-budget.ts
+import { createHash as createHash3 } from "crypto";
+import { mkdir as mkdir2, open, readFile as readFile3, rename as rename2, rmdir, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
 import os from "os";
 import path3 from "path";
+var ONE_MILLION = 1e6;
+var MAX_BOUNDED_CALL_CREDITS = 300;
+var SOL_MODEL = /^gpt-5\.6-sol$/i;
+var CREDIT_RATES = [
+  [/^gpt-5\.6-sol$/i, { input: 125, cachedInput: 12.5, output: 750 }],
+  [/^gpt-5\.6-terra$/i, { input: 62.5, cachedInput: 6.25, output: 375 }],
+  [/^gpt-5\.6-luna$/i, { input: 25, cachedInput: 2.5, output: 150 }],
+  [/^gpt-5\.5$/i, { input: 125, cachedInput: 12.5, output: 750 }],
+  [/^gpt-5\.4-mini$/i, { input: 18.75, cachedInput: 1.875, output: 113 }],
+  [/^gpt-5\.4$/i, { input: 62.5, cachedInput: 6.25, output: 375 }],
+  [/^gpt-5\.3-codex$/i, { input: 43.75, cachedInput: 4.375, output: 350 }],
+  [/^gpt-5\.2$/i, { input: 43.75, cachedInput: 4.375, output: 350 }]
+];
+var completionQueue = Promise.resolve();
+var CodexCreditAccountingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodexCreditAccountingError";
+  }
+};
+var CodexCreditDispatchError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CodexCreditDispatchError";
+  }
+};
+function resolveCodexCreditBudgetConfig(env = process.env, fallbackRunId) {
+  const rawBudget = env.REMNIC_BENCH_CODEX_CREDIT_BUDGET?.trim();
+  if (!rawBudget) return void 0;
+  const budgetCredits = parsePositiveNumber(
+    rawBudget,
+    "REMNIC_BENCH_CODEX_CREDIT_BUDGET"
+  );
+  const reserveCredits = parseNonNegativeNumber(
+    env.REMNIC_BENCH_CODEX_CREDIT_RESERVE?.trim() ?? "473",
+    "REMNIC_BENCH_CODEX_CREDIT_RESERVE"
+  );
+  if (reserveCredits >= budgetCredits) {
+    throw new Error(
+      "REMNIC_BENCH_CODEX_CREDIT_RESERVE must be smaller than REMNIC_BENCH_CODEX_CREDIT_BUDGET"
+    );
+  }
+  if (reserveCredits < MAX_BOUNDED_CALL_CREDITS) {
+    throw new Error(
+      `REMNIC_BENCH_CODEX_CREDIT_RESERVE must be at least ${MAX_BOUNDED_CALL_CREDITS} credits to cover the conservative maximum cost of the one serialized in-flight call`
+    );
+  }
+  const ledgerPath = path3.resolve(
+    expandHomeRelativePath(
+      env.REMNIC_BENCH_CODEX_CREDIT_LEDGER?.trim() || ".remnic/bench/codex-credit-ledger.json"
+    )
+  );
+  const runId = parseOptionalRunId(env.REMNIC_BENCH_RUN_ID) ?? parseOptionalRunId(fallbackRunId);
+  return {
+    budgetCredits,
+    reserveCredits,
+    ledgerPath,
+    allowSol: /^(?:1|true|yes|on)$/i.test(
+      env.REMNIC_BENCH_CODEX_ALLOW_SOL?.trim() ?? ""
+    ),
+    ...runId ? { runId } : {}
+  };
+}
+async function runWithinCodexCreditBudget(args) {
+  if (!args.config) {
+    return (await args.run()).value;
+  }
+  const previous = completionQueue;
+  let release;
+  completionQueue = new Promise((resolve) => {
+    release = resolve;
+  });
+  await previous;
+  const lockPath = `${args.config.ledgerPath}.lock`;
+  let lock;
+  let dispatchStarted = false;
+  let accountingSettled = false;
+  try {
+    await mkdir2(path3.dirname(lockPath), { recursive: true, mode: 448 });
+    lock = await acquireLedgerLock(lockPath);
+    assertModelAllowed(args.model, args.config);
+    const ledger = await readLedger(args.config);
+    if (ledger.blockedReason) {
+      throw new Error(
+        `Codex credit ledger is blocked pending manual reconciliation: ${ledger.blockedReason}`
+      );
+    }
+    const usableCredits = args.config.budgetCredits - args.config.reserveCredits;
+    const dispatchHeadroom = usableCredits - ledger.spentCredits;
+    if (dispatchHeadroom < MAX_BOUNDED_CALL_CREDITS) {
+      throw new Error(
+        `Codex credit budget cannot safely dispatch another call: ${ledger.spentCredits.toFixed(3)} spent; ${dispatchHeadroom.toFixed(3)} remains below the ${usableCredits.toFixed(3)} planned-spend ceiling, but ${MAX_BOUNDED_CALL_CREDITS.toFixed(3)} credits of worst-case call headroom are required.`
+      );
+    }
+    await writeLockState(lock, "in-flight");
+    dispatchStarted = true;
+    let result;
+    try {
+      result = await args.run();
+    } catch (error) {
+      if (error instanceof CodexCreditDispatchError) {
+        await writeLockState(lock, "settled");
+        accountingSettled = true;
+      } else {
+        const blockedLedger = {
+          ...ledger,
+          blockedReason: error instanceof CodexCreditAccountingError ? error.message : `Codex dispatch outcome is unknown after an unexpected error: ${safeErrorMessage(error)}`
+        };
+        await writeLedger(args.config.ledgerPath, blockedLedger);
+        await writeLockState(lock, "settled");
+        accountingSettled = true;
+      }
+      throw error;
+    }
+    const credits = calculateCodexCredits(args.model, result.usage);
+    const nextSpent = ledger.spentCredits + credits;
+    const nextLedger = {
+      ...ledger,
+      spentCredits: nextSpent,
+      entries: [
+        ...ledger.entries,
+        {
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          model: args.model,
+          credits,
+          ...args.config.runId ? { runId: args.config.runId } : {},
+          ...result.usage
+        }
+      ]
+    };
+    await writeLedger(args.config.ledgerPath, nextLedger);
+    await writeLockState(lock, "settled");
+    accountingSettled = true;
+    args.onUsagePersisted?.(result.usage);
+    if (nextSpent > usableCredits) {
+      throw new Error(
+        `Codex planned-spend ceiling exceeded by completed call: ${nextSpent.toFixed(3)} > ${usableCredits.toFixed(3)} credits. Usage was persisted; stop the benchmark immediately.`
+      );
+    }
+    return result.value;
+  } finally {
+    try {
+      if (lock) {
+        try {
+          await lock.close();
+        } finally {
+          if (!dispatchStarted || accountingSettled) {
+            await removeOwnedLedgerLock(lockPath);
+          }
+        }
+      }
+    } finally {
+      release();
+    }
+  }
+}
+async function acquireLedgerLock(lockPath) {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      await mkdir2(lockPath, { mode: 448 });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const owner = await readLockOwner(lockPath);
+      if (!owner || isProcessAlive(owner.pid) || owner.phase === "in-flight") {
+        throw new Error(
+          `Codex credit ledger is locked${owner?.phase === "in-flight" ? " with unreconciled in-flight usage" : " by another benchmark process"} (${lockPath}); refusing credit spend.`
+        );
+      }
+      await reclaimStaleLedgerLock(lockPath, owner);
+      continue;
+    }
+    let createdLock;
+    try {
+      await mkdir2(lockHeldPath(lockPath));
+      createdLock = await open(lockOwnerPath(lockPath), "wx", 384);
+      await writeLockState(createdLock, "preflight");
+      return createdLock;
+    } catch (error) {
+      await createdLock?.close().catch(() => void 0);
+      await unlink2(lockOwnerPath(lockPath)).catch(() => void 0);
+      await rmdir(lockHeldPath(lockPath)).catch(() => void 0);
+      await rmdir(lockPath).catch(() => void 0);
+      throw error;
+    }
+  }
+  throw new Error(`Unable to acquire Codex credit ledger lock (${lockPath})`);
+}
+async function readLockOwner(lockPath) {
+  try {
+    const parsed = JSON.parse(await readFile3(lockOwnerPath(lockPath), "utf8"));
+    if (!Number.isSafeInteger(parsed.pid) || parsed.pid <= 0 || parsed.phase !== "preflight" && parsed.phase !== "in-flight" && parsed.phase !== "settled") {
+      return void 0;
+    }
+    return { pid: parsed.pid, phase: parsed.phase };
+  } catch {
+    return void 0;
+  }
+}
+async function reclaimStaleLedgerLock(lockPath, expectedOwner) {
+  try {
+    await rmdir(lockHeldPath(lockPath));
+  } catch (error) {
+    throw new Error(
+      `Codex credit ledger stale-lock reclamation is already claimed or incomplete (${lockPath}); refusing credit spend: ${safeErrorMessage(error)}`
+    );
+  }
+  const currentOwner = await readLockOwner(lockPath);
+  if (!currentOwner || currentOwner.pid !== expectedOwner.pid || currentOwner.phase !== expectedOwner.phase || isProcessAlive(currentOwner.pid) || currentOwner.phase === "in-flight") {
+    throw new Error(
+      `Codex credit ledger owner changed during stale-lock reclamation (${lockPath}); refusing credit spend.`
+    );
+  }
+  await unlink2(lockOwnerPath(lockPath));
+  await rmdir(lockPath);
+}
+async function removeOwnedLedgerLock(lockPath) {
+  await rmdir(lockHeldPath(lockPath));
+  await unlink2(lockOwnerPath(lockPath));
+  await rmdir(lockPath);
+}
+function lockOwnerPath(lockPath) {
+  return path3.join(lockPath, "owner.json");
+}
+function lockHeldPath(lockPath) {
+  return path3.join(lockPath, "held");
+}
+async function writeLockState(lock, phase) {
+  const contents = `${JSON.stringify({
+    pid: process.pid,
+    phase,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  })}
+`;
+  await lock.truncate(0);
+  await lock.write(contents, 0, "utf8");
+  await lock.sync();
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function parseCodexJsonlUsage(output) {
+  let usage;
+  for (const line of output.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      const event = JSON.parse(trimmed);
+      if (event.type !== "turn.completed" || !event.usage) continue;
+      const inputTokens = readCounter(event.usage.input_tokens);
+      const outputTokens = readCounter(event.usage.output_tokens);
+      const cachedInputTokens = readOptionalCounter(
+        event.usage.cached_input_tokens
+      );
+      const reasoningOutputTokens = readOptionalCounter(
+        event.usage.reasoning_output_tokens
+      );
+      if (inputTokens !== void 0 && outputTokens !== void 0 && cachedInputTokens !== void 0 && reasoningOutputTokens !== void 0) {
+        usage = {
+          inputTokens,
+          cachedInputTokens,
+          outputTokens,
+          reasoningOutputTokens
+        };
+      }
+    } catch {
+    }
+  }
+  return usage;
+}
+function calculateCodexCredits(model, usage) {
+  const rate = resolveRate(model);
+  const cached = Math.min(usage.inputTokens, usage.cachedInputTokens);
+  const uncached = usage.inputTokens - cached;
+  return (uncached * rate.input + cached * rate.cachedInput + usage.outputTokens * rate.output) / ONE_MILLION;
+}
+async function buildCodexCreditReceipt(ledgerPath, runId) {
+  const resolvedPath = path3.resolve(expandHomeRelativePath(ledgerPath));
+  const contents = await readFile3(resolvedPath);
+  const ledger = parseLedger(JSON.parse(contents.toString("utf8")));
+  const normalizedRunId = parseOptionalRunId(runId);
+  const cumulative = summarizeLedgerEntries(ledger.entries);
+  const runEntries = normalizedRunId ? ledger.entries.filter((entry) => entry.runId === normalizedRunId) : [];
+  return {
+    schemaVersion: 1,
+    ledgerSha256: createHash3("sha256").update(contents).digest("hex"),
+    budgetCredits: ledger.budgetCredits,
+    reserveCredits: ledger.reserveCredits,
+    plannedSpendCeilingCredits: ledger.budgetCredits - ledger.reserveCredits,
+    totalSpentCredits: ledger.spentCredits,
+    totalRemainingCredits: ledger.budgetCredits - ledger.spentCredits,
+    blocked: ledger.blockedReason !== void 0,
+    cumulative,
+    ...normalizedRunId ? { run: { id: normalizedRunId, ...summarizeLedgerEntries(runEntries) } } : {}
+  };
+}
+function resolveRate(model) {
+  const match = CREDIT_RATES.find(([pattern]) => pattern.test(model));
+  if (!match) {
+    throw new Error(
+      `No Codex credit rate is configured for model ${JSON.stringify(model)}; refusing to run under a bounded credit budget.`
+    );
+  }
+  return match[1];
+}
+function assertModelAllowed(model, config) {
+  resolveRate(model);
+  if (SOL_MODEL.test(model) && !config.allowSol) {
+    throw new Error(
+      "gpt-5.6-sol is disabled for bounded benchmark runs because it is the most expensive GPT-5.6 tier. Use gpt-5.6-terra or gpt-5.6-luna, or explicitly set REMNIC_BENCH_CODEX_ALLOW_SOL=1."
+    );
+  }
+}
+async function readLedger(config) {
+  try {
+    const parsed = parseLedger(
+      JSON.parse(await readFile3(config.ledgerPath, "utf8"))
+    );
+    if (parsed.budgetCredits !== config.budgetCredits || parsed.reserveCredits !== config.reserveCredits) {
+      throw new Error("ledger schema or budget does not match this run");
+    }
+    return parsed;
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw new Error(`Invalid Codex credit ledger at ${config.ledgerPath}: ${String(error)}`);
+    }
+    return {
+      schemaVersion: 1,
+      budgetCredits: config.budgetCredits,
+      reserveCredits: config.reserveCredits,
+      spentCredits: 0,
+      entries: []
+    };
+  }
+}
+function parseLedger(parsed) {
+  const entryCredits = Array.isArray(parsed.entries) ? parsed.entries.reduce(
+    (sum, entry) => sum + (typeof entry?.credits === "number" ? entry.credits ?? 0 : 0),
+    0
+  ) : Number.NaN;
+  if (parsed.schemaVersion !== 1 || typeof parsed.budgetCredits !== "number" || !Number.isFinite(parsed.budgetCredits) || parsed.budgetCredits <= 0 || typeof parsed.reserveCredits !== "number" || !Number.isFinite(parsed.reserveCredits) || parsed.reserveCredits < 0 || parsed.reserveCredits >= parsed.budgetCredits || typeof parsed.spentCredits !== "number" || !Number.isFinite(parsed.spentCredits) || parsed.spentCredits < 0 || !Array.isArray(parsed.entries) || !parsed.entries.every(isLedgerEntry) || Math.abs(entryCredits - parsed.spentCredits) > 1e-9 || parsed.blockedReason !== void 0 && typeof parsed.blockedReason !== "string") {
+    throw new Error("ledger schema is invalid");
+  }
+  return parsed;
+}
+function isLedgerEntry(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  const candidate = entry;
+  return typeof candidate.at === "string" && typeof candidate.model === "string" && candidate.model.length > 0 && typeof candidate.credits === "number" && Number.isFinite(candidate.credits) && candidate.credits >= 0 && (candidate.runId === void 0 || isValidStoredRunId(candidate.runId)) && readCounter(candidate.inputTokens) !== void 0 && readCounter(candidate.cachedInputTokens) !== void 0 && readCounter(candidate.outputTokens) !== void 0 && readCounter(candidate.reasoningOutputTokens) !== void 0 && (candidate.cachedInputTokens ?? 0) <= (candidate.inputTokens ?? 0) && isEntryCreditConsistent(candidate);
+}
+function isEntryCreditConsistent(entry) {
+  try {
+    return Math.abs(calculateCodexCredits(entry.model, entry) - entry.credits) <= 1e-9;
+  } catch {
+    return false;
+  }
+}
+function summarizeLedgerEntries(entries) {
+  const byModel = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const modelEntries = byModel.get(entry.model) ?? [];
+    modelEntries.push(entry);
+    byModel.set(entry.model, modelEntries);
+  }
+  const totals = summarizeUsage(entries);
+  return {
+    calls: entries.length,
+    credits: entries.reduce((sum, entry) => sum + entry.credits, 0),
+    ...totals,
+    models: [...byModel.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([model, modelEntries]) => ({
+      model,
+      calls: modelEntries.length,
+      credits: modelEntries.reduce((sum, entry) => sum + entry.credits, 0),
+      ...summarizeUsage(modelEntries)
+    }))
+  };
+}
+function summarizeUsage(entries) {
+  return entries.reduce(
+    (totals, entry) => ({
+      inputTokens: totals.inputTokens + entry.inputTokens,
+      cachedInputTokens: totals.cachedInputTokens + entry.cachedInputTokens,
+      outputTokens: totals.outputTokens + entry.outputTokens,
+      reasoningOutputTokens: totals.reasoningOutputTokens + entry.reasoningOutputTokens
+    }),
+    { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0 }
+  );
+}
+async function writeLedger(filePath, ledger) {
+  await mkdir2(path3.dirname(filePath), { recursive: true, mode: 448 });
+  const tempPath = `${filePath}.${process.pid}.tmp`;
+  await writeFile2(tempPath, `${JSON.stringify(ledger, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await rename2(tempPath, filePath);
+}
+function readCounter(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function readOptionalCounter(value) {
+  return value === void 0 ? 0 : readCounter(value);
+}
+function safeErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function expandHomeRelativePath(value) {
+  if (value === "~") return os.homedir();
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path3.join(os.homedir(), value.slice(2));
+  }
+  return value;
+}
+function parsePositiveNumber(value, name) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${name} must be a finite number greater than zero`);
+  }
+  return parsed;
+}
+function parseNonNegativeNumber(value, name) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error(`${name} must be a finite non-negative number`);
+  }
+  return parsed;
+}
+function parseOptionalRunId(value) {
+  const runId = value?.trim();
+  if (!runId) return void 0;
+  if (runId.length > 128 || hasControlCharacters(runId)) {
+    throw new Error("REMNIC_BENCH_RUN_ID must be at most 128 characters without control characters");
+  }
+  return runId;
+}
+function isValidStoredRunId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 128 && value === value.trim() && !hasControlCharacters(value);
+}
+function hasControlCharacters(value) {
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint <= 31 || codePoint === 127) return true;
+  }
+  return false;
+}
+
+// src/results-store.ts
+import { mkdir as mkdir3, readdir as readdir3, readFile as readFile4, unlink as unlink3, writeFile as writeFile3 } from "fs/promises";
+import fs from "fs";
+import os2 from "os";
+import path4 from "path";
 
 // src/integrity/contamination.ts
 var EMPTY_CONTAMINATION_MANIFEST = {
@@ -5972,14 +6428,14 @@ ${renderProvenance(result, provenance)}
 var BASELINE_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
 var REPRO_MANIFEST_FILENAME = "MANIFEST.json";
 function defaultBenchmarkBaselineDir() {
-  const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
-  return path3.join(homeDir, ".remnic", "bench", "baselines");
+  const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? os2.homedir();
+  return path4.join(homeDir, ".remnic", "bench", "baselines");
 }
 function defaultBenchmarkPublishPath(target) {
-  const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
+  const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? os2.homedir();
   switch (target) {
     case "remnic-ai":
-      return path3.join(homeDir, ".remnic", "published", "benchmarks.json");
+      return path4.join(homeDir, ".remnic", "published", "benchmarks.json");
   }
 }
 function compareResultSummaries(left, right) {
@@ -6004,10 +6460,10 @@ function isFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
 async function loadBenchmarkReportCardProvenance(outputDir, resultId) {
-  const manifestPath = path3.join(outputDir, REPRO_MANIFEST_FILENAME);
+  const manifestPath = path4.join(outputDir, REPRO_MANIFEST_FILENAME);
   let parsed;
   try {
-    parsed = JSON.parse(await readFile3(manifestPath, "utf8"));
+    parsed = JSON.parse(await readFile4(manifestPath, "utf8"));
   } catch {
     return {};
   }
@@ -6114,7 +6570,7 @@ function toBaselineSummary(baseline, filePath) {
   };
 }
 async function loadBenchmarkResult(filePath) {
-  const content = await readFile3(filePath, "utf8");
+  const content = await readFile4(filePath, "utf8");
   const parsed = JSON.parse(content);
   if (!isBenchmarkResult(parsed)) {
     throw new Error(`Invalid benchmark result file: ${filePath}`);
@@ -6131,7 +6587,7 @@ async function listBenchmarkResults(outputDir) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const filePath = path3.join(outputDir, entry.name);
+    const filePath = path4.join(outputDir, entry.name);
     try {
       const result = await loadBenchmarkResult(filePath);
       results.push(toSummary(result, filePath));
@@ -6144,20 +6600,20 @@ async function listBenchmarkResults(outputDir) {
 async function saveBenchmarkBaseline(baselineDir, name, result, source) {
   assertValidBaselineName(name);
   assertUsableBaselineDir(baselineDir);
-  await mkdir2(baselineDir, { recursive: true });
-  const filePath = path3.join(baselineDir, `${name}.json`);
+  await mkdir3(baselineDir, { recursive: true });
+  const filePath = path4.join(baselineDir, `${name}.json`);
   const payload = {
     name,
     savedAt: (/* @__PURE__ */ new Date()).toISOString(),
     result,
     source
   };
-  await writeFile2(filePath, `${JSON.stringify(payload, null, 2)}
+  await writeFile3(filePath, `${JSON.stringify(payload, null, 2)}
 `);
   return filePath;
 }
 async function loadBenchmarkBaseline(filePath) {
-  const content = await readFile3(filePath, "utf8");
+  const content = await readFile4(filePath, "utf8");
   const parsed = JSON.parse(content);
   if (!isStoredBenchmarkBaseline(parsed)) {
     throw new Error(`Invalid benchmark baseline file: ${filePath}`);
@@ -6175,7 +6631,7 @@ async function listBenchmarkBaselines(baselineDir) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const filePath = path3.join(baselineDir, entry.name);
+    const filePath = path4.join(baselineDir, entry.name);
     try {
       const baseline = await loadBenchmarkBaseline(filePath);
       baselines.push(toBaselineSummary(baseline, filePath));
@@ -6192,7 +6648,7 @@ async function resolveBenchmarkResultReference(outputDir, reference) {
     return exactIdMatch;
   }
   const basenameMatch = summaries.find(
-    (summary) => path3.basename(summary.path) === reference
+    (summary) => path4.basename(summary.path) === reference
   );
   if (basenameMatch) {
     return basenameMatch;
@@ -6208,7 +6664,7 @@ async function resolveBenchmarkResultReference(outputDir, reference) {
   return void 0;
 }
 function looksLikeFilesystemPath(reference) {
-  return path3.isAbsolute(reference) || reference.includes("/") || reference.includes(path3.sep) || reference.endsWith(".json");
+  return path4.isAbsolute(reference) || reference.includes("/") || reference.includes(path4.sep) || reference.endsWith(".json");
 }
 async function deleteBenchmarkResults(outputDir, references) {
   const summaries = await listBenchmarkResults(outputDir);
@@ -6216,9 +6672,9 @@ async function deleteBenchmarkResults(outputDir, references) {
   const missing = [];
   const seenPaths = /* @__PURE__ */ new Set();
   for (const reference of references) {
-    let summary = summaries.find((entry) => entry.id === reference) ?? summaries.find((entry) => path3.basename(entry.path) === reference);
+    let summary = summaries.find((entry) => entry.id === reference) ?? summaries.find((entry) => path4.basename(entry.path) === reference);
     if (!summary && looksLikeFilesystemPath(reference)) {
-      const canonicalRef = path3.resolve(reference);
+      const canonicalRef = path4.resolve(reference);
       if (seenPaths.has(canonicalRef)) {
         continue;
       }
@@ -6235,13 +6691,13 @@ async function deleteBenchmarkResults(outputDir, references) {
       missing.push(reference);
       continue;
     }
-    const canonicalPath = path3.resolve(summary.path);
+    const canonicalPath = path4.resolve(summary.path);
     if (seenPaths.has(canonicalPath)) {
       continue;
     }
     seenPaths.add(canonicalPath);
     try {
-      await unlink2(summary.path);
+      await unlink3(summary.path);
     } catch (error) {
       if (error.code === "ENOENT") {
       } else {
@@ -6366,8 +6822,8 @@ async function buildBenchmarkPublishFeed(outputDir, target, options = {}) {
   };
 }
 async function writeBenchmarkPublishFeed(feed, outputPath) {
-  await mkdir2(path3.dirname(outputPath), { recursive: true });
-  await writeFile2(outputPath, `${JSON.stringify(feed, null, 2)}
+  await mkdir3(path4.dirname(outputPath), { recursive: true });
+  await writeFile3(outputPath, `${JSON.stringify(feed, null, 2)}
 `);
   return outputPath;
 }
@@ -6422,8 +6878,8 @@ function renderBenchmarkResultExport(result, format, options = {}) {
 // src/run-identity.ts
 var BENCHMARK_RUN_ID_ENV = "REMNIC_BENCH_RUN_ID";
 var generatedBenchmarkRunId;
-function resolveBenchmarkRunId() {
-  const explicit = process.env[BENCHMARK_RUN_ID_ENV]?.trim();
+function resolveBenchmarkRunId(env = process.env) {
+  const explicit = env[BENCHMARK_RUN_ID_ENV]?.trim();
   if (explicit) {
     return explicit;
   }
@@ -6627,14 +7083,22 @@ var BENCH_OPTION_BOUNDARY_FLAGS = /* @__PURE__ */ new Set([
 ]);
 var SECRET_KEY_PATTERN = /(^|[-_])(?:api[-_]?key|secret[-_]?access[-_]?key|secret[-_]?key|client[-_]?secret(?:[-_]?key)?|app[-_]?secret(?:[-_]?key)?|provider[-_]?secret(?:[-_]?key)?|access[-_]?key|private[-_]?key|secret|password|authorization|credential|access[-_]?token|auth[-_]?token|refresh[-_]?token|id[-_]?token|token)$/i;
 var REDACTED_ARG_VALUE = "[redacted]";
+var CODEX_CREDIT_REPRO_ENV_KEYS = [
+  "REMNIC_BENCH_CODEX_ALLOW_SOL",
+  "REMNIC_BENCH_CODEX_CREDIT_BUDGET",
+  "REMNIC_BENCH_CODEX_CREDIT_LEDGER",
+  "REMNIC_BENCH_CODEX_CREDIT_RESERVE",
+  "REMNIC_BENCH_CODEX_CLI_DIAGNOSTICS_MODE",
+  "REMNIC_BENCH_RUN_ID"
+];
 function sha256String(value) {
-  return createHash3("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
 function sha256Buffer(value) {
-  return createHash3("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
 async function sha256File(filePath) {
-  const hash = createHash3("sha256");
+  const hash = createHash4("sha256");
   await new Promise((resolve, reject) => {
     const stream = createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
@@ -7137,7 +7601,10 @@ function isAsciiAlnum2(char) {
   return isUppercaseAscii(char) || isLowercaseAscii(char) || char >= "0" && char <= "9";
 }
 function sanitizeEnvKeys(env, explicitKeys) {
-  const sourceKeys = explicitKeys ?? Object.keys(env ?? {});
+  const sourceKeys = [
+    ...explicitKeys ?? Object.keys(env ?? {}),
+    ...CODEX_CREDIT_REPRO_ENV_KEYS.filter((key) => env?.[key] !== void 0)
+  ];
   return [...new Set(sourceKeys)].filter((key) => typeof key === "string" && key.length > 0).sort((left, right) => left.localeCompare(right));
 }
 function gitOutput(args, cwd) {
@@ -7191,7 +7658,8 @@ function buildArtifactHashIdentity(manifest) {
     ...manifest.qmd ? { qmd: manifest.qmd } : {},
     configFiles: manifest.configFiles,
     datasets: manifest.datasets,
-    results: manifest.results
+    results: manifest.results,
+    ...manifest.codexCredit ? { codexCredit: manifest.codexCredit } : {}
   };
 }
 async function scanDatasetFiles(root) {
@@ -7200,18 +7668,18 @@ async function scanDatasetFiles(root) {
     const entries = await readdir4(directory, { withFileTypes: true });
     entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
-      const entryPath = path4.join(directory, entry.name);
+      const entryPath = path5.join(directory, entry.name);
       const entryStat = await lstat3(entryPath);
-      const relativePath = path4.relative(root, entryPath).split(path4.sep).join("/");
+      const relativePath = path5.relative(root, entryPath).split(path5.sep).join("/");
       if (entryStat.isSymbolicLink()) {
         const target = await readlink(entryPath);
-        const resolvedTarget = path4.resolve(directory, target);
+        const resolvedTarget = path5.resolve(directory, target);
         const realTarget = await realpath3(resolvedTarget);
-        const targetRelativePath = path4.relative(root, realTarget);
-        if (targetRelativePath.length === 0 || targetRelativePath === ".." || targetRelativePath.startsWith(`..${path4.sep}`) || path4.isAbsolute(targetRelativePath)) {
+        const targetRelativePath = path5.relative(root, realTarget);
+        if (targetRelativePath.length === 0 || targetRelativePath === ".." || targetRelativePath.startsWith(`..${path5.sep}`) || path5.isAbsolute(targetRelativePath)) {
           throw new Error(`dataset symlink target must be inside ${root}: ${entryPath}`);
         }
-        const manifestTarget = path4.isAbsolute(target) ? targetRelativePath.split(path4.sep).join("/") : target;
+        const manifestTarget = path5.isAbsolute(target) ? targetRelativePath.split(path5.sep).join("/") : target;
         files.push({
           path: relativePath,
           kind: "symlink",
@@ -7239,9 +7707,9 @@ async function scanDatasetFiles(root) {
   return files.sort((left, right) => left.path.localeCompare(right.path));
 }
 async function lstatPathWithoutSymlinkComponents(targetPath) {
-  const parsed = path4.parse(targetPath);
-  const relativePath = path4.relative(parsed.root, targetPath);
-  const parts = relativePath.length > 0 ? relativePath.split(path4.sep) : [];
+  const parsed = path5.parse(targetPath);
+  const relativePath = path5.relative(parsed.root, targetPath);
+  const parts = relativePath.length > 0 ? relativePath.split(path5.sep) : [];
   let currentPath = parsed.root;
   let currentStat;
   try {
@@ -7249,7 +7717,7 @@ async function lstatPathWithoutSymlinkComponents(targetPath) {
       currentStat = await lstat3(currentPath);
     }
     for (const part of parts) {
-      currentPath = path4.join(currentPath, part);
+      currentPath = path5.join(currentPath, part);
       currentStat = await lstat3(currentPath);
       if (currentStat.isSymbolicLink()) {
         return void 0;
@@ -7270,7 +7738,7 @@ async function buildDatasetManifest(benchmark, datasetDir) {
       files: []
     };
   }
-  const datasetRoot = path4.resolve(datasetDir);
+  const datasetRoot = path5.resolve(datasetDir);
   const datasetStat = await lstatPathWithoutSymlinkComponents(datasetRoot);
   if (!datasetStat) {
     return {
@@ -7312,7 +7780,7 @@ async function buildResultManifest(resultsDir, resultPath, result) {
   await assertRegularFileWithoutSymlinkComponents(resultPath, "result path");
   const fileStats = await stat2(resultPath);
   return {
-    path: path4.relative(resultsDir, resultPath).split(path4.sep).join("/"),
+    path: path5.relative(resultsDir, resultPath).split(path5.sep).join("/"),
     sha256: await sha256File(resultPath),
     sizeBytes: fileStats.size,
     resultId: result.meta.id,
@@ -7334,7 +7802,7 @@ async function resolveResultPaths(resultsDir, explicitPaths) {
   if (explicitPaths !== void 0) {
     const resolvedPaths = await Promise.all(
       explicitPaths.map(async (entry) => {
-        const resultPath = path4.resolve(entry);
+        const resultPath = path5.resolve(entry);
         assertPathInsideRoot(resultsDir, resultPath, "result path");
         await assertRegularFileWithoutSymlinkComponents(resultPath, "result path");
         return resultPath;
@@ -7343,20 +7811,20 @@ async function resolveResultPaths(resultsDir, explicitPaths) {
     return [...new Set(resolvedPaths)].sort((left, right) => left.localeCompare(right));
   }
   const summaries = await listBenchmarkResults(resultsDir);
-  return summaries.map((summary) => path4.resolve(summary.path));
+  return summaries.map((summary) => path5.resolve(summary.path));
 }
 function assertPathInsideRoot(root, targetPath, label) {
-  const resolvedRoot = path4.resolve(root);
-  const resolvedTargetPath = path4.resolve(targetPath);
-  const relativePath = path4.relative(resolvedRoot, resolvedTargetPath);
-  if (relativePath.length === 0 || relativePath === ".." || relativePath.startsWith(`..${path4.sep}`) || path4.isAbsolute(relativePath)) {
+  const resolvedRoot = path5.resolve(root);
+  const resolvedTargetPath = path5.resolve(targetPath);
+  const relativePath = path5.relative(resolvedRoot, resolvedTargetPath);
+  if (relativePath.length === 0 || relativePath === ".." || relativePath.startsWith(`..${path5.sep}`) || path5.isAbsolute(relativePath)) {
     throw new Error(`${label} must be inside ${resolvedRoot}: ${resolvedTargetPath}`);
   }
 }
 async function assertRegularFileWithoutSymlinkComponents(targetPath, label) {
-  const targetStat = await lstatPathWithoutSymlinkComponents(path4.resolve(targetPath));
+  const targetStat = await lstatPathWithoutSymlinkComponents(path5.resolve(targetPath));
   if (!targetStat?.isFile()) {
-    throw new Error(`${label} must be a regular file without symlink components: ${path4.resolve(targetPath)}`);
+    throw new Error(`${label} must be a regular file without symlink components: ${path5.resolve(targetPath)}`);
   }
 }
 function isKnownNonSecretOptionFlag(arg) {
@@ -7402,7 +7870,7 @@ async function buildConfigFileEntries(configFiles = []) {
         entries.push({ label: configFile.label, path: configFile.path, missing: true });
         continue;
       }
-      const content = await readFile4(configFile.path);
+      const content = await readFile5(configFile.path);
       const sanitizedConfig = sanitizeConfigFileContent(content);
       entries.push({
         label: configFile.label,
@@ -7469,7 +7937,7 @@ function resolvePackageManager(cwd) {
   }
 }
 async function buildBenchmarkReproManifest(resultsDir, options = {}) {
-  const resolvedResultsDir = path4.resolve(resultsDir);
+  const resolvedResultsDir = path5.resolve(resultsDir);
   const cwd = options.command?.cwd ?? process.cwd();
   const resultPaths = await resolveResultPaths(resolvedResultsDir, options.resultPaths);
   const loadedResults = await Promise.all(resultPaths.map((resultPath) => loadBenchmarkResult(resultPath)));
@@ -7487,11 +7955,23 @@ async function buildBenchmarkReproManifest(resultsDir, options = {}) {
   );
   const qmdCollections = collectQmdCollections(options.qmd?.collections, loadedResults);
   const pnpmVersion = resolvePackageManager(cwd);
+  const commandEnv = options.command?.env ?? process.env;
+  const runId = options.runId ?? resolveBenchmarkRunId(commandEnv);
+  const resolvedCreditConfig = resolveCodexCreditBudgetConfig(commandEnv, runId);
+  const creditConfig = resolvedCreditConfig ? { ...resolvedCreditConfig, runId } : void 0;
+  let codexCredit;
+  if (creditConfig) {
+    try {
+      codexCredit = await buildCodexCreditReceipt(creditConfig.ledgerPath, creditConfig.runId);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
   const manifestWithoutHash = {
     schemaVersion: BENCHMARK_REPRO_MANIFEST_SCHEMA_VERSION,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     run: {
-      id: options.runId ?? resolveBenchmarkRunId(),
+      id: runId,
       ...options.mode ? { mode: options.mode } : {},
       selectedBenchmarks,
       runtimeProfiles: options.runtimeProfiles ?? [],
@@ -7503,13 +7983,13 @@ async function buildBenchmarkReproManifest(resultsDir, options = {}) {
     command: {
       cwd,
       argv: sanitizeArgv(options.command?.argv ?? process.argv.slice(2)),
-      envKeys: sanitizeEnvKeys(options.command?.env, options.command?.envKeys)
+      envKeys: sanitizeEnvKeys(commandEnv, options.command?.envKeys)
     },
     environment: {
       platform: process.platform,
       arch: process.arch,
       nodeVersion: process.version,
-      hostname: os2.hostname(),
+      hostname: os3.hostname(),
       ...pnpmVersion ? { packageManager: `pnpm@${pnpmVersion}` } : {}
     },
     ...options.qmd || qmdCollections.length > 0 ? {
@@ -7521,7 +8001,8 @@ async function buildBenchmarkReproManifest(resultsDir, options = {}) {
     } : {},
     configFiles: await buildConfigFileEntries(options.configFiles),
     datasets,
-    results: resultEntries.sort((left, right) => left.path.localeCompare(right.path))
+    results: resultEntries.sort((left, right) => left.path.localeCompare(right.path)),
+    ...codexCredit ? { codexCredit } : {}
   };
   return {
     ...manifestWithoutHash,
@@ -7529,18 +8010,18 @@ async function buildBenchmarkReproManifest(resultsDir, options = {}) {
   };
 }
 async function writeBenchmarkReproManifest(resultsDir, options = {}) {
-  await mkdir3(resultsDir, { recursive: true });
+  await mkdir4(resultsDir, { recursive: true });
   const manifest = await buildBenchmarkReproManifest(resultsDir, options);
-  const manifestPath = path4.join(resultsDir, BENCHMARK_REPRO_MANIFEST_FILENAME);
-  await writeFile3(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  const manifestPath = path5.join(resultsDir, BENCHMARK_REPRO_MANIFEST_FILENAME);
+  await writeFile4(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
   return manifestPath;
 }
 
 // src/published-artifact.ts
-import { createHash as createHash4 } from "crypto";
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import path5 from "path";
+import { createHash as createHash5 } from "crypto";
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import path6 from "path";
 var BENCHMARK_ARTIFACT_SCHEMA_VERSION = 1;
 var PUBLISHED_BENCHMARK_ARTIFACT_IDS = Object.freeze([
   "ama-bench",
@@ -7681,25 +8162,25 @@ function serializeBenchmarkArtifact(artifact) {
 `;
 }
 function hashBenchmarkArtifact(artifact) {
-  return createHash4("sha256").update(serializeBenchmarkArtifact(artifact)).digest("hex");
+  return createHash5("sha256").update(serializeBenchmarkArtifact(artifact)).digest("hex");
 }
 async function writeBenchmarkArtifact(artifact, outputDir) {
-  await mkdir4(outputDir, { recursive: true });
+  await mkdir5(outputDir, { recursive: true });
   const filename = buildBenchmarkArtifactFilename(artifact);
   const body = serializeBenchmarkArtifact(artifact);
-  const resolvedDir = path5.resolve(outputDir);
-  const abs = path5.resolve(resolvedDir, filename);
-  const relative = path5.relative(resolvedDir, abs);
-  if (relative.length === 0 || relative.startsWith("..") || path5.isAbsolute(relative) || relative.includes(path5.sep)) {
+  const resolvedDir = path6.resolve(outputDir);
+  const abs = path6.resolve(resolvedDir, filename);
+  const relative = path6.relative(resolvedDir, abs);
+  if (relative.length === 0 || relative.startsWith("..") || path6.isAbsolute(relative) || relative.includes(path6.sep)) {
     throw new Error(
       `writeBenchmarkArtifact: refusing to write outside outputDir (filename="${filename}", resolved="${abs}").`
     );
   }
-  await writeFile4(abs, body);
+  await writeFile5(abs, body);
   return {
     path: abs,
     filename,
-    sha256: createHash4("sha256").update(body).digest("hex"),
+    sha256: createHash5("sha256").update(body).digest("hex"),
     bytes: Buffer.byteLength(body, "utf8")
   };
 }
@@ -7804,11 +8285,11 @@ function parseBenchmarkArtifact(raw) {
   return parsed;
 }
 async function loadBenchmarkArtifact(filePath) {
-  const raw = await readFile5(filePath, "utf8");
+  const raw = await readFile6(filePath, "utf8");
   const artifact = parseBenchmarkArtifact(raw);
   return {
     artifact,
-    sha256: createHash4("sha256").update(raw).digest("hex"),
+    sha256: createHash5("sha256").update(raw).digest("hex"),
     bytes: Buffer.byteLength(raw, "utf8")
   };
 }
@@ -8211,8 +8692,8 @@ function createAnthropicProvider(config) {
 // src/providers/claude-cli.ts
 import { spawn } from "child_process";
 import { mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
-import os3 from "os";
-import path6 from "path";
+import os4 from "os";
+import path7 from "path";
 var CLAUDE_CLI_STDIO_LIMIT = 64e3;
 var CLAUDE_CLI_PARENT_SIGNALS = ["SIGHUP", "SIGINT", "SIGTERM"];
 var CLAUDE_CLI_FORCED_PARENT_EXIT_MS = 1e3;
@@ -8365,7 +8846,7 @@ var ClaudeCliProvider = class {
     let transientAttempt = 1;
     let usageLimitAttempt = 1;
     while (true) {
-      const tempDir = await mkdtemp2(path6.join(os3.tmpdir(), "remnic-claude-cli-"));
+      const tempDir = await mkdtemp2(path7.join(os4.tmpdir(), "remnic-claude-cli-"));
       try {
         const request = this.buildRunRequest(prompt, opts, tempDir);
         const result = await this.runClaudeCli(request);
@@ -8577,14 +9058,14 @@ function resolveClaudeCliExecutable(config) {
   if (trimmed.length === 0) {
     throw new Error(`${CLAUDE_CLI_EXECUTABLE_ENV} / claude-cli executable must not be empty`);
   }
-  return expandHomeRelativePath(trimmed);
+  return expandHomeRelativePath2(trimmed);
 }
-function expandHomeRelativePath(value) {
+function expandHomeRelativePath2(value) {
   if (value === "~") {
-    return os3.homedir();
+    return os4.homedir();
   }
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path6.join(os3.homedir(), value.slice(2));
+    return path7.join(os4.homedir(), value.slice(2));
   }
   return value;
 }
@@ -8971,7 +9452,7 @@ function createClaudeCliProvider(config, deps) {
 
 // src/providers/codex-cli.ts
 import { spawn as spawn2 } from "child_process";
-import { createHash as createHash5, randomUUID } from "crypto";
+import { createHash as createHash6, randomUUID } from "crypto";
 import { mkdir as mkdir6, mkdtemp as mkdtemp3, readFile as readFile7, rm as rm3, writeFile as writeFile6 } from "fs/promises";
 import os5 from "os";
 import path8 from "path";
@@ -9165,364 +9646,6 @@ function throwJudgeFailure(provider, failure) {
   throw provider.createJudgeError?.(failure) ?? new StructuredJudgeError(failure);
 }
 
-// src/providers/codex-credit-budget.ts
-import { mkdir as mkdir5, open, readFile as readFile6, rename as rename2, rmdir, unlink as unlink3, writeFile as writeFile5 } from "fs/promises";
-import os4 from "os";
-import path7 from "path";
-var ONE_MILLION = 1e6;
-var MAX_BOUNDED_CALL_CREDITS = 300;
-var SOL_MODEL = /^gpt-5\.6-sol$/i;
-var CREDIT_RATES = [
-  [/^gpt-5\.6-sol$/i, { input: 125, cachedInput: 12.5, output: 750 }],
-  [/^gpt-5\.6-terra$/i, { input: 62.5, cachedInput: 6.25, output: 375 }],
-  [/^gpt-5\.6-luna$/i, { input: 25, cachedInput: 2.5, output: 150 }],
-  [/^gpt-5\.5$/i, { input: 125, cachedInput: 12.5, output: 750 }],
-  [/^gpt-5\.4-mini$/i, { input: 18.75, cachedInput: 1.875, output: 113 }],
-  [/^gpt-5\.4$/i, { input: 62.5, cachedInput: 6.25, output: 375 }],
-  [/^gpt-5\.3-codex$/i, { input: 43.75, cachedInput: 4.375, output: 350 }],
-  [/^gpt-5\.2$/i, { input: 43.75, cachedInput: 4.375, output: 350 }]
-];
-var completionQueue = Promise.resolve();
-var CodexCreditAccountingError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CodexCreditAccountingError";
-  }
-};
-var CodexCreditDispatchError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "CodexCreditDispatchError";
-  }
-};
-function resolveCodexCreditBudgetConfig(env = process.env) {
-  const rawBudget = env.REMNIC_BENCH_CODEX_CREDIT_BUDGET?.trim();
-  if (!rawBudget) return void 0;
-  const budgetCredits = parsePositiveNumber(
-    rawBudget,
-    "REMNIC_BENCH_CODEX_CREDIT_BUDGET"
-  );
-  const reserveCredits = parseNonNegativeNumber(
-    env.REMNIC_BENCH_CODEX_CREDIT_RESERVE?.trim() ?? "473",
-    "REMNIC_BENCH_CODEX_CREDIT_RESERVE"
-  );
-  if (reserveCredits >= budgetCredits) {
-    throw new Error(
-      "REMNIC_BENCH_CODEX_CREDIT_RESERVE must be smaller than REMNIC_BENCH_CODEX_CREDIT_BUDGET"
-    );
-  }
-  if (reserveCredits < MAX_BOUNDED_CALL_CREDITS) {
-    throw new Error(
-      `REMNIC_BENCH_CODEX_CREDIT_RESERVE must be at least ${MAX_BOUNDED_CALL_CREDITS} credits to cover the conservative maximum cost of the one serialized in-flight call`
-    );
-  }
-  const ledgerPath = path7.resolve(
-    expandHomeRelativePath2(
-      env.REMNIC_BENCH_CODEX_CREDIT_LEDGER?.trim() || ".remnic/bench/codex-credit-ledger.json"
-    )
-  );
-  return {
-    budgetCredits,
-    reserveCredits,
-    ledgerPath,
-    allowSol: /^(?:1|true|yes|on)$/i.test(
-      env.REMNIC_BENCH_CODEX_ALLOW_SOL?.trim() ?? ""
-    )
-  };
-}
-async function runWithinCodexCreditBudget(args) {
-  if (!args.config) {
-    return (await args.run()).value;
-  }
-  const previous = completionQueue;
-  let release;
-  completionQueue = new Promise((resolve) => {
-    release = resolve;
-  });
-  await previous;
-  const lockPath = `${args.config.ledgerPath}.lock`;
-  let lock;
-  let dispatchStarted = false;
-  let accountingSettled = false;
-  try {
-    await mkdir5(path7.dirname(lockPath), { recursive: true, mode: 448 });
-    lock = await acquireLedgerLock(lockPath);
-    assertModelAllowed(args.model, args.config);
-    const ledger = await readLedger(args.config);
-    if (ledger.blockedReason) {
-      throw new Error(
-        `Codex credit ledger is blocked pending manual reconciliation: ${ledger.blockedReason}`
-      );
-    }
-    const usableCredits = args.config.budgetCredits - args.config.reserveCredits;
-    if (ledger.spentCredits >= usableCredits) {
-      throw new Error(
-        `Codex credit budget exhausted: ${ledger.spentCredits.toFixed(3)} spent; ${usableCredits.toFixed(3)} usable after the ${args.config.reserveCredits.toFixed(3)} safety reserve.`
-      );
-    }
-    await writeLockState(lock, "in-flight");
-    dispatchStarted = true;
-    let result;
-    try {
-      result = await args.run();
-    } catch (error) {
-      if (error instanceof CodexCreditDispatchError) {
-        await writeLockState(lock, "settled");
-        accountingSettled = true;
-      } else {
-        const blockedLedger = {
-          ...ledger,
-          blockedReason: error instanceof CodexCreditAccountingError ? error.message : `Codex dispatch outcome is unknown after an unexpected error: ${safeErrorMessage(error)}`
-        };
-        await writeLedger(args.config.ledgerPath, blockedLedger);
-        await writeLockState(lock, "settled");
-        accountingSettled = true;
-      }
-      throw error;
-    }
-    const credits = calculateCodexCredits(args.model, result.usage);
-    const nextSpent = ledger.spentCredits + credits;
-    const nextLedger = {
-      ...ledger,
-      spentCredits: nextSpent,
-      entries: [
-        ...ledger.entries,
-        {
-          at: (/* @__PURE__ */ new Date()).toISOString(),
-          model: args.model,
-          credits,
-          ...result.usage
-        }
-      ]
-    };
-    await writeLedger(args.config.ledgerPath, nextLedger);
-    await writeLockState(lock, "settled");
-    accountingSettled = true;
-    args.onUsagePersisted?.(result.usage);
-    if (nextSpent > args.config.budgetCredits) {
-      throw new Error(
-        `Codex credit budget exceeded by completed call: ${nextSpent.toFixed(3)} > ${args.config.budgetCredits.toFixed(3)} credits. Usage was persisted; stop the benchmark immediately.`
-      );
-    }
-    return result.value;
-  } finally {
-    try {
-      if (lock) {
-        try {
-          await lock.close();
-        } finally {
-          if (!dispatchStarted || accountingSettled) {
-            await removeOwnedLedgerLock(lockPath);
-          }
-        }
-      }
-    } finally {
-      release();
-    }
-  }
-}
-async function acquireLedgerLock(lockPath) {
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    try {
-      await mkdir5(lockPath, { mode: 448 });
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-      const owner = await readLockOwner(lockPath);
-      if (!owner || isProcessAlive(owner.pid) || owner.phase === "in-flight") {
-        throw new Error(
-          `Codex credit ledger is locked${owner?.phase === "in-flight" ? " with unreconciled in-flight usage" : " by another benchmark process"} (${lockPath}); refusing credit spend.`
-        );
-      }
-      await reclaimStaleLedgerLock(lockPath, owner);
-      continue;
-    }
-    let createdLock;
-    try {
-      await mkdir5(lockHeldPath(lockPath));
-      createdLock = await open(lockOwnerPath(lockPath), "wx", 384);
-      await writeLockState(createdLock, "preflight");
-      return createdLock;
-    } catch (error) {
-      await createdLock?.close().catch(() => void 0);
-      await unlink3(lockOwnerPath(lockPath)).catch(() => void 0);
-      await rmdir(lockHeldPath(lockPath)).catch(() => void 0);
-      await rmdir(lockPath).catch(() => void 0);
-      throw error;
-    }
-  }
-  throw new Error(`Unable to acquire Codex credit ledger lock (${lockPath})`);
-}
-async function readLockOwner(lockPath) {
-  try {
-    const parsed = JSON.parse(await readFile6(lockOwnerPath(lockPath), "utf8"));
-    if (!Number.isSafeInteger(parsed.pid) || parsed.pid <= 0 || parsed.phase !== "preflight" && parsed.phase !== "in-flight" && parsed.phase !== "settled") {
-      return void 0;
-    }
-    return { pid: parsed.pid, phase: parsed.phase };
-  } catch {
-    return void 0;
-  }
-}
-async function reclaimStaleLedgerLock(lockPath, expectedOwner) {
-  try {
-    await rmdir(lockHeldPath(lockPath));
-  } catch (error) {
-    throw new Error(
-      `Codex credit ledger stale-lock reclamation is already claimed or incomplete (${lockPath}); refusing credit spend: ${safeErrorMessage(error)}`
-    );
-  }
-  const currentOwner = await readLockOwner(lockPath);
-  if (!currentOwner || currentOwner.pid !== expectedOwner.pid || currentOwner.phase !== expectedOwner.phase || isProcessAlive(currentOwner.pid) || currentOwner.phase === "in-flight") {
-    throw new Error(
-      `Codex credit ledger owner changed during stale-lock reclamation (${lockPath}); refusing credit spend.`
-    );
-  }
-  await unlink3(lockOwnerPath(lockPath));
-  await rmdir(lockPath);
-}
-async function removeOwnedLedgerLock(lockPath) {
-  await rmdir(lockHeldPath(lockPath));
-  await unlink3(lockOwnerPath(lockPath));
-  await rmdir(lockPath);
-}
-function lockOwnerPath(lockPath) {
-  return path7.join(lockPath, "owner.json");
-}
-function lockHeldPath(lockPath) {
-  return path7.join(lockPath, "held");
-}
-async function writeLockState(lock, phase) {
-  const contents = `${JSON.stringify({
-    pid: process.pid,
-    phase,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  })}
-`;
-  await lock.truncate(0);
-  await lock.write(contents, 0, "utf8");
-  await lock.sync();
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
-function parseCodexJsonlUsage(output) {
-  let usage;
-  for (const line of output.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("{")) continue;
-    try {
-      const event = JSON.parse(trimmed);
-      if (event.type !== "turn.completed" || !event.usage) continue;
-      const inputTokens = readCounter(event.usage.input_tokens);
-      const outputTokens = readCounter(event.usage.output_tokens);
-      const cachedInputTokens = readOptionalCounter(
-        event.usage.cached_input_tokens
-      );
-      const reasoningOutputTokens = readOptionalCounter(
-        event.usage.reasoning_output_tokens
-      );
-      if (inputTokens !== void 0 && outputTokens !== void 0 && cachedInputTokens !== void 0 && reasoningOutputTokens !== void 0) {
-        usage = {
-          inputTokens,
-          cachedInputTokens,
-          outputTokens,
-          reasoningOutputTokens
-        };
-      }
-    } catch {
-    }
-  }
-  return usage;
-}
-function calculateCodexCredits(model, usage) {
-  const rate = resolveRate(model);
-  const cached = Math.min(usage.inputTokens, usage.cachedInputTokens);
-  const uncached = usage.inputTokens - cached;
-  return (uncached * rate.input + cached * rate.cachedInput + usage.outputTokens * rate.output) / ONE_MILLION;
-}
-function resolveRate(model) {
-  const match = CREDIT_RATES.find(([pattern]) => pattern.test(model));
-  if (!match) {
-    throw new Error(
-      `No Codex credit rate is configured for model ${JSON.stringify(model)}; refusing to run under a bounded credit budget.`
-    );
-  }
-  return match[1];
-}
-function assertModelAllowed(model, config) {
-  resolveRate(model);
-  if (SOL_MODEL.test(model) && !config.allowSol) {
-    throw new Error(
-      "gpt-5.6-sol is disabled for bounded benchmark runs because it is the most expensive GPT-5.6 tier. Use gpt-5.6-terra or gpt-5.6-luna, or explicitly set REMNIC_BENCH_CODEX_ALLOW_SOL=1."
-    );
-  }
-}
-async function readLedger(config) {
-  try {
-    const parsed = JSON.parse(await readFile6(config.ledgerPath, "utf8"));
-    if (parsed.schemaVersion !== 1 || parsed.budgetCredits !== config.budgetCredits || parsed.reserveCredits !== config.reserveCredits || typeof parsed.spentCredits !== "number" || !Number.isFinite(parsed.spentCredits) || parsed.spentCredits < 0 || !Array.isArray(parsed.entries)) {
-      throw new Error("ledger schema or budget does not match this run");
-    }
-    return parsed;
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      throw new Error(`Invalid Codex credit ledger at ${config.ledgerPath}: ${String(error)}`);
-    }
-    return {
-      schemaVersion: 1,
-      budgetCredits: config.budgetCredits,
-      reserveCredits: config.reserveCredits,
-      spentCredits: 0,
-      entries: []
-    };
-  }
-}
-async function writeLedger(filePath, ledger) {
-  await mkdir5(path7.dirname(filePath), { recursive: true, mode: 448 });
-  const tempPath = `${filePath}.${process.pid}.tmp`;
-  await writeFile5(tempPath, `${JSON.stringify(ledger, null, 2)}
-`, {
-    encoding: "utf8",
-    mode: 384
-  });
-  await rename2(tempPath, filePath);
-}
-function readCounter(value) {
-  return Number.isSafeInteger(value) && value >= 0 ? value : void 0;
-}
-function readOptionalCounter(value) {
-  return value === void 0 ? 0 : readCounter(value);
-}
-function safeErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function expandHomeRelativePath2(value) {
-  if (value === "~") return os4.homedir();
-  if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path7.join(os4.homedir(), value.slice(2));
-  }
-  return value;
-}
-function parsePositiveNumber(value, name) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new Error(`${name} must be a finite number greater than zero`);
-  }
-  return parsed;
-}
-function parseNonNegativeNumber(value, name) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed < 0) {
-    throw new Error(`${name} must be a finite non-negative number`);
-  }
-  return parsed;
-}
-
 // src/providers/codex-cli.ts
 var DEFAULT_REASONING_EFFORT = "xhigh";
 var DEFAULT_SERVICE_TIER = "default";
@@ -9611,7 +9734,10 @@ var CodexCliProvider = class {
       throw codexCliAbortError(opts.signal);
     }
     const startedAt = performance.now();
-    const creditBudget = resolveCodexCreditBudgetConfig();
+    const creditBudget = resolveCodexCreditBudgetConfig(
+      process.env,
+      resolveBenchmarkRunId()
+    );
     if (creditBudget) {
       await this.assertChatGptCreditAuth();
     }
@@ -10194,7 +10320,7 @@ function resolveCodexCliDiagnosticsMode(config) {
 }
 function inspectCodexCompletionPrompt(prompt) {
   const stats = {
-    sha256: createHash5("sha256").update(prompt).digest("hex"),
+    sha256: createHash6("sha256").update(prompt).digest("hex"),
     chars: prompt.length,
     lines: prompt.length === 0 ? 0 : prompt.split("\n").length
   };
@@ -14427,6 +14553,8 @@ function resolveOpenClawRemnicPluginEntry(raw) {
 }
 var REDACTED_CONFIG_VALUE = "[redacted]";
 var INTERNAL_GATEWAY_AGENT_ID = "remnic-bench-internal";
+var DEFAULT_CODEX_CLI_REQUEST_TIMEOUT_MS = 18e4;
+var DEFAULT_CODEX_CLI_DRAIN_TIMEOUT_MS = 6e5;
 var codexCliFallbackRegistered = false;
 var codexCliFallbackChain = Promise.resolve();
 async function resolveBenchRuntimeProfile(options) {
@@ -14480,8 +14608,11 @@ async function resolveBenchRuntimeProfile(options) {
     { disableThinking: options.internalDisableThinking === true }
   );
   const lcmObserveConcurrencyOverrides = buildLcmObserveConcurrencyOverrides(options.lcmObserveConcurrency);
+  const usesImplicitCodexRequestTimeout = options.requestTimeout === void 0 && [systemProvider, judgeProvider, internalProvider].some(
+    (config) => config?.provider === "codex-cli"
+  );
   const drainTimeoutMs = normalizeDrainTimeoutMs2(
-    options.drainTimeout ?? options.requestTimeout
+    options.drainTimeout ?? options.requestTimeout ?? (usesImplicitCodexRequestTimeout ? DEFAULT_CODEX_CLI_DRAIN_TIMEOUT_MS : void 0)
   );
   registerCodexCliFallbackRunnerIfNeeded(internalProvider);
   const responderFactoryConfig = systemProvider ? asProviderFactoryConfig(systemProvider) : void 0;
@@ -14693,6 +14824,7 @@ function resolveProviderConfig(kind, provider, model, baseUrl, requestTimeout, d
       `${kind} Codex reasoning effort requires provider "codex-cli"`
     );
   }
+  const providerRequestTimeoutMs = requestTimeout === void 0 && provider === "codex-cli" ? DEFAULT_CODEX_CLI_REQUEST_TIMEOUT_MS : void 0;
   return {
     provider,
     model: resolvedModel.trim(),
@@ -14703,6 +14835,7 @@ function resolveProviderConfig(kind, provider, model, baseUrl, requestTimeout, d
       ...requestTimeout != null ? { timeoutMs: requestTimeout } : {},
       ...max429WaitMs != null ? { max429WaitMs } : {}
     } } : {},
+    ...providerRequestTimeoutMs !== void 0 ? { providerRequestTimeoutMs } : {},
     ...disableThinking ? { disableThinking: true } : {},
     ...provider === "codex-cli" ? { reasoningEffort: reasoningEffort ?? "xhigh" } : {},
     ...responderContextBudgetChars !== void 0 ? { responderContextBudgetChars } : {},
@@ -14758,13 +14891,14 @@ function buildInternalRemnicConfigOverrides(config, options) {
       ...config.retryOptions?.timeoutMs ? { localLlmTimeoutMs: config.retryOptions.timeoutMs } : {}
     };
   }
+  const providerTimeoutMs = config.retryOptions?.timeoutMs ?? config.providerRequestTimeoutMs;
   return {
     ...thinkingOverrides,
     modelSource: "gateway",
     localLlmEnabled: false,
-    ...config.retryOptions?.timeoutMs ? {
-      localLlmTimeoutMs: config.retryOptions.timeoutMs,
-      localLlmFastTimeoutMs: config.retryOptions.timeoutMs
+    ...providerTimeoutMs ? {
+      localLlmTimeoutMs: providerTimeoutMs,
+      localLlmFastTimeoutMs: providerTimeoutMs
     } : {},
     gatewayConfig: buildInternalGatewayConfig(config, options),
     gatewayAgentId: INTERNAL_GATEWAY_AGENT_ID,
@@ -14774,7 +14908,7 @@ function buildInternalRemnicConfigOverrides(config, options) {
 function buildInternalGatewayConfig(config, options) {
   const providerId = INTERNAL_GATEWAY_AGENT_ID;
   const modelRef = `${providerId}/${config.model}`;
-  const timeoutMs = config.retryOptions?.timeoutMs;
+  const timeoutMs = config.retryOptions?.timeoutMs ?? config.providerRequestTimeoutMs;
   return {
     agents: {
       defaults: {
@@ -14960,12 +15094,16 @@ function createAssistantAgentFromResponder2(responder) {
   };
 }
 function asProviderFactoryConfig(config) {
+  const retryOptions = config.retryOptions || config.providerRequestTimeoutMs !== void 0 ? {
+    ...config.retryOptions,
+    ...config.retryOptions?.timeoutMs === void 0 && config.providerRequestTimeoutMs !== void 0 ? { timeoutMs: config.providerRequestTimeoutMs } : {}
+  } : void 0;
   return {
     provider: config.provider,
     model: config.model,
     ...config.baseUrl ? { baseUrl: config.baseUrl } : {},
     ...config.apiKey ? { apiKey: config.apiKey } : {},
-    ...config.retryOptions ? { retryOptions: config.retryOptions } : {},
+    ...retryOptions ? { retryOptions } : {},
     ...config.disableThinking ? { disableThinking: config.disableThinking } : {},
     ...config.reasoningEffort ? { reasoningEffort: config.reasoningEffort } : {},
     ...config.temperature !== void 0 ? { temperature: config.temperature } : {},
@@ -15061,11 +15199,11 @@ async function resolveLocalLabRuntimeProfile(options) {
 // src/benchmark.ts
 import fs2 from "fs";
 import path35 from "path";
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { expandTildePath as expandTildePath3 } from "@remnic/core";
 
 // src/judges/judge-cache.ts
-import { createHash as createHash6, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash7, randomBytes as randomBytes2 } from "crypto";
 import {
   mkdir as mkdir9,
   readFile as readFile11,
@@ -15108,8 +15246,8 @@ var JudgeCache = class {
   }
   /** Compute the sha256-hex key for a set of parts. Pure, sync, side-effect-free. */
   computeKey(parts) {
-    const fieldDigest = (value) => createHash6("sha256").update(value).digest();
-    return createHash6("sha256").update(fieldDigest(parts.benchmarkId)).update(fieldDigest(parts.datasetVersion)).update(fieldDigest(parts.questionId)).update(fieldDigest(parts.answerText)).update(fieldDigest(parts.judgePromptHash)).update(fieldDigest(parts.judgeModelId)).update(fieldDigest(parts.judgeParamsHash)).digest("hex");
+    const fieldDigest = (value) => createHash7("sha256").update(value).digest();
+    return createHash7("sha256").update(fieldDigest(parts.benchmarkId)).update(fieldDigest(parts.datasetVersion)).update(fieldDigest(parts.questionId)).update(fieldDigest(parts.answerText)).update(fieldDigest(parts.judgePromptHash)).update(fieldDigest(parts.judgeModelId)).update(fieldDigest(parts.judgeParamsHash)).digest("hex");
   }
   /**
    * Read a previously-stored verdict. Returns `undefined` on miss, corrupted
@@ -15304,7 +15442,7 @@ function runJudgeWithCache(options) {
           // Binary prompts are content-sensitive: two distinct prompts of
           // the same character length would collide on the previous
           // `binary:N` key, so key on a sha256 prefix of the prompt body.
-          questionId: `binary:${createHash6("sha256").update(prompt).digest("hex").slice(0, 16)}`,
+          questionId: `binary:${createHash7("sha256").update(prompt).digest("hex").slice(0, 16)}`,
           answerText: prompt,
           judgePromptHash: keyExtras.judgePromptHash ?? "unknown-prompt",
           judgeModelId: keyExtras.judgeModelId ?? "unknown-judge",
@@ -22795,7 +22933,7 @@ var StructuredLiteralParser = class {
 };
 
 // src/benchmarks/published/personamem/runner.ts
-import { createHash as createHash7, randomUUID as randomUUID7 } from "crypto";
+import { createHash as createHash8, randomUUID as randomUUID7 } from "crypto";
 import { readFile as readFile16, realpath as realpath4 } from "fs/promises";
 import path19 from "path";
 
@@ -23400,7 +23538,7 @@ function buildMcqPrompt(sample, seed) {
 function deterministicShuffle(values, seedMaterial) {
   return values.map((value, index) => ({
     value,
-    key: createHash7("sha256").update(`${seedMaterial}:${index}:${value}`).digest("hex"),
+    key: createHash8("sha256").update(`${seedMaterial}:${index}:${value}`).digest("hex"),
     index
   })).sort((left, right) => {
     const byKey = left.key.localeCompare(right.key);
@@ -31859,7 +31997,7 @@ function pairedDeltaConfidenceInterval(candidateValues, baselineValues, options
 }
 
 // src/judges/sealed-rubric.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import { appendFileSync, mkdirSync } from "fs";
 import path31 from "path";
 
@@ -31968,9 +32106,9 @@ function loadSealedRubric(id = DEFAULT_ASSISTANT_RUBRIC_ID, options = {}) {
   if (typeof prompt !== "string" || prompt.length === 0) {
     throw new Error(`sealed rubric not found in registry: ${id}`);
   }
-  const sha256 = createHash8("sha256").update(prompt, "utf8").digest("hex");
+  const sha2562 = createHash9("sha256").update(prompt, "utf8").digest("hex");
   const version = parseVersionFromId(id);
-  return { id, version, prompt, sha256 };
+  return { id, version, prompt, sha256: sha2562 };
 }
 function verifyRubricDigest(expectedSha256, options = {}) {
   const rubric = loadSealedRubric(options.id, { registry: options.registry });
@@ -34171,7 +34309,7 @@ async function runRetentionAgedDatasetBenchmark(options) {
 import { randomUUID as randomUUID31 } from "crypto";
 
 // src/benchmarks/remnic/memcorrect/generator.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 
 // src/benchmarks/remnic/memcorrect/token-pools.ts
 var PERSONAS = [
@@ -34495,7 +34633,7 @@ function corpusHash(corpus) {
     uptakeLatencyCap: corpus.options.uptakeLatencyCap,
     scenarios: corpus.scenarios
   });
-  return createHash9("sha256").update(canonical).digest("hex");
+  return createHash10("sha256").update(canonical).digest("hex");
 }
 
 // src/benchmarks/remnic/memcorrect/schema.ts
@@ -35450,7 +35588,7 @@ import { mkdir as mkdir17, writeFile as writeFile16 } from "fs/promises";
 import path34 from "path";
 
 // src/benchmarks/remnic/bounded-memory-contracts/fixture.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 var SCOPE_ACME = "project:acme";
 var SCOPE_BETA = "project:beta";
 var SCOPE_ALICE = "user:alice";
@@ -35933,7 +36071,7 @@ var BOUNDED_MEMORY_SMOKE_FIXTURE = [
 function fixtureHash(tasks) {
   const source = tasks ?? BOUNDED_MEMORY_FIXTURE;
   const payload = JSON.stringify(source);
-  return createHash10("sha256").update(payload, "utf8").digest("hex");
+  return createHash11("sha256").update(payload, "utf8").digest("hex");
 }
 
 // src/benchmarks/remnic/bounded-memory-contracts/agent.ts
@@ -37193,13 +37331,13 @@ function wrapJudgeWithCache(args) {
       // differentiator is part of the prompt hash. Bumping
       // JUDGE_CACHE_PROTOCOL_VERSION invalidates verdicts when judge
       // prompt/parse semantics change (PR #1591, High).
-      judgePromptHash: createHash11("sha256").update(JUDGE_CACHE_PROTOCOL_VERSION).update("
").update(args.amaBenchJudgeProtocol).update("
").update(args.role).digest("hex"),
+      judgePromptHash: createHash12("sha256").update(JUDGE_CACHE_PROTOCOL_VERSION).update("
").update(args.amaBenchJudgeProtocol).update("
").update(args.role).digest("hex"),
       judgeModelId: args.provider?.model !== void 0 && args.provider.model.length > 0 ? `${args.provider.model}${crossJudgeIdSuffix}` : `unknown-${args.role}-judge`,
       // Full judge configuration, deterministically serialized (sorted
       // keys) so provider/base-url/retry changes produce fresh cache
       // keys. `role` is included so primary and cross judges never
       // share a paramsHash.
-      judgeParamsHash: createHash11("sha256").update(
+      judgeParamsHash: createHash12("sha256").update(
         stableStringify2({
           role: args.role,
           provider: args.provider
@@ -37904,6 +38042,523 @@ function formatSignedScore(value) {
   return `${value >= 0 ? "+" : ""}${formatScore(value)}`;
 }
 
+// src/stats/locomo-recall-delta.ts
+import { createHash as createHash13 } from "crypto";
+import { basename } from "path";
+var LOCOMO_FULL_TASK_COUNT = 1986;
+var LOCOMO_RECALL_EXCERPT_CHARS = 240;
+var LOCOMO_RECALL_DIFF_LINE_LIMIT = 20;
+var LOCOMO_CATEGORY_ORDER2 = ["single_hop", "multi_hop", "temporal", "open_domain", "adversarial"];
+var LOCOMO_TASK_CATEGORY_PATTERN2 = /-(single_hop|multi_hop|temporal|open_domain|adversarial)$/;
+var SOURCE_TURN_PATTERN = /^\[([^,\]\s]+),\s*turn\s+(\d+),\s*([^,\]]+?)(?:,\s*score\s+[^\]]+)?\]/i;
+var SHA256_PATTERN = /^[a-f0-9]{64}$/;
+function sanitizeLoComoResultReference(path40) {
+  const reference = basename(path40).replace(/[\u0000-\u001f\u007f`]/g, "_");
+  if (!reference) throw new Error("Result path must identify a file.");
+  return reference;
+}
+function diagnoseLoComoRecallDelta(options) {
+  const primaryMetric2 = options.primaryMetric ?? "llm_judge";
+  const maxRegressions = parseNonNegativeInteger(options.maxRegressions ?? 20, "maxRegressions");
+  assertEvidenceEnvelope(options.baseline, "baseline");
+  assertEvidenceEnvelope(options.real, "real");
+  assertCompleteResult(options.baseline.result, "baseline");
+  assertCompleteResult(options.real.result, "real");
+  assertComparableResults(options.baseline.result, options.real.result);
+  const joined = joinTasks2(options.baseline.result, options.real.result);
+  assertMetricSets(joined, primaryMetric2);
+  verifyAggregateMeans(options.baseline.result, joined, "baseline");
+  verifyAggregateMeans(options.real.result, joined, "real");
+  const overall = summarizeMetric(joined, primaryMetric2);
+  const categories = [...new Set(joined.map((task) => task.category))].sort(compareLoComoCategories2).map((category) => {
+    const tasks = joined.filter((task) => task.category === category);
+    return {
+      category,
+      taskCount: tasks.length,
+      ...summarizeMetric(tasks, primaryMetric2)
+    };
+  });
+  const topRegressions = joined.map((task) => buildRegression(task, primaryMetric2, LOCOMO_RECALL_EXCERPT_CHARS, LOCOMO_RECALL_DIFF_LINE_LIMIT)).filter((task) => task.delta < 0).sort((left, right) => left.delta - right.delta || compareStrings(left.taskId, right.taskId)).slice(0, maxRegressions);
+  return {
+    schemaVersion: 1,
+    benchmarkId: "locomo",
+    comparison: {
+      baseline: buildProvenance(options.baseline, "baseline", joined, "baseline"),
+      real: buildProvenance(options.real, "real", joined, "real")
+    },
+    taskCount: joined.length,
+    primaryMetric: primaryMetric2,
+    overall,
+    categories,
+    topRegressions,
+    evidenceBoundary: {
+      finalContextComparison: "complete",
+      retrievalTierAttribution: "unavailable-in-cached-results",
+      hiddenEvidenceUsed: false,
+      explanation: "Cached BenchmarkResult files preserve the final transformed recall context, but not pre-transform candidates, section provenance, filter traces, or served-by tiers."
+    }
+  };
+}
+function renderLoComoRecallDeltaMarkdown(report) {
+  const lines = [
+    "# LoCoMo paired final-context diagnosis",
+    "",
+    `Joined ${report.taskCount} complete paired tasks. The primary metric is \`${report.primaryMetric}\` (real minus baseline).`,
+    "",
+    "| Category | Tasks | Baseline | Real | Delta | Wins | Losses | Ties |",
+    "|---|---:|---:|---:|---:|---:|---:|---:|"
+  ];
+  for (const category of report.categories) {
+    lines.push(
+      `| ${escapeMarkdownCell(category.category)} | ${category.taskCount} | ${formatScore2(category.baselineMean)} | ${formatScore2(category.realMean)} | ${formatSignedScore2(category.delta)} | ${category.wins} | ${category.losses} | ${category.ties} |`
+    );
+  }
+  lines.push(
+    `| **Overall** | **${report.taskCount}** | **${formatScore2(report.overall.baselineMean)}** | **${formatScore2(report.overall.realMean)}** | **${formatSignedScore2(report.overall.delta)}** | **${report.overall.wins}** | **${report.overall.losses}** | **${report.overall.ties}** |`,
+    "",
+    "## Highest-priority final-context regressions",
+    ""
+  );
+  for (const task of report.topRegressions) {
+    lines.push(
+      `### ${escapeMarkdownCell(task.taskId)}`,
+      "",
+      `Category: \`${task.category}\`; baseline ${formatScore2(task.baselineScore)}, real ${formatScore2(task.realScore)}, delta ${formatSignedScore2(task.delta)}.`,
+      "",
+      `Recall: baseline ${task.baseline.recall.charCount} chars (expected-token coverage ${formatScore2(task.baseline.recall.expectedTokenCoverage)}), real ${task.real.recall.charCount} chars (coverage ${formatScore2(task.real.recall.expectedTokenCoverage)}).`,
+      "",
+      `Displaced lines: ${task.displacedLines.totalCount}; introduced lines: ${task.introducedLines.totalCount}.`,
+      ""
+    );
+    const displaced = task.displacedLines.lines[0];
+    if (displaced) {
+      lines.push(
+        `- Baseline-only evidence: ${escapeMarkdownCell(displaced.excerpt)} (sha256 \`${displaced.sha256}\`)`
+      );
+    }
+    const introduced = task.introducedLines.lines[0];
+    if (introduced) {
+      lines.push(
+        `- Real-only evidence: ${escapeMarkdownCell(introduced.excerpt)} (sha256 \`${introduced.sha256}\`)`
+      );
+    }
+    if (displaced || introduced) lines.push("");
+  }
+  lines.push(
+    "## Evidence boundary",
+    "",
+    "The final responder contexts are compared completely by hash, length, headings, source references, and bounded line-difference receipts. Retrieval-tier attribution is unavailable because the cached results do not preserve served-by or candidate traces. Hidden `details.evidence` metadata is not read or emitted.",
+    "",
+    `Baseline: \`${report.comparison.baseline.reference}\` (sha256 \`${report.comparison.baseline.sha256}\`)`,
+    "",
+    `Real: \`${report.comparison.real.reference}\` (sha256 \`${report.comparison.real.sha256}\`)`,
+    ""
+  );
+  return `${lines.join("\n")}
+`;
+}
+function assertEvidenceEnvelope(evidence, label) {
+  if (!evidence.reference.trim()) {
+    throw new Error(`${label} result reference must not be empty.`);
+  }
+  if (!SHA256_PATTERN.test(evidence.sha256)) {
+    throw new Error(`${label} result sha256 must be 64 lowercase hexadecimal characters.`);
+  }
+}
+function assertCompleteResult(result, label) {
+  if (result.meta.benchmark !== "locomo") {
+    throw new Error(`${label} result must be a locomo benchmark result.`);
+  }
+  if (result.meta.mode !== "full" || result.meta.status === "partial") {
+    throw new Error(`${label} result must be a complete full-mode run.`);
+  }
+  if (!result.config.systemProvider || !result.config.judgeProvider) {
+    throw new Error(`${label} result must identify both system and judge providers.`);
+  }
+  const limit = result.config.benchmarkOptions?.limit;
+  const trialLimit = result.config.benchmarkOptions?.trialLimit;
+  if (limit !== void 0 || trialLimit !== void 0) {
+    throw new Error(`${label} result is limited and cannot be used as complete evidence.`);
+  }
+  if (result.results.tasks.length !== LOCOMO_FULL_TASK_COUNT) {
+    throw new Error(
+      `${label} result must contain exactly ${LOCOMO_FULL_TASK_COUNT} tasks; got ${result.results.tasks.length}.`
+    );
+  }
+  for (const task of result.results.tasks) {
+    const details = asRecord(task.details);
+    const failure = details?.benchmarkFailure;
+    const legacyError = details?.error;
+    if (failure !== void 0 && failure !== null || typeof legacyError === "string" && legacyError.length > 0) {
+      throw new Error(`${label} result contains failed task ${JSON.stringify(task.taskId)}.`);
+    }
+  }
+}
+function assertComparableResults(baseline, real) {
+  if (baseline.config.runtimeProfile !== "baseline") {
+    throw new Error('baseline result runtimeProfile must be "baseline".');
+  }
+  if (real.config.runtimeProfile !== "real") {
+    throw new Error('real result runtimeProfile must be "real".');
+  }
+  const checks = [
+    ["meta.version", baseline.meta.version, real.meta.version],
+    ["meta.remnicVersion", baseline.meta.remnicVersion, real.meta.remnicVersion],
+    ["meta.gitSha", baseline.meta.gitSha, real.meta.gitSha],
+    ["meta.runCount", baseline.meta.runCount, real.meta.runCount],
+    ["meta.seeds", baseline.meta.seeds, real.meta.seeds],
+    ["meta.datasetHash", baseline.meta.datasetHash ?? null, real.meta.datasetHash ?? null],
+    ["config.adapterMode", baseline.config.adapterMode, real.config.adapterMode],
+    [
+      "config.systemProvider",
+      providerIdentity(baseline.config.systemProvider),
+      providerIdentity(real.config.systemProvider)
+    ],
+    [
+      "config.judgeProvider",
+      providerIdentity(baseline.config.judgeProvider),
+      providerIdentity(real.config.judgeProvider)
+    ],
+    [
+      "config.internalProvider",
+      providerIdentity(baseline.config.internalProvider),
+      providerIdentity(real.config.internalProvider)
+    ]
+  ];
+  for (const [field, baselineValue, realValue] of checks) {
+    if (stableJson(baselineValue) !== stableJson(realValue)) {
+      throw new Error(
+        `Results are not comparable: ${field} differs (${stableJson(baselineValue)} vs ${stableJson(realValue)}).`
+      );
+    }
+  }
+}
+function joinTasks2(baseline, real) {
+  const baselineTasks = indexTasks2(baseline.results.tasks, "baseline");
+  const realTasks = indexTasks2(real.results.tasks, "real");
+  const missingFromReal = [...baselineTasks.keys()].filter((id) => !realTasks.has(id)).sort(compareStrings);
+  const missingFromBaseline = [...realTasks.keys()].filter((id) => !baselineTasks.has(id)).sort(compareStrings);
+  if (missingFromReal.length > 0 || missingFromBaseline.length > 0) {
+    throw new Error(
+      `Results do not contain identical task-id sets: ${missingFromReal.length} missing from real, ${missingFromBaseline.length} missing from baseline.`
+    );
+  }
+  return [...baselineTasks.keys()].sort(compareStrings).map((taskId) => {
+    const baselineTask = baselineTasks.get(taskId);
+    const realTask = realTasks.get(taskId);
+    if (!baselineTask || !realTask) {
+      throw new Error(`Task ${JSON.stringify(taskId)} disappeared during the validated join.`);
+    }
+    for (const [field, baselineValue, realValue] of [
+      ["question", baselineTask.question, realTask.question],
+      ["expected", baselineTask.expected, realTask.expected]
+    ]) {
+      if (baselineValue !== realValue) {
+        throw new Error(`Task ${JSON.stringify(taskId)} has mismatched ${field} payloads.`);
+      }
+    }
+    const baselineCategory = resolveCategory2(baselineTask);
+    const realCategory = resolveCategory2(realTask);
+    if (baselineCategory !== realCategory) {
+      throw new Error(`Task ${JSON.stringify(taskId)} has mismatched categories.`);
+    }
+    return { taskId, category: baselineCategory, baseline: baselineTask, real: realTask };
+  });
+}
+function indexTasks2(tasks, label) {
+  const result = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (!task.taskId || result.has(task.taskId)) {
+      throw new Error(`${label} result contains duplicate or empty task id ${JSON.stringify(task.taskId)}.`);
+    }
+    if (!task.question || !task.expected) {
+      throw new Error(`${label} task ${JSON.stringify(task.taskId)} has an empty question or expected answer.`);
+    }
+    const recalledText = asRecord(task.details)?.recalledText;
+    if (typeof recalledText !== "string") {
+      throw new Error(`${label} task ${JSON.stringify(task.taskId)} has no final recalledText.`);
+    }
+    result.set(task.taskId, task);
+  }
+  return result;
+}
+function assertMetricSets(joined, primaryMetric2) {
+  const first = joined[0];
+  if (!first) throw new Error("Cannot validate metric sets for an empty paired result.");
+  const expectedMetrics = Object.keys(first.baseline.scores).sort(compareStrings);
+  for (const task of joined) {
+    const baselineMetrics = Object.keys(task.baseline.scores).sort(compareStrings);
+    const realMetrics = Object.keys(task.real.scores).sort(compareStrings);
+    if (stableJson(baselineMetrics) !== stableJson(realMetrics)) {
+      throw new Error(`Task ${JSON.stringify(task.taskId)} has mismatched metric sets.`);
+    }
+    if (stableJson(baselineMetrics) !== stableJson(expectedMetrics)) {
+      throw new Error(`Task ${JSON.stringify(task.taskId)} has an inconsistent metric set.`);
+    }
+    if (!baselineMetrics.includes(primaryMetric2)) {
+      throw new Error(`Task ${JSON.stringify(task.taskId)} is missing metric ${JSON.stringify(primaryMetric2)}.`);
+    }
+    for (const [side, scores] of [
+      ["baseline", task.baseline.scores],
+      ["real", task.real.scores]
+    ]) {
+      for (const [metric, score] of Object.entries(scores)) {
+        if (!Number.isFinite(score)) {
+          throw new Error(`${side} task ${JSON.stringify(task.taskId)} metric ${metric} is not finite.`);
+        }
+      }
+    }
+  }
+}
+function buildRegression(task, metric, excerptChars, maxDiffLines) {
+  const baselineRecall = finalRecallText(task.baseline);
+  const realRecall = finalRecallText(task.real);
+  const baselineLines = contentLines(baselineRecall);
+  const realLines = contentLines(realRecall);
+  const displaced = subtractLineMultiset(baselineLines, realLines);
+  const introduced = subtractLineMultiset(realLines, baselineLines);
+  const baselineScore = requireMetricScore(task.baseline, metric, "baseline");
+  const realScore = requireMetricScore(task.real, metric, "real");
+  return {
+    taskId: task.taskId,
+    category: task.category,
+    baselineScore,
+    realScore,
+    delta: realScore - baselineScore,
+    questionSha256: sha256(normalizeText3(task.baseline.question)),
+    expectedAnswerSha256: sha256(normalizeText3(task.baseline.expected)),
+    baseline: {
+      answer: textDigest(task.baseline.actual, excerptChars),
+      recall: recallSummary(baselineRecall, task.baseline.expected)
+    },
+    real: {
+      answer: textDigest(task.real.actual, excerptChars),
+      recall: recallSummary(realRecall, task.real.expected)
+    },
+    displacedLines: lineDelta(displaced, maxDiffLines, excerptChars),
+    introducedLines: lineDelta(introduced, maxDiffLines, excerptChars)
+  };
+}
+function buildProvenance(evidence, profile, joined, side) {
+  const system = requireProvider(evidence.result.config.systemProvider, profile, "system");
+  const judge = requireProvider(evidence.result.config.judgeProvider, profile, "judge");
+  const payload = joined.map((task) => ({
+    taskId: task.taskId,
+    category: task.category,
+    question: task[side].question,
+    expected: task[side].expected
+  }));
+  return {
+    reference: evidence.reference,
+    sha256: evidence.sha256,
+    resultId: evidence.result.meta.id,
+    gitSha: evidence.result.meta.gitSha,
+    remnicVersion: evidence.result.meta.remnicVersion,
+    runtimeProfile: profile,
+    systemProvider: system.provider,
+    systemModel: system.model,
+    judgeProvider: judge.provider,
+    judgeModel: judge.model,
+    seeds: [...evidence.result.meta.seeds],
+    taskPayloadSha256: sha256(stableJson(payload))
+  };
+}
+function summarizeMetric(tasks, metric) {
+  let baselineSum = 0;
+  let realSum = 0;
+  let wins = 0;
+  let losses = 0;
+  let ties = 0;
+  for (const task of tasks) {
+    const baseline = requireMetricScore(task.baseline, metric, "baseline");
+    const real = requireMetricScore(task.real, metric, "real");
+    baselineSum += baseline;
+    realSum += real;
+    if (real > baseline) wins += 1;
+    else if (real < baseline) losses += 1;
+    else ties += 1;
+  }
+  const baselineMean = baselineSum / tasks.length;
+  const realMean = realSum / tasks.length;
+  return { baselineMean, realMean, delta: realMean - baselineMean, wins, losses, ties };
+}
+function lineDelta(lines, maxDiffLines, excerptChars) {
+  return {
+    totalCount: lines.length,
+    shownCount: Math.min(lines.length, maxDiffLines),
+    lines: lines.slice(0, maxDiffLines).map((line) => {
+      const parsedSourceRef = sourceRef(line.text);
+      return {
+        ordinal: line.ordinal,
+        ...textDigest(line.text, excerptChars),
+        ...parsedSourceRef ? { sourceRef: parsedSourceRef } : {}
+      };
+    })
+  };
+}
+function recallSummary(text, expected) {
+  const normalized = normalizeText3(text);
+  const lines = normalized.split("\n").map((line) => line.trim()).filter(Boolean);
+  return {
+    sha256: sha256(normalized),
+    charCount: normalized.length,
+    lineCount: lines.length,
+    headings: [...new Set(lines.filter(isHeading))],
+    sourceRefs: [...new Set(lines.map(sourceRef).filter((value) => !!value))].sort(compareStrings),
+    expectedTokenCoverage: tokenCoverage(expected, normalized)
+  };
+}
+function textDigest(text, excerptChars) {
+  const normalized = normalizeText3(text);
+  return {
+    sha256: sha256(normalized),
+    charCount: normalized.length,
+    excerpt: normalized.slice(0, excerptChars)
+  };
+}
+function contentLines(text) {
+  return normalizeText3(text).split("\n").map((line, ordinal) => ({ text: line.trim(), ordinal })).filter((line) => line.text.length > 0 && !isHeading(line.text));
+}
+function subtractLineMultiset(source, comparison) {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const line of comparison) {
+    remaining.set(line.text, (remaining.get(line.text) ?? 0) + 1);
+  }
+  return source.filter((line) => {
+    const count = remaining.get(line.text) ?? 0;
+    if (count === 0) return true;
+    remaining.set(line.text, count - 1);
+    return false;
+  });
+}
+function verifyAggregateMeans(result, joined, side) {
+  const first = joined[0];
+  if (!first) throw new Error("Cannot verify aggregates for an empty paired result.");
+  const metrics = Object.keys(first[side].scores).sort(compareStrings);
+  for (const metric of metrics) {
+    const aggregate = result.results.aggregates[metric];
+    if (!aggregate || !Number.isFinite(aggregate.mean)) {
+      throw new Error(`${side} result has no finite aggregate mean for ${JSON.stringify(metric)}.`);
+    }
+    const computed = joined.reduce((sum, task) => sum + requireMetricScore(task[side], metric, side), 0) / joined.length;
+    if (Math.abs(aggregate.mean - computed) > 1e-12) {
+      throw new Error(`${side} aggregate ${metric}=${aggregate.mean} does not match task mean ${computed}.`);
+    }
+  }
+}
+function tokenCoverage(expected, recalled) {
+  const expectedTokens = new Set(tokenize6(expected));
+  if (expectedTokens.size === 0) return 0;
+  const recalledTokens = new Set(tokenize6(recalled));
+  let matched = 0;
+  for (const token of expectedTokens) {
+    if (recalledTokens.has(token)) matched += 1;
+  }
+  return matched / expectedTokens.size;
+}
+function tokenize6(value) {
+  return normalizeText3(value).toLocaleLowerCase("en-US").match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+function resolveCategory2(task) {
+  const categoryName = asRecord(task.details)?.categoryName;
+  if (typeof categoryName === "string" && categoryName.trim()) return categoryName;
+  const match = task.taskId.match(LOCOMO_TASK_CATEGORY_PATTERN2);
+  if (!match?.[1]) {
+    throw new Error(`Cannot derive LoCoMo category from task id ${JSON.stringify(task.taskId)}.`);
+  }
+  return match[1];
+}
+function finalRecallText(task) {
+  const recalledText = asRecord(task.details)?.recalledText;
+  if (typeof recalledText !== "string") {
+    throw new Error(`Task ${JSON.stringify(task.taskId)} has no final recalledText.`);
+  }
+  return recalledText;
+}
+function providerIdentity(provider) {
+  if (!provider) return null;
+  return {
+    provider: provider.provider,
+    model: provider.model,
+    rubricVersion: provider.rubricVersion ?? null,
+    baseUrl: provider.baseUrl ?? null,
+    providerRequestTimeoutMs: provider.providerRequestTimeoutMs ?? null,
+    retryOptions: provider.retryOptions ? {
+      maxAttempts: provider.retryOptions.maxAttempts ?? null,
+      baseBackoffMs: provider.retryOptions.baseBackoffMs ?? null,
+      timeoutMs: provider.retryOptions.timeoutMs ?? null,
+      retryOnTimeout: provider.retryOptions.retryOnTimeout ?? null,
+      max429WaitMs: provider.retryOptions.max429WaitMs ?? null
+    } : null,
+    disableThinking: provider.disableThinking ?? null,
+    reasoningEffort: provider.reasoningEffort ?? null,
+    responderContextBudgetChars: provider.responderContextBudgetChars ?? null,
+    responderPromptBudgetChars: provider.responderPromptBudgetChars ?? null,
+    temperature: provider.temperature ?? null,
+    seed: provider.seed ?? null
+  };
+}
+function sourceRef(line) {
+  const match = line.match(SOURCE_TURN_PATTERN);
+  const sessionId = match?.[1];
+  const turn = match?.[2];
+  const role = match?.[3];
+  if (!sessionId || !turn || !role) return void 0;
+  return `${sessionId}:turn-${turn}:${role.trim().toLowerCase()}`;
+}
+function requireMetricScore(task, metric, side) {
+  const score = task.scores[metric];
+  if (typeof score !== "number" || !Number.isFinite(score)) {
+    throw new Error(`${side} task ${JSON.stringify(task.taskId)} metric ${metric} is not finite.`);
+  }
+  return score;
+}
+function requireProvider(provider, profile, role) {
+  if (!provider) throw new Error(`${profile} result has no ${role} provider identity.`);
+  return provider;
+}
+function isHeading(line) {
+  return /^##\s+/.test(line);
+}
+function normalizeText3(value) {
+  return value.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+}
+function sha256(value) {
+  return createHash13("sha256").update(value).digest("hex");
+}
+function stableJson(value) {
+  return JSON.stringify(value);
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function parseNonNegativeInteger(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative integer.`);
+  }
+  return value;
+}
+function compareLoComoCategories2(left, right) {
+  const leftIndex = LOCOMO_CATEGORY_ORDER2.indexOf(left);
+  const rightIndex = LOCOMO_CATEGORY_ORDER2.indexOf(right);
+  if (leftIndex >= 0 && rightIndex >= 0) return leftIndex - rightIndex;
+  if (leftIndex >= 0) return -1;
+  if (rightIndex >= 0) return 1;
+  return compareStrings(left, right);
+}
+function compareStrings(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function escapeMarkdownCell(value) {
+  return value.replaceAll("|", "\\|").replaceAll("\n", " ");
+}
+function formatScore2(value) {
+  return value.toFixed(4);
+}
+function formatSignedScore2(value) {
+  return `${value >= 0 ? "+" : ""}${formatScore2(value)}`;
+}
+
 // src/integrity/sealed-qrels.ts
 import { readFile as readFile20 } from "fs/promises";
 function isSealedQrelsArtifact(value) {
@@ -39307,7 +39962,7 @@ var chatFixture = {
 };
 
 // src/judges/calibration-slice.ts
-import { createHash as createHash12, randomBytes as randomBytes3 } from "crypto";
+import { createHash as createHash14, randomBytes as randomBytes3 } from "crypto";
 import { mkdir as mkdir18, readFile as readFile22, rename as rename4, unlink as unlink4, writeFile as writeFile17 } from "fs/promises";
 import path37 from "path";
 
@@ -39454,7 +40109,7 @@ function selectCalibrationSlice(questionIds, size = CALIBRATION_SLICE_SIZE) {
       unique.push(id);
     }
   }
-  return unique.map((id) => ({ id, digest: createHash12("sha256").update(id, "utf8").digest("hex") })).sort((a, b) => a.digest < b.digest ? -1 : a.digest > b.digest ? 1 : 0).slice(0, Math.min(size, unique.length)).map((entry) => entry.id);
+  return unique.map((id) => ({ id, digest: createHash14("sha256").update(id, "utf8").digest("hex") })).sort((a, b) => a.digest < b.digest ? -1 : a.digest > b.digest ? 1 : 0).slice(0, Math.min(size, unique.length)).map((entry) => entry.id);
 }
 async function runJudgeCalibration(options) {
   const binScore = options.binScore ?? ((score) => binarizeJudgeScore(score));
@@ -39529,7 +40184,7 @@ function validatePinnedQuestionIds(ids, availableIds) {
   return [...ids];
 }
 function hashCalibrationAnswerSet(answers) {
-  return createHash12("sha256").update(JSON.stringify(answers.map((answer) => [
+  return createHash14("sha256").update(JSON.stringify(answers.map((answer) => [
     answer.questionId,
     answer.question,
     answer.predicted,
@@ -40216,7 +40871,7 @@ var PROCEDURAL_REAL_SCENARIOS_SMOKE = [
 ];
 
 // src/security/extraction-attack/tokenize.ts
-function tokenize6(text) {
+function tokenize7(text) {
   return text.toLowerCase().split(/[^a-z0-9]+/u).filter((t) => t.length > 2);
 }
 
@@ -40258,7 +40913,7 @@ function createSeededRng2(seed) {
     }
   };
 }
-var tokenizeContent = tokenize6;
+var tokenizeContent = tokenize7;
 function recoveryTokensFor(memory) {
   if (memory.tokens && memory.tokens.length > 0) {
     const seen = /* @__PURE__ */ new Set();
@@ -40737,11 +41392,11 @@ function createSyntheticTarget(options) {
   }
   const normalized = memories.map((m) => ({
     memory: m,
-    tokens: new Set((m.tokens ?? tokenize6(m.content)).map((t) => t.toLowerCase()))
+    tokens: new Set((m.tokens ?? tokenize7(m.content)).map((t) => t.toLowerCase()))
   }));
   return {
     async recall(query, recallOptions) {
-      const qTokens = tokenize6(query);
+      const qTokens = tokenize7(query);
       if (qTokens.length === 0) return [];
       const requestedNs = recallOptions?.namespace;
       if (enforceNamespaceAcl && requestedNs !== void 0 && requestedNs !== allowedNamespace) {
@@ -40985,7 +41640,7 @@ function createMitigatedTarget(config) {
 }
 
 // src/coding-graph/generator.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 function createSeededRng3(seed) {
   let state = seed >>> 0;
   return function rng() {
@@ -41014,7 +41669,7 @@ var EDGE_TYPE_WEIGHTS = [
 var PROVENANCE_VALUES = ["heuristic", "heuristic", "heuristic", "trace"];
 var AVG_BYTES_PER_LINE = 40;
 function hashContent(input) {
-  return createHash13("sha256").update(input).digest("hex").slice(0, 16);
+  return createHash15("sha256").update(input).digest("hex").slice(0, 16);
 }
 function generateSyntheticRepo(config) {
   const rng = createSeededRng3(config.seed);
@@ -41582,6 +42237,9 @@ export {
   JUDGE_CALIBRATION_KAPPA_THRESHOLD,
   LOCAL_LAB_PROVIDER_KINDS,
   LOCOMO_DATASET_FILENAMES,
+  LOCOMO_FULL_TASK_COUNT,
+  LOCOMO_RECALL_DIFF_LINE_LIMIT,
+  LOCOMO_RECALL_EXCERPT_CHARS,
   LONG_MEM_EVAL_DATASET_FILENAMES,
   LettaMemCorrectAdapter,
   LocalLabPreflightError,
@@ -41692,6 +42350,7 @@ export {
   defaultBenchmarkPublishPath,
   deleteBenchmarkResults,
   diagnoseLoComoProfileDelta,
+  diagnoseLoComoRecallDelta,
   discoverAllProviders,
   discoveryEndpointFor,
   emailFixture,
@@ -41766,6 +42425,7 @@ export {
   renderBaselineMarkdown,
   renderBenchmarkResultExport,
   renderLoComoProfileDeltaMarkdown,
+  renderLoComoRecallDeltaMarkdown,
   renderMemorySummaryForJudge,
   renderMemoryViewForAgent,
   resolveAssistantAgent,
@@ -41801,6 +42461,7 @@ export {
   runSealedJudge,
   runSequentialPhases,
   safeHexEqual,
+  sanitizeLoComoResultReference,
   saveBaseline,
   saveBenchmarkBaseline,
   schemaCompleteness,