@remnic/bench 9.6.20 → 9.6.21

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
   };
@@ -15061,11 +15187,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 +15234,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 +15430,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 +22921,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 +23526,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 +31985,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,7 +32094,7 @@ 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 sha256 = createHash9("sha256").update(prompt, "utf8").digest("hex");
   const version = parseVersionFromId(id);
   return { id, version, prompt, sha256 };
 }
@@ -34171,7 +34297,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 +34621,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 +35576,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 +36059,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 +37319,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
@@ -39307,7 +39433,7 @@ var chatFixture = {
 };
 
 // src/judges/calibration-slice.ts
-import { createHash as createHash12, randomBytes as randomBytes3 } from "crypto";
+import { createHash as createHash13, 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 +39580,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: createHash13("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 +39655,7 @@ function validatePinnedQuestionIds(ids, availableIds) {
   return [...ids];
 }
 function hashCalibrationAnswerSet(answers) {
-  return createHash12("sha256").update(JSON.stringify(answers.map((answer) => [
+  return createHash13("sha256").update(JSON.stringify(answers.map((answer) => [
     answer.questionId,
     answer.question,
     answer.predicted,
@@ -40985,7 +41111,7 @@ function createMitigatedTarget(config) {
 }
 
 // src/coding-graph/generator.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function createSeededRng3(seed) {
   let state = seed >>> 0;
   return function rng() {
@@ -41014,7 +41140,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 createHash14("sha256").update(input).digest("hex").slice(0, 16);
 }
 function generateSyntheticRepo(config) {
   const rng = createSeededRng3(config.seed);