@remnic/bench 9.6.19 → 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,12 +9452,203 @@ function createClaudeCliProvider(config, deps) {
 
 // src/providers/codex-cli.ts
 import { spawn as spawn2 } from "child_process";
-import { createHash as createHash5, randomUUID } from "crypto";
-import { mkdir as mkdir5, mkdtemp as mkdtemp3, readFile as readFile6, rm as rm3, writeFile as writeFile5 } from "fs/promises";
-import os4 from "os";
-import path7 from "path";
+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";
+
+// src/judges/memcorrect-rubrics.ts
+var OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION = "openai-responses-bench-v1";
+var MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC_VERSION = "memcorrect-correction-acceptance-v1";
+var MEMCORRECT_STALE_HARM_RUBRIC_VERSION = "memcorrect-stale-memory-harm-v1";
+var GENERAL_ANSWER_JUDGE_RUBRIC = [
+  "Grade the predicted benchmark answer against the reference answer.",
+  "A score of 1 means fully correct, 0 means fully incorrect, and values between 0 and 1 mean partially correct.",
+  "Do not reward unsupported claims. Ignore harmless wording and formatting differences."
+].join(" ");
+var MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC = [
+  "Decide whether the memory system accepted the user's correction.",
+  "Pass only when the corrected fact is reflected and the retired fact is not asserted as current.",
+  "A quotation or correction-history record that clearly marks the retired fact as obsolete is not stale recall.",
+  "Use a score of 1 for accepted, 0 for not accepted, and a fractional score only when the evidence is genuinely ambiguous."
+].join(" ");
+var MEMCORRECT_STALE_HARM_RUBRIC = [
+  "Decide whether the memory system avoided stale-memory harm after a correction.",
+  "Pass only when the answer does not present the retired fact as current and does not act on it.",
+  "Correction provenance may mention the retired fact only when it is explicitly identified as obsolete.",
+  "Use a score of 1 when no stale harm is present, 0 when stale information affected the answer, and a fractional score only for genuinely ambiguous evidence."
+].join(" ");
+
+// src/providers/structured-judge.ts
+var VERDICT_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["score", "decision", "reason"],
+  properties: {
+    score: { type: "number", minimum: 0, maximum: 1 },
+    decision: { type: "string", enum: ["pass", "partial", "fail"] },
+    reason: { type: "string" }
+  }
+};
+var ASSISTANT_RUBRIC_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["identity_accuracy", "stance_coherence", "novelty", "calibration", "notes"],
+  properties: {
+    identity_accuracy: { type: "number", minimum: 0, maximum: 5 },
+    stance_coherence: { type: "number", minimum: 0, maximum: 5 },
+    novelty: { type: "number", minimum: 0, maximum: 5 },
+    calibration: { type: "number", minimum: 0, maximum: 5 },
+    notes: { type: "string" }
+  }
+};
+var StructuredJudgeError = class extends Error {
+  code;
+  retryable;
+  httpStatus;
+  telemetry;
+  constructor(failure) {
+    super(failure.error.message);
+    this.name = "StructuredJudgeError";
+    this.code = failure.error.code;
+    this.retryable = failure.error.retryable;
+    this.httpStatus = failure.error.httpStatus;
+    this.telemetry = failure.telemetry;
+  }
+};
+function isStructuredJudgeProvider(provider) {
+  const candidate = provider;
+  return typeof candidate.judge === "function" && typeof candidate.evaluateAssistantRubric === "function";
+}
+function createStructuredBenchJudge(provider, rubricVersion = OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION) {
+  const scoreWithMetrics = async (question, predicted, expected, control) => unwrapJudgeResult(
+    provider,
+    await provider.judge({
+      rubric: GENERAL_ANSWER_JUDGE_RUBRIC,
+      rubricVersion,
+      input: [`QUESTION: ${question}`, `REFERENCE_ANSWER: ${expected}`, `PREDICTED_ANSWER: ${predicted}`].join(
+        "\n\n"
+      ),
+      signal: control?.signal
+    })
+  );
+  const scoreBinaryPrompt = async (prompt, control) => {
+    const result = await provider.judge({
+      rubric: `${GENERAL_ANSWER_JUDGE_RUBRIC} This evaluator is binary: score must be exactly 0 or 1.`,
+      rubricVersion,
+      input: prompt,
+      signal: control?.signal
+    });
+    if (result.ok && result.verdict.score !== 0 && result.verdict.score !== 1) {
+      throwJudgeFailure(provider, {
+        ok: false,
+        error: {
+          code: "malformed_verdict",
+          message: "Structured judge returned a non-binary verdict for a binary rubric.",
+          retryable: false
+        },
+        telemetry: { ...result.telemetry, errorCode: "malformed_verdict" }
+      });
+    }
+    return unwrapJudgeResult(provider, result);
+  };
+  const judgeSpecialized = async (request, rubric, control) => {
+    const result = await provider.judge({
+      rubric: rubric === "correction" ? MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC : MEMCORRECT_STALE_HARM_RUBRIC,
+      rubricVersion: rubric === "correction" ? MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC_VERSION : MEMCORRECT_STALE_HARM_RUBRIC_VERSION,
+      input: serializeMemCorrectJudgeRequest(request),
+      signal: control?.signal
+    });
+    if (!result.ok) {
+      throwJudgeFailure(provider, result);
+    }
+    const base = unwrapJudgeResult(provider, result);
+    return {
+      ...base,
+      decision: result.verdict.decision,
+      reason: result.verdict.reason,
+      rubricVersion: result.telemetry.rubricVersion
+    };
+  };
+  return {
+    async score(question, predicted, expected, control) {
+      return (await scoreWithMetrics(question, predicted, expected, control)).score;
+    },
+    scoreWithMetrics,
+    scoreBinaryPrompt,
+    judgeMemCorrectCorrectionAcceptance: (request, control) => judgeSpecialized(request, "correction", control),
+    judgeMemCorrectStaleMemoryHarm: (request, control) => judgeSpecialized(request, "stale_harm", control)
+  };
+}
+function parseStructuredJudgeVerdict(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const candidate = parsed;
+  if (Object.keys(candidate).sort().join(",") !== "decision,reason,score") return null;
+  if (typeof candidate.score !== "number" || !Number.isFinite(candidate.score) || candidate.score < 0 || candidate.score > 1 || candidate.decision !== "pass" && candidate.decision !== "partial" && candidate.decision !== "fail" || typeof candidate.reason !== "string" || candidate.reason.trim().length === 0) {
+    return null;
+  }
+  return {
+    score: candidate.score,
+    decision: candidate.decision,
+    reason: candidate.reason.trim()
+  };
+}
+function isValidAssistantRubric(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return false;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
+  const candidate = parsed;
+  if (Object.keys(candidate).sort().join(",") !== "calibration,identity_accuracy,notes,novelty,stance_coherence") {
+    return false;
+  }
+  return ["identity_accuracy", "stance_coherence", "novelty", "calibration"].every(
+    (key) => typeof candidate[key] === "number" && Number.isFinite(candidate[key]) && candidate[key] >= 0 && candidate[key] <= 5
+  ) && typeof candidate.notes === "string";
+}
+function serializeMemCorrectJudgeRequest(request) {
+  return JSON.stringify({
+    taskId: request.taskId,
+    query: request.query,
+    retiredContent: request.retiredContent,
+    correctedContent: request.correctedContent,
+    evidence: {
+      postCorrectionRecall: request.postCorrectionRecall,
+      postMaintenanceRecall: request.postMaintenanceRecall,
+      postReingestRecall: request.postReingestRecall
+    }
+  });
+}
+function unwrapJudgeResult(provider, result) {
+  if (!result.ok) {
+    throwJudgeFailure(provider, result);
+  }
+  return {
+    score: result.verdict.score,
+    tokens: {
+      input: result.telemetry.inputTokens,
+      output: result.telemetry.outputTokens
+    },
+    latencyMs: result.telemetry.latencyMs,
+    model: result.telemetry.model
+  };
+}
+function throwJudgeFailure(provider, failure) {
+  throw provider.createJudgeError?.(failure) ?? new StructuredJudgeError(failure);
+}
+
+// src/providers/codex-cli.ts
 var DEFAULT_REASONING_EFFORT = "xhigh";
-var DEFAULT_SERVICE_TIER = "fast";
+var DEFAULT_SERVICE_TIER = "default";
 var CODEX_CLI_STDIO_LIMIT = 64e3;
 var CODEX_CLI_PARENT_SIGNALS = [
   "SIGHUP",
@@ -8987,12 +9659,8 @@ var CODEX_CLI_FORCED_PARENT_EXIT_MS = 1e3;
 var CODEX_CLI_DIAGNOSTICS_DIR_ENV = "REMNIC_BENCH_CODEX_CLI_DIAGNOSTICS_DIR";
 var CODEX_CLI_DIAGNOSTICS_MODE_ENV = "REMNIC_BENCH_CODEX_CLI_DIAGNOSTICS_MODE";
 var CODEX_CLI_EXECUTABLE_ENV = "REMNIC_BENCH_CODEX_CLI_EXECUTABLE";
-var CODEX_CLI_TRANSPORT_ENV = "REMNIC_BENCH_CODEX_CLI_TRANSPORT";
 var CODEX_CLI_VERSION_TIMEOUT_MS = 5e3;
-var CODEX_CLI_HEALTH_CACHE_TTL_MS = 3e4;
-var OPENAI_API_KEY_ENV = "OPENAI_API_KEY";
-var OPENAI_BASE_URL_ENV = "OPENAI_BASE_URL";
-var OPENAI_RESPONSES_BASE_URL = "https://api.openai.com/v1";
+var CODEX_CLI_PRE_START_ABORT_MESSAGE = "Codex CLI aborted before start.";
 var CODEX_CLI_RUNTIME_ENV_ALLOWLIST = /* @__PURE__ */ new Set([
   "ALL_PROXY",
   "APPDATA",
@@ -9010,9 +9678,6 @@ var CODEX_CLI_RUNTIME_ENV_ALLOWLIST = /* @__PURE__ */ new Set([
   "NODE_EXTRA_CA_CERTS",
   "NO_PROXY",
   "NUMBER_OF_PROCESSORS",
-  OPENAI_BASE_URL_ENV,
-  "OPENAI_ORGANIZATION",
-  "OPENAI_PROJECT",
   "OS",
   "PATH",
   "PATHEXT",
@@ -9040,7 +9705,7 @@ var CODEX_CLI_RUNTIME_ENV_ALLOWLIST = /* @__PURE__ */ new Set([
 ]);
 var activeCodexCliChildPids = /* @__PURE__ */ new Set();
 var codexCliParentCleanupInstalled = false;
-var codexCliHealthCache = /* @__PURE__ */ new Map();
+var codexCliLoginStatusCache = /* @__PURE__ */ new Map();
 var CodexCliProvider = class {
   provider = "codex-cli";
   id;
@@ -9048,7 +9713,8 @@ var CodexCliProvider = class {
   config;
   runCodexCli;
   runCodexVersion;
-  shouldProbeCliHealth;
+  runCodexLoginStatus;
+  requiresExactUsage;
   usage = {
     inputTokens: 0,
     outputTokens: 0,
@@ -9058,23 +9724,31 @@ var CodexCliProvider = class {
     this.config = config;
     this.runCodexCli = deps.runCodexCli ?? runCodexCliCommand;
     this.runCodexVersion = deps.runCodexVersion ?? runCodexVersionCommand;
-    this.shouldProbeCliHealth = deps.runCodexCli === void 0;
+    this.runCodexLoginStatus = deps.runCodexLoginStatus ?? runCodexLoginStatusCommand;
+    this.requiresExactUsage = deps.runCodexCli === void 0;
     this.id = `codex-cli:${config.model}`;
     this.name = config.model;
   }
   async complete(prompt, opts = {}) {
+    if (opts.signal?.aborted) {
+      throw codexCliAbortError(opts.signal);
+    }
     const startedAt = performance.now();
-    if (await this.shouldUseResponsesFallback()) {
-      return this.completeViaResponsesApi(prompt, opts, startedAt);
+    const creditBudget = resolveCodexCreditBudgetConfig(
+      process.env,
+      resolveBenchmarkRunId()
+    );
+    if (creditBudget) {
+      await this.assertChatGptCreditAuth();
     }
     const maxAttempts = normalizeCodexCliMaxAttempts(
-      this.config.retryOptions?.maxAttempts
+      creditBudget ? 1 : this.config.retryOptions?.maxAttempts
     );
     let lastError;
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-      const tempDir = await mkdtemp3(path7.join(os4.tmpdir(), "remnic-codex-cli-"));
-      const workspacePath = path7.join(tempDir, "workspace");
-      const outputPath = path7.join(tempDir, "last-message.txt");
+      const tempDir = await mkdtemp3(path8.join(os5.tmpdir(), "remnic-codex-cli-"));
+      const workspacePath = path8.join(tempDir, "workspace");
+      const outputPath = path8.join(tempDir, "last-message.txt");
       let diagnostics;
       let diagnosticsFinished = false;
       const finishDiagnostics = async (outcome) => {
@@ -9085,7 +9759,7 @@ var CodexCliProvider = class {
         await finishCodexCliDiagnostics(diagnostics, startedAt, outcome);
       };
       try {
-        await mkdir5(workspacePath, { recursive: true });
+        await mkdir6(workspacePath, { recursive: true });
         const request = this.buildRunRequest(prompt, opts, workspacePath, outputPath);
         diagnostics = await startCodexCliDiagnostics({
           config: this.config,
@@ -9094,12 +9768,48 @@ var CodexCliProvider = class {
           serviceTier: DEFAULT_SERVICE_TIER,
           retry: { attempt, maxAttempts }
         });
-        const result = await this.runCodexCli(request);
+        const result = creditBudget ? await runWithinCodexCreditBudget({
+          config: creditBudget,
+          model: this.config.model,
+          onUsagePersisted: (usage) => {
+            this.recordUsage(usage.inputTokens, usage.outputTokens);
+          },
+          run: async () => {
+            if (opts.signal?.aborted) {
+              throw codexCliPreStartAbortError(opts.signal);
+            }
+            let value;
+            try {
+              value = await this.runCodexCli(request);
+            } catch (error) {
+              if (error instanceof CodexCreditDispatchError || error instanceof CodexCreditAccountingError) {
+                throw error;
+              }
+              throw new CodexCreditAccountingError(
+                `Codex CLI failed after dispatch; account balance must be reconciled before resuming: ${safeErrorMessage2(error)}`
+              );
+            }
+            const usage = parseCodexJsonlUsage(
+              `${value.stdout}
+${value.stderr}`
+            );
+            if (!usage) {
+              throw new CodexCreditAccountingError(
+                `Codex CLI exited ${value.status ?? "without a status"} without exact turn.completed usage; account balance must be reconciled before resuming.`
+              );
+            }
+            return { value, usage };
+          }
+        }) : await this.runCodexCli(request);
+        const exactUsage = parseCodexJsonlUsage(
+          `${result.stdout}
+${result.stderr}`
+        );
+        if (!creditBudget && exactUsage) {
+          this.recordUsage(exactUsage.inputTokens, exactUsage.outputTokens);
+        }
         if (result.status !== 0) {
-          const exitLabel = result.signal ? `signal ${result.signal}` : `exit ${result.status ?? "unknown"}`;
-          const error = new Error(
-            `Codex CLI completion failed (${exitLabel}): ${summarizeProcessOutput2(result.stderr, result.stdout)}`
-          );
+          const error = codexCliResultError(result);
           if (attempt < maxAttempts && isRetryableCodexCliResult(result)) {
             lastError = error;
             await finishDiagnostics({
@@ -9126,12 +9836,14 @@ var CodexCliProvider = class {
           throw error;
         }
         await finishDiagnostics({ result });
-        const tokens = parseCodexTokenUsage(
-          `${result.stderr}
-${result.stdout}`,
-          text
-        );
-        this.recordUsage(tokens.input, tokens.output);
+        const nativeUsage = exactUsage ?? (this.requiresExactUsage ? requireCodexJsonlUsage(result) : readCodexUsage(result, text));
+        const tokens = {
+          input: nativeUsage.inputTokens,
+          output: nativeUsage.outputTokens
+        };
+        if (!creditBudget && !exactUsage) {
+          this.recordUsage(tokens.input, tokens.output);
+        }
         return {
           text,
           tokens,
@@ -9139,15 +9851,93 @@ ${result.stdout}`,
           model: this.config.model
         };
       } catch (error) {
-        lastError = error;
-        await finishDiagnostics({ error });
-        throw error;
+        const surfacedError = unwrapCodexCliPreStartAbort(error);
+        lastError = surfacedError;
+        await finishDiagnostics({ error: surfacedError });
+        throw surfacedError;
       } finally {
         await rm3(tempDir, { force: true, recursive: true });
       }
     }
     throw lastError instanceof Error ? lastError : new Error(String(lastError));
   }
+  async judge(request) {
+    const startedAt = performance.now();
+    try {
+      const completion = await this.complete(request.input, {
+        systemPrompt: buildCodexStructuredJudgePrompt(request.rubric),
+        temperature: 0,
+        maxTokens: request.maxTokens ?? 256,
+        signal: request.signal
+      });
+      const telemetry = {
+        model: completion.model,
+        rubricVersion: request.rubricVersion,
+        inputTokens: completion.tokens.input,
+        outputTokens: completion.tokens.output,
+        latencyMs: completion.latencyMs
+      };
+      const verdict = parseStructuredJudgeVerdict(completion.text);
+      if (!verdict) {
+        return {
+          ok: false,
+          error: {
+            code: "malformed_verdict",
+            message: "Codex CLI returned a verdict that failed schema validation.",
+            retryable: false
+          },
+          telemetry: { ...telemetry, errorCode: "malformed_verdict" }
+        };
+      }
+      return { ok: true, verdict, telemetry };
+    } catch (error) {
+      const aborted = isCodexStructuredJudgeAbort(error, request.signal);
+      const errorCode = aborted ? "aborted" : "transport_error";
+      return {
+        ok: false,
+        error: {
+          code: errorCode,
+          message: aborted ? "Codex CLI judging was aborted by the caller." : `Codex CLI judging failed (${structuredJudgeErrorName(error)}).`,
+          retryable: false
+        },
+        telemetry: {
+          model: this.config.model,
+          rubricVersion: request.rubricVersion,
+          inputTokens: 0,
+          outputTokens: 0,
+          latencyMs: Math.round(performance.now() - startedAt),
+          errorCode
+        }
+      };
+    }
+  }
+  async evaluateAssistantRubric(request) {
+    const rubricVersion = `sealed:${request.rubricId}`;
+    const completion = await this.complete(request.user, {
+      systemPrompt: buildCodexAssistantRubricPrompt(request.system),
+      temperature: 0,
+      maxTokens: 512
+    });
+    if (isValidAssistantRubric(completion.text)) {
+      return completion.text;
+    }
+    throw new StructuredJudgeError({
+      ok: false,
+      error: {
+        code: "malformed_verdict",
+        message: "Codex CLI returned an invalid sealed assistant-rubric verdict.",
+        retryable: false
+      },
+      telemetry: {
+        model: completion.model,
+        rubricVersion,
+        inputTokens: completion.tokens.input,
+        outputTokens: completion.tokens.output,
+        latencyMs: completion.latencyMs,
+        errorCode: "malformed_verdict"
+      }
+    });
+  }
   async discover() {
     const version = await this.runCodexVersion(
       resolveCodexCliExecutable(this.config),
@@ -9177,6 +9967,26 @@ ${result.stdout}`,
       totalTokens: 0
     };
   }
+  async assertChatGptCreditAuth() {
+    const executable = resolveCodexCliExecutable(this.config);
+    const env = buildIsolatedCodexEnv();
+    const cacheKey = `${executable}\0${env.CODEX_HOME ?? env.HOME ?? ""}`;
+    let check = codexCliLoginStatusCache.get(cacheKey);
+    if (!check) {
+      check = this.runCodexLoginStatus(executable, env).then((result) => {
+        const output = `${result.stdout}
+${result.stderr}`.trim();
+        if (result.status !== 0 || !/logged in using chatgpt/i.test(output)) {
+          throw new Error(
+            `Bounded Codex credit runs require ChatGPT-backed Codex CLI authentication; \`codex login status\` reported: ${output || `exit ${result.status ?? "unknown"}`}`
+          );
+        }
+      });
+      codexCliLoginStatusCache.set(cacheKey, check);
+      check.catch(() => codexCliLoginStatusCache.delete(cacheKey));
+    }
+    await check;
+  }
   recordUsage(inputTokens, outputTokens) {
     this.usage = {
       inputTokens: this.usage.inputTokens + inputTokens,
@@ -9184,126 +9994,57 @@ ${result.stdout}`,
       totalTokens: this.usage.totalTokens + inputTokens + outputTokens
     };
   }
-  async shouldUseResponsesFallback() {
-    const transport = process.env[CODEX_CLI_TRANSPORT_ENV]?.trim().toLowerCase();
-    if (transport === "cli") {
-      return false;
-    }
-    if (transport === "responses") {
-      return true;
-    }
-    if (!this.shouldProbeCliHealth || this.resolveOpenAiApiKey().length === 0) {
-      return false;
-    }
-    return !await this.isCliHealthy();
-  }
-  async isCliHealthy() {
-    const executable = resolveCodexCliExecutable(this.config);
-    const env = buildIsolatedCodexEnv(this.config.apiKey);
-    if (this.runCodexVersion !== runCodexVersionCommand) {
-      return this.probeCliHealth(executable, env);
-    }
-    const cacheKey = `${executable}\0${env.PATH ?? ""}`;
-    const cached = codexCliHealthCache.get(cacheKey);
-    if (cached && Date.now() - cached.checkedAt < CODEX_CLI_HEALTH_CACHE_TTL_MS) {
-      return cached.promise;
-    }
-    if (cached) {
-      codexCliHealthCache.delete(cacheKey);
-    }
-    const promise = this.probeCliHealth(executable, env).then((healthy) => {
-      if (!healthy) {
-        codexCliHealthCache.delete(cacheKey);
-      }
-      return healthy;
-    });
-    codexCliHealthCache.set(cacheKey, { checkedAt: Date.now(), promise });
-    return promise;
-  }
-  async probeCliHealth(executable, env) {
-    try {
-      const version = await this.runCodexVersion(executable, env);
-      return version.status === 0;
-    } catch {
-      return false;
-    }
-  }
-  resolveOpenAiApiKey() {
-    return (this.config.apiKey ?? process.env[OPENAI_API_KEY_ENV] ?? "").trim();
-  }
-  async completeViaResponsesApi(prompt, opts, startedAt) {
-    const apiKey = this.resolveOpenAiApiKey();
-    if (apiKey.length === 0) {
-      throw new Error(
-        `Codex CLI fallback requires ${OPENAI_API_KEY_ENV} or codex-cli apiKey.`
-      );
-    }
-    const serviceTier = responsesApiServiceTier(DEFAULT_SERVICE_TIER);
-    const body = {
-      model: this.config.model,
-      instructions: buildResponsesInstructions(opts.systemPrompt),
-      input: prompt,
-      reasoning: {
-        effort: this.config.reasoningEffort ?? DEFAULT_REASONING_EFFORT
-      },
-      ...serviceTier ? { service_tier: serviceTier } : {},
-      max_output_tokens: Math.max(1, Math.floor(opts.maxTokens ?? 1024)),
-      store: false
-    };
-    const response = await retryFetch(
-      this.responsesApiUrl(),
-      {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization: `Bearer ${apiKey}`
-        },
-        signal: opts.signal,
-        body: JSON.stringify(body)
-      },
-      this.config.retryOptions
-    );
-    if (!response.ok) {
-      throw new Error(
-        `Codex CLI Responses API fallback failed: ${response.status} ${response.statusText}${await readResponseErrorBody(response)}`
-      );
-    }
-    const payload = await response.json();
-    const text = extractResponsesOutputText(payload).trim();
-    if (text.length === 0) {
-      throw new Error("Codex CLI Responses API fallback returned no text.");
-    }
-    const inputTokens = payload.usage?.input_tokens ?? 0;
-    const outputTokens = payload.usage?.output_tokens ?? 0;
-    this.recordUsage(inputTokens, outputTokens);
-    return {
-      text,
-      tokens: { input: inputTokens, output: outputTokens },
-      latencyMs: Math.round(performance.now() - startedAt),
-      model: payload.model ?? this.config.model
-    };
-  }
-  responsesApiUrl() {
-    const baseUrl = (this.config.baseUrl ?? OPENAI_RESPONSES_BASE_URL).replace(
-      /\/$/,
-      ""
-    );
-    return baseUrl.endsWith("/v1") ? `${baseUrl}/responses` : `${baseUrl}/v1/responses`;
-  }
   buildRunRequest(prompt, opts, workspacePath, outputPath) {
     const reasoningEffort = this.config.reasoningEffort ?? DEFAULT_REASONING_EFFORT;
     const args = [
       "exec",
+      "--strict-config",
       "--model",
       this.config.model,
       "--config",
       `model_reasoning_effort=${tomlString(reasoningEffort)}`,
       "--config",
-      `service_tier=${tomlString(DEFAULT_SERVICE_TIER)}`,
-      "--config",
       'approval_policy="never"',
+      "--config",
+      'web_search="disabled"',
+      "--disable",
+      "hooks",
+      "--disable",
+      "shell_tool",
+      "--disable",
+      "unified_exec",
+      "--disable",
+      "apps",
+      "--disable",
+      "plugins",
+      "--disable",
+      "remote_plugin",
+      "--disable",
+      "multi_agent",
+      "--disable",
+      "browser_use",
+      "--disable",
+      "browser_use_external",
+      "--disable",
+      "browser_use_full_cdp_access",
+      "--disable",
+      "computer_use",
+      "--disable",
+      "image_generation",
+      "--disable",
+      "in_app_browser",
+      "--disable",
+      "goals",
+      "--disable",
+      "memories",
+      "--disable",
+      "chronicle",
       "--disable",
-      "codex_hooks",
+      "tool_suggest",
+      "--disable",
+      "workspace_dependencies",
+      "--disable",
+      "shell_snapshot",
       "--ephemeral",
       "--ignore-user-config",
       "--ignore-rules",
@@ -9312,6 +10053,7 @@ ${result.stdout}`,
       "--cd",
       workspacePath,
       "--skip-git-repo-check",
+      "--json",
       "--output-last-message",
       outputPath,
       "-"
@@ -9324,50 +10066,10 @@ ${result.stdout}`,
       workspacePath,
       timeoutMs: this.config.retryOptions?.timeoutMs,
       signal: opts.signal,
-      env: buildIsolatedCodexEnv(this.config.apiKey, this.config.baseUrl)
+      env: buildIsolatedCodexEnv()
     };
   }
 };
-function responsesApiServiceTier(serviceTier) {
-  if (serviceTier === "auto" || serviceTier === "default" || serviceTier === "flex" || serviceTier === "scale" || serviceTier === "priority") {
-    return serviceTier;
-  }
-  return void 0;
-}
-function buildResponsesInstructions(systemPrompt) {
-  return [
-    "You are acting as a benchmark LLM completion endpoint, not as a coding agent.",
-    "Use only the user input and the benchmark system instructions.",
-    "Do not inspect files, run commands, browse, use tools, or use persisted memory.",
-    "Return only the final answer text. If the request asks for JSON, return raw JSON only.",
-    ...systemPrompt?.trim() ? ["", systemPrompt.trim()] : []
-  ].join("\n");
-}
-async function readResponseErrorBody(response) {
-  try {
-    const body = await response.text();
-    return body.trim().length > 0 ? ` \u2014 ${body.slice(0, 1e3)}` : "";
-  } catch {
-    return "";
-  }
-}
-function extractResponsesOutputText(payload) {
-  if (typeof payload.output_text === "string" && payload.output_text.length > 0) {
-    return payload.output_text;
-  }
-  const parts = [];
-  for (const item of payload.output ?? []) {
-    if (typeof item.text === "string" && item.text.length > 0) {
-      parts.push(item.text);
-    }
-    for (const content of item.content ?? []) {
-      if (typeof content.text === "string" && content.text.length > 0 && (content.type === void 0 || content.type.endsWith("_text"))) {
-        parts.push(content.text);
-      }
-    }
-  }
-  return parts.join("\n");
-}
 function runCodexVersionCommand(executable, env) {
   return new Promise((resolve, reject) => {
     const child = spawn2(executable, ["--version"], {
@@ -9425,6 +10127,58 @@ Codex CLI --version timed out after ${CODEX_CLI_VERSION_TIMEOUT_MS}ms.`
     });
   });
 }
+function runCodexLoginStatusCommand(executable, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2(executable, ["login", "status"], {
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32",
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let killTimeout;
+    const terminate = (signal) => {
+      if (child.pid && process.platform !== "win32") {
+        try {
+          process.kill(-child.pid, signal);
+          return;
+        } catch {
+        }
+      }
+      child.kill(signal);
+    };
+    const timeout = setTimeout(() => {
+      stderr = appendBounded2(
+        stderr,
+        `
+Codex CLI login status timed out after ${CODEX_CLI_VERSION_TIMEOUT_MS}ms.`
+      );
+      terminate("SIGTERM");
+      killTimeout = setTimeout(() => terminate("SIGKILL"), 1e3);
+      killTimeout.unref();
+    }, CODEX_CLI_VERSION_TIMEOUT_MS);
+    timeout.unref();
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout = appendBounded2(stdout, chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr = appendBounded2(stderr, chunk);
+    });
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      if (killTimeout) clearTimeout(killTimeout);
+      reject(error);
+    });
+    child.on("close", (status) => {
+      clearTimeout(timeout);
+      if (killTimeout) clearTimeout(killTimeout);
+      resolve({ status, stdout, stderr });
+    });
+  });
+}
 function resolveCodexCliExecutable(config) {
   const configured = config.executable ?? process.env[CODEX_CLI_EXECUTABLE_ENV];
   if (configured === void 0) {
@@ -9436,7 +10190,7 @@ function resolveCodexCliExecutable(config) {
       `${CODEX_CLI_EXECUTABLE_ENV} / codex-cli executable must not be empty`
     );
   }
-  return expandHomeRelativePath2(trimmed);
+  return expandHomeRelativePath3(trimmed);
 }
 function buildCodexCompletionPrompt(userPrompt, systemPrompt) {
   const payload = {
@@ -9454,21 +10208,13 @@ function buildCodexCompletionPrompt(userPrompt, systemPrompt) {
     JSON.stringify(payload, null, 2)
   ].join("\n");
 }
-function buildIsolatedCodexEnv(apiKey, baseUrl) {
+function buildIsolatedCodexEnv() {
   const env = {};
   for (const [key, value] of Object.entries(process.env)) {
     if (value !== void 0 && isAllowedCodexRuntimeEnvKey(key)) {
       env[key] = value;
     }
   }
-  const resolvedApiKey = (apiKey ?? process.env[OPENAI_API_KEY_ENV] ?? "").trim();
-  if (resolvedApiKey.length > 0) {
-    env[OPENAI_API_KEY_ENV] = resolvedApiKey;
-  }
-  const resolvedBaseUrl = (baseUrl ?? process.env[OPENAI_BASE_URL_ENV] ?? "").trim();
-  if (resolvedBaseUrl.length > 0) {
-    env[OPENAI_BASE_URL_ENV] = resolvedBaseUrl;
-  }
   return env;
 }
 function isAllowedCodexRuntimeEnvKey(key) {
@@ -9481,7 +10227,7 @@ async function startCodexCliDiagnostics(args) {
     return void 0;
   }
   try {
-    await mkdir5(diagnosticsDir, { recursive: true, mode: 448 });
+    await mkdir6(diagnosticsDir, { recursive: true, mode: 448 });
     const id = `${Date.now()}-${process.pid}-${randomUUID()}`;
     const promptStats = inspectCodexCompletionPrompt(args.request.input);
     const mode = resolveCodexCliDiagnosticsMode(args.config);
@@ -9494,10 +10240,10 @@ async function startCodexCliDiagnostics(args) {
       model: args.config.model,
       reasoningEffort: args.reasoningEffort,
       serviceTier: args.serviceTier,
-      executable: path7.basename(args.request.executable),
+      executable: path8.basename(args.request.executable),
       ...args.request.timeoutMs ? { timeoutMs: args.request.timeoutMs } : {},
-      workspaceBasename: path7.basename(args.request.workspacePath),
-      outputBasename: path7.basename(args.request.outputPath),
+      workspaceBasename: path8.basename(args.request.workspacePath),
+      outputBasename: path8.basename(args.request.outputPath),
       prompt: promptStats,
       command: {
         args: redactCodexCliArgs(args.request.args)
@@ -9505,7 +10251,7 @@ async function startCodexCliDiagnostics(args) {
       retry: args.retry,
       ...mode === "full" ? { fullPrompt: args.request.input } : {}
     };
-    const filePath = path7.join(diagnosticsDir, `${id}.json`);
+    const filePath = path8.join(diagnosticsDir, `${id}.json`);
     await writeCodexCliDiagnosticRecord(filePath, record);
     return { path: filePath, record };
   } catch {
@@ -9548,7 +10294,7 @@ async function finishCodexCliDiagnostics(handle, startedAt, outcome) {
   }
 }
 async function writeCodexCliDiagnosticRecord(filePath, record) {
-  await writeFile5(filePath, `${JSON.stringify(record, null, 2)}
+  await writeFile6(filePath, `${JSON.stringify(record, null, 2)}
 `, {
     encoding: "utf8",
     mode: 384
@@ -9557,14 +10303,14 @@ async function writeCodexCliDiagnosticRecord(filePath, record) {
 function resolveCodexCliDiagnosticsDir(config) {
   const dir = config.diagnosticsDir ?? process.env[CODEX_CLI_DIAGNOSTICS_DIR_ENV];
   const trimmed = typeof dir === "string" ? dir.trim() : "";
-  return trimmed.length > 0 ? path7.resolve(expandHomeRelativePath2(trimmed)) : void 0;
+  return trimmed.length > 0 ? path8.resolve(expandHomeRelativePath3(trimmed)) : void 0;
 }
-function expandHomeRelativePath2(value) {
+function expandHomeRelativePath3(value) {
   if (value === "~") {
-    return os4.homedir();
+    return os5.homedir();
   }
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path7.join(os4.homedir(), value.slice(2));
+    return path8.join(os5.homedir(), value.slice(2));
   }
   return value;
 }
@@ -9574,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
   };
@@ -9614,13 +10360,7 @@ function redactCodexCliArgs(args) {
 function runCodexCliCommand(request) {
   return new Promise((resolve, reject) => {
     if (request.signal?.aborted) {
-      resolve({
-        status: 124,
-        signal: null,
-        stdout: "",
-        stderr: "Codex CLI aborted before start.",
-        outputText: ""
-      });
+      reject(codexCliPreStartAbortError(request.signal));
       return;
     }
     const child = spawn2(request.executable, request.args, {
@@ -9704,7 +10444,15 @@ Codex CLI stdin error: ${error.code ?? error.message}`
         unregisterActiveCodexCliChild(child.pid);
       }
       request.signal?.removeEventListener("abort", onAbort);
-      reject(error);
+      reject(
+        child.pid ? new Error(
+          `Codex CLI failed after its process started: ${safeErrorMessage2(error)}`,
+          { cause: error }
+        ) : new CodexCreditDispatchError(
+          `Codex CLI could not start: ${safeErrorMessage2(error)}`,
+          { cause: error }
+        )
+      );
     });
     child.on("close", async (status, signal) => {
       if (timeout) {
@@ -9740,10 +10488,17 @@ Codex CLI timed out after ${request.timeoutMs}ms.`
         return;
       }
       try {
-        const outputText = await readCodexOutput(request.outputPath, stdout);
+        const outputText = await readCodexOutput(request.outputPath, status);
         resolve({ status, signal, stdout, stderr, outputText });
       } catch (error) {
-        reject(error);
+        resolve({
+          status,
+          signal,
+          stdout,
+          stderr: appendBounded2(stderr, `
+${safeErrorMessage2(error)}`),
+          outputText: ""
+        });
       }
     });
     try {
@@ -9817,13 +10572,21 @@ function signalExitCode2(signal) {
       return 1;
   }
 }
-async function readCodexOutput(outputPath, stdout) {
+async function readCodexOutput(outputPath, status) {
   try {
-    return await readFile6(outputPath, "utf8");
-  } catch {
-    return stdout;
+    return await readFile7(outputPath, "utf8");
+  } catch (error) {
+    if (status === 0) {
+      throw new Error(
+        `Codex CLI exited successfully but did not write --output-last-message: ${safeErrorMessage2(error)}`
+      );
+    }
+    return "";
   }
 }
+function safeErrorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 function appendBounded2(existing, next) {
   const combined = existing + next;
   if (combined.length <= CODEX_CLI_STDIO_LIMIT) {
@@ -9894,64 +10657,118 @@ function codexCliAbortError(signal) {
   }
   return new DOMException("The operation was aborted.", "AbortError");
 }
+function codexCliPreStartAbortError(signal) {
+  return new CodexCreditDispatchError(CODEX_CLI_PRE_START_ABORT_MESSAGE, {
+    cause: codexCliAbortError(signal)
+  });
+}
+function unwrapCodexCliPreStartAbort(error) {
+  return error instanceof CodexCreditDispatchError && error.message === CODEX_CLI_PRE_START_ABORT_MESSAGE && error.cause instanceof Error ? error.cause : error;
+}
 function summarizeProcessOutput2(stderr, stdout) {
   const summary = [stderr.trim(), stdout.trim()].filter((value) => value.length > 0).join("\n").trim();
   return summary.length > 0 ? summary.slice(-1e3) : "no process output";
 }
-function parseCodexTokenUsage(stderr, outputText) {
-  const totalTokens = parseCodexTotalTokens(stderr);
-  if (totalTokens === void 0) {
-    return { input: 0, output: 0 };
+function requireCodexJsonlUsage(result) {
+  const usage = parseCodexJsonlUsage(`${result.stdout}
+${result.stderr}`);
+  if (!usage) {
+    throw new Error(
+      `Codex CLI completion did not emit a valid turn.completed usage event: ${summarizeProcessOutput2(result.stderr, result.stdout)}`
+    );
   }
-  const estimatedOutputTokens = Math.min(
-    totalTokens,
-    Math.max(1, Math.ceil(outputText.length / 4))
+  return usage;
+}
+function readCodexUsage(result, outputText) {
+  const exact = parseCodexJsonlUsage(`${result.stdout}
+${result.stderr}`);
+  if (exact) return exact;
+  const legacy = parseCodexTokenUsage(
+    `${result.stderr}
+${result.stdout}`,
+    outputText
   );
   return {
-    input: totalTokens - estimatedOutputTokens,
-    output: estimatedOutputTokens
+    inputTokens: legacy.input,
+    cachedInputTokens: 0,
+    outputTokens: legacy.output,
+    reasoningOutputTokens: 0
   };
 }
-function parseCodexTotalTokens(stderr) {
-  const matches = [...stderr.matchAll(/\btokens used\s+([0-9][0-9,]*)\b/gi)];
+function parseCodexTokenUsage(output, outputText) {
+  const matches = [...output.matchAll(/\btokens used\s+([0-9][0-9,]*)\b/gi)];
   const raw = matches.at(-1)?.[1];
-  if (!raw) {
-    return void 0;
+  if (!raw) return { input: 0, output: 0 };
+  const totalTokens = Number(raw.replace(/,/g, ""));
+  if (!Number.isSafeInteger(totalTokens) || totalTokens < 0) {
+    return { input: 0, output: 0 };
   }
-  const parsed = Number(raw.replace(/,/g, ""));
-  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+  const outputTokens = Math.min(
+    totalTokens,
+    Math.max(1, Math.ceil(outputText.length / 4))
+  );
+  return { input: totalTokens - outputTokens, output: outputTokens };
+}
+function codexCliResultError(result) {
+  const exitLabel = result.signal ? `signal ${result.signal}` : `exit ${result.status ?? "unknown"}`;
+  return new Error(
+    `Codex CLI completion failed (${exitLabel}): ${summarizeProcessOutput2(result.stderr, result.stdout)}`
+  );
 }
 function tomlString(value) {
   return JSON.stringify(value);
 }
+function buildCodexStructuredJudgePrompt(rubric) {
+  return [
+    rubric,
+    "Return raw JSON only, with exactly these keys:",
+    '{"score":<number from 0 to 1>,"decision":"pass|partial|fail","reason":"non-empty concise reason"}',
+    "Do not wrap the JSON in Markdown or add any other text."
+  ].join("\n\n");
+}
+function buildCodexAssistantRubricPrompt(systemPrompt) {
+  return [
+    systemPrompt,
+    "Return raw JSON only, with exactly these keys:",
+    '{"identity_accuracy":<0-5>,"stance_coherence":<0-5>,"novelty":<0-5>,"calibration":<0-5>,"notes":"string"}',
+    "Every numeric value must be finite and within the inclusive range 0 to 5.",
+    "Do not wrap the JSON in Markdown or add any other text."
+  ].join("\n\n");
+}
+function isCodexStructuredJudgeAbort(error, signal) {
+  return signal?.aborted === true || error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+function structuredJudgeErrorName(error) {
+  return error instanceof Error && error.name.trim().length > 0 ? error.name : "unknown error";
+}
 function createCodexCliProvider(config, deps) {
   return new CodexCliProvider(config, deps);
 }
 
 // src/reporter.ts
 import { execSync } from "child_process";
-import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
-import path10 from "path";
+import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
+import path11 from "path";
 
 // src/filename-safety.ts
-import path8 from "path";
+import path9 from "path";
 function sanitizeFilenameSegment(value) {
   const sanitized = value.trim().replace(/[^a-zA-Z0-9._-]/g, "_");
   return sanitized.length > 0 ? sanitized : "unknown";
 }
 function resolveContainedPath(root, ...segments) {
-  const outputRoot = path8.resolve(root);
-  const filePath = path8.resolve(outputRoot, ...segments);
-  const relativePath = path8.relative(outputRoot, filePath);
-  if (relativePath === ".." || relativePath.startsWith(`..${path8.sep}`) || path8.isAbsolute(relativePath)) {
+  const outputRoot = path9.resolve(root);
+  const filePath = path9.resolve(outputRoot, ...segments);
+  const relativePath = path9.relative(outputRoot, filePath);
+  if (relativePath === ".." || relativePath.startsWith(`..${path9.sep}`) || path9.isAbsolute(relativePath)) {
     throw new Error(`Refusing to write benchmark artifact outside ${outputRoot}`);
   }
   return filePath;
 }
 
 // src/leaderboard-export.ts
-import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
-import path9 from "path";
+import { mkdir as mkdir7, writeFile as writeFile7 } from "fs/promises";
+import path10 from "path";
 async function writeLeaderboardArtifactsForResult(result, outputDir) {
   if (result.meta.benchmark === "ama-bench") {
     return writeAmaBenchLeaderboard(result, outputDir);
@@ -9966,12 +10783,12 @@ async function writeAmaBenchLeaderboard(result, outputDir) {
   if (rows.length === 0) {
     return [];
   }
-  const outputRoot = path9.resolve(outputDir);
+  const outputRoot = path10.resolve(outputDir);
   const leaderboardDir = resolveContainedPath(outputRoot, "leaderboard");
-  await mkdir6(leaderboardDir, { recursive: true });
+  await mkdir7(leaderboardDir, { recursive: true });
   const timestamp = sanitizeFilenameSegment(result.meta.timestamp.replace(/[:.]/g, "-"));
   const filePath = resolveContainedPath(leaderboardDir, `ama-bench-${timestamp}-answers.jsonl`);
-  await writeFile6(filePath, serializeJsonl(rows), "utf8");
+  await writeFile7(filePath, serializeJsonl(rows), "utf8");
   return [
     {
       benchmark: "ama-bench",
@@ -9984,16 +10801,16 @@ async function writeAmaBenchLeaderboard(result, outputDir) {
 async function writeMemCorrectLeaderboard(result, outputDir) {
   const row = buildMemCorrectLeaderboardRow(result);
   if (!row) return [];
-  const outputRoot = path9.resolve(outputDir);
+  const outputRoot = path10.resolve(outputDir);
   const leaderboardDir = resolveContainedPath(outputRoot, "leaderboard");
-  await mkdir6(leaderboardDir, { recursive: true });
+  await mkdir7(leaderboardDir, { recursive: true });
   const timestamp = sanitizeFilenameSegment(result.meta.timestamp.replace(/[:.]/g, "-"));
   const safeAdapter = sanitizeFilenameSegment(row.adapter);
   const filePath = resolveContainedPath(
     leaderboardDir,
     `memcorrect-${safeAdapter}-${timestamp}.jsonl`
   );
-  await writeFile6(filePath, `${JSON.stringify(row)}
+  await writeFile7(filePath, `${JSON.stringify(row)}
 `, "utf8");
   return [
     {
@@ -10352,8 +11169,8 @@ function replaceLoneSurrogates(value) {
   return out;
 }
 async function writeBenchmarkResult(result, outputDir) {
-  const outputRoot = path10.resolve(outputDir);
-  await mkdir7(outputRoot, { recursive: true });
+  const outputRoot = path11.resolve(outputDir);
+  await mkdir8(outputRoot, { recursive: true });
   const safeBenchmark = sanitizeFilenameSegment(result.meta.benchmark);
   const safeRemnicVersion = sanitizeFilenameSegment(result.meta.remnicVersion);
   const timestamp = sanitizeFilenameSegment(result.meta.timestamp.replace(/[:.]/g, "-"));
@@ -10381,14 +11198,14 @@ async function writeBenchmarkResult(result, outputDir) {
     }
   };
   const publicResult = sanitizeBenchmarkResultForJson(redactBenchmarkResultSecrets(resultWithArtifacts));
-  await writeFile7(filePath, `${JSON.stringify(publicResult, null, 2)}
+  await writeFile8(filePath, `${JSON.stringify(publicResult, null, 2)}
 `);
   return filePath;
 }
 async function getRemnicVersion() {
   try {
     const packageJson = JSON.parse(
-      await readFile7(path10.resolve(import.meta.dirname, "../../../package.json"), "utf8")
+      await readFile8(path11.resolve(import.meta.dirname, "../../../package.json"), "utf8")
     );
     return typeof packageJson.version === "string" ? packageJson.version : "unknown";
   } catch {
@@ -11641,52 +12458,8 @@ function asStringArray(value) {
 // src/responders.ts
 import { FallbackLlmClient } from "@remnic/core";
 
-// src/judges/memcorrect-rubrics.ts
-var OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION = "openai-responses-bench-v1";
-var MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC_VERSION = "memcorrect-correction-acceptance-v1";
-var MEMCORRECT_STALE_HARM_RUBRIC_VERSION = "memcorrect-stale-memory-harm-v1";
-var GENERAL_ANSWER_JUDGE_RUBRIC = [
-  "Grade the predicted benchmark answer against the reference answer.",
-  "A score of 1 means fully correct, 0 means fully incorrect, and values between 0 and 1 mean partially correct.",
-  "Do not reward unsupported claims. Ignore harmless wording and formatting differences."
-].join(" ");
-var MEMCORRECT_CORRECTION_ACCEPTANCE_RUBRIC = [
-  "Decide whether the memory system accepted the user's correction.",
-  "Pass only when the corrected fact is reflected and the retired fact is not asserted as current.",
-  "A quotation or correction-history record that clearly marks the retired fact as obsolete is not stale recall.",
-  "Use a score of 1 for accepted, 0 for not accepted, and a fractional score only when the evidence is genuinely ambiguous."
-].join(" ");
-var MEMCORRECT_STALE_HARM_RUBRIC = [
-  "Decide whether the memory system avoided stale-memory harm after a correction.",
-  "Pass only when the answer does not present the retired fact as current and does not act on it.",
-  "Correction provenance may mention the retired fact only when it is explicitly identified as obsolete.",
-  "Use a score of 1 when no stale harm is present, 0 when stale information affected the answer, and a fractional score only for genuinely ambiguous evidence."
-].join(" ");
-
 // src/providers/openai-responses.ts
 var DEFAULT_OPENAI_RESPONSES_JUDGE_MODEL = "gpt-5.6";
-var VERDICT_JSON_SCHEMA = {
-  type: "object",
-  additionalProperties: false,
-  required: ["score", "decision", "reason"],
-  properties: {
-    score: { type: "number", minimum: 0, maximum: 1 },
-    decision: { type: "string", enum: ["pass", "partial", "fail"] },
-    reason: { type: "string" }
-  }
-};
-var ASSISTANT_RUBRIC_JSON_SCHEMA = {
-  type: "object",
-  additionalProperties: false,
-  required: ["identity_accuracy", "stance_coherence", "novelty", "calibration", "notes"],
-  properties: {
-    identity_accuracy: { type: "number", minimum: 0, maximum: 5 },
-    stance_coherence: { type: "number", minimum: 0, maximum: 5 },
-    novelty: { type: "number", minimum: 0, maximum: 5 },
-    calibration: { type: "number", minimum: 0, maximum: 5 },
-    notes: { type: "string" }
-  }
-};
 var OpenAiResponsesJudgeError = class extends Error {
   code;
   retryable;
@@ -11825,7 +12598,7 @@ var OpenAiResponsesProvider = class {
       this.recordTelemetry(failure.telemetry);
       return failure;
     }
-    const verdict = parseVerdict(parsed.text);
+    const verdict = parseStructuredJudgeVerdict(parsed.text);
     if (!verdict) {
       const failure = this.failure(
         "malformed_verdict",
@@ -11879,7 +12652,7 @@ var OpenAiResponsesProvider = class {
       this.recordTelemetry(parsed.telemetry);
       throw new OpenAiResponsesJudgeError(parsed);
     }
-    if (parsed.text === null || !parseAssistantRubric(parsed.text)) {
+    if (parsed.text === null || !isValidAssistantRubric(parsed.text)) {
       const failure = this.failure(
         "malformed_verdict",
         "OpenAI Responses API returned an invalid sealed assistant-rubric verdict.",
@@ -11901,6 +12674,9 @@ var OpenAiResponsesProvider = class {
   getTelemetryEvents() {
     return this.telemetryEvents.map((event) => ({ ...event }));
   }
+  createJudgeError(failure) {
+    return new OpenAiResponsesJudgeError(failure);
+  }
   async parseResponse(response, startedAt, rubricVersion) {
     let payload;
     try {
@@ -12052,61 +12828,10 @@ function createOpenAiResponsesProvider(config = {}) {
   return new OpenAiResponsesProvider(config);
 }
 function createOpenAiResponsesBenchJudge(config = {}, provider = createOpenAiResponsesProvider(config)) {
-  const scoreWithMetrics = async (question, predicted, expected, control) => {
-    const result = await provider.judge({
-      rubric: GENERAL_ANSWER_JUDGE_RUBRIC,
-      rubricVersion: config.rubricVersion ?? OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION,
-      input: [
-        `QUESTION: ${question}`,
-        `REFERENCE_ANSWER: ${expected}`,
-        `PREDICTED_ANSWER: ${predicted}`
-      ].join("\n\n"),
-      signal: control?.signal
-    });
-    if (!result.ok) throw new OpenAiResponsesJudgeError(result);
-    return toBenchJudgeResult(result);
-  };
-  const scoreBinaryPrompt = async (prompt, control) => {
-    const result = await provider.judge({
-      rubric: `${GENERAL_ANSWER_JUDGE_RUBRIC} This evaluator is binary: score must be exactly 0 or 1.`,
-      rubricVersion: config.rubricVersion ?? OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION,
-      input: prompt,
-      signal: control?.signal
-    });
-    if (!result.ok) throw new OpenAiResponsesJudgeError(result);
-    if (result.verdict.score !== 0 && result.verdict.score !== 1) {
-      const failure = {
-        ok: false,
-        error: {
-          code: "malformed_verdict",
-          message: "OpenAI Responses API returned a non-binary verdict for a binary rubric.",
-          retryable: false
-        },
-        telemetry: { ...result.telemetry, errorCode: "malformed_verdict" }
-      };
-      throw new OpenAiResponsesJudgeError(failure);
-    }
-    return toBenchJudgeResult(result);
-  };
-  const judgeSpecialized = async (request, rubric, control) => {
-    const result = rubric === "correction" ? await judgeMemCorrectCorrectionAcceptance(provider, serializeMemCorrectJudgeRequest(request), control?.signal) : await judgeMemCorrectStaleMemoryHarm(provider, serializeMemCorrectJudgeRequest(request), control?.signal);
-    if (!result.ok) throw new OpenAiResponsesJudgeError(result);
-    return {
-      ...toBenchJudgeResult(result),
-      decision: result.verdict.decision,
-      reason: result.verdict.reason,
-      rubricVersion: result.telemetry.rubricVersion
-    };
-  };
-  return {
-    async score(question, predicted, expected, control) {
-      return (await scoreWithMetrics(question, predicted, expected, control)).score;
-    },
-    scoreWithMetrics,
-    scoreBinaryPrompt,
-    judgeMemCorrectCorrectionAcceptance: (request, control) => judgeSpecialized(request, "correction", control),
-    judgeMemCorrectStaleMemoryHarm: (request, control) => judgeSpecialized(request, "stale_harm", control)
-  };
+  return createStructuredBenchJudge(
+    provider,
+    config.rubricVersion ?? OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION
+  );
 }
 async function judgeMemCorrectCorrectionAcceptance(provider, input, signal) {
   return provider.judge({
@@ -12124,17 +12849,6 @@ async function judgeMemCorrectStaleMemoryHarm(provider, input, signal) {
     signal
   });
 }
-function toBenchJudgeResult(result) {
-  return {
-    score: result.verdict.score,
-    tokens: {
-      input: result.telemetry.inputTokens,
-      output: result.telemetry.outputTokens
-    },
-    latencyMs: result.telemetry.latencyMs,
-    model: result.telemetry.model
-  };
-}
 function normalizeModel(model) {
   if (model === void 0) return DEFAULT_OPENAI_RESPONSES_JUDGE_MODEL;
   const trimmed = model.trim();
@@ -12143,54 +12857,6 @@ function normalizeModel(model) {
   }
   return trimmed;
 }
-function parseVerdict(text) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    return null;
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-  const candidate = parsed;
-  const keys = Object.keys(candidate).sort();
-  if (keys.join(",") !== "decision,reason,score") return null;
-  if (typeof candidate.score !== "number" || !Number.isFinite(candidate.score) || candidate.score < 0 || candidate.score > 1 || candidate.decision !== "pass" && candidate.decision !== "partial" && candidate.decision !== "fail" || typeof candidate.reason !== "string" || candidate.reason.trim().length === 0) {
-    return null;
-  }
-  return {
-    score: candidate.score,
-    decision: candidate.decision,
-    reason: candidate.reason.trim()
-  };
-}
-function parseAssistantRubric(text) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    return false;
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
-  const candidate = parsed;
-  const keys = Object.keys(candidate).sort();
-  if (keys.join(",") !== "calibration,identity_accuracy,notes,novelty,stance_coherence") return false;
-  return ["identity_accuracy", "stance_coherence", "novelty", "calibration"].every(
-    (key) => typeof candidate[key] === "number" && Number.isFinite(candidate[key]) && candidate[key] >= 0 && candidate[key] <= 5
-  ) && typeof candidate.notes === "string";
-}
-function serializeMemCorrectJudgeRequest(request) {
-  return JSON.stringify({
-    taskId: request.taskId,
-    query: request.query,
-    retiredContent: request.retiredContent,
-    correctedContent: request.correctedContent,
-    evidence: {
-      postCorrectionRecall: request.postCorrectionRecall,
-      postMaintenanceRecall: request.postMaintenanceRecall,
-      postReingestRecall: request.postReingestRecall
-    }
-  });
-}
 function readOutputText(payload) {
   const text = (payload.output ?? []).flatMap((item) => item.type === "message" ? item.content ?? [] : []).filter((part) => part.type === "output_text").map((part) => part.text ?? "").join("").trim();
   return text.length > 0 ? text : null;
@@ -12715,10 +13381,11 @@ function createJudgeFromProvider(provider) {
 }
 function createProviderBackedJudge(config, providerInstance) {
   validateProviderConfig(config, "judge");
-  if (config.provider === "openai" && providerInstance === void 0) {
-    return createOpenAiResponsesBenchJudge({ ...config, provider: "openai" });
+  const provider = providerInstance ?? createJudgeProvider(config);
+  if (isStructuredJudgeProvider(provider)) {
+    return createStructuredBenchJudge(provider, config.rubricVersion);
   }
-  return createJudgeFromProvider(providerInstance ?? createProvider(config));
+  return createJudgeFromProvider(provider);
 }
 function createAmaBenchRecommendedJudgeFromProvider(provider) {
   async function scoreWithMetrics(question, predicted, expected, control) {
@@ -12771,15 +13438,16 @@ function createStructuredJudgeFromProvider(provider) {
 }
 function createProviderBackedStructuredJudge(config, providerInstance) {
   validateProviderConfig(config, "judge");
-  if (config.provider === "openai" && providerInstance === void 0) {
-    const provider = createOpenAiResponsesProvider({ ...config, provider: "openai" });
+  const provider = providerInstance ?? createJudgeProvider(config);
+  if (isStructuredJudgeProvider(provider)) {
     return {
       evaluate: (request) => provider.evaluateAssistantRubric(request)
     };
   }
-  return createStructuredJudgeFromProvider(
-    providerInstance ?? createProvider(config)
-  );
+  return createStructuredJudgeFromProvider(provider);
+}
+function createJudgeProvider(config) {
+  return config.provider === "openai" ? createOpenAiResponsesProvider({ ...config, provider: "openai" }) : createProvider(config);
 }
 function createGatewayResponder(options) {
   if (!options.gatewayConfig) {
@@ -13052,8 +13720,8 @@ function clampNormalizedScore(value) {
 }
 
 // src/runtime-profiles.ts
-import path11 from "path";
-import { readFile as readFile9 } from "fs/promises";
+import path12 from "path";
+import { readFile as readFile10 } from "fs/promises";
 import {
   resolvePluginEntry,
   setCodexCliFallbackRunnerForProcess
@@ -13401,7 +14069,7 @@ function buildPromptSpecificRequirements(prompt) {
 }
 
 // src/local-lab/manifest.ts
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 var LOCAL_LAB_PROVIDER_KINDS = [
   "openai-compatible",
   "ollama"
@@ -13438,7 +14106,7 @@ function parseLocalLabManifest(raw) {
 async function loadLocalLabManifest(filePath) {
   let text;
   try {
-    text = await readFile8(filePath, "utf8");
+    text = await readFile9(filePath, "utf8");
   } catch (error) {
     const code = error?.code ?? "EUNKNOWN";
     throw new Error(`local-lab manifest at ${filePath} could not be read (${code})`);
@@ -14099,14 +14767,14 @@ async function loadOpenclawRuntimeConfig(filePath) {
   };
 }
 function deriveOpenclawRuntimeContext(configPath) {
-  const rootDir = path11.dirname(path11.resolve(configPath));
+  const rootDir = path12.dirname(path12.resolve(configPath));
   return {
-    agentDir: path11.join(rootDir, "agents", "main", "agent"),
-    workspaceDir: path11.join(rootDir, "workspace")
+    agentDir: path12.join(rootDir, "agents", "main", "agent"),
+    workspaceDir: path12.join(rootDir, "workspace")
   };
 }
 async function loadJsonObject(filePath, label) {
-  const raw = await readFile9(filePath, "utf8");
+  const raw = await readFile10(filePath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -14518,20 +15186,20 @@ async function resolveLocalLabRuntimeProfile(options) {
 
 // src/benchmark.ts
 import fs2 from "fs";
-import path34 from "path";
-import { createHash as createHash11 } from "crypto";
+import path35 from "path";
+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 mkdir8,
-  readFile as readFile10,
-  rename as rename2,
+  mkdir as mkdir9,
+  readFile as readFile11,
+  rename as rename3,
   rm as rm4,
-  writeFile as writeFile8
+  writeFile as writeFile9
 } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 var JUDGE_CACHE_PROTOCOL_VERSION = "judge-protocol-v1";
 function stableStringify2(value) {
   if (Array.isArray(value)) {
@@ -14562,12 +15230,12 @@ var JudgeCache = class {
   inflight = /* @__PURE__ */ new Map();
   cachedDirExists = false;
   constructor(options) {
-    this.dir = path12.resolve(options.dir);
+    this.dir = path13.resolve(options.dir);
   }
   /** 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
@@ -14587,7 +15255,7 @@ var JudgeCache = class {
     const filePath = this.entryPath(key);
     let raw;
     try {
-      raw = await readFile10(filePath, "utf8");
+      raw = await readFile11(filePath, "utf8");
     } catch {
       return void 0;
     }
@@ -14633,25 +15301,25 @@ var JudgeCache = class {
   }
   async writeOne(key, envelope) {
     if (!this.cachedDirExists) {
-      await mkdir8(this.dir, { recursive: true });
+      await mkdir9(this.dir, { recursive: true });
       this.cachedDirExists = true;
     }
     const filePath = this.entryPath(key);
-    const tempPath = path12.join(
+    const tempPath = path13.join(
       this.dir,
       `.${key}.${randomBytes2(6).toString("hex")}.tmp`
     );
-    await writeFile8(tempPath, `${JSON.stringify(envelope)}
+    await writeFile9(tempPath, `${JSON.stringify(envelope)}
 `, "utf8");
     try {
-      await rename2(tempPath, filePath);
+      await rename3(tempPath, filePath);
     } catch (error) {
       await rm4(tempPath, { force: true }).catch(() => void 0);
       throw error;
     }
   }
   entryPath(key) {
-    return path12.join(this.dir, `${key}.json`);
+    return path13.join(this.dir, `${key}.json`);
   }
 };
 function runJudgeWithCache(options) {
@@ -14762,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",
@@ -14841,8 +15509,8 @@ function isBenchJudgeResult(value) {
 
 // src/benchmarks/published/ama-bench/runner.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile11 } from "fs/promises";
-import path13 from "path";
+import { readFile as readFile12 } from "fs/promises";
+import path14 from "path";
 
 // src/benchmarks/published/ama-bench/fixture.ts
 var AMA_BENCH_SMOKE_FIXTURE = [
@@ -15417,10 +16085,10 @@ async function loadDataset(mode, datasetDir, limit) {
     return episodes;
   };
   if (datasetDir) {
-    const filePath = path13.join(datasetDir, "open_end_qa_set.jsonl");
+    const filePath = path14.join(datasetDir, "open_end_qa_set.jsonl");
     let raw;
     try {
-      raw = await readFile11(filePath, "utf8");
+      raw = await readFile12(filePath, "utf8");
     } catch (error) {
       throw new Error(
         `AMA-Bench dataset not found at ${filePath}: ${error instanceof Error ? error.message : String(error)}`
@@ -15712,8 +16380,8 @@ function isValidQaPairs(value) {
 
 // src/benchmarks/published/amemgym/runner.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { readFile as readFile12 } from "fs/promises";
-import path14 from "path";
+import { readFile as readFile13 } from "fs/promises";
+import path15 from "path";
 
 // src/benchmarks/published/amemgym/fixture.ts
 var AMEMGYM_SMOKE_FIXTURE = [
@@ -16242,7 +16910,7 @@ async function loadDataset2(mode, datasetDir, limit) {
     const datasetErrors = [];
     for (const filename of DATASET_FILENAMES) {
       try {
-        const raw = await readFile12(path14.join(datasetDir, filename), "utf8");
+        const raw = await readFile13(path15.join(datasetDir, filename), "utf8");
         const parsed = parseDataset(raw, filename, normalizedLimit);
         return ensureDatasetProfiles(parsed);
       } catch (error) {
@@ -16416,8 +17084,8 @@ function normalizeRole(role) {
 
 // src/benchmarks/published/memory-arena/runner.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { readFile as readFile13, readdir as readdir5, stat as stat3 } from "fs/promises";
-import path15 from "path";
+import { readFile as readFile14, readdir as readdir5, stat as stat3 } from "fs/promises";
+import path16 from "path";
 import { expandTildePath as expandTildePath2 } from "@remnic/core";
 
 // src/benchmarks/published/memory-arena/fixture.ts
@@ -16744,7 +17412,7 @@ async function loadDataset3(mode, datasetDir, limit) {
       if (remainingLimit2 === 0) {
         break;
       }
-      const raw = await readFile13(path15.join(datasetDir, filename), "utf8");
+      const raw = await readFile14(path16.join(datasetDir, filename), "utf8");
       const parsedTasks = [];
       raw.split("\n").forEach((line, lineIndex) => {
         if (line.trim().length === 0) {
@@ -17080,7 +17748,7 @@ async function loadMemoryArenaWebshopProductCatalog(datasetDir) {
       `MemoryArena WebShop product sidecar is ${sourceStat.size} bytes; provide a compact JSON/JSONL sidecar smaller than ${MEMORY_ARENA_WEBSHOP_PRODUCTS_MAX_BYTES} bytes instead of the full WebShop catalog.`
     );
   }
-  const raw = await readFile13(sourcePath, "utf8");
+  const raw = await readFile14(sourcePath, "utf8");
   const records = parseMemoryArenaWebshopSidecarRecords(raw, sourcePath);
   const byAsin = /* @__PURE__ */ new Map();
   for (const record of records) {
@@ -17100,14 +17768,14 @@ async function loadMemoryArenaWebshopProductCatalog(datasetDir) {
 async function resolveMemoryArenaWebshopProductCatalogPath(datasetDir) {
   const configuredPath = process.env[MEMORY_ARENA_WEBSHOP_PRODUCTS_ENV]?.trim();
   if (configuredPath && configuredPath.length > 0) {
-    return path15.resolve(expandTildePath2(configuredPath));
+    return path16.resolve(expandTildePath2(configuredPath));
   }
   if (datasetDir === void 0) {
     return void 0;
   }
   const candidatePaths = [
     ...MEMORY_ARENA_WEBSHOP_PRODUCT_SIDECAR_FILENAMES
-  ].map((filename) => path15.join(datasetDir, filename));
+  ].map((filename) => path16.join(datasetDir, filename));
   for (const candidatePath of candidatePaths) {
     try {
       const candidateStat = await stat3(candidatePath);
@@ -18529,8 +19197,8 @@ function scoreSubtaskSuccess(scores) {
 import { collectTemporalLexicalCues } from "@remnic/core";
 
 // src/benchmarks/published/dataset-loader.ts
-import { readFile as readFile14 } from "fs/promises";
-import path16 from "path";
+import { readFile as readFile15 } from "fs/promises";
+import path17 from "path";
 
 // src/benchmarks/published/longmemeval/fixture.ts
 var LONG_MEM_EVAL_SMOKE_FIXTURE = [
@@ -18633,10 +19301,10 @@ async function loadDataset4(options) {
   const errors = [];
   if (options.datasetDir) {
     for (const filename of options.filenames) {
-      const abs = path16.join(options.datasetDir, filename);
+      const abs = path17.join(options.datasetDir, filename);
       let raw;
       try {
-        raw = await readFile14(abs, "utf8");
+        raw = await readFile15(abs, "utf8");
       } catch (error) {
         errors.push(
           `${filename}: ${error instanceof Error ? error.message : String(error)}`
@@ -20743,7 +21411,7 @@ function normalizeQaArray(value, location) {
 import { randomUUID as randomUUID6 } from "crypto";
 import { createReadStream as createReadStream2 } from "fs";
 import { readdir as readdir6 } from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 import { createInterface } from "readline/promises";
 import {
   asyncBufferFromFile,
@@ -21214,8 +21882,8 @@ async function listBeamDatasetFiles(datasetDir) {
     return directFiles;
   }
   try {
-    const nestedFilenames = await readdir6(path17.join(datasetDir, "data"));
-    return nestedFilenames.filter((filename) => isBeamDatasetFilename(filename)).map((filename) => path17.join("data", filename));
+    const nestedFilenames = await readdir6(path18.join(datasetDir, "data"));
+    return nestedFilenames.filter((filename) => isBeamDatasetFilename(filename)).map((filename) => path18.join("data", filename));
   } catch {
     return [];
   }
@@ -21242,7 +21910,7 @@ async function* iterateDatasetFiles(datasetDir, datasetFiles, limit) {
   let remainingLimit = limit;
   for (const filename of datasetFiles) {
     const scale = inferScaleFromFilename(filename);
-    const filePath = path17.join(datasetDir, filename);
+    const filePath = path18.join(datasetDir, filename);
     const conversations = filename.endsWith(".jsonl") ? streamJsonlDataset(filePath, filename, remainingLimit) : filename.endsWith(".parquet") ? streamParquetDataset(filePath, filename, remainingLimit) : streamJsonDataset(filePath, filename, remainingLimit);
     for await (const conversation of conversations) {
       yield {
@@ -22253,9 +22921,9 @@ var StructuredLiteralParser = class {
 };
 
 // src/benchmarks/published/personamem/runner.ts
-import { createHash as createHash7, randomUUID as randomUUID7 } from "crypto";
-import { readFile as readFile15, realpath as realpath4 } from "fs/promises";
-import path18 from "path";
+import { createHash as createHash8, randomUUID as randomUUID7 } from "crypto";
+import { readFile as readFile16, realpath as realpath4 } from "fs/promises";
+import path19 from "path";
 
 // src/benchmarks/published/personamem/fixture.ts
 var PERSONAMEM_SMOKE_FIXTURE = [
@@ -22531,10 +23199,10 @@ async function loadDataset8(mode, datasetDir, limit) {
   if (datasetDir) {
     const datasetErrors = [];
     for (const relativePath of DATASET_FILE_CANDIDATES) {
-      const datasetPath = path18.join(datasetDir, relativePath);
+      const datasetPath = path19.join(datasetDir, relativePath);
       let raw;
       try {
-        raw = await readFile15(datasetPath, "utf8");
+        raw = await readFile16(datasetPath, "utf8");
       } catch (error) {
         datasetErrors.push(
           `${relativePath}: ${error instanceof Error ? error.message : String(error)}`
@@ -22592,7 +23260,7 @@ async function hydrateSample(row, datasetRoot) {
     datasetRoot,
     row.chat_history_32k_link
   );
-  const chatHistoryRaw = await readFile15(chatHistoryPath, "utf8");
+  const chatHistoryRaw = await readFile16(chatHistoryPath, "utf8");
   const chatHistory = parseChatHistory(
     chatHistoryRaw,
     row.chat_history_32k_link
@@ -22725,12 +23393,12 @@ function parseCsv(raw, limit) {
   return rows;
 }
 async function resolveDatasetFilePath(datasetRoot, relativePath) {
-  const rootPath = path18.resolve(datasetRoot);
+  const rootPath = path19.resolve(datasetRoot);
   const rootRealPath = await realpath4(rootPath);
-  const candidatePath = path18.resolve(rootPath, relativePath);
+  const candidatePath = path19.resolve(rootPath, relativePath);
   const candidateRealPath = await realpath4(candidatePath);
-  const relativeToRoot = path18.relative(rootRealPath, candidateRealPath);
-  if (relativeToRoot.startsWith("..") || path18.isAbsolute(relativeToRoot)) {
+  const relativeToRoot = path19.relative(rootRealPath, candidateRealPath);
+  if (relativeToRoot.startsWith("..") || path19.isAbsolute(relativeToRoot)) {
     throw new Error(
       `PersonaMem-v2 dataset file reference "${relativePath}" must stay within datasetDir.`
     );
@@ -22858,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);
@@ -23058,8 +23726,8 @@ function applyLimit6(items, limit) {
 
 // src/benchmarks/published/membench/runner.ts
 import { randomUUID as randomUUID8 } from "crypto";
-import { readFile as readFile16, readdir as readdir7 } from "fs/promises";
-import path19 from "path";
+import { readFile as readFile17, readdir as readdir7 } from "fs/promises";
+import path20 from "path";
 
 // src/benchmarks/published/membench/fixture.ts
 var MEMBENCH_SMOKE_FIXTURE = [
@@ -23320,7 +23988,7 @@ async function loadDataset9(mode, datasetDir, limit) {
     let remainingLimit = normalizedLimit;
     for (const filename of filenames) {
       try {
-        const raw = await readFile16(path19.join(datasetDir, filename), "utf8");
+        const raw = await readFile17(path20.join(datasetDir, filename), "utf8");
         const parsed = filename.endsWith(".jsonl") ? parseJsonlDataset(raw, filename) : parseJsonDataset(raw, filename);
         const limitedCases = remainingLimit === 0 ? [] : applyLimit7(parsed, remainingLimit);
         if (limitedCases.length > 0) {
@@ -24187,8 +24855,8 @@ function isPlainObject4(value) {
 
 // src/benchmarks/published/memoryagentbench/runner.ts
 import { randomUUID as randomUUID9 } from "crypto";
-import { access, readFile as readFile17 } from "fs/promises";
-import path20 from "path";
+import { access, readFile as readFile18 } from "fs/promises";
+import path21 from "path";
 
 // src/benchmarks/published/memoryagentbench/fixture.ts
 var MEMORY_AGENT_BENCH_SMOKE_FIXTURE = [
@@ -25210,7 +25878,7 @@ async function loadRecSysEntityMapping(datasetDir) {
     }
     let parsed;
     try {
-      parsed = JSON.parse(await readFile17(candidate, "utf8"));
+      parsed = JSON.parse(await readFile18(candidate, "utf8"));
     } catch (error) {
       console.error(
         `  [WARN] MemoryAgentBench ReDial entity mapping ${candidate} is invalid JSON; trying the next candidate: ${error instanceof Error ? error.message : String(error)}`
@@ -25267,21 +25935,21 @@ function recsysEntityMappingCandidates(datasetDir) {
   if (!datasetDir) {
     return [];
   }
-  const absoluteDatasetDir = path20.resolve(datasetDir);
+  const absoluteDatasetDir = path21.resolve(datasetDir);
   const roots = [
     absoluteDatasetDir,
-    path20.dirname(absoluteDatasetDir)
+    path21.dirname(absoluteDatasetDir)
   ];
   const canonicalSuffixes = [
-    path20.join("processed_data", "Recsys_Redial", "entity2id.json"),
-    path20.join("Recsys_Redial", "entity2id.json")
+    path21.join("processed_data", "Recsys_Redial", "entity2id.json"),
+    path21.join("Recsys_Redial", "entity2id.json")
   ];
   const looseSuffixes = ["entity2id.json"];
   return [
     ...roots.flatMap(
-      (root) => canonicalSuffixes.map((suffix) => path20.join(root, suffix))
+      (root) => canonicalSuffixes.map((suffix) => path21.join(root, suffix))
     ),
-    ...looseSuffixes.map((suffix) => path20.join(absoluteDatasetDir, suffix))
+    ...looseSuffixes.map((suffix) => path21.join(absoluteDatasetDir, suffix))
   ];
 }
 async function fileExists(filePath) {
@@ -25318,7 +25986,7 @@ async function loadDataset10(mode, datasetDir, limit) {
     const datasetErrors = [];
     for (const filename of DATASET_BUNDLE_CANDIDATES) {
       const parsed = await tryReadDatasetFile(
-        path20.join(datasetDir, filename),
+        path21.join(datasetDir, filename),
         filename,
         datasetErrors
       );
@@ -25335,7 +26003,7 @@ async function loadDataset10(mode, datasetDir, limit) {
       let splitData;
       for (const filename of splitConfig.candidates) {
         try {
-          splitData = await readDatasetFile(path20.join(datasetDir, filename), filename);
+          splitData = await readDatasetFile(path21.join(datasetDir, filename), filename);
           break;
         } catch (error) {
           if (!isFileNotFoundError2(error)) {
@@ -25373,7 +26041,7 @@ async function loadDataset10(mode, datasetDir, limit) {
   return ensureDatasetItems(applyLimit8(MEMORY_AGENT_BENCH_SMOKE_FIXTURE, normalizedLimit));
 }
 async function readDatasetFile(filePath, filename) {
-  const raw = await readFile17(filePath, "utf8");
+  const raw = await readFile18(filePath, "utf8");
   const parsed = filename.endsWith(".jsonl") ? parseJsonLines(raw, filename) : parseJsonArray(raw, filename);
   return parsed.map(
     (item, index) => parseMemoryAgentBenchItem(item, `${filename} item ${index + 1}`)
@@ -25983,8 +26651,8 @@ function loadCases(mode, limit) {
 
 // src/benchmarks/remnic/extraction-judge-calibration/runner.ts
 import { randomUUID as randomUUID11 } from "crypto";
-import os5 from "os";
-import path21 from "path";
+import os6 from "os";
+import path22 from "path";
 import {
   createVerdictCache,
   judgeFactDurability,
@@ -26094,8 +26762,8 @@ var extractionJudgeCalibrationDefinition = {
 async function runExtractionJudgeCalibrationBenchmark(options) {
   const cases = loadCases2(options.mode, options.limit);
   const config = parseConfig2({
-    memoryDir: path21.join(os5.tmpdir(), "remnic-bench-extraction-judge"),
-    workspaceDir: path21.join(os5.tmpdir(), "remnic-bench-extraction-judge-workspace"),
+    memoryDir: path22.join(os6.tmpdir(), "remnic-bench-extraction-judge"),
+    workspaceDir: path22.join(os6.tmpdir(), "remnic-bench-extraction-judge-workspace"),
     openaiApiKey: "bench-test-key",
     extractionJudgeEnabled: true,
     extractionJudgeBatchSize: 4,
@@ -26643,8 +27311,8 @@ function constantAggregate2(value) {
 }
 
 // src/benchmarks/remnic/entity-consolidation/runner.ts
-import os6 from "os";
-import path22 from "path";
+import os7 from "os";
+import path23 from "path";
 import { randomUUID as randomUUID13 } from "crypto";
 import { mkdtemp as mkdtemp4, rm as rm5 } from "fs/promises";
 import { StorageManager } from "@remnic/core";
@@ -26807,7 +27475,7 @@ function loadCases4(mode, limit) {
   return limited;
 }
 async function executeCase(sample) {
-  const tmpDir = await mkdtemp4(path22.join(os6.tmpdir(), "remnic-bench-entity-consolidation-"));
+  const tmpDir = await mkdtemp4(path23.join(os7.tmpdir(), "remnic-bench-entity-consolidation-"));
   try {
     const storage = new StorageManager(tmpDir);
     await storage.ensureDirectories();
@@ -26986,9 +27654,9 @@ function parseNonNegativeInt(rawValue) {
 
 // src/benchmarks/remnic/page-versioning/runner.ts
 import { randomUUID as randomUUID14 } from "crypto";
-import { mkdir as mkdir9, mkdtemp as mkdtemp5, readFile as readFile18, rm as rm6, writeFile as writeFile9 } from "fs/promises";
-import os7 from "os";
-import path23 from "path";
+import { mkdir as mkdir10, mkdtemp as mkdtemp5, readFile as readFile19, rm as rm6, writeFile as writeFile10 } from "fs/promises";
+import os8 from "os";
+import path24 from "path";
 import {
   createVersion,
   diffVersions,
@@ -27152,21 +27820,21 @@ function loadCases5(mode, limit) {
   return limited;
 }
 async function executeCase2(sample, dependencies) {
-  const tmpDir = await mkdtemp5(path23.join(os7.tmpdir(), "remnic-bench-page-versioning-"));
+  const tmpDir = await mkdtemp5(path24.join(os8.tmpdir(), "remnic-bench-page-versioning-"));
   try {
-    const factsDir = path23.join(tmpDir, "facts");
-    const pagePath = path23.join(factsDir, `${sample.id}.md`);
-    await mkdir9(factsDir, { recursive: true });
+    const factsDir = path24.join(tmpDir, "facts");
+    const pagePath = path24.join(factsDir, `${sample.id}.md`);
+    await mkdir10(factsDir, { recursive: true });
     const config = versioningConfig();
     switch (sample.scenario) {
       case "revert-flow": {
-        await writeFile9(pagePath, "original content", "utf-8");
+        await writeFile10(pagePath, "original content", "utf-8");
         await dependencies.createVersion(pagePath, "original content", "write", config, void 0, void 0, tmpDir);
-        await writeFile9(pagePath, "modified content", "utf-8");
+        await writeFile10(pagePath, "modified content", "utf-8");
         await dependencies.createVersion(pagePath, "modified content", "write", config, void 0, void 0, tmpDir);
         await dependencies.revertToVersion(pagePath, "1", config, void 0, tmpDir);
         const history = await dependencies.listVersions(pagePath, config, tmpDir);
-        const pageContent = await readFile18(pagePath, "utf-8");
+        const pageContent = await readFile19(pagePath, "utf-8");
         const observed = await dependencies.getVersion(pagePath, "3", config, tmpDir);
         return {
           versionIds: history.versions.map((version) => version.versionId),
@@ -27179,11 +27847,11 @@ async function executeCase2(sample, dependencies) {
         const pruningConfig = versioningConfig({ maxVersionsPerPage: 2 });
         for (let index = 1; index <= 4; index += 1) {
           const content = `content v${index}`;
-          await writeFile9(pagePath, content, "utf-8");
+          await writeFile10(pagePath, content, "utf-8");
           await dependencies.createVersion(pagePath, content, "write", pruningConfig, void 0, void 0, tmpDir);
         }
         const history = await dependencies.listVersions(pagePath, pruningConfig, tmpDir);
-        const pageContent = await readFile18(pagePath, "utf-8");
+        const pageContent = await readFile19(pagePath, "utf-8");
         const prunedIds = [];
         for (const versionId of ["1", "2"]) {
           try {
@@ -27203,7 +27871,7 @@ async function executeCase2(sample, dependencies) {
         };
       }
       case "diff-output": {
-        await writeFile9(pagePath, "line 1\nline 2\nline 3", "utf-8");
+        await writeFile10(pagePath, "line 1\nline 2\nline 3", "utf-8");
         await dependencies.createVersion(
           pagePath,
           "line 1\nline 2\nline 3",
@@ -27213,7 +27881,7 @@ async function executeCase2(sample, dependencies) {
           void 0,
           tmpDir
         );
-        await writeFile9(pagePath, "line 1\nline 2 changed\nline 3\nline 4", "utf-8");
+        await writeFile10(pagePath, "line 1\nline 2 changed\nline 3\nline 4", "utf-8");
         await dependencies.createVersion(
           pagePath,
           "line 1\nline 2 changed\nline 3\nline 4",
@@ -27224,7 +27892,7 @@ async function executeCase2(sample, dependencies) {
           tmpDir
         );
         const history = await dependencies.listVersions(pagePath, config, tmpDir);
-        const pageContent = await readFile18(pagePath, "utf-8");
+        const pageContent = await readFile19(pagePath, "utf-8");
         const diff = await dependencies.diffVersions(pagePath, "1", "2", config, tmpDir);
         const observedLines = normalizeDiffChangedLines(diff);
         return {
@@ -29510,8 +30178,8 @@ function loadCases9(mode, limit) {
 // src/benchmarks/remnic/procedural-recall/runner.ts
 import { randomUUID as randomUUID21 } from "crypto";
 import { mkdtemp as mkdtemp6, rm as rm7 } from "fs/promises";
-import os8 from "os";
-import path24 from "path";
+import os9 from "os";
+import path25 from "path";
 import {
   StorageManager as StorageManager2,
   parseConfig as parseConfig3,
@@ -29641,7 +30309,7 @@ async function runProceduralRecallBenchmark(options) {
   }
   for (const sample of e2eCases) {
     const startedAt = performance.now();
-    const dir = await mkdtemp6(path24.join(os8.tmpdir(), "remnic-bench-procedural-recall-"));
+    const dir = await mkdtemp6(path25.join(os9.tmpdir(), "remnic-bench-procedural-recall-"));
     let section = null;
     try {
       const storage = new StorageManager2(dir);
@@ -29656,7 +30324,7 @@ ${body}`,
       );
       const config = parseConfig3({
         memoryDir: dir,
-        workspaceDir: path24.join(dir, "ws"),
+        workspaceDir: path25.join(dir, "ws"),
         openaiApiKey: "bench-key",
         procedural: {
           enabled: sample.proceduralEnabled !== false,
@@ -29726,9 +30394,9 @@ ${body}`,
 
 // src/benchmarks/remnic/ingestion-entity-recall/runner.ts
 import { randomUUID as randomUUID22 } from "crypto";
-import { mkdtemp as mkdtemp7, writeFile as writeFile10, rm as rm8, mkdir as mkdir10, realpath as realpath5 } from "fs/promises";
+import { mkdtemp as mkdtemp7, writeFile as writeFile11, rm as rm8, mkdir as mkdir11, realpath as realpath5 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import path25 from "path";
+import path26 from "path";
 
 // src/ingestion-scorer.ts
 function normalize(value) {
@@ -30230,13 +30898,13 @@ async function runIngestionEntityRecallBenchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp7(path25.join(tmpdir2(), "bench-email-"));
+  const fixtureDir = await mkdtemp7(path26.join(tmpdir2(), "bench-email-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path25.join(fixtureDir, file.relativePath);
-      await mkdir10(path25.dirname(filePath), { recursive: true });
-      await writeFile10(filePath, file.content, "utf8");
+      const filePath = path26.join(fixtureDir, file.relativePath);
+      await mkdir11(path26.dirname(filePath), { recursive: true });
+      await writeFile11(filePath, file.content, "utf8");
     }
     const { result: ingestionLog, durationMs } = await timed(
       async () => options.ingestionAdapter.ingest(await realpath5(fixtureDir))
@@ -30363,9 +31031,9 @@ async function buildResult(options, tasks, totalLatencyMs) {
 
 // src/benchmarks/remnic/ingestion-schema-completeness/runner.ts
 import { randomUUID as randomUUID23 } from "crypto";
-import { mkdtemp as mkdtemp8, writeFile as writeFile11, rm as rm9, mkdir as mkdir11, realpath as realpath6 } from "fs/promises";
+import { mkdtemp as mkdtemp8, writeFile as writeFile12, rm as rm9, mkdir as mkdir12, realpath as realpath6 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import path26 from "path";
+import path27 from "path";
 var ingestionSchemaCompletenessDefinition = {
   id: "ingestion-schema-completeness",
   title: "Ingestion: Schema Completeness",
@@ -30384,13 +31052,13 @@ async function runIngestionSchemaCompletenessBenchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp8(path26.join(tmpdir3(), "bench-email-"));
+  const fixtureDir = await mkdtemp8(path27.join(tmpdir3(), "bench-email-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path26.join(fixtureDir, file.relativePath);
-      await mkdir11(path26.dirname(filePath), { recursive: true });
-      await writeFile11(filePath, file.content, "utf8");
+      const filePath = path27.join(fixtureDir, file.relativePath);
+      await mkdir12(path27.dirname(filePath), { recursive: true });
+      await writeFile12(filePath, file.content, "utf8");
     }
     const { result: ingestionLog, durationMs } = await timed(
       async () => options.ingestionAdapter.ingest(await realpath6(fixtureDir))
@@ -30536,9 +31204,9 @@ async function runIngestionSchemaCompletenessBenchmark(options) {
 
 // src/benchmarks/remnic/ingestion-backlink-f1/runner.ts
 import { randomUUID as randomUUID24 } from "crypto";
-import { mkdtemp as mkdtemp9, writeFile as writeFile12, rm as rm10, mkdir as mkdir12, realpath as realpath7 } from "fs/promises";
+import { mkdtemp as mkdtemp9, writeFile as writeFile13, rm as rm10, mkdir as mkdir13, realpath as realpath7 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import path27 from "path";
+import path28 from "path";
 var ingestionBacklinkF1Definition = {
   id: "ingestion-backlink-f1",
   title: "Ingestion: Backlink F1",
@@ -30557,13 +31225,13 @@ async function runIngestionBacklinkF1Benchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp9(path27.join(tmpdir4(), "bench-email-"));
+  const fixtureDir = await mkdtemp9(path28.join(tmpdir4(), "bench-email-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path27.join(fixtureDir, file.relativePath);
-      await mkdir12(path27.dirname(filePath), { recursive: true });
-      await writeFile12(filePath, file.content, "utf8");
+      const filePath = path28.join(fixtureDir, file.relativePath);
+      await mkdir13(path28.dirname(filePath), { recursive: true });
+      await writeFile13(filePath, file.content, "utf8");
     }
     const { result: ingestionLog, durationMs } = await timed(
       async () => options.ingestionAdapter.ingest(await realpath7(fixtureDir))
@@ -30637,9 +31305,9 @@ async function runIngestionBacklinkF1Benchmark(options) {
 
 // src/benchmarks/remnic/ingestion-setup-friction/runner.ts
 import { randomUUID as randomUUID25 } from "crypto";
-import { mkdtemp as mkdtemp10, writeFile as writeFile13, rm as rm11, mkdir as mkdir13, realpath as realpath8 } from "fs/promises";
+import { mkdtemp as mkdtemp10, writeFile as writeFile14, rm as rm11, mkdir as mkdir14, realpath as realpath8 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
-import path28 from "path";
+import path29 from "path";
 var INGESTION_SETUP_FRICTION_LOWER_IS_BETTER = /* @__PURE__ */ new Set(["setup_friction", "commands_count", "prompts_count", "errors_count"]);
 var ingestionSetupFrictionDefinition = {
   id: "ingestion-setup-friction",
@@ -30659,13 +31327,13 @@ async function runIngestionSetupFrictionBenchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp10(path28.join(tmpdir5(), "bench-friction-"));
+  const fixtureDir = await mkdtemp10(path29.join(tmpdir5(), "bench-friction-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path28.join(fixtureDir, file.relativePath);
-      await mkdir13(path28.dirname(filePath), { recursive: true });
-      await writeFile13(filePath, file.content, "utf8");
+      const filePath = path29.join(fixtureDir, file.relativePath);
+      await mkdir14(path29.dirname(filePath), { recursive: true });
+      await writeFile14(filePath, file.content, "utf8");
     }
     const { result: ingestionLog, durationMs } = await timed(
       async () => options.ingestionAdapter.ingest(await realpath8(fixtureDir))
@@ -30743,9 +31411,9 @@ async function runIngestionSetupFrictionBenchmark(options) {
 
 // src/benchmarks/remnic/ingestion-citation-accuracy/runner.ts
 import { randomUUID as randomUUID26 } from "crypto";
-import { mkdtemp as mkdtemp11, writeFile as writeFile14, rm as rm12, mkdir as mkdir14, realpath as realpath9 } from "fs/promises";
+import { mkdtemp as mkdtemp11, writeFile as writeFile15, rm as rm12, mkdir as mkdir15, realpath as realpath9 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import path29 from "path";
+import path30 from "path";
 var CITATION_SUPPORT_THRESHOLD = 0.72;
 var ingestionCitationAccuracyDefinition = {
   id: "ingestion-citation-accuracy",
@@ -30804,10 +31472,10 @@ function resolveCitedSources(sourceRefs, seeAlso, pageRef, sourceContentMap) {
     return "";
   }
   for (const ref of normalizedRefs) {
-    const refBase = path29.basename(ref).toLowerCase();
+    const refBase = path30.basename(ref).toLowerCase();
     let matched = false;
     for (const [relativePath, content] of sourceContentMap) {
-      if (relativePath === ref || relativePath.endsWith(ref) || path29.basename(relativePath).toLowerCase() === refBase) {
+      if (relativePath === ref || relativePath.endsWith(ref) || path30.basename(relativePath).toLowerCase() === refBase) {
         resolved.push(content);
         matched = true;
         break;
@@ -30823,9 +31491,9 @@ function resolveCitedSources(sourceRefs, seeAlso, pageRef, sourceContentMap) {
   if (normalizedRefs.length > 0) {
     return "";
   }
-  const pageBase = path29.basename(pageRef).toLowerCase();
+  const pageBase = path30.basename(pageRef).toLowerCase();
   for (const [relativePath, content] of sourceContentMap) {
-    if (path29.basename(relativePath).toLowerCase() === pageBase) {
+    if (path30.basename(relativePath).toLowerCase() === pageBase) {
       return content;
     }
   }
@@ -30836,13 +31504,13 @@ async function runIngestionCitationAccuracyBenchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp11(path29.join(tmpdir6(), "bench-citation-"));
+  const fixtureDir = await mkdtemp11(path30.join(tmpdir6(), "bench-citation-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path29.join(fixtureDir, file.relativePath);
-      await mkdir14(path29.dirname(filePath), { recursive: true });
-      await writeFile14(filePath, file.content, "utf8");
+      const filePath = path30.join(fixtureDir, file.relativePath);
+      await mkdir15(path30.dirname(filePath), { recursive: true });
+      await writeFile15(filePath, file.content, "utf8");
     }
     const benchmarkStart = performance.now();
     const { result: ingestionLog, durationMs: ingestionDurationMs } = await timed(
@@ -31227,7 +31895,7 @@ var ASSISTANT_MORNING_BRIEF_SMOKE_SCENARIOS = ASSISTANT_MORNING_BRIEF_SCENARIOS.
 
 // src/benchmarks/remnic/_assistant-common/runner.ts
 import { randomUUID as randomUUID27 } from "crypto";
-import path31 from "path";
+import path32 from "path";
 
 // src/run-seeds.ts
 function buildBenchmarkRunSeeds(runCount, baseSeed) {
@@ -31317,9 +31985,9 @@ 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 path30 from "path";
+import path31 from "path";
 
 // src/judges/sealed-prompts/assistant-rubric-v1.ts
 var ASSISTANT_RUBRIC_V1 = `# Assistant rubric v1 (sealed)
@@ -31426,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 };
 }
@@ -31599,7 +32267,7 @@ function createSpotCheckFileLogger(options) {
     return { log() {
     } };
   }
-  const logPath = path30.join(directory, `${runId}.jsonl`);
+  const logPath = path31.join(directory, `${runId}.jsonl`);
   let written = 0;
   let warnedOnWriteFailure = false;
   const cap = typeof sampleSize === "number" && sampleSize > 0 ? sampleSize : 5;
@@ -31688,7 +32356,7 @@ async function runAssistantBenchmark(definition, scenarios, resolved, runnerOpti
   const runId = buildRunId(definition.id);
   const spotCheckLogger = createSpotCheckFileLogger({
     runId,
-    directory: runnerOptions.spotCheckDir ?? path31.join(process.cwd(), "benchmarks", "results", "spot-checks"),
+    directory: runnerOptions.spotCheckDir ?? path32.join(process.cwd(), "benchmarks", "results", "spot-checks"),
     sampleRate: 0.35,
     sampleSize: 5
   });
@@ -32337,9 +33005,9 @@ async function runAssistantSynthesisBenchmark(options) {
 
 // src/benchmarks/remnic/buffer-surprise-trigger/runner.ts
 import { randomUUID as randomUUID28 } from "crypto";
-import path32 from "path";
-import os9 from "os";
-import { mkdir as mkdir15, rm as rm13 } from "fs/promises";
+import path33 from "path";
+import os10 from "os";
+import { mkdir as mkdir16, rm as rm13 } from "fs/promises";
 import {
   SmartBuffer,
   computeSurprise,
@@ -32568,11 +33236,11 @@ function hasExplicitTopicPivotCue(text) {
 }
 async function runBufferSurpriseTriggerBenchmark(options) {
   const cases = loadCases10(options.mode, options.limit);
-  const tmpRoot = path32.join(
-    os9.tmpdir(),
+  const tmpRoot = path33.join(
+    os10.tmpdir(),
     `remnic-bench-buffer-surprise-${randomUUID28()}`
   );
-  await mkdir15(tmpRoot, { recursive: true });
+  await mkdir16(tmpRoot, { recursive: true });
   const tasks = [];
   const startedAt = performance.now();
   try {
@@ -32637,12 +33305,12 @@ async function runBufferSurpriseTriggerBenchmark(options) {
   };
 }
 async function runSingleCase(caseDef, options) {
-  const memoryDir = path32.join(
+  const memoryDir = path33.join(
     options.tmpRoot,
     `${caseDef.id}-${options.label}`
   );
-  const workspaceDir = path32.join(memoryDir, "workspace");
-  await mkdir15(workspaceDir, { recursive: true });
+  const workspaceDir = path33.join(memoryDir, "workspace");
+  await mkdir16(workspaceDir, { recursive: true });
   const config = parseConfig4({
     memoryDir,
     workspaceDir,
@@ -33629,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 = [
@@ -33953,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
@@ -34904,11 +35572,11 @@ async function runMemCorrectBenchmark(options) {
 
 // src/benchmarks/remnic/bounded-memory-contracts/runner.ts
 import { randomUUID as randomUUID32 } from "crypto";
-import { mkdir as mkdir16, writeFile as writeFile15 } from "fs/promises";
-import path33 from "path";
+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";
@@ -35391,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
@@ -36137,24 +36805,24 @@ async function runBoundedMemoryContractsBenchmark(options) {
   };
 }
 async function writeArtifacts(outputDir, byCondition, conditionAggregates, tasks) {
-  const root = path33.resolve(outputDir);
-  await mkdir16(path33.join(root, "conditions"), { recursive: true });
-  await mkdir16(path33.join(root, "prompts"), { recursive: true });
-  await mkdir16(path33.join(root, "retrieval"), { recursive: true });
-  await mkdir16(path33.join(root, "scores"), { recursive: true });
+  const root = path34.resolve(outputDir);
+  await mkdir17(path34.join(root, "conditions"), { recursive: true });
+  await mkdir17(path34.join(root, "prompts"), { recursive: true });
+  await mkdir17(path34.join(root, "retrieval"), { recursive: true });
+  await mkdir17(path34.join(root, "scores"), { recursive: true });
   const csvRows = [
     "task_id,condition,family,scope,task_success,should_ask_accuracy,relevant_memory_recall,stale_memory_harm_rate,wrong_scope_retrieval_rate,supersession_respected_rate,citation_coverage,memory_tokens_injected,retrieved_item_count,compression_ratio_vs_raw_transcript"
   ];
   for (const condition of BOUNDED_MEMORY_CONDITIONS) {
     const results = byCondition.get(condition);
-    const condDir = path33.join(root, "conditions", condition);
-    await mkdir16(condDir, { recursive: true });
+    const condDir = path34.join(root, "conditions", condition);
+    await mkdir17(condDir, { recursive: true });
     for (const { task, pack, decision } of results) {
       const scores = scoreTaskPair(task, pack, decision);
       const promptMd = renderPromptPack(task, condition, pack);
-      const promptPath = path33.join(root, "prompts", `${task.id}.${condition}.md`);
-      await mkdir16(path33.dirname(promptPath), { recursive: true });
-      await writeFile15(promptPath, promptMd, "utf8");
+      const promptPath = path34.join(root, "prompts", `${task.id}.${condition}.md`);
+      await mkdir17(path34.dirname(promptPath), { recursive: true });
+      await writeFile16(promptPath, promptMd, "utf8");
       const retrievalJson = `${JSON.stringify(
         {
           taskId: task.id,
@@ -36177,8 +36845,8 @@ async function writeArtifacts(outputDir, byCondition, conditionAggregates, tasks
         2
       )}
 `;
-      const retrievalPath = path33.join(root, "retrieval", `${task.id}.${condition}.json`);
-      await writeFile15(retrievalPath, retrievalJson, "utf8");
+      const retrievalPath = path34.join(root, "retrieval", `${task.id}.${condition}.json`);
+      await writeFile16(retrievalPath, retrievalJson, "utf8");
       csvRows.push(
         [
           task.id,
@@ -36198,24 +36866,24 @@ async function writeArtifacts(outputDir, byCondition, conditionAggregates, tasks
         ].join(",")
       );
     }
-    await writeFile15(
-      path33.join(condDir, "summary.json"),
+    await writeFile16(
+      path34.join(condDir, "summary.json"),
       `${JSON.stringify(conditionAggregates[condition], null, 2)}
 `,
       "utf8"
     );
   }
-  await writeFile15(path33.join(root, "scores", "per-task.csv"), `${csvRows.join("\n")}
+  await writeFile16(path34.join(root, "scores", "per-task.csv"), `${csvRows.join("\n")}
 `, "utf8");
-  await writeFile15(
-    path33.join(root, "scores", "aggregate.json"),
+  await writeFile16(
+    path34.join(root, "scores", "aggregate.json"),
     `${JSON.stringify(conditionAggregates, null, 2)}
 `,
     "utf8"
   );
   const report = renderReportMarkdown(tasks, conditionAggregates);
-  await writeFile15(path33.join(root, "report.md"), report, "utf8");
-  return path33.join(root, "report.md");
+  await writeFile16(path34.join(root, "report.md"), report, "utf8");
+  return path34.join(root, "report.md");
 }
 function renderPromptPack(task, condition, pack) {
   const lines = [];
@@ -36440,8 +37108,8 @@ function finalizeBenchmarkResultConfig(result, options) {
 }
 
 // src/benchmark.ts
-var DEFAULT_BASELINE_PATH = path34.join(process.cwd(), "benchmarks", "baseline.json");
-var DEFAULT_REPORT_PATH = path34.join(process.cwd(), "benchmarks", "report.json");
+var DEFAULT_BASELINE_PATH = path35.join(process.cwd(), "benchmarks", "baseline.json");
+var DEFAULT_REPORT_PATH = path35.join(process.cwd(), "benchmarks", "report.json");
 var BASELINE_VERSION = 1;
 var DEFAULT_TOLERANCE = 10;
 var DEFAULT_FULL_RUN_COUNT = 5;
@@ -36519,7 +37187,7 @@ async function runBenchmark(benchmarkId, options) {
     if (!willWrapPrimary && !willWrapCross) {
       return void 0;
     }
-    const cacheDir = options.judgeCacheDir ? path34.resolve(expandTildePath3(options.judgeCacheDir)) : options.outputDir ? path34.join(path34.resolve(expandTildePath3(options.outputDir)), "judge-cache") : void 0;
+    const cacheDir = options.judgeCacheDir ? path35.resolve(expandTildePath3(options.judgeCacheDir)) : options.outputDir ? path35.join(path35.resolve(expandTildePath3(options.outputDir)), "judge-cache") : void 0;
     if (cacheDir === void 0) {
       return void 0;
     }
@@ -36651,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
@@ -36718,7 +37386,7 @@ function loadBaseline(baselinePath) {
   return raw;
 }
 function saveBaseline(baselinePath, baseline) {
-  fs2.mkdirSync(path34.dirname(baselinePath), { recursive: true });
+  fs2.mkdirSync(path35.dirname(baselinePath), { recursive: true });
   fs2.writeFileSync(baselinePath, `${JSON.stringify(baseline, null, 2)}
 `);
 }
@@ -36948,7 +37616,7 @@ function generateReport(results, reportPath) {
     totalDurationMs: results.reduce((sum, result) => sum + result.totalDurationMs, 0)
   };
   if (reportPath) {
-    fs2.mkdirSync(path34.dirname(reportPath), { recursive: true });
+    fs2.mkdirSync(path35.dirname(reportPath), { recursive: true });
     fs2.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}
 `);
   }
@@ -37363,7 +38031,7 @@ function formatSignedScore(value) {
 }
 
 // src/integrity/sealed-qrels.ts
-import { readFile as readFile19 } from "fs/promises";
+import { readFile as readFile20 } from "fs/promises";
 function isSealedQrelsArtifact(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -37433,7 +38101,7 @@ function parseSealedQrels(raw, options = {}) {
   };
 }
 async function loadSealedQrels(filePath, options = {}) {
-  const raw = await readFile19(filePath, "utf8");
+  const raw = await readFile20(filePath, "utf8");
   return parseSealedQrels(raw, options);
 }
 function serializeSealedQrels(artifact) {
@@ -37553,7 +38221,7 @@ function selectFixtureVariant(variants, seed) {
 }
 
 // src/benchmarks/custom/loader.ts
-import { readFile as readFile20 } from "fs/promises";
+import { readFile as readFile21 } from "fs/promises";
 import { parse as parseYaml } from "yaml";
 var CUSTOM_SCORING_VALUES = /* @__PURE__ */ new Set([
   "exact_match",
@@ -37573,7 +38241,7 @@ function parseCustomBenchmark(source) {
 async function loadCustomBenchmarkFile(filePath) {
   let source;
   try {
-    source = await readFile20(filePath, "utf8");
+    source = await readFile21(filePath, "utf8");
   } catch (error) {
     throw new Error(
       `Failed to read custom benchmark file ${filePath}: ${formatError(error)}`
@@ -37681,7 +38349,7 @@ function formatError(error) {
 
 // src/benchmarks/custom/runner.ts
 import { randomUUID as randomUUID33 } from "crypto";
-import path35 from "path";
+import path36 from "path";
 import { expandTildePath as expandTildePath4 } from "@remnic/core";
 async function runCustomBenchmarkFile(filePath, options) {
   const spec = await loadCustomBenchmarkFile(filePath);
@@ -37694,7 +38362,7 @@ async function runCustomBenchmarkFile(filePath, options) {
   let cacheRestore;
   let cacheCounters;
   if (spec.scoring === "llm_judge" && runOptions.system.judge !== void 0 && !runOptions.noJudgeCache && (runOptions.judgeProvider ?? null) !== null) {
-    const cacheDir = runOptions.judgeCacheDir ? path35.resolve(expandTildePath4(runOptions.judgeCacheDir)) : runOptions.outputDir ? path35.join(path35.resolve(expandTildePath4(runOptions.outputDir)), "judge-cache") : void 0;
+    const cacheDir = runOptions.judgeCacheDir ? path36.resolve(expandTildePath4(runOptions.judgeCacheDir)) : runOptions.outputDir ? path36.join(path36.resolve(expandTildePath4(runOptions.outputDir)), "judge-cache") : void 0;
     if (cacheDir !== void 0) {
       const originalJudge = runOptions.system.judge;
       const wrapped = wrapJudgeWithCache({
@@ -37895,7 +38563,7 @@ async function scoreTask(scoring, options, question, actual, expected) {
   }
 }
 function createCustomBenchmarkDefinition(benchmark, filePath) {
-  const id = `custom:${slugify(path35.basename(filePath, path35.extname(filePath)) || benchmark.name)}`;
+  const id = `custom:${slugify(path36.basename(filePath, path36.extname(filePath)) || benchmark.name)}`;
   return {
     id,
     title: benchmark.name,
@@ -38765,9 +39433,9 @@ var chatFixture = {
 };
 
 // src/judges/calibration-slice.ts
-import { createHash as createHash12, randomBytes as randomBytes3 } from "crypto";
-import { mkdir as mkdir17, readFile as readFile21, rename as rename3, unlink as unlink3, writeFile as writeFile16 } from "fs/promises";
-import path36 from "path";
+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";
 
 // src/judges/cohen-kappa.ts
 var DEFAULT_KAPPA_BOOTSTRAP_SAMPLES = 2e3;
@@ -38912,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));
@@ -38987,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,
@@ -38995,7 +39663,7 @@ function hashCalibrationAnswerSet(answers) {
   ]))).digest("hex");
 }
 async function writeJudgeCalibrationState(result, calibrationDir, identities, provenance) {
-  await mkdir17(calibrationDir, { recursive: true });
+  await mkdir18(calibrationDir, { recursive: true });
   const state = {
     kappa: result.kappa,
     sampleSize: result.sampleSize,
@@ -39008,23 +39676,23 @@ async function writeJudgeCalibrationState(result, calibrationDir, identities, pr
     ...provenance ? provenance : {},
     ...identities ? identities : {}
   };
-  const filePath = path36.join(calibrationDir, `${sanitizeCalibrationSegment(result.benchmarkId)}.json`);
+  const filePath = path37.join(calibrationDir, `${sanitizeCalibrationSegment(result.benchmarkId)}.json`);
   const tempPath = `${filePath}.${randomBytes3(6).toString("hex")}.tmp`;
-  await writeFile16(tempPath, `${JSON.stringify(state, null, 2)}
+  await writeFile17(tempPath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
   try {
-    await rename3(tempPath, filePath);
+    await rename4(tempPath, filePath);
   } catch (error) {
-    await unlink3(tempPath).catch(() => void 0);
+    await unlink4(tempPath).catch(() => void 0);
     throw error;
   }
   return filePath;
 }
 async function loadJudgeCalibrationState(benchmarkId, calibrationDir) {
-  const filePath = path36.join(calibrationDir, `${sanitizeCalibrationSegment(benchmarkId)}.json`);
+  const filePath = path37.join(calibrationDir, `${sanitizeCalibrationSegment(benchmarkId)}.json`);
   let raw;
   try {
-    raw = await readFile21(filePath, "utf8");
+    raw = await readFile22(filePath, "utf8");
   } catch {
     return void 0;
   }
@@ -39108,9 +39776,9 @@ function sanitizeCalibrationSegment(value) {
 }
 
 // src/benchmarks/remnic/procedural-recall/ablation.ts
-import { mkdir as mkdir18, mkdtemp as mkdtemp12, rm as rm14, writeFile as writeFile17, readFile as readFile22 } from "fs/promises";
-import os10 from "os";
-import path37 from "path";
+import { mkdir as mkdir19, mkdtemp as mkdtemp12, rm as rm14, writeFile as writeFile18, readFile as readFile23 } from "fs/promises";
+import os11 from "os";
+import path38 from "path";
 import {
   StorageManager as StorageManager3,
   parseConfig as parseConfig5,
@@ -39141,7 +39809,7 @@ async function runSide(scenarios, proceduralEnabled) {
   const observed = [];
   for (const scenario of scenarios) {
     const dir = await mkdtemp12(
-      path37.join(os10.tmpdir(), "remnic-bench-proc-ablation-")
+      path38.join(os11.tmpdir(), "remnic-bench-proc-ablation-")
     );
     try {
       const storage = new StorageManager3(dir);
@@ -39156,7 +39824,7 @@ ${body}`,
       );
       const config = parseConfig5({
         memoryDir: dir,
-        workspaceDir: path37.join(dir, "ws"),
+        workspaceDir: path38.join(dir, "ws"),
         openaiApiKey: "bench-key",
         procedural: {
           enabled: proceduralEnabled,
@@ -39231,7 +39899,7 @@ async function runProceduralAblation(options) {
   };
 }
 async function loadAblationFixture(fixturePath) {
-  const raw = await readFile22(fixturePath, "utf8");
+  const raw = await readFile23(fixturePath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -39327,9 +39995,9 @@ async function runProceduralAblationCli(args) {
     random: args.random,
     seed: args.seed
   });
-  const outDir = path37.dirname(path37.resolve(args.outPath));
-  await mkdir18(outDir, { recursive: true });
-  await writeFile17(args.outPath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
+  const outDir = path38.dirname(path38.resolve(args.outPath));
+  await mkdir19(outDir, { recursive: true });
+  await writeFile18(args.outPath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
   return artifact;
 }
 
@@ -40443,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() {
@@ -40472,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);
@@ -40570,8 +41238,8 @@ import { performance as performance2 } from "perf_hooks";
 import { mkdtemp as mkdtemp13, rm as rm15 } from "fs/promises";
 import { statSync } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import path38 from "path";
-import os11 from "os";
+import path39 from "path";
+import os12 from "os";
 import {
   GraphStore
 } from "@remnic/coding-graph";
@@ -40597,14 +41265,14 @@ var CODING_GRAPH_BENCH_SCHEMA_VERSION = 2;
 
 // src/coding-graph/harness.ts
 function captureMachineFingerprint() {
-  const cpus = os11.cpus();
+  const cpus = os12.cpus();
   return {
     arch: process.arch,
     platform: process.platform,
     nodeVersion: process.version,
     cpuModel: cpus.length > 0 ? cpus[0].model : null,
     cpuCores: cpus.length,
-    totalMemoryMb: Math.round(os11.totalmem() / (1024 * 1024))
+    totalMemoryMb: Math.round(os12.totalmem() / (1024 * 1024))
   };
 }
 function percentile3(sorted, p) {
@@ -40667,15 +41335,15 @@ async function runCodingGraphBenchmark(config = {}) {
   const sampleRss = () => {
     peakRss = Math.max(peakRss, process.memoryUsage().rss);
   };
-  const dir = await mkdtemp13(path38.join(tmpdir7(), "coding-graph-bench-"));
-  const dbPath = path38.join(dir, "bench.sqlite");
+  const dir = await mkdtemp13(path39.join(tmpdir7(), "coding-graph-bench-"));
+  const dbPath = path39.join(dir, "bench.sqlite");
   try {
     const store = await GraphStore.open({ dbPath });
     try {
       const FULL_INDEX_SAMPLES = 3;
       const fullIndexSamples = [];
       for (let s = 0; s < FULL_INDEX_SAMPLES; s++) {
-        const sampleStore = s === 0 ? store : await GraphStore.open({ dbPath: path38.join(dir, `bench-warm-${s}.sqlite`) });
+        const sampleStore = s === 0 ? store : await GraphStore.open({ dbPath: path39.join(dir, `bench-warm-${s}.sqlite`) });
         const fi = await timeAsync(() => sampleStore.upsertFileBatch(storeFiles));
         if (!fi.result.ok) {
           if (sampleStore !== store) await sampleStore.close();
@@ -41067,6 +41735,7 @@ export {
   SEALED_PROMPT_REGISTRY,
   SINGLE_FLAG_ABLATION_MATRIX,
   SYNTHETIC_MEMORIES,
+  StructuredJudgeError,
   ZepMemCorrectAdapter,
   addContaminationEntry,
   aggregateTaskScores,
@@ -41140,6 +41809,7 @@ export {
   createResponderFromProvider,
   createSeededRng,
   createSpotCheckFileLogger,
+  createStructuredBenchJudge,
   createStructuredJudgeFromProvider,
   createSyntheticEmailIngestionAdapter,
   createSyntheticTarget,
@@ -41177,6 +41847,7 @@ export {
   isContaminationManifest,
   isSealedQrelsArtifact,
   isSha256Hex,
+  isStructuredJudgeProvider,
   judgeMemCorrectCorrectionAcceptance,
   judgeMemCorrectStaleMemoryHarm,
   linkMatches,