@remnic/bench 9.6.19 → 9.6.20

package/dist/index.js

@@ -8972,11 +8972,560 @@ 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 { 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-credit-budget.ts
+import { mkdir as mkdir5, open, readFile as readFile6, rename as rename2, rmdir, unlink as unlink3, writeFile as writeFile5 } from "fs/promises";
 import os4 from "os";
 import path7 from "path";
+var ONE_MILLION = 1e6;
+var MAX_BOUNDED_CALL_CREDITS = 300;
+var SOL_MODEL = /^gpt-5\.6-sol$/i;
+var CREDIT_RATES = [
+  [/^gpt-5\.6-sol$/i, { input: 125, cachedInput: 12.5, output: 750 }],
+  [/^gpt-5\.6-terra$/i, { input: 62.5, cachedInput: 6.25, output: 375 }],
+  [/^gpt-5\.6-luna$/i, { input: 25, cachedInput: 2.5, output: 150 }],
+  [/^gpt-5\.5$/i, { input: 125, cachedInput: 12.5, output: 750 }],
+  [/^gpt-5\.4-mini$/i, { input: 18.75, cachedInput: 1.875, output: 113 }],
+  [/^gpt-5\.4$/i, { input: 62.5, cachedInput: 6.25, output: 375 }],
+  [/^gpt-5\.3-codex$/i, { input: 43.75, cachedInput: 4.375, output: 350 }],
+  [/^gpt-5\.2$/i, { input: 43.75, cachedInput: 4.375, output: 350 }]
+];
+var completionQueue = Promise.resolve();
+var CodexCreditAccountingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodexCreditAccountingError";
+  }
+};
+var CodexCreditDispatchError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CodexCreditDispatchError";
+  }
+};
+function resolveCodexCreditBudgetConfig(env = process.env) {
+  const rawBudget = env.REMNIC_BENCH_CODEX_CREDIT_BUDGET?.trim();
+  if (!rawBudget) return void 0;
+  const budgetCredits = parsePositiveNumber(
+    rawBudget,
+    "REMNIC_BENCH_CODEX_CREDIT_BUDGET"
+  );
+  const reserveCredits = parseNonNegativeNumber(
+    env.REMNIC_BENCH_CODEX_CREDIT_RESERVE?.trim() ?? "473",
+    "REMNIC_BENCH_CODEX_CREDIT_RESERVE"
+  );
+  if (reserveCredits >= budgetCredits) {
+    throw new Error(
+      "REMNIC_BENCH_CODEX_CREDIT_RESERVE must be smaller than REMNIC_BENCH_CODEX_CREDIT_BUDGET"
+    );
+  }
+  if (reserveCredits < MAX_BOUNDED_CALL_CREDITS) {
+    throw new Error(
+      `REMNIC_BENCH_CODEX_CREDIT_RESERVE must be at least ${MAX_BOUNDED_CALL_CREDITS} credits to cover the conservative maximum cost of the one serialized in-flight call`
+    );
+  }
+  const ledgerPath = path7.resolve(
+    expandHomeRelativePath2(
+      env.REMNIC_BENCH_CODEX_CREDIT_LEDGER?.trim() || ".remnic/bench/codex-credit-ledger.json"
+    )
+  );
+  return {
+    budgetCredits,
+    reserveCredits,
+    ledgerPath,
+    allowSol: /^(?:1|true|yes|on)$/i.test(
+      env.REMNIC_BENCH_CODEX_ALLOW_SOL?.trim() ?? ""
+    )
+  };
+}
+async function runWithinCodexCreditBudget(args) {
+  if (!args.config) {
+    return (await args.run()).value;
+  }
+  const previous = completionQueue;
+  let release;
+  completionQueue = new Promise((resolve) => {
+    release = resolve;
+  });
+  await previous;
+  const lockPath = `${args.config.ledgerPath}.lock`;
+  let lock;
+  let dispatchStarted = false;
+  let accountingSettled = false;
+  try {
+    await mkdir5(path7.dirname(lockPath), { recursive: true, mode: 448 });
+    lock = await acquireLedgerLock(lockPath);
+    assertModelAllowed(args.model, args.config);
+    const ledger = await readLedger(args.config);
+    if (ledger.blockedReason) {
+      throw new Error(
+        `Codex credit ledger is blocked pending manual reconciliation: ${ledger.blockedReason}`
+      );
+    }
+    const usableCredits = args.config.budgetCredits - args.config.reserveCredits;
+    if (ledger.spentCredits >= usableCredits) {
+      throw new Error(
+        `Codex credit budget exhausted: ${ledger.spentCredits.toFixed(3)} spent; ${usableCredits.toFixed(3)} usable after the ${args.config.reserveCredits.toFixed(3)} safety reserve.`
+      );
+    }
+    await writeLockState(lock, "in-flight");
+    dispatchStarted = true;
+    let result;
+    try {
+      result = await args.run();
+    } catch (error) {
+      if (error instanceof CodexCreditDispatchError) {
+        await writeLockState(lock, "settled");
+        accountingSettled = true;
+      } else {
+        const blockedLedger = {
+          ...ledger,
+          blockedReason: error instanceof CodexCreditAccountingError ? error.message : `Codex dispatch outcome is unknown after an unexpected error: ${safeErrorMessage(error)}`
+        };
+        await writeLedger(args.config.ledgerPath, blockedLedger);
+        await writeLockState(lock, "settled");
+        accountingSettled = true;
+      }
+      throw error;
+    }
+    const credits = calculateCodexCredits(args.model, result.usage);
+    const nextSpent = ledger.spentCredits + credits;
+    const nextLedger = {
+      ...ledger,
+      spentCredits: nextSpent,
+      entries: [
+        ...ledger.entries,
+        {
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          model: args.model,
+          credits,
+          ...result.usage
+        }
+      ]
+    };
+    await writeLedger(args.config.ledgerPath, nextLedger);
+    await writeLockState(lock, "settled");
+    accountingSettled = true;
+    args.onUsagePersisted?.(result.usage);
+    if (nextSpent > args.config.budgetCredits) {
+      throw new Error(
+        `Codex credit budget exceeded by completed call: ${nextSpent.toFixed(3)} > ${args.config.budgetCredits.toFixed(3)} credits. Usage was persisted; stop the benchmark immediately.`
+      );
+    }
+    return result.value;
+  } finally {
+    try {
+      if (lock) {
+        try {
+          await lock.close();
+        } finally {
+          if (!dispatchStarted || accountingSettled) {
+            await removeOwnedLedgerLock(lockPath);
+          }
+        }
+      }
+    } finally {
+      release();
+    }
+  }
+}
+async function acquireLedgerLock(lockPath) {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      await mkdir5(lockPath, { mode: 448 });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const owner = await readLockOwner(lockPath);
+      if (!owner || isProcessAlive(owner.pid) || owner.phase === "in-flight") {
+        throw new Error(
+          `Codex credit ledger is locked${owner?.phase === "in-flight" ? " with unreconciled in-flight usage" : " by another benchmark process"} (${lockPath}); refusing credit spend.`
+        );
+      }
+      await reclaimStaleLedgerLock(lockPath, owner);
+      continue;
+    }
+    let createdLock;
+    try {
+      await mkdir5(lockHeldPath(lockPath));
+      createdLock = await open(lockOwnerPath(lockPath), "wx", 384);
+      await writeLockState(createdLock, "preflight");
+      return createdLock;
+    } catch (error) {
+      await createdLock?.close().catch(() => void 0);
+      await unlink3(lockOwnerPath(lockPath)).catch(() => void 0);
+      await rmdir(lockHeldPath(lockPath)).catch(() => void 0);
+      await rmdir(lockPath).catch(() => void 0);
+      throw error;
+    }
+  }
+  throw new Error(`Unable to acquire Codex credit ledger lock (${lockPath})`);
+}
+async function readLockOwner(lockPath) {
+  try {
+    const parsed = JSON.parse(await readFile6(lockOwnerPath(lockPath), "utf8"));
+    if (!Number.isSafeInteger(parsed.pid) || parsed.pid <= 0 || parsed.phase !== "preflight" && parsed.phase !== "in-flight" && parsed.phase !== "settled") {
+      return void 0;
+    }
+    return { pid: parsed.pid, phase: parsed.phase };
+  } catch {
+    return void 0;
+  }
+}
+async function reclaimStaleLedgerLock(lockPath, expectedOwner) {
+  try {
+    await rmdir(lockHeldPath(lockPath));
+  } catch (error) {
+    throw new Error(
+      `Codex credit ledger stale-lock reclamation is already claimed or incomplete (${lockPath}); refusing credit spend: ${safeErrorMessage(error)}`
+    );
+  }
+  const currentOwner = await readLockOwner(lockPath);
+  if (!currentOwner || currentOwner.pid !== expectedOwner.pid || currentOwner.phase !== expectedOwner.phase || isProcessAlive(currentOwner.pid) || currentOwner.phase === "in-flight") {
+    throw new Error(
+      `Codex credit ledger owner changed during stale-lock reclamation (${lockPath}); refusing credit spend.`
+    );
+  }
+  await unlink3(lockOwnerPath(lockPath));
+  await rmdir(lockPath);
+}
+async function removeOwnedLedgerLock(lockPath) {
+  await rmdir(lockHeldPath(lockPath));
+  await unlink3(lockOwnerPath(lockPath));
+  await rmdir(lockPath);
+}
+function lockOwnerPath(lockPath) {
+  return path7.join(lockPath, "owner.json");
+}
+function lockHeldPath(lockPath) {
+  return path7.join(lockPath, "held");
+}
+async function writeLockState(lock, phase) {
+  const contents = `${JSON.stringify({
+    pid: process.pid,
+    phase,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  })}
+`;
+  await lock.truncate(0);
+  await lock.write(contents, 0, "utf8");
+  await lock.sync();
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function parseCodexJsonlUsage(output) {
+  let usage;
+  for (const line of output.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      const event = JSON.parse(trimmed);
+      if (event.type !== "turn.completed" || !event.usage) continue;
+      const inputTokens = readCounter(event.usage.input_tokens);
+      const outputTokens = readCounter(event.usage.output_tokens);
+      const cachedInputTokens = readOptionalCounter(
+        event.usage.cached_input_tokens
+      );
+      const reasoningOutputTokens = readOptionalCounter(
+        event.usage.reasoning_output_tokens
+      );
+      if (inputTokens !== void 0 && outputTokens !== void 0 && cachedInputTokens !== void 0 && reasoningOutputTokens !== void 0) {
+        usage = {
+          inputTokens,
+          cachedInputTokens,
+          outputTokens,
+          reasoningOutputTokens
+        };
+      }
+    } catch {
+    }
+  }
+  return usage;
+}
+function calculateCodexCredits(model, usage) {
+  const rate = resolveRate(model);
+  const cached = Math.min(usage.inputTokens, usage.cachedInputTokens);
+  const uncached = usage.inputTokens - cached;
+  return (uncached * rate.input + cached * rate.cachedInput + usage.outputTokens * rate.output) / ONE_MILLION;
+}
+function resolveRate(model) {
+  const match = CREDIT_RATES.find(([pattern]) => pattern.test(model));
+  if (!match) {
+    throw new Error(
+      `No Codex credit rate is configured for model ${JSON.stringify(model)}; refusing to run under a bounded credit budget.`
+    );
+  }
+  return match[1];
+}
+function assertModelAllowed(model, config) {
+  resolveRate(model);
+  if (SOL_MODEL.test(model) && !config.allowSol) {
+    throw new Error(
+      "gpt-5.6-sol is disabled for bounded benchmark runs because it is the most expensive GPT-5.6 tier. Use gpt-5.6-terra or gpt-5.6-luna, or explicitly set REMNIC_BENCH_CODEX_ALLOW_SOL=1."
+    );
+  }
+}
+async function readLedger(config) {
+  try {
+    const parsed = JSON.parse(await readFile6(config.ledgerPath, "utf8"));
+    if (parsed.schemaVersion !== 1 || parsed.budgetCredits !== config.budgetCredits || parsed.reserveCredits !== config.reserveCredits || typeof parsed.spentCredits !== "number" || !Number.isFinite(parsed.spentCredits) || parsed.spentCredits < 0 || !Array.isArray(parsed.entries)) {
+      throw new Error("ledger schema or budget does not match this run");
+    }
+    return parsed;
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw new Error(`Invalid Codex credit ledger at ${config.ledgerPath}: ${String(error)}`);
+    }
+    return {
+      schemaVersion: 1,
+      budgetCredits: config.budgetCredits,
+      reserveCredits: config.reserveCredits,
+      spentCredits: 0,
+      entries: []
+    };
+  }
+}
+async function writeLedger(filePath, ledger) {
+  await mkdir5(path7.dirname(filePath), { recursive: true, mode: 448 });
+  const tempPath = `${filePath}.${process.pid}.tmp`;
+  await writeFile5(tempPath, `${JSON.stringify(ledger, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await rename2(tempPath, filePath);
+}
+function readCounter(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function readOptionalCounter(value) {
+  return value === void 0 ? 0 : readCounter(value);
+}
+function safeErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function expandHomeRelativePath2(value) {
+  if (value === "~") return os4.homedir();
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path7.join(os4.homedir(), value.slice(2));
+  }
+  return value;
+}
+function parsePositiveNumber(value, name) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${name} must be a finite number greater than zero`);
+  }
+  return parsed;
+}
+function parseNonNegativeNumber(value, name) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error(`${name} must be a finite non-negative number`);
+  }
+  return parsed;
+}
+
+// src/providers/codex-cli.ts
 var DEFAULT_REASONING_EFFORT = "xhigh";
-var DEFAULT_SERVICE_TIER = "fast";
+var DEFAULT_SERVICE_TIER = "default";
 var CODEX_CLI_STDIO_LIMIT = 64e3;
 var CODEX_CLI_PARENT_SIGNALS = [
   "SIGHUP",
@@ -8987,12 +9536,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 +9555,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 +9582,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 +9590,8 @@ var CodexCliProvider = class {
   config;
   runCodexCli;
   runCodexVersion;
-  shouldProbeCliHealth;
+  runCodexLoginStatus;
+  requiresExactUsage;
   usage = {
     inputTokens: 0,
     outputTokens: 0,
@@ -9058,23 +9601,28 @@ 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();
+    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 +9633,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 +9642,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 +9710,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 +9725,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 +9841,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 +9868,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",
-      "codex_hooks",
+      "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",
+      "tool_suggest",
+      "--disable",
+      "workspace_dependencies",
+      "--disable",
+      "shell_snapshot",
       "--ephemeral",
       "--ignore-user-config",
       "--ignore-rules",
@@ -9312,6 +9927,7 @@ ${result.stdout}`,
       "--cd",
       workspacePath,
       "--skip-git-repo-check",
+      "--json",
       "--output-last-message",
       outputPath,
       "-"
@@ -9324,50 +9940,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 +10001,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 +10064,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 +10082,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 +10101,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 +10114,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 +10125,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 +10168,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 +10177,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;
 }
@@ -9614,13 +10234,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 +10318,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 +10362,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 +10446,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,35 +10531,89 @@ 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) {
+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)}`
+    );
+  }
+  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 {
+    inputTokens: legacy.input,
+    cachedInputTokens: 0,
+    outputTokens: legacy.output,
+    reasoningOutputTokens: 0
+  };
+}
+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 { input: 0, output: 0 };
+  const totalTokens = Number(raw.replace(/,/g, ""));
+  if (!Number.isSafeInteger(totalTokens) || totalTokens < 0) {
     return { input: 0, output: 0 };
   }
-  const estimatedOutputTokens = Math.min(
+  const outputTokens = Math.min(
     totalTokens,
     Math.max(1, Math.ceil(outputText.length / 4))
   );
-  return {
-    input: totalTokens - estimatedOutputTokens,
-    output: estimatedOutputTokens
-  };
+  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 parseCodexTotalTokens(stderr) {
-  const matches = [...stderr.matchAll(/\btokens used\s+([0-9][0-9,]*)\b/gi)];
-  const raw = matches.at(-1)?.[1];
-  if (!raw) {
-    return void 0;
-  }
-  const parsed = Number(raw.replace(/,/g, ""));
-  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+function isCodexStructuredJudgeAbort(error, signal) {
+  return signal?.aborted === true || error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
 }
-function tomlString(value) {
-  return JSON.stringify(value);
+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);
@@ -9930,28 +10621,28 @@ function createCodexCliProvider(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 +10657,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 +10675,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 +11043,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 +11072,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 +12332,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 +12472,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 +12526,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 +12548,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 +12702,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 +12723,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 +12731,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 +13255,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 +13312,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 +13594,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 +13943,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 +13980,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 +14641,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 +15060,20 @@ async function resolveLocalLabRuntimeProfile(options) {
 
 // src/benchmark.ts
 import fs2 from "fs";
-import path34 from "path";
+import path35 from "path";
 import { createHash as createHash11 } from "crypto";
 import { expandTildePath as expandTildePath3 } from "@remnic/core";
 
 // src/judges/judge-cache.ts
 import { createHash as createHash6, 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,7 +15104,7 @@ 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) {
@@ -14587,7 +15129,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 +15175,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) {
@@ -14841,8 +15383,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 +15959,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 +16254,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 +16784,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 +16958,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 +17286,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 +17622,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 +17642,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 +19071,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 +19175,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 +21285,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 +21756,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 +21784,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 {
@@ -22254,8 +22796,8 @@ 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 { 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 +23073,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 +23134,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 +23267,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.`
     );
@@ -23058,8 +23600,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 +23862,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 +24729,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 +25752,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 +25809,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 +25860,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 +25877,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 +25915,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 +26525,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 +26636,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 +27185,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 +27349,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 +27528,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 +27694,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 +27721,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 +27745,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 +27755,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 +27766,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 +30052,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 +30183,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 +30198,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 +30268,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 +30772,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 +30905,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 +30926,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 +31078,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 +31099,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 +31179,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 +31201,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 +31285,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 +31346,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 +31365,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 +31378,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 +31769,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) {
@@ -31319,7 +31861,7 @@ function pairedDeltaConfidenceInterval(candidateValues, baselineValues, options
 // src/judges/sealed-rubric.ts
 import { createHash as createHash8 } 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)
@@ -31599,7 +32141,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 +32230,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 +32879,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 +33110,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 +33179,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,
@@ -34904,8 +35446,8 @@ 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";
@@ -36137,24 +36679,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 +36719,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 +36740,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 +36982,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 +37061,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;
     }
@@ -36718,7 +37260,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 +37490,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 +37905,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 +37975,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 +38095,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 +38115,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 +38223,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 +38236,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 +38437,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,
@@ -38766,8 +39308,8 @@ 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 { 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;
@@ -38995,7 +39537,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 +39550,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 +39650,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 +39683,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 +39698,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 +39773,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 +39869,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;
 }
 
@@ -40570,8 +41112,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 +41139,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 +41209,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 +41609,7 @@ export {
   SEALED_PROMPT_REGISTRY,
   SINGLE_FLAG_ABLATION_MATRIX,
   SYNTHETIC_MEMORIES,
+  StructuredJudgeError,
   ZepMemCorrectAdapter,
   addContaminationEntry,
   aggregateTaskScores,
@@ -41140,6 +41683,7 @@ export {
   createResponderFromProvider,
   createSeededRng,
   createSpotCheckFileLogger,
+  createStructuredBenchJudge,
   createStructuredJudgeFromProvider,
   createSyntheticEmailIngestionAdapter,
   createSyntheticTarget,
@@ -41177,6 +41721,7 @@ export {
   isContaminationManifest,
   isSealedQrelsArtifact,
   isSha256Hex,
+  isStructuredJudgeProvider,
   judgeMemCorrectCorrectionAcceptance,
   judgeMemCorrectStaleMemoryHarm,
   linkMatches,