@remnic/bench 9.3.729 → 9.3.730

package/dist/index.js

@@ -1,3 +1,598 @@
+// src/benchmarks/remnic/memcorrect/third-party/shared.ts
+var MissingCredentialError = class extends Error {
+  reason;
+  constructor(system, missing) {
+    const reason = `${system} MemCorrect adapter is not runnable: missing ${missing.join(", ")}. Provide the required credentials (env vars or config) to exercise this adapter; skipped \u2014 no keys in CI.`;
+    super(reason);
+    this.name = "MissingCredentialError";
+    this.reason = reason;
+  }
+};
+function requireCredentials(system, missing) {
+  if (missing.length > 0) {
+    throw new MissingCredentialError(system, missing);
+  }
+}
+function resolveFetch(override) {
+  if (override) return override;
+  if (typeof fetch === "function") return fetch;
+  throw new Error(
+    "No fetch implementation available. Provide `fetch` in the adapter config or run in a runtime with a global fetch (Node 18+)."
+  );
+}
+async function httpJson(fetchImpl, method, url, options = {}) {
+  const { headers = {}, body, timeoutMs } = options;
+  const controller = new AbortController();
+  const { promise: timeoutPromise, resolve: resolveTimeout } = Promise.withResolvers();
+  const timer = timeoutMs !== void 0 ? setTimeout(() => resolveTimeout(), timeoutMs) : void 0;
+  if (timer) timer.unref?.();
+  const fetchPromise = fetchImpl(url, {
+    method,
+    headers: { "Content-Type": "application/json", ...headers },
+    body: body !== void 0 ? JSON.stringify(body) : void 0,
+    signal: controller.signal
+  });
+  fetchPromise.catch(() => {
+  });
+  let response;
+  try {
+    if (timer) {
+      const winner = await Promise.race([
+        fetchPromise.then((r) => r),
+        timeoutPromise.then(() => "timeout")
+      ]);
+      if (winner === "timeout") {
+        controller.abort();
+        throw new Error(`Request timed out after ${timeoutMs}ms: ${method} ${url}`);
+      }
+      response = winner;
+    } else {
+      response = await fetchPromise;
+    }
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+  if (response.status === 204) return null;
+  const text = await response.text();
+  if (!response.ok) {
+    const excerpt = text.length > 500 ? `${text.slice(0, 500)}\u2026` : text;
+    throw new HttpError(method, url, response.status, excerpt);
+  }
+  if (text.length === 0) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+var HttpError = class extends Error {
+  status;
+  method;
+  url;
+  bodyExcerpt;
+  constructor(method, url, status, bodyExcerpt) {
+    super(`HTTP ${status} from ${method} ${url}: ${bodyExcerpt}`);
+    this.name = "HttpError";
+    this.method = method;
+    this.url = url;
+    this.status = status;
+    this.bodyExcerpt = bodyExcerpt;
+  }
+};
+function delay(ms) {
+  if (ms <= 0) return Promise.resolve();
+  const { promise, resolve } = Promise.withResolvers();
+  setTimeout(() => resolve(), ms);
+  return promise;
+}
+var runSuffixCounter = 0;
+function uniqueRunSuffix() {
+  runSuffixCounter += 1;
+  const pid = typeof process !== "undefined" && typeof process.pid === "number" ? process.pid : 0;
+  return `${pid.toString(36)}-${Date.now().toString(36)}-${runSuffixCounter.toString(36)}`;
+}
+function isNotFoundDelete(err) {
+  return err instanceof HttpError && (err.status === 404 || err.status === 422);
+}
+function isConflict(err) {
+  return err instanceof HttpError && err.status === 409;
+}
+async function resetTrackedIds(system, ids, deleteFn) {
+  const snapshot = [...ids];
+  const failed = [];
+  for (const id of snapshot) {
+    try {
+      await deleteFn(id);
+      ids.delete(id);
+    } catch (err) {
+      if (isNotFoundDelete(err)) {
+        ids.delete(id);
+      } else {
+        failed.push(id);
+      }
+    }
+  }
+  if (failed.length > 0) {
+    throw new Error(
+      `${system} reset could not clean ${failed.length} session(s): ${failed.join(", ")}. Remote data may remain; the failed ids are retained for the next reset() retry.`
+    );
+  }
+}
+
+// src/benchmarks/remnic/memcorrect/third-party/mem0-adapter.ts
+var Mem0MemCorrectAdapter = class {
+  label;
+  mode;
+  baseUrl;
+  apiKey;
+  userIdPrefix;
+  ossAuthMode;
+  pollIntervalMs;
+  maxPolls;
+  fetchImpl;
+  timeoutMs;
+  /** Session-scoped user_ids we have ingested under, for precise reset. */
+  knownSessions = /* @__PURE__ */ new Set();
+  constructor(config = {}) {
+    this.mode = config.mode ?? (config.baseUrl && !config.baseUrl.includes("api.mem0.ai") ? "oss" : "hosted");
+    this.baseUrl = config.baseUrl?.replace(/\/+$/, "") ?? (this.mode === "hosted" ? "https://api.mem0.ai" : "");
+    this.apiKey = config.apiKey;
+    this.userIdPrefix = config.userIdPrefix ?? `memcorrect-${uniqueRunSuffix()}`;
+    this.ossAuthMode = config.ossAuthMode ?? "x-api-key";
+    this.pollIntervalMs = config.pollIntervalMs ?? 500;
+    this.maxPolls = config.maxPolls ?? 120;
+    this.fetchImpl = resolveFetch(config.fetch);
+    this.timeoutMs = config.timeoutMs;
+    this.label = `mem0-${this.mode}`;
+  }
+  /** Whether this adapter has the credentials needed to run. */
+  isConfigured() {
+    if (!this.apiKey) return false;
+    if (this.mode === "oss" && !this.baseUrl) return false;
+    return true;
+  }
+  userIdFor(sessionKey) {
+    return `${this.userIdPrefix}:${sessionKey}`;
+  }
+  ensureReady() {
+    const missing = [];
+    if (!this.apiKey) missing.push("apiKey (MEM0_API_KEY)");
+    if (this.mode === "oss" && !this.baseUrl)
+      missing.push("baseUrl (MEM0_BASE_URL)");
+    requireCredentials("Mem0", missing);
+  }
+  authHeaders() {
+    if (this.mode === "hosted") {
+      return { Authorization: `Token ${this.apiKey}` };
+    }
+    if (this.ossAuthMode === "bearer") {
+      return { Authorization: `Bearer ${this.apiKey}` };
+    }
+    return { "X-API-Key": this.apiKey };
+  }
+  async reset() {
+    this.ensureReady();
+    await resetTrackedIds("Mem0", this.knownSessions, async (sessionKey) => {
+      const userId = this.userIdFor(sessionKey);
+      if (this.mode === "oss") {
+        await httpJson(
+          this.fetchImpl,
+          "DELETE",
+          `${this.baseUrl}/memories?user_id=${encodeURIComponent(userId)}`,
+          { headers: this.authHeaders(), timeoutMs: this.timeoutMs }
+        );
+      } else {
+        await httpJson(
+          this.fetchImpl,
+          "DELETE",
+          `${this.baseUrl}/v1/memories/?user_id=${encodeURIComponent(userId)}`,
+          { headers: this.authHeaders(), timeoutMs: this.timeoutMs }
+        );
+      }
+    });
+  }
+  async ingestTurn(sessionKey, role, text, _at) {
+    this.ensureReady();
+    const userId = this.userIdFor(sessionKey);
+    this.knownSessions.add(sessionKey);
+    if (this.mode === "oss") {
+      await httpJson(this.fetchImpl, "POST", `${this.baseUrl}/memories`, {
+        headers: this.authHeaders(),
+        body: {
+          messages: [{ role, content: text }],
+          user_id: userId
+        },
+        timeoutMs: this.timeoutMs
+      });
+    } else {
+      const addResponse = await httpJson(
+        this.fetchImpl,
+        "POST",
+        `${this.baseUrl}/v3/memories/add/`,
+        {
+          headers: this.authHeaders(),
+          body: {
+            messages: [{ role, content: text }],
+            user_id: userId
+          },
+          timeoutMs: this.timeoutMs
+        }
+      );
+      if (addResponse?.status === "FAILED") {
+        throw new Error(
+          `Mem0 hosted add failed immediately: ${addResponse.error ?? addResponse.status}`
+        );
+      }
+      const eventId = addResponse?.event_id;
+      if (eventId) {
+        await this.pollEvent(eventId);
+      }
+    }
+  }
+  async recall(query, sessionKey) {
+    this.ensureReady();
+    const userId = this.userIdFor(sessionKey);
+    let results;
+    if (this.mode === "oss") {
+      const body = await httpJson(
+        this.fetchImpl,
+        "POST",
+        `${this.baseUrl}/search`,
+        {
+          headers: this.authHeaders(),
+          // Mem0 OSS v3 aligns search with the platform API: entity IDs go
+          // inside `filters` and the count parameter is `top_k`, not
+          // top-level `user_id`/`limit` (oss-v2-to-v3 migration).
+          body: { query, filters: { user_id: userId }, top_k: 10 },
+          timeoutMs: this.timeoutMs
+        }
+      );
+      results = normalizeSearchResults(body);
+    } else {
+      const body = await httpJson(
+        this.fetchImpl,
+        "POST",
+        `${this.baseUrl}/v3/memories/search/`,
+        {
+          headers: this.authHeaders(),
+          body: { query, filters: { user_id: userId }, top_k: 10 },
+          timeoutMs: this.timeoutMs
+        }
+      );
+      results = normalizeSearchResults(body);
+    }
+    return results.map((r) => r.memory).filter((m) => typeof m === "string" && m.length > 0);
+  }
+  async correct(text, sessionKey, _at) {
+    await this.ingestTurn(sessionKey, "user", text, _at ?? (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async runMaintenance() {
+  }
+  /** Poll the hosted event endpoint until the add is processed. */
+  async pollEvent(eventId) {
+    for (let i = 0; i < this.maxPolls; i++) {
+      await delay(this.pollIntervalMs);
+      const status = await httpJson(
+        this.fetchImpl,
+        "GET",
+        `${this.baseUrl}/v1/event/${eventId}/`,
+        {
+          headers: this.authHeaders(),
+          timeoutMs: this.timeoutMs
+        }
+      );
+      if (status?.status === "SUCCEEDED") return;
+      if (status?.status === "FAILED") {
+        throw new Error(
+          `Mem0 add event ${eventId} failed: ${status.error ?? "unknown"}`
+        );
+      }
+    }
+    throw new Error(
+      `Mem0 add event ${eventId} did not complete after ${this.maxPolls} polls`
+    );
+  }
+};
+function normalizeSearchResults(body) {
+  if (!body) return [];
+  if (Array.isArray(body)) return body;
+  return body.results ?? [];
+}
+
+// src/benchmarks/remnic/memcorrect/third-party/zep-adapter.ts
+var ZepMemCorrectAdapter = class {
+  label = "zep";
+  baseUrl;
+  apiKey;
+  sessionPrefix;
+  settleMs;
+  fetchImpl;
+  timeoutMs;
+  /** Sessions we have ensured exist, to avoid redundant POST /sessions calls. */
+  knownSessions = /* @__PURE__ */ new Set();
+  /** True when turns have been ingested since the last settle, so recall() can
+   * wait for Zep's async graph pipeline before a scored read. */
+  pendingIngest = false;
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl?.replace(/\/+$/, "") ?? "https://api.getzep.com/api/v2";
+    this.apiKey = config.apiKey;
+    this.sessionPrefix = config.sessionPrefix ?? `memcorrect-${uniqueRunSuffix()}`;
+    this.settleMs = config.settleMs ?? 0;
+    this.fetchImpl = resolveFetch(config.fetch);
+    this.timeoutMs = config.timeoutMs;
+  }
+  isConfigured() {
+    return !!this.apiKey;
+  }
+  sessionIdFor(sessionKey) {
+    return `${this.sessionPrefix}:${sessionKey}`;
+  }
+  ensureReady() {
+    requireCredentials("Zep", this.apiKey ? [] : ["apiKey (ZEP_API_KEY)"]);
+  }
+  authHeaders() {
+    return { Authorization: `Api-Key ${this.apiKey}` };
+  }
+  async reset() {
+    this.ensureReady();
+    await resetTrackedIds("Zep", this.knownSessions, async (sessionId) => {
+      try {
+        await httpJson(
+          this.fetchImpl,
+          "DELETE",
+          `${this.baseUrl}/sessions/${encodeURIComponent(sessionId)}`,
+          { headers: this.authHeaders(), timeoutMs: this.timeoutMs }
+        );
+      } catch (err) {
+        if (!isNotFoundDelete(err)) throw err;
+      }
+      await httpJson(
+        this.fetchImpl,
+        "DELETE",
+        `${this.baseUrl}/users/${encodeURIComponent(sessionId)}`,
+        { headers: this.authHeaders(), timeoutMs: this.timeoutMs }
+      );
+    });
+    this.pendingIngest = false;
+  }
+  /** Ensure the Zep session (and its user) exist before adding memory. */
+  async ensureSession(sessionId) {
+    if (this.knownSessions.has(sessionId)) return;
+    try {
+      await httpJson(this.fetchImpl, "POST", `${this.baseUrl}/users`, {
+        headers: this.authHeaders(),
+        body: { user_id: sessionId },
+        timeoutMs: this.timeoutMs
+      });
+    } catch (err) {
+      if (!isConflict(err)) throw err;
+    }
+    try {
+      await httpJson(
+        this.fetchImpl,
+        "POST",
+        `${this.baseUrl}/sessions`,
+        {
+          headers: this.authHeaders(),
+          body: { session_id: sessionId, user_id: sessionId },
+          timeoutMs: this.timeoutMs
+        }
+      );
+    } catch (err) {
+      if (!isConflict(err)) throw err;
+    }
+    this.knownSessions.add(sessionId);
+  }
+  async ingestTurn(sessionKey, role, text, _at) {
+    this.ensureReady();
+    const sessionId = this.sessionIdFor(sessionKey);
+    await this.ensureSession(sessionId);
+    const roleType = role === "user" ? "user" : "assistant";
+    await httpJson(
+      this.fetchImpl,
+      "POST",
+      `${this.baseUrl}/sessions/${encodeURIComponent(sessionId)}/memory`,
+      {
+        headers: this.authHeaders(),
+        body: {
+          messages: [{ role, role_type: roleType, content: text }]
+        },
+        timeoutMs: this.timeoutMs
+      }
+    );
+    this.pendingIngest = true;
+  }
+  async recall(query, sessionKey) {
+    this.ensureReady();
+    if (this.pendingIngest && this.settleMs > 0) {
+      await delay(this.settleMs);
+      this.pendingIngest = false;
+    }
+    const sessionId = this.sessionIdFor(sessionKey);
+    await this.ensureSession(sessionId);
+    const results = await httpJson(
+      this.fetchImpl,
+      "POST",
+      `${this.baseUrl}/graph/search`,
+      {
+        headers: this.authHeaders(),
+        body: { user_id: sessionId, query, scope: "edges", limit: 10 },
+        timeoutMs: this.timeoutMs
+      }
+    );
+    if (!results || !results.edges) return [];
+    const strings = [];
+    for (const edge of results.edges) {
+      const fact3 = edge.fact;
+      if (fact3 && fact3.trim().length > 0) {
+        strings.push(fact3.trim());
+      }
+    }
+    return strings;
+  }
+  async correct(text, sessionKey, _at) {
+    await this.ingestTurn(
+      sessionKey,
+      "user",
+      text,
+      _at ?? (/* @__PURE__ */ new Date()).toISOString()
+    );
+  }
+  async runMaintenance() {
+    if (this.settleMs > 0 && this.pendingIngest) {
+      await delay(this.settleMs);
+      this.pendingIngest = false;
+    }
+  }
+};
+
+// src/benchmarks/remnic/memcorrect/third-party/letta-adapter.ts
+var LettaMemCorrectAdapter = class {
+  label = "letta";
+  baseUrl;
+  apiKey;
+  model;
+  agentNamePrefix;
+  personaBlock;
+  fetchImpl;
+  timeoutMs;
+  /** Maps MemCorrect sessionKey → Letta agent_id. */
+  agentsBySession = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl?.replace(/\/+$/, "") ?? "";
+    this.apiKey = config.apiKey;
+    this.model = config.model;
+    this.agentNamePrefix = config.agentNamePrefix ?? "memcorrect";
+    this.personaBlock = config.personaBlock ?? "You are a memory benchmark agent. Store every fact the user states in your human memory block. When the user corrects a fact, use memory_replace to update it.";
+    this.fetchImpl = resolveFetch(config.fetch);
+    this.timeoutMs = config.timeoutMs;
+  }
+  isConfigured() {
+    return !!(this.apiKey && this.baseUrl && this.model);
+  }
+  ensureReady() {
+    const missing = [];
+    if (!this.apiKey) missing.push("apiKey (LETTA_API_KEY)");
+    if (!this.baseUrl) missing.push("baseUrl (LETTA_BASE_URL)");
+    if (!this.model) missing.push("model (LETTA_MODEL)");
+    requireCredentials("Letta", missing);
+  }
+  authHeaders() {
+    return this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {};
+  }
+  async reset() {
+    this.ensureReady();
+    const failed = [];
+    for (const [sessionKey, agentId] of [...this.agentsBySession]) {
+      try {
+        await httpJson(
+          this.fetchImpl,
+          "DELETE",
+          `${this.baseUrl}/v1/agents/${encodeURIComponent(agentId)}`,
+          { headers: this.authHeaders(), timeoutMs: this.timeoutMs }
+        );
+        this.agentsBySession.delete(sessionKey);
+      } catch (err) {
+        if (isNotFoundDelete(err)) {
+          this.agentsBySession.delete(sessionKey);
+        } else {
+          failed.push(agentId);
+        }
+      }
+    }
+    if (failed.length > 0) {
+      throw new Error(
+        `Letta reset could not clean ${failed.length} agent(s): ${failed.join(", ")}. The failed agents are retained in agentsBySession for the next reset() retry.`
+      );
+    }
+  }
+  /** Create a Letta agent for the session if one does not yet exist. */
+  async ensureAgent(sessionKey) {
+    const existing = this.agentsBySession.get(sessionKey);
+    if (existing) return existing;
+    const agent = await httpJson(
+      this.fetchImpl,
+      "POST",
+      `${this.baseUrl}/v1/agents/`,
+      {
+        headers: this.authHeaders(),
+        body: {
+          name: `${this.agentNamePrefix}-${sessionKey}`,
+          agent_type: "memgpt_agent",
+          model: this.model,
+          memory_blocks: [
+            { label: "human", value: "", limit: 5e3 },
+            { label: "persona", value: this.personaBlock, limit: 5e3 }
+          ]
+        },
+        timeoutMs: this.timeoutMs
+      }
+    );
+    const agentId = agent?.id;
+    if (!agentId) {
+      throw new Error(
+        `Letta agent creation did not return an agent id for session ${sessionKey}`
+      );
+    }
+    this.agentsBySession.set(sessionKey, agentId);
+    return agentId;
+  }
+  async ingestTurn(sessionKey, role, text, _at) {
+    this.ensureReady();
+    const agentId = await this.ensureAgent(sessionKey);
+    await httpJson(
+      this.fetchImpl,
+      "POST",
+      `${this.baseUrl}/v1/agents/${encodeURIComponent(agentId)}/messages`,
+      {
+        headers: this.authHeaders(),
+        body: {
+          messages: [{ role, content: text }],
+          // Letta's /messages endpoint defaults to streaming (SSE). Request a
+          // single JSON response so httpJson parses it and ingestTurn resolves
+          // only after the agent (and its memory tools) finish processing.
+          stream: false
+        },
+        timeoutMs: this.timeoutMs
+      }
+    );
+  }
+  async recall(_query, sessionKey) {
+    this.ensureReady();
+    const agentId = await this.ensureAgent(sessionKey);
+    const response = await httpJson(
+      this.fetchImpl,
+      "GET",
+      `${this.baseUrl}/v1/agents/${encodeURIComponent(agentId)}/core-memory/blocks`,
+      { headers: this.authHeaders(), timeoutMs: this.timeoutMs }
+    );
+    if (!response) return [];
+    const blocks = Array.isArray(response) ? response : response.memory ?? response.blocks ?? [];
+    const strings = [];
+    for (const block of blocks) {
+      if (block.label === "persona") continue;
+      const value = block.value ?? block.text ?? block.content;
+      if (value && value.trim().length > 0) {
+        for (const line of value.split(/\n+/)) {
+          const trimmed = line.trim();
+          if (trimmed) strings.push(trimmed);
+        }
+      }
+    }
+    return strings;
+  }
+  async correct(text, sessionKey, _at) {
+    await this.ingestTurn(
+      sessionKey,
+      "user",
+      text,
+      _at ?? (/* @__PURE__ */ new Date()).toISOString()
+    );
+  }
+  async runMaintenance() {
+  }
+};
+
 // src/ingestion-types.ts
 var REQUIRED_FRONTMATTER_FIELDS = ["title", "type", "state", "created", "see-also"];
 
@@ -2945,7 +3540,7 @@ async function withTimeout(label, timeoutMs, fn, onTimeout) {
           () => void 0,
           () => void 0
         ),
-        delay(BENCHMARK_TIMEOUT_ABORT_GRACE_MS)
+        delay2(BENCHMARK_TIMEOUT_ABORT_GRACE_MS)
       ]);
     }
     throw error;
@@ -2955,7 +3550,7 @@ async function withTimeout(label, timeoutMs, fn, onTimeout) {
     }
   }
 }
-function delay(ms) {
+function delay2(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -6285,34 +6880,20 @@ function createAnthropicProvider(config) {
   return new AnthropicProvider(config);
 }
 
-// src/providers/codex-cli.ts
+// src/providers/claude-cli.ts
 import { spawn } from "child_process";
-import { createHash as createHash5, randomUUID } from "crypto";
-import { mkdir as mkdir5, mkdtemp as mkdtemp2, readFile as readFile6, rm as rm2, writeFile as writeFile5 } from "fs/promises";
+import { mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
 import os3 from "os";
 import path6 from "path";
-var DEFAULT_REASONING_EFFORT = "xhigh";
-var DEFAULT_SERVICE_TIER = "fast";
-var CODEX_CLI_STDIO_LIMIT = 64e3;
-var CODEX_CLI_PARENT_SIGNALS = [
-  "SIGHUP",
-  "SIGINT",
-  "SIGTERM"
-];
-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_RUNTIME_ENV_ALLOWLIST = /* @__PURE__ */ new Set([
+var CLAUDE_CLI_STDIO_LIMIT = 64e3;
+var CLAUDE_CLI_PARENT_SIGNALS = ["SIGHUP", "SIGINT", "SIGTERM"];
+var CLAUDE_CLI_FORCED_PARENT_EXIT_MS = 1e3;
+var CLAUDE_CLI_EXECUTABLE_ENV = "REMNIC_BENCH_CLAUDE_CLI_EXECUTABLE";
+var CLAUDE_CLI_VERSION_TIMEOUT_MS = 5e3;
+var CLAUDE_CLI_RUNTIME_ENV_ALLOWLIST = /* @__PURE__ */ new Set([
   "ALL_PROXY",
   "APPDATA",
-  "CODEX_HOME",
+  "CLAUDE_CODE_OAUTH_TOKEN",
   "COLORTERM",
   "COMSPEC",
   "FORCE_COLOR",
@@ -6326,9 +6907,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",
@@ -6354,17 +6932,84 @@ var CODEX_CLI_RUNTIME_ENV_ALLOWLIST = /* @__PURE__ */ new Set([
   "XDG_DATA_HOME",
   "XDG_RUNTIME_DIR"
 ]);
-var activeCodexCliChildPids = /* @__PURE__ */ new Set();
-var codexCliParentCleanupInstalled = false;
-var codexCliHealthCache = /* @__PURE__ */ new Map();
-var CodexCliProvider = class {
-  provider = "codex-cli";
+var DEFAULT_USAGE_LIMIT_MAX_WAIT_MS = 30 * 60 * 1e3;
+var USAGE_LIMIT_BASE_BACKOFF_MS = 6e4;
+var USAGE_LIMIT_MAX_STEP_MS = 10 * 60 * 1e3;
+var activeClaudeCliChildPids = /* @__PURE__ */ new Set();
+var claudeCliParentCleanupInstalled = false;
+var ClaudeCliConcurrencyGate = class {
+  active = 0;
+  limit;
+  waiters = [];
+  constructor(limit) {
+    this.limit = normalizeGateLimit(limit);
+  }
+  async run(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  /** Raises the gate's limit if `limit` is higher than the current one;
+   * never lowers it. Immediately wakes any queued waiters that fit under
+   * the new, higher limit — see `getSharedClaudeCliGate` for the policy
+   * this implements (shared max across all constructed instances). */
+  raiseLimit(limit) {
+    const normalized = normalizeGateLimit(limit);
+    if (normalized <= this.limit) {
+      return;
+    }
+    this.limit = normalized;
+    while (this.active < this.limit) {
+      const next = this.waiters.shift();
+      if (!next) {
+        break;
+      }
+      next();
+    }
+  }
+  acquire() {
+    if (this.active < this.limit) {
+      this.active += 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.waiters.push(() => {
+        this.active += 1;
+        resolve();
+      });
+    });
+  }
+  release() {
+    this.active = Math.max(0, this.active - 1);
+    const next = this.waiters.shift();
+    if (next) {
+      next();
+    }
+  }
+};
+function normalizeGateLimit(limit) {
+  return Number.isFinite(limit) && limit >= 1 ? Math.floor(limit) : 1;
+}
+var sharedClaudeCliGate;
+function getSharedClaudeCliGate(requestedLimit) {
+  if (!sharedClaudeCliGate) {
+    sharedClaudeCliGate = new ClaudeCliConcurrencyGate(requestedLimit);
+    return sharedClaudeCliGate;
+  }
+  sharedClaudeCliGate.raiseLimit(requestedLimit);
+  return sharedClaudeCliGate;
+}
+var ClaudeCliProvider = class {
+  provider = "claude-cli";
   id;
   name;
   config;
-  runCodexCli;
-  runCodexVersion;
-  shouldProbeCliHealth;
+  runClaudeCli;
+  runClaudeVersion;
+  gate;
   usage = {
     inputTokens: 0,
     outputTokens: 0,
@@ -6372,112 +7017,801 @@ var CodexCliProvider = class {
   };
   constructor(config, deps = {}) {
     this.config = config;
-    this.runCodexCli = deps.runCodexCli ?? runCodexCliCommand;
-    this.runCodexVersion = deps.runCodexVersion ?? runCodexVersionCommand;
-    this.shouldProbeCliHealth = deps.runCodexCli === void 0;
-    this.id = `codex-cli:${config.model}`;
+    this.runClaudeCli = deps.runClaudeCli ?? runClaudeCliCommand;
+    this.runClaudeVersion = deps.runClaudeVersion ?? runClaudeVersionCommand;
+    this.gate = getSharedClaudeCliGate(config.concurrency ?? 1);
+    this.id = `claude-cli:${config.model}`;
     this.name = config.model;
   }
   async complete(prompt, opts = {}) {
-    const startedAt = performance.now();
-    if (await this.shouldUseResponsesFallback()) {
-      return this.completeViaResponsesApi(prompt, opts, startedAt);
+    return this.gate.run(() => this.completeSerialized(prompt, opts));
+  }
+  async completeSerialized(prompt, opts) {
+    if (opts.signal?.aborted) {
+      throw claudeCliAbortError(opts.signal);
     }
-    const maxAttempts = normalizeCodexCliMaxAttempts(
-      this.config.retryOptions?.maxAttempts
-    );
-    let lastError;
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-      const tempDir = await mkdtemp2(path6.join(os3.tmpdir(), "remnic-codex-cli-"));
-      const workspacePath = path6.join(tempDir, "workspace");
-      const outputPath = path6.join(tempDir, "last-message.txt");
-      let diagnostics;
-      let diagnosticsFinished = false;
-      const finishDiagnostics = async (outcome) => {
-        if (diagnosticsFinished) {
-          return;
-        }
-        diagnosticsFinished = true;
-        await finishCodexCliDiagnostics(diagnostics, startedAt, outcome);
-      };
+    const startedAt = performance.now();
+    const maxAttempts = normalizeClaudeCliMaxAttempts(this.config.retryOptions?.maxAttempts);
+    const usageLimitBudgetMs = normalizeUsageLimitMaxWaitMs(this.config.retryOptions?.max429WaitMs);
+    const loopStartedAt = performance.now();
+    let transientAttempt = 1;
+    let usageLimitAttempt = 1;
+    while (true) {
+      const tempDir = await mkdtemp2(path6.join(os3.tmpdir(), "remnic-claude-cli-"));
       try {
-        await mkdir5(workspacePath, { recursive: true });
-        const request = this.buildRunRequest(prompt, opts, workspacePath, outputPath);
-        diagnostics = await startCodexCliDiagnostics({
-          config: this.config,
-          request,
-          reasoningEffort: this.config.reasoningEffort ?? DEFAULT_REASONING_EFFORT,
-          serviceTier: DEFAULT_SERVICE_TIER,
-          retry: { attempt, maxAttempts }
-        });
-        const result = await this.runCodexCli(request);
+        const request = this.buildRunRequest(prompt, opts, tempDir);
+        const result = await this.runClaudeCli(request);
         if (result.status !== 0) {
+          if (isClaudeUsageLimitSignal(`${result.stderr}
+${result.stdout}`)) {
+            await sleepBeforeUsageLimitRetry({
+              attempt: usageLimitAttempt,
+              loopStartedAt,
+              budgetMs: usageLimitBudgetMs,
+              failureSummary: summarizeProcessOutput(result.stderr, result.stdout),
+              signal: opts.signal
+            });
+            usageLimitAttempt += 1;
+            continue;
+          }
           const exitLabel = result.signal ? `signal ${result.signal}` : `exit ${result.status ?? "unknown"}`;
           const error = new Error(
-            `Codex CLI completion failed (${exitLabel}): ${summarizeProcessOutput(result.stderr, result.stdout)}`
+            `Claude CLI completion failed (${exitLabel}): ${summarizeProcessOutput(result.stderr, result.stdout)}`
           );
-          if (attempt < maxAttempts && isRetryableCodexCliResult(result)) {
-            lastError = error;
-            await finishDiagnostics({
-              result,
-              error,
-              transientFailure: true
+          if (transientAttempt < maxAttempts && isRetryableClaudeCliResult(result)) {
+            await sleepBeforeClaudeCliRetry({
+              attempt: transientAttempt,
+              baseBackoffMs: this.config.retryOptions?.baseBackoffMs,
+              maxStepMs: 3e4,
+              capMs: Number.POSITIVE_INFINITY,
+              signal: opts.signal
             });
-            await sleepBeforeCodexCliRetry(
-              attempt,
-              this.config.retryOptions?.baseBackoffMs,
-              opts.signal
-            );
+            transientAttempt += 1;
             continue;
           }
-          await finishDiagnostics({ result, error });
           throw error;
         }
-        const text = result.outputText.trim();
+        const payload = parseClaudeCliJsonResult(result.stdout);
+        if (isClaudeCliErrorFlagSet(payload.is_error)) {
+          if (isClaudeUsageLimitSignal(
+            `${result.stderr}
+${payload.error ?? ""}
+${payload.result ?? ""}`
+          )) {
+            await sleepBeforeUsageLimitRetry({
+              attempt: usageLimitAttempt,
+              loopStartedAt,
+              budgetMs: usageLimitBudgetMs,
+              failureSummary: summarizeProcessOutput(result.stderr, result.stdout),
+              signal: opts.signal
+            });
+            usageLimitAttempt += 1;
+            continue;
+          }
+          throw new Error(
+            `Claude CLI reported is_error: ${payload.error?.trim() || payload.result?.trim() || summarizeProcessOutput(result.stderr, result.stdout)}`
+          );
+        }
+        const text = typeof payload.result === "string" ? payload.result.trim() : "";
         if (text.length === 0) {
-          const error = new Error(
-            `Codex CLI completion returned no final message: ${summarizeProcessOutput(result.stderr, result.stdout)}`
+          if (isClaudeUsageLimitSignal(`${result.stderr}
+${payload.error ?? ""}`)) {
+            await sleepBeforeUsageLimitRetry({
+              attempt: usageLimitAttempt,
+              loopStartedAt,
+              budgetMs: usageLimitBudgetMs,
+              failureSummary: summarizeProcessOutput(result.stderr, result.stdout),
+              signal: opts.signal
+            });
+            usageLimitAttempt += 1;
+            continue;
+          }
+          throw new Error(
+            `Claude CLI completion returned no result text: ${summarizeProcessOutput(result.stderr, result.stdout)}`
           );
-          await finishDiagnostics({ result, error });
-          throw error;
         }
-        await finishDiagnostics({ result });
-        const tokens = parseCodexTokenUsage(
-          `${result.stderr}
-${result.stdout}`,
-          text
-        );
-        this.recordUsage(tokens.input, tokens.output);
+        const inputTokens = nonNegativeInt(payload.usage?.input_tokens);
+        const outputTokens = nonNegativeInt(payload.usage?.output_tokens);
+        this.recordUsage(inputTokens, outputTokens);
         return {
           text,
-          tokens,
+          tokens: { input: inputTokens, output: outputTokens },
           latencyMs: Math.round(performance.now() - startedAt),
           model: this.config.model
         };
-      } catch (error) {
-        lastError = error;
-        await finishDiagnostics({ error });
-        throw error;
       } finally {
         await rm2(tempDir, { force: true, recursive: true });
       }
     }
-    throw lastError instanceof Error ? lastError : new Error(String(lastError));
   }
   async discover() {
-    const version = await this.runCodexVersion(
-      resolveCodexCliExecutable(this.config),
-      buildIsolatedCodexEnv()
+    const version = await this.runClaudeVersion(
+      resolveClaudeCliExecutable(this.config),
+      buildIsolatedClaudeEnv(this.config)
     );
     if (version.status !== 0) {
       throw new Error(
-        `Codex CLI discovery failed: ${version.stderr.trim() || `exit ${version.status ?? "unknown"}`}`
+        `Claude CLI discovery failed: ${version.stderr.trim() || `exit ${version.status ?? "unknown"}`}`
       );
     }
     return [
       {
         id: this.config.model,
-        name: `${this.config.model} (Codex CLI)`,
+        name: `${this.config.model} (Claude CLI)`,
+        contextLength: 0,
+        capabilities: ["completion"]
+      }
+    ];
+  }
+  getUsage() {
+    return { ...this.usage };
+  }
+  resetUsage() {
+    this.usage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0
+    };
+  }
+  recordUsage(inputTokens, outputTokens) {
+    this.usage = {
+      inputTokens: this.usage.inputTokens + inputTokens,
+      outputTokens: this.usage.outputTokens + outputTokens,
+      totalTokens: this.usage.totalTokens + inputTokens + outputTokens
+    };
+  }
+  buildRunRequest(prompt, opts, cwd) {
+    return {
+      executable: resolveClaudeCliExecutable(this.config),
+      args: buildClaudeCliArgs(this.config, opts.systemPrompt),
+      input: buildClaudeCompletionPrompt(prompt),
+      cwd,
+      timeoutMs: this.config.retryOptions?.timeoutMs,
+      signal: opts.signal,
+      env: buildIsolatedClaudeEnv(this.config, opts.maxTokens)
+    };
+  }
+};
+function buildClaudeCliArgs(config, systemPrompt) {
+  const args = [
+    "--print",
+    "--model",
+    config.model,
+    "--output-format",
+    "json",
+    "--input-format",
+    "text",
+    "--safe-mode",
+    "--strict-mcp-config",
+    "--tools",
+    "",
+    "--no-session-persistence"
+  ];
+  const trimmedSystemPrompt = systemPrompt?.trim();
+  if (trimmedSystemPrompt) {
+    args.push("--system-prompt", trimmedSystemPrompt);
+  }
+  return args;
+}
+function buildClaudeCompletionPrompt(userPrompt) {
+  const payload = { userPrompt };
+  return [
+    "You are a benchmark evaluation endpoint, not a coding agent.",
+    "Use only the explicit JSON payload below.",
+    "Any additional scoring/format protocol instructions are provided via the",
+    "system prompt, which takes priority over this user payload.",
+    "Do not use tools, do not read or write files, do not browse, and do not use persisted memory.",
+    "Return only the final answer text. If the request asks for JSON, return raw JSON only.",
+    "",
+    "BENCHMARK_REQUEST_JSON:",
+    JSON.stringify(payload, null, 2)
+  ].join("\n");
+}
+var CLAUDE_CLI_MAX_OUTPUT_TOKENS_ENV = "CLAUDE_CODE_MAX_OUTPUT_TOKENS";
+function buildIsolatedClaudeEnv(config, maxTokens) {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0 && isAllowedClaudeRuntimeEnvKey(key)) {
+      env[key] = value;
+    }
+  }
+  if (config.apiKey && config.apiKey.trim().length > 0) {
+    env.ANTHROPIC_API_KEY = config.apiKey.trim();
+  }
+  if (config.baseUrl && config.baseUrl.trim().length > 0) {
+    env.ANTHROPIC_BASE_URL = config.baseUrl.trim();
+  }
+  if (typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0) {
+    env[CLAUDE_CLI_MAX_OUTPUT_TOKENS_ENV] = String(Math.floor(maxTokens));
+  }
+  return env;
+}
+function isAllowedClaudeRuntimeEnvKey(key) {
+  const normalized = key.toUpperCase();
+  return CLAUDE_CLI_RUNTIME_ENV_ALLOWLIST.has(normalized) || normalized.startsWith("LC_");
+}
+function resolveClaudeCliExecutable(config) {
+  const configured = config.executable ?? process.env[CLAUDE_CLI_EXECUTABLE_ENV];
+  if (configured === void 0) {
+    return "claude";
+  }
+  const trimmed = configured.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`${CLAUDE_CLI_EXECUTABLE_ENV} / claude-cli executable must not be empty`);
+  }
+  return expandHomeRelativePath(trimmed);
+}
+function expandHomeRelativePath(value) {
+  if (value === "~") {
+    return os3.homedir();
+  }
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path6.join(os3.homedir(), value.slice(2));
+  }
+  return value;
+}
+function parseClaudeCliJsonResult(stdout) {
+  const trimmed = stdout.trim();
+  if (trimmed.length === 0) {
+    return { is_error: true, error: "Claude CLI produced no stdout." };
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { is_error: true, error: trimmed.slice(-1e3) };
+    }
+    return parsed;
+  } catch {
+    return { is_error: true, error: trimmed.slice(-1e3) };
+  }
+}
+function nonNegativeInt(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 0;
+}
+function isClaudeCliErrorFlagSet(value) {
+  return value === true;
+}
+var USAGE_LIMIT_SIGNAL_REGEX = /\b(?:usage limit|session limit|weekly limit|opus limit|sonnet limit|rate[- ]limit(?:ed)?|too many requests|quota exceeded|429)\b/i;
+function isClaudeUsageLimitSignal(combinedOutput) {
+  return USAGE_LIMIT_SIGNAL_REGEX.test(combinedOutput);
+}
+function isRetryableClaudeCliResult(result) {
+  if (!result.signal) {
+    return false;
+  }
+  const stderr = result.stderr.toLowerCase();
+  if (stderr.includes("timed out after") || stderr.includes("aborted by benchmark timeout")) {
+    return false;
+  }
+  return true;
+}
+function normalizeClaudeCliMaxAttempts(value) {
+  if (value === void 0) {
+    return 3;
+  }
+  if (!Number.isFinite(value) || value < 1) {
+    return 1;
+  }
+  return Math.min(10, Math.floor(value));
+}
+function normalizeUsageLimitMaxWaitMs(value) {
+  if (value === void 0) {
+    return DEFAULT_USAGE_LIMIT_MAX_WAIT_MS;
+  }
+  if (!Number.isFinite(value) || value < 0) {
+    return DEFAULT_USAGE_LIMIT_MAX_WAIT_MS;
+  }
+  return value;
+}
+async function sleepBeforeUsageLimitRetry(options) {
+  const delayMs = Math.min(
+    USAGE_LIMIT_BASE_BACKOFF_MS * Math.pow(2, options.attempt - 1),
+    USAGE_LIMIT_MAX_STEP_MS
+  );
+  const remainingBudgetMs = options.budgetMs - (performance.now() - options.loopStartedAt);
+  if (delayMs > remainingBudgetMs) {
+    throw new Error(
+      `Claude CLI usage-limit backoff budget (${options.budgetMs}ms) exhausted: ${options.failureSummary}`
+    );
+  }
+  await sleepBeforeClaudeCliRetry({
+    attempt: options.attempt,
+    baseBackoffMs: USAGE_LIMIT_BASE_BACKOFF_MS,
+    maxStepMs: USAGE_LIMIT_MAX_STEP_MS,
+    capMs: remainingBudgetMs,
+    signal: options.signal
+  });
+}
+async function sleepBeforeClaudeCliRetry(options) {
+  const baseBackoffMs = options.baseBackoffMs !== void 0 && Number.isFinite(options.baseBackoffMs) && options.baseBackoffMs > 0 ? options.baseBackoffMs : 1e3;
+  const uncappedDelayMs = baseBackoffMs * Math.pow(2, options.attempt - 1);
+  const delayMs = Math.max(0, Math.min(uncappedDelayMs, options.maxStepMs, options.capMs));
+  const signal = options.signal;
+  if (!signal) {
+    await new Promise((resolve) => {
+      setTimeout(resolve, delayMs);
+    });
+    return;
+  }
+  if (signal.aborted) {
+    throw claudeCliAbortError(signal);
+  }
+  await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      clearTimeout(timeout);
+      cleanup();
+      reject(claudeCliAbortError(signal));
+    };
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, delayMs);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function claudeCliAbortError(signal) {
+  if (signal.reason instanceof Error) {
+    return signal.reason;
+  }
+  if (signal.reason !== void 0) {
+    return new Error(String(signal.reason));
+  }
+  return new DOMException("The operation was aborted.", "AbortError");
+}
+function summarizeProcessOutput(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 runClaudeVersionCommand(executable, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(executable, ["--version"], {
+      env,
+      stdio: ["ignore", "ignore", "pipe"],
+      detached: process.platform !== "win32",
+      windowsHide: true
+    });
+    let stderr = "";
+    let timedOut = false;
+    let killTimeout;
+    const terminateChild = (signal) => {
+      if (child.pid && process.platform !== "win32") {
+        try {
+          process.kill(-child.pid, signal);
+          return;
+        } catch {
+        }
+      }
+      child.kill(signal);
+    };
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      terminateChild("SIGTERM");
+      killTimeout = setTimeout(() => {
+        terminateChild("SIGKILL");
+      }, 1e3);
+      killTimeout.unref();
+    }, CLAUDE_CLI_VERSION_TIMEOUT_MS);
+    timeout.unref();
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      stderr = appendBounded(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: timedOut ? status ?? 124 : status,
+        stderr: timedOut ? appendBounded(stderr, `
+Claude CLI --version timed out after ${CLAUDE_CLI_VERSION_TIMEOUT_MS}ms.`) : stderr
+      });
+    });
+  });
+}
+function runClaudeCliCommand(request) {
+  return new Promise((resolve, reject) => {
+    if (request.signal?.aborted) {
+      resolve({
+        status: 124,
+        signal: null,
+        stdout: "",
+        stderr: "Claude CLI aborted before start."
+      });
+      return;
+    }
+    const child = spawn(request.executable, request.args, {
+      cwd: request.cwd,
+      env: request.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: process.platform !== "win32",
+      windowsHide: true
+    });
+    if (child.pid) {
+      registerActiveClaudeCliChild(child.pid);
+    }
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let aborted = false;
+    let killTimeout;
+    const clearKillTimeout = () => {
+      if (killTimeout) {
+        clearTimeout(killTimeout);
+        killTimeout = void 0;
+      }
+    };
+    const terminateChild = (signal) => {
+      if (child.pid && process.platform !== "win32") {
+        try {
+          process.kill(-child.pid, signal);
+          return;
+        } catch {
+        }
+      }
+      child.kill(signal);
+    };
+    const scheduleForcedKill = () => {
+      clearKillTimeout();
+      killTimeout = setTimeout(() => {
+        terminateChild("SIGKILL");
+      }, 1e3);
+      killTimeout.unref();
+    };
+    const onAbort = () => {
+      if (aborted) {
+        return;
+      }
+      aborted = true;
+      stderr = appendBounded(stderr, "\nClaude CLI aborted by benchmark timeout.");
+      terminateChild("SIGTERM");
+      scheduleForcedKill();
+    };
+    request.signal?.addEventListener("abort", onAbort, { once: true });
+    if (request.signal?.aborted) {
+      onAbort();
+    }
+    const timeout = request.timeoutMs ? setTimeout(() => {
+      timedOut = true;
+      terminateChild("SIGTERM");
+      scheduleForcedKill();
+    }, request.timeoutMs) : void 0;
+    timeout?.unref();
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout = appendBounded(stdout, chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr = appendBounded(stderr, chunk);
+    });
+    child.stdin?.on("error", (error) => {
+      stderr = appendBounded(stderr, `
+Claude CLI stdin error: ${error.code ?? error.message}`);
+    });
+    child.on("error", (error) => {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      clearKillTimeout();
+      if (child.pid) {
+        unregisterActiveClaudeCliChild(child.pid);
+      }
+      request.signal?.removeEventListener("abort", onAbort);
+      reject(error);
+    });
+    child.on("close", (status, signal) => {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      clearKillTimeout();
+      if (child.pid) {
+        unregisterActiveClaudeCliChild(child.pid);
+      }
+      request.signal?.removeEventListener("abort", onAbort);
+      if (timedOut) {
+        resolve({
+          status: status ?? 124,
+          signal,
+          stdout,
+          stderr: appendBounded(stderr, `
+Claude CLI timed out after ${request.timeoutMs}ms.`)
+        });
+        return;
+      }
+      if (aborted) {
+        resolve({
+          status: status ?? 124,
+          signal,
+          stdout,
+          stderr
+        });
+        return;
+      }
+      resolve({ status, signal, stdout, stderr });
+    });
+    try {
+      child.stdin?.end(request.input);
+    } catch (error) {
+      stderr = appendBounded(stderr, `
+Claude CLI stdin error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+}
+function registerActiveClaudeCliChild(pid) {
+  installClaudeCliParentCleanup();
+  activeClaudeCliChildPids.add(pid);
+}
+function unregisterActiveClaudeCliChild(pid) {
+  activeClaudeCliChildPids.delete(pid);
+}
+function installClaudeCliParentCleanup() {
+  if (claudeCliParentCleanupInstalled) {
+    return;
+  }
+  claudeCliParentCleanupInstalled = true;
+  process.once("exit", () => {
+    terminateActiveClaudeCliChildren("SIGTERM");
+  });
+  for (const signal of CLAUDE_CLI_PARENT_SIGNALS) {
+    process.once(signal, () => {
+      const activeChildren = activeClaudeCliChildPids.size;
+      terminateActiveClaudeCliChildren(signal === "SIGINT" ? "SIGINT" : "SIGTERM");
+      process.exitCode = signalExitCode(signal);
+      setTimeout(
+        () => {
+          terminateActiveClaudeCliChildren("SIGKILL");
+          process.exit(signalExitCode(signal));
+        },
+        activeChildren > 0 ? CLAUDE_CLI_FORCED_PARENT_EXIT_MS : 0
+      );
+    });
+  }
+}
+function terminateActiveClaudeCliChildren(signal) {
+  for (const pid of activeClaudeCliChildPids) {
+    terminateClaudeCliChildPid(pid, signal);
+  }
+}
+function terminateClaudeCliChildPid(pid, signal) {
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    process.kill(pid, signal);
+  } catch {
+  }
+}
+function signalExitCode(signal) {
+  switch (signal) {
+    case "SIGHUP":
+      return 129;
+    case "SIGINT":
+      return 130;
+    case "SIGTERM":
+      return 143;
+    default:
+      return 1;
+  }
+}
+function appendBounded(existing, next) {
+  const combined = existing + next;
+  if (combined.length <= CLAUDE_CLI_STDIO_LIMIT) {
+    return combined;
+  }
+  return combined.slice(combined.length - CLAUDE_CLI_STDIO_LIMIT);
+}
+function createClaudeCliProvider(config, deps) {
+  return new ClaudeCliProvider(config, deps);
+}
+
+// src/providers/codex-cli.ts
+import { spawn as spawn2 } from "child_process";
+import { createHash as createHash5, randomUUID } from "crypto";
+import { mkdir as mkdir5, mkdtemp as mkdtemp3, readFile as readFile6, rm as rm3, writeFile as writeFile5 } from "fs/promises";
+import os4 from "os";
+import path7 from "path";
+var DEFAULT_REASONING_EFFORT = "xhigh";
+var DEFAULT_SERVICE_TIER = "fast";
+var CODEX_CLI_STDIO_LIMIT = 64e3;
+var CODEX_CLI_PARENT_SIGNALS = [
+  "SIGHUP",
+  "SIGINT",
+  "SIGTERM"
+];
+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_RUNTIME_ENV_ALLOWLIST = /* @__PURE__ */ new Set([
+  "ALL_PROXY",
+  "APPDATA",
+  "CODEX_HOME",
+  "COLORTERM",
+  "COMSPEC",
+  "FORCE_COLOR",
+  "HOME",
+  "HOMEDRIVE",
+  "HOMEPATH",
+  "LANG",
+  "LOCALAPPDATA",
+  "LOGNAME",
+  "NO_COLOR",
+  "NODE_EXTRA_CA_CERTS",
+  "NO_PROXY",
+  "NUMBER_OF_PROCESSORS",
+  OPENAI_BASE_URL_ENV,
+  "OPENAI_ORGANIZATION",
+  "OPENAI_PROJECT",
+  "OS",
+  "PATH",
+  "PATHEXT",
+  "PROGRAMDATA",
+  "PROCESSOR_ARCHITECTURE",
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "SHELL",
+  "SSL_CERT_DIR",
+  "SSL_CERT_FILE",
+  "SYSTEMDRIVE",
+  "SYSTEMROOT",
+  "TEMP",
+  "TERM",
+  "TMP",
+  "TMPDIR",
+  "USER",
+  "USERNAME",
+  "USERPROFILE",
+  "WINDIR",
+  "XDG_CACHE_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_RUNTIME_DIR"
+]);
+var activeCodexCliChildPids = /* @__PURE__ */ new Set();
+var codexCliParentCleanupInstalled = false;
+var codexCliHealthCache = /* @__PURE__ */ new Map();
+var CodexCliProvider = class {
+  provider = "codex-cli";
+  id;
+  name;
+  config;
+  runCodexCli;
+  runCodexVersion;
+  shouldProbeCliHealth;
+  usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0
+  };
+  constructor(config, deps = {}) {
+    this.config = config;
+    this.runCodexCli = deps.runCodexCli ?? runCodexCliCommand;
+    this.runCodexVersion = deps.runCodexVersion ?? runCodexVersionCommand;
+    this.shouldProbeCliHealth = deps.runCodexCli === void 0;
+    this.id = `codex-cli:${config.model}`;
+    this.name = config.model;
+  }
+  async complete(prompt, opts = {}) {
+    const startedAt = performance.now();
+    if (await this.shouldUseResponsesFallback()) {
+      return this.completeViaResponsesApi(prompt, opts, startedAt);
+    }
+    const maxAttempts = normalizeCodexCliMaxAttempts(
+      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");
+      let diagnostics;
+      let diagnosticsFinished = false;
+      const finishDiagnostics = async (outcome) => {
+        if (diagnosticsFinished) {
+          return;
+        }
+        diagnosticsFinished = true;
+        await finishCodexCliDiagnostics(diagnostics, startedAt, outcome);
+      };
+      try {
+        await mkdir5(workspacePath, { recursive: true });
+        const request = this.buildRunRequest(prompt, opts, workspacePath, outputPath);
+        diagnostics = await startCodexCliDiagnostics({
+          config: this.config,
+          request,
+          reasoningEffort: this.config.reasoningEffort ?? DEFAULT_REASONING_EFFORT,
+          serviceTier: DEFAULT_SERVICE_TIER,
+          retry: { attempt, maxAttempts }
+        });
+        const result = await this.runCodexCli(request);
+        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)}`
+          );
+          if (attempt < maxAttempts && isRetryableCodexCliResult(result)) {
+            lastError = error;
+            await finishDiagnostics({
+              result,
+              error,
+              transientFailure: true
+            });
+            await sleepBeforeCodexCliRetry(
+              attempt,
+              this.config.retryOptions?.baseBackoffMs,
+              opts.signal
+            );
+            continue;
+          }
+          await finishDiagnostics({ result, error });
+          throw error;
+        }
+        const text = result.outputText.trim();
+        if (text.length === 0) {
+          const error = new Error(
+            `Codex CLI completion returned no final message: ${summarizeProcessOutput2(result.stderr, result.stdout)}`
+          );
+          await finishDiagnostics({ result, error });
+          throw error;
+        }
+        await finishDiagnostics({ result });
+        const tokens = parseCodexTokenUsage(
+          `${result.stderr}
+${result.stdout}`,
+          text
+        );
+        this.recordUsage(tokens.input, tokens.output);
+        return {
+          text,
+          tokens,
+          latencyMs: Math.round(performance.now() - startedAt),
+          model: this.config.model
+        };
+      } catch (error) {
+        lastError = error;
+        await finishDiagnostics({ error });
+        throw error;
+      } finally {
+        await rm3(tempDir, { force: true, recursive: true });
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  }
+  async discover() {
+    const version = await this.runCodexVersion(
+      resolveCodexCliExecutable(this.config),
+      buildIsolatedCodexEnv()
+    );
+    if (version.status !== 0) {
+      throw new Error(
+        `Codex CLI discovery failed: ${version.stderr.trim() || `exit ${version.status ?? "unknown"}`}`
+      );
+    }
+    return [
+      {
+        id: this.config.model,
+        name: `${this.config.model} (Codex CLI)`,
         contextLength: 0,
         capabilities: ["completion"]
       }
@@ -6686,7 +8020,7 @@ function extractResponsesOutputText(payload) {
 }
 function runCodexVersionCommand(executable, env) {
   return new Promise((resolve, reject) => {
-    const child = spawn(executable, ["--version"], {
+    const child = spawn2(executable, ["--version"], {
       env,
       stdio: ["ignore", "ignore", "pipe"],
       detached: process.platform !== "win32",
@@ -6716,7 +8050,7 @@ function runCodexVersionCommand(executable, env) {
     timeout.unref();
     child.stderr?.setEncoding("utf8");
     child.stderr?.on("data", (chunk) => {
-      stderr = appendBounded(stderr, chunk);
+      stderr = appendBounded2(stderr, chunk);
     });
     child.on("error", (error) => {
       clearTimeout(timeout);
@@ -6732,7 +8066,7 @@ function runCodexVersionCommand(executable, env) {
       }
       resolve({
         status: timedOut ? status ?? 124 : status,
-        stderr: timedOut ? appendBounded(
+        stderr: timedOut ? appendBounded2(
           stderr,
           `
 Codex CLI --version timed out after ${CODEX_CLI_VERSION_TIMEOUT_MS}ms.`
@@ -6752,7 +8086,7 @@ function resolveCodexCliExecutable(config) {
       `${CODEX_CLI_EXECUTABLE_ENV} / codex-cli executable must not be empty`
     );
   }
-  return expandHomeRelativePath(trimmed);
+  return expandHomeRelativePath2(trimmed);
 }
 function buildCodexCompletionPrompt(userPrompt, systemPrompt) {
   const payload = {
@@ -6810,10 +8144,10 @@ async function startCodexCliDiagnostics(args) {
       model: args.config.model,
       reasoningEffort: args.reasoningEffort,
       serviceTier: args.serviceTier,
-      executable: path6.basename(args.request.executable),
+      executable: path7.basename(args.request.executable),
       ...args.request.timeoutMs ? { timeoutMs: args.request.timeoutMs } : {},
-      workspaceBasename: path6.basename(args.request.workspacePath),
-      outputBasename: path6.basename(args.request.outputPath),
+      workspaceBasename: path7.basename(args.request.workspacePath),
+      outputBasename: path7.basename(args.request.outputPath),
       prompt: promptStats,
       command: {
         args: redactCodexCliArgs(args.request.args)
@@ -6821,7 +8155,7 @@ async function startCodexCliDiagnostics(args) {
       retry: args.retry,
       ...mode === "full" ? { fullPrompt: args.request.input } : {}
     };
-    const filePath = path6.join(diagnosticsDir, `${id}.json`);
+    const filePath = path7.join(diagnosticsDir, `${id}.json`);
     await writeCodexCliDiagnosticRecord(filePath, record);
     return { path: filePath, record };
   } catch {
@@ -6873,14 +8207,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 ? path6.resolve(expandHomeRelativePath(trimmed)) : void 0;
+  return trimmed.length > 0 ? path7.resolve(expandHomeRelativePath2(trimmed)) : void 0;
 }
-function expandHomeRelativePath(value) {
+function expandHomeRelativePath2(value) {
   if (value === "~") {
-    return os3.homedir();
+    return os4.homedir();
   }
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path6.join(os3.homedir(), value.slice(2));
+    return path7.join(os4.homedir(), value.slice(2));
   }
   return value;
 }
@@ -6939,7 +8273,7 @@ function runCodexCliCommand(request) {
       });
       return;
     }
-    const child = spawn(request.executable, request.args, {
+    const child = spawn2(request.executable, request.args, {
       cwd: request.workspacePath,
       env: request.env,
       stdio: ["pipe", "pipe", "pipe"],
@@ -6982,7 +8316,7 @@ function runCodexCliCommand(request) {
         return;
       }
       aborted = true;
-      stderr = appendBounded(stderr, "\nCodex CLI aborted by benchmark timeout.");
+      stderr = appendBounded2(stderr, "\nCodex CLI aborted by benchmark timeout.");
       terminateChild("SIGTERM");
       scheduleForcedKill();
     };
@@ -6999,13 +8333,13 @@ function runCodexCliCommand(request) {
     child.stdout?.setEncoding("utf8");
     child.stderr?.setEncoding("utf8");
     child.stdout?.on("data", (chunk) => {
-      stdout = appendBounded(stdout, chunk);
+      stdout = appendBounded2(stdout, chunk);
     });
     child.stderr?.on("data", (chunk) => {
-      stderr = appendBounded(stderr, chunk);
+      stderr = appendBounded2(stderr, chunk);
     });
     child.stdin?.on("error", (error) => {
-      stderr = appendBounded(
+      stderr = appendBounded2(
         stderr,
         `
 Codex CLI stdin error: ${error.code ?? error.message}`
@@ -7036,7 +8370,7 @@ Codex CLI stdin error: ${error.code ?? error.message}`
           status: status ?? 124,
           signal,
           stdout,
-          stderr: appendBounded(
+          stderr: appendBounded2(
             stderr,
             `
 Codex CLI timed out after ${request.timeoutMs}ms.`
@@ -7065,7 +8399,7 @@ Codex CLI timed out after ${request.timeoutMs}ms.`
     try {
       child.stdin?.end(request.input);
     } catch (error) {
-      stderr = appendBounded(
+      stderr = appendBounded2(
         stderr,
         `
 Codex CLI stdin error: ${error instanceof Error ? error.message : String(error)}`
@@ -7092,11 +8426,11 @@ function installCodexCliParentCleanup() {
     process.once(signal, () => {
       const activeChildren = activeCodexCliChildPids.size;
       terminateActiveCodexCliChildren(signal === "SIGINT" ? "SIGINT" : "SIGTERM");
-      process.exitCode = signalExitCode(signal);
+      process.exitCode = signalExitCode2(signal);
       setTimeout(
         () => {
           terminateActiveCodexCliChildren("SIGKILL");
-          process.exit(signalExitCode(signal));
+          process.exit(signalExitCode2(signal));
         },
         activeChildren > 0 ? CODEX_CLI_FORCED_PARENT_EXIT_MS : 0
       );
@@ -7121,7 +8455,7 @@ function terminateCodexCliChildPid(pid, signal) {
   } catch {
   }
 }
-function signalExitCode(signal) {
+function signalExitCode2(signal) {
   switch (signal) {
     case "SIGHUP":
       return 129;
@@ -7140,7 +8474,7 @@ async function readCodexOutput(outputPath, stdout) {
     return stdout;
   }
 }
-function appendBounded(existing, next) {
+function appendBounded2(existing, next) {
   const combined = existing + next;
   if (combined.length <= CODEX_CLI_STDIO_LIMIT) {
     return combined;
@@ -7210,7 +8544,7 @@ function codexCliAbortError(signal) {
   }
   return new DOMException("The operation was aborted.", "AbortError");
 }
-function summarizeProcessOutput(stderr, stdout) {
+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";
 }
@@ -7247,19 +8581,19 @@ 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 path9 from "path";
+import path10 from "path";
 
 // src/filename-safety.ts
-import path7 from "path";
+import path8 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 = path7.resolve(root);
-  const filePath = path7.resolve(outputRoot, ...segments);
-  const relativePath = path7.relative(outputRoot, filePath);
-  if (relativePath === ".." || relativePath.startsWith(`..${path7.sep}`) || path7.isAbsolute(relativePath)) {
+  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)) {
     throw new Error(`Refusing to write benchmark artifact outside ${outputRoot}`);
   }
   return filePath;
@@ -7267,7 +8601,7 @@ function resolveContainedPath(root, ...segments) {
 
 // src/leaderboard-export.ts
 import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 async function writeLeaderboardArtifactsForResult(result, outputDir) {
   if (result.meta.benchmark === "ama-bench") {
     return writeAmaBenchLeaderboard(result, outputDir);
@@ -7282,7 +8616,7 @@ async function writeAmaBenchLeaderboard(result, outputDir) {
   if (rows.length === 0) {
     return [];
   }
-  const outputRoot = path8.resolve(outputDir);
+  const outputRoot = path9.resolve(outputDir);
   const leaderboardDir = resolveContainedPath(outputRoot, "leaderboard");
   await mkdir6(leaderboardDir, { recursive: true });
   const timestamp = sanitizeFilenameSegment(result.meta.timestamp.replace(/[:.]/g, "-"));
@@ -7300,7 +8634,7 @@ async function writeAmaBenchLeaderboard(result, outputDir) {
 async function writeMemCorrectLeaderboard(result, outputDir) {
   const row = buildMemCorrectLeaderboardRow(result);
   if (!row) return [];
-  const outputRoot = path8.resolve(outputDir);
+  const outputRoot = path9.resolve(outputDir);
   const leaderboardDir = resolveContainedPath(outputRoot, "leaderboard");
   await mkdir6(leaderboardDir, { recursive: true });
   const timestamp = sanitizeFilenameSegment(result.meta.timestamp.replace(/[:.]/g, "-"));
@@ -7668,7 +9002,7 @@ function replaceLoneSurrogates(value) {
   return out;
 }
 async function writeBenchmarkResult(result, outputDir) {
-  const outputRoot = path9.resolve(outputDir);
+  const outputRoot = path10.resolve(outputDir);
   await mkdir7(outputRoot, { recursive: true });
   const safeBenchmark = sanitizeFilenameSegment(result.meta.benchmark);
   const safeRemnicVersion = sanitizeFilenameSegment(result.meta.remnicVersion);
@@ -7704,7 +9038,7 @@ async function writeBenchmarkResult(result, outputDir) {
 async function getRemnicVersion() {
   try {
     const packageJson = JSON.parse(
-      await readFile7(path9.resolve(import.meta.dirname, "../../../package.json"), "utf8")
+      await readFile7(path10.resolve(import.meta.dirname, "../../../package.json"), "utf8")
     );
     return typeof packageJson.version === "string" ? packageJson.version : "unknown";
   } catch {
@@ -8210,6 +9544,8 @@ function createProvider(config) {
       return createLocalLlmProvider(config);
     case "codex-cli":
       return createCodexCliProvider(config);
+    case "claude-cli":
+      return createClaudeCliProvider(config);
     default: {
       const exhaustive = config;
       throw new Error(`Unknown provider: ${JSON.stringify(exhaustive)}`);
@@ -9752,7 +11088,7 @@ function clampNormalizedScore(value) {
 }
 
 // src/runtime-profiles.ts
-import path10 from "path";
+import path11 from "path";
 import { readFile as readFile9 } from "fs/promises";
 import {
   resolvePluginEntry,
@@ -10796,10 +12132,10 @@ async function loadOpenclawRuntimeConfig(filePath) {
   };
 }
 function deriveOpenclawRuntimeContext(configPath) {
-  const rootDir = path10.dirname(path10.resolve(configPath));
+  const rootDir = path11.dirname(path11.resolve(configPath));
   return {
-    agentDir: path10.join(rootDir, "agents", "main", "agent"),
-    workspaceDir: path10.join(rootDir, "workspace")
+    agentDir: path11.join(rootDir, "agents", "main", "agent"),
+    workspaceDir: path11.join(rootDir, "workspace")
   };
 }
 async function loadJsonObject(filePath, label) {
@@ -10836,6 +12172,11 @@ function resolveProviderConfig(kind, provider, model, baseUrl, requestTimeout, d
       `${kind} provider "local-llm" requires a baseUrl (e.g. http://localhost:8080/v1 for llama.cpp).`
     );
   }
+  if (kind === "internal" && provider === "claude-cli") {
+    throw new Error(
+      `${kind} provider "claude-cli" is not supported: it has no @remnic/core gateway wiring and is only available via --provider, --system-provider, or --judge-provider.`
+    );
+  }
   if (reasoningEffort !== void 0 && provider !== "codex-cli") {
     throw new Error(
       `${kind} Codex reasoning effort requires provider "codex-cli"`
@@ -10958,6 +12299,11 @@ function gatewayProviderApi(provider) {
   if (provider === "codex-cli") {
     return "codex-cli";
   }
+  if (provider === "claude-cli") {
+    throw new Error(
+      "claude-cli has no @remnic/core gateway api mapping; it is only supported as a --provider / --system-provider / --judge-provider, not an internal provider."
+    );
+  }
   if (provider === "ollama") {
     return "ollama-chat";
   }
@@ -10978,6 +12324,10 @@ function defaultInternalBaseUrl(provider) {
       return "http://localhost:11434/api";
     case "codex-cli":
       return "codex-cli://local";
+    case "claude-cli":
+      throw new Error(
+        "claude-cli has no internal-provider base URL; it is only supported as a --provider / --system-provider / --judge-provider, not an internal provider."
+      );
     case "local-llm":
       return void 0;
     default: {
@@ -11198,7 +12548,7 @@ async function resolveLocalLabRuntimeProfile(options) {
 
 // src/benchmark.ts
 import fs2 from "fs";
-import path33 from "path";
+import path34 from "path";
 import { createHash as createHash11 } from "crypto";
 import { expandTildePath as expandTildePath3 } from "@remnic/core";
 
@@ -11208,10 +12558,10 @@ import {
   mkdir as mkdir8,
   readFile as readFile10,
   rename as rename2,
-  rm as rm3,
+  rm as rm4,
   writeFile as writeFile8
 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 var JUDGE_CACHE_PROTOCOL_VERSION = "judge-protocol-v1";
 function stableStringify2(value) {
   if (Array.isArray(value)) {
@@ -11242,7 +12592,7 @@ var JudgeCache = class {
   inflight = /* @__PURE__ */ new Map();
   cachedDirExists = false;
   constructor(options) {
-    this.dir = path11.resolve(options.dir);
+    this.dir = path12.resolve(options.dir);
   }
   /** Compute the sha256-hex key for a set of parts. Pure, sync, side-effect-free. */
   computeKey(parts) {
@@ -11317,7 +12667,7 @@ var JudgeCache = class {
       this.cachedDirExists = true;
     }
     const filePath = this.entryPath(key);
-    const tempPath = path11.join(
+    const tempPath = path12.join(
       this.dir,
       `.${key}.${randomBytes2(6).toString("hex")}.tmp`
     );
@@ -11326,12 +12676,12 @@ var JudgeCache = class {
     try {
       await rename2(tempPath, filePath);
     } catch (error) {
-      await rm3(tempPath, { force: true }).catch(() => void 0);
+      await rm4(tempPath, { force: true }).catch(() => void 0);
       throw error;
     }
   }
   entryPath(key) {
-    return path11.join(this.dir, `${key}.json`);
+    return path12.join(this.dir, `${key}.json`);
   }
 };
 function runJudgeWithCache(options) {
@@ -11506,7 +12856,7 @@ function isBenchJudgeResult(value) {
 // src/benchmarks/published/ama-bench/runner.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { readFile as readFile11 } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 
 // src/benchmarks/published/ama-bench/fixture.ts
 var AMA_BENCH_SMOKE_FIXTURE = [
@@ -12081,7 +13431,7 @@ async function loadDataset(mode, datasetDir, limit) {
     return episodes;
   };
   if (datasetDir) {
-    const filePath = path12.join(datasetDir, "open_end_qa_set.jsonl");
+    const filePath = path13.join(datasetDir, "open_end_qa_set.jsonl");
     let raw;
     try {
       raw = await readFile11(filePath, "utf8");
@@ -12377,7 +13727,7 @@ function isValidQaPairs(value) {
 // src/benchmarks/published/amemgym/runner.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { readFile as readFile12 } from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 
 // src/benchmarks/published/amemgym/fixture.ts
 var AMEMGYM_SMOKE_FIXTURE = [
@@ -12906,7 +14256,7 @@ async function loadDataset2(mode, datasetDir, limit) {
     const datasetErrors = [];
     for (const filename of DATASET_FILENAMES) {
       try {
-        const raw = await readFile12(path13.join(datasetDir, filename), "utf8");
+        const raw = await readFile12(path14.join(datasetDir, filename), "utf8");
         const parsed = parseDataset(raw, filename, normalizedLimit);
         return ensureDatasetProfiles(parsed);
       } catch (error) {
@@ -13081,7 +14431,7 @@ 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 path14 from "path";
+import path15 from "path";
 import { expandTildePath as expandTildePath2 } from "@remnic/core";
 
 // src/benchmarks/published/memory-arena/fixture.ts
@@ -13408,7 +14758,7 @@ async function loadDataset3(mode, datasetDir, limit) {
       if (remainingLimit2 === 0) {
         break;
       }
-      const raw = await readFile13(path14.join(datasetDir, filename), "utf8");
+      const raw = await readFile13(path15.join(datasetDir, filename), "utf8");
       const parsedTasks = [];
       raw.split("\n").forEach((line, lineIndex) => {
         if (line.trim().length === 0) {
@@ -13764,14 +15114,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 path14.resolve(expandTildePath2(configuredPath));
+    return path15.resolve(expandTildePath2(configuredPath));
   }
   if (datasetDir === void 0) {
     return void 0;
   }
   const candidatePaths = [
     ...MEMORY_ARENA_WEBSHOP_PRODUCT_SIDECAR_FILENAMES
-  ].map((filename) => path14.join(datasetDir, filename));
+  ].map((filename) => path15.join(datasetDir, filename));
   for (const candidatePath of candidatePaths) {
     try {
       const candidateStat = await stat3(candidatePath);
@@ -15194,7 +16544,7 @@ import { collectTemporalLexicalCues } from "@remnic/core";
 
 // src/benchmarks/published/dataset-loader.ts
 import { readFile as readFile14 } from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 
 // src/benchmarks/published/longmemeval/fixture.ts
 var LONG_MEM_EVAL_SMOKE_FIXTURE = [
@@ -15297,7 +16647,7 @@ async function loadDataset4(options) {
   const errors = [];
   if (options.datasetDir) {
     for (const filename of options.filenames) {
-      const abs = path15.join(options.datasetDir, filename);
+      const abs = path16.join(options.datasetDir, filename);
       let raw;
       try {
         raw = await readFile14(abs, "utf8");
@@ -17037,7 +18387,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 path16 from "path";
+import path17 from "path";
 import { createInterface } from "readline/promises";
 import {
   asyncBufferFromFile,
@@ -17508,8 +18858,8 @@ async function listBeamDatasetFiles(datasetDir) {
     return directFiles;
   }
   try {
-    const nestedFilenames = await readdir6(path16.join(datasetDir, "data"));
-    return nestedFilenames.filter((filename) => isBeamDatasetFilename(filename)).map((filename) => path16.join("data", filename));
+    const nestedFilenames = await readdir6(path17.join(datasetDir, "data"));
+    return nestedFilenames.filter((filename) => isBeamDatasetFilename(filename)).map((filename) => path17.join("data", filename));
   } catch {
     return [];
   }
@@ -17536,7 +18886,7 @@ async function* iterateDatasetFiles(datasetDir, datasetFiles, limit) {
   let remainingLimit = limit;
   for (const filename of datasetFiles) {
     const scale = inferScaleFromFilename(filename);
-    const filePath = path16.join(datasetDir, filename);
+    const filePath = path17.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 {
@@ -18549,7 +19899,7 @@ 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 path17 from "path";
+import path18 from "path";
 
 // src/benchmarks/published/personamem/fixture.ts
 var PERSONAMEM_SMOKE_FIXTURE = [
@@ -18825,7 +20175,7 @@ async function loadDataset8(mode, datasetDir, limit) {
   if (datasetDir) {
     const datasetErrors = [];
     for (const relativePath of DATASET_FILE_CANDIDATES) {
-      const datasetPath = path17.join(datasetDir, relativePath);
+      const datasetPath = path18.join(datasetDir, relativePath);
       let raw;
       try {
         raw = await readFile15(datasetPath, "utf8");
@@ -19019,12 +20369,12 @@ function parseCsv(raw, limit) {
   return rows;
 }
 async function resolveDatasetFilePath(datasetRoot, relativePath) {
-  const rootPath = path17.resolve(datasetRoot);
+  const rootPath = path18.resolve(datasetRoot);
   const rootRealPath = await realpath4(rootPath);
-  const candidatePath = path17.resolve(rootPath, relativePath);
+  const candidatePath = path18.resolve(rootPath, relativePath);
   const candidateRealPath = await realpath4(candidatePath);
-  const relativeToRoot = path17.relative(rootRealPath, candidateRealPath);
-  if (relativeToRoot.startsWith("..") || path17.isAbsolute(relativeToRoot)) {
+  const relativeToRoot = path18.relative(rootRealPath, candidateRealPath);
+  if (relativeToRoot.startsWith("..") || path18.isAbsolute(relativeToRoot)) {
     throw new Error(
       `PersonaMem-v2 dataset file reference "${relativePath}" must stay within datasetDir.`
     );
@@ -19353,7 +20703,7 @@ 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 path18 from "path";
+import path19 from "path";
 
 // src/benchmarks/published/membench/fixture.ts
 var MEMBENCH_SMOKE_FIXTURE = [
@@ -19614,7 +20964,7 @@ async function loadDataset9(mode, datasetDir, limit) {
     let remainingLimit = normalizedLimit;
     for (const filename of filenames) {
       try {
-        const raw = await readFile16(path18.join(datasetDir, filename), "utf8");
+        const raw = await readFile16(path19.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) {
@@ -20482,7 +21832,7 @@ function isPlainObject4(value) {
 // src/benchmarks/published/memoryagentbench/runner.ts
 import { randomUUID as randomUUID9 } from "crypto";
 import { access, readFile as readFile17 } from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 
 // src/benchmarks/published/memoryagentbench/fixture.ts
 var MEMORY_AGENT_BENCH_SMOKE_FIXTURE = [
@@ -21561,21 +22911,21 @@ function recsysEntityMappingCandidates(datasetDir) {
   if (!datasetDir) {
     return [];
   }
-  const absoluteDatasetDir = path19.resolve(datasetDir);
+  const absoluteDatasetDir = path20.resolve(datasetDir);
   const roots = [
     absoluteDatasetDir,
-    path19.dirname(absoluteDatasetDir)
+    path20.dirname(absoluteDatasetDir)
   ];
   const canonicalSuffixes = [
-    path19.join("processed_data", "Recsys_Redial", "entity2id.json"),
-    path19.join("Recsys_Redial", "entity2id.json")
+    path20.join("processed_data", "Recsys_Redial", "entity2id.json"),
+    path20.join("Recsys_Redial", "entity2id.json")
   ];
   const looseSuffixes = ["entity2id.json"];
   return [
     ...roots.flatMap(
-      (root) => canonicalSuffixes.map((suffix) => path19.join(root, suffix))
+      (root) => canonicalSuffixes.map((suffix) => path20.join(root, suffix))
     ),
-    ...looseSuffixes.map((suffix) => path19.join(absoluteDatasetDir, suffix))
+    ...looseSuffixes.map((suffix) => path20.join(absoluteDatasetDir, suffix))
   ];
 }
 async function fileExists(filePath) {
@@ -21612,7 +22962,7 @@ async function loadDataset10(mode, datasetDir, limit) {
     const datasetErrors = [];
     for (const filename of DATASET_BUNDLE_CANDIDATES) {
       const parsed = await tryReadDatasetFile(
-        path19.join(datasetDir, filename),
+        path20.join(datasetDir, filename),
         filename,
         datasetErrors
       );
@@ -21629,7 +22979,7 @@ async function loadDataset10(mode, datasetDir, limit) {
       let splitData;
       for (const filename of splitConfig.candidates) {
         try {
-          splitData = await readDatasetFile(path19.join(datasetDir, filename), filename);
+          splitData = await readDatasetFile(path20.join(datasetDir, filename), filename);
           break;
         } catch (error) {
           if (!isFileNotFoundError2(error)) {
@@ -22277,8 +23627,8 @@ function loadCases(mode, limit) {
 
 // src/benchmarks/remnic/extraction-judge-calibration/runner.ts
 import { randomUUID as randomUUID11 } from "crypto";
-import os4 from "os";
-import path20 from "path";
+import os5 from "os";
+import path21 from "path";
 import {
   createVerdictCache,
   judgeFactDurability,
@@ -22388,8 +23738,8 @@ var extractionJudgeCalibrationDefinition = {
 async function runExtractionJudgeCalibrationBenchmark(options) {
   const cases = loadCases2(options.mode, options.limit);
   const config = parseConfig2({
-    memoryDir: path20.join(os4.tmpdir(), "remnic-bench-extraction-judge"),
-    workspaceDir: path20.join(os4.tmpdir(), "remnic-bench-extraction-judge-workspace"),
+    memoryDir: path21.join(os5.tmpdir(), "remnic-bench-extraction-judge"),
+    workspaceDir: path21.join(os5.tmpdir(), "remnic-bench-extraction-judge-workspace"),
     openaiApiKey: "bench-test-key",
     extractionJudgeEnabled: true,
     extractionJudgeBatchSize: 4,
@@ -22937,10 +24287,10 @@ function constantAggregate2(value) {
 }
 
 // src/benchmarks/remnic/entity-consolidation/runner.ts
-import os5 from "os";
-import path21 from "path";
+import os6 from "os";
+import path22 from "path";
 import { randomUUID as randomUUID13 } from "crypto";
-import { mkdtemp as mkdtemp3, rm as rm4 } from "fs/promises";
+import { mkdtemp as mkdtemp4, rm as rm5 } from "fs/promises";
 import { StorageManager } from "@remnic/core";
 
 // src/benchmarks/remnic/entity-consolidation/fixture.ts
@@ -23101,7 +24451,7 @@ function loadCases4(mode, limit) {
   return limited;
 }
 async function executeCase(sample) {
-  const tmpDir = await mkdtemp3(path21.join(os5.tmpdir(), "remnic-bench-entity-consolidation-"));
+  const tmpDir = await mkdtemp4(path22.join(os6.tmpdir(), "remnic-bench-entity-consolidation-"));
   try {
     const storage = new StorageManager(tmpDir);
     await storage.ensureDirectories();
@@ -23109,7 +24459,7 @@ async function executeCase(sample) {
     const rawEntity = await storage.readEntity(canonicalName);
     return summarizeEntity(rawEntity, canonicalName);
   } finally {
-    await rm4(tmpDir, { recursive: true, force: true });
+    await rm5(tmpDir, { recursive: true, force: true });
   }
 }
 async function applyScenario(storage, sample) {
@@ -23280,9 +24630,9 @@ function parseNonNegativeInt(rawValue) {
 
 // src/benchmarks/remnic/page-versioning/runner.ts
 import { randomUUID as randomUUID14 } from "crypto";
-import { mkdir as mkdir9, mkdtemp as mkdtemp4, readFile as readFile18, rm as rm5, writeFile as writeFile9 } from "fs/promises";
-import os6 from "os";
-import path22 from "path";
+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 {
   createVersion,
   diffVersions,
@@ -23446,10 +24796,10 @@ function loadCases5(mode, limit) {
   return limited;
 }
 async function executeCase2(sample, dependencies) {
-  const tmpDir = await mkdtemp4(path22.join(os6.tmpdir(), "remnic-bench-page-versioning-"));
+  const tmpDir = await mkdtemp5(path23.join(os7.tmpdir(), "remnic-bench-page-versioning-"));
   try {
-    const factsDir = path22.join(tmpDir, "facts");
-    const pagePath = path22.join(factsDir, `${sample.id}.md`);
+    const factsDir = path23.join(tmpDir, "facts");
+    const pagePath = path23.join(factsDir, `${sample.id}.md`);
     await mkdir9(factsDir, { recursive: true });
     const config = versioningConfig();
     switch (sample.scenario) {
@@ -23530,7 +24880,7 @@ async function executeCase2(sample, dependencies) {
       }
     }
   } finally {
-    await rm5(tmpDir, { recursive: true, force: true });
+    await rm6(tmpDir, { recursive: true, force: true });
   }
 }
 function isMissingPageVersionError(error, pagePath, versionId) {
@@ -25803,9 +27153,9 @@ function loadCases9(mode, limit) {
 
 // src/benchmarks/remnic/procedural-recall/runner.ts
 import { randomUUID as randomUUID21 } from "crypto";
-import { mkdtemp as mkdtemp5, rm as rm6 } from "fs/promises";
-import os7 from "os";
-import path23 from "path";
+import { mkdtemp as mkdtemp6, rm as rm7 } from "fs/promises";
+import os8 from "os";
+import path24 from "path";
 import {
   StorageManager as StorageManager2,
   parseConfig as parseConfig3,
@@ -25935,7 +27285,7 @@ async function runProceduralRecallBenchmark(options) {
   }
   for (const sample of e2eCases) {
     const startedAt = performance.now();
-    const dir = await mkdtemp5(path23.join(os7.tmpdir(), "remnic-bench-procedural-recall-"));
+    const dir = await mkdtemp6(path24.join(os8.tmpdir(), "remnic-bench-procedural-recall-"));
     let section = null;
     try {
       const storage = new StorageManager2(dir);
@@ -25950,7 +27300,7 @@ ${body}`,
       );
       const config = parseConfig3({
         memoryDir: dir,
-        workspaceDir: path23.join(dir, "ws"),
+        workspaceDir: path24.join(dir, "ws"),
         openaiApiKey: "bench-key",
         procedural: {
           enabled: sample.proceduralEnabled !== false,
@@ -25959,7 +27309,7 @@ ${body}`,
       });
       section = await buildProcedureRecallSection(storage, sample.prompt, config);
     } finally {
-      await rm6(dir, { recursive: true, force: true });
+      await rm7(dir, { recursive: true, force: true });
     }
     const latencyMs = Math.round(performance.now() - startedAt);
     const nonNull = section !== null && section.length > 0;
@@ -26020,9 +27370,9 @@ ${body}`,
 
 // src/benchmarks/remnic/ingestion-entity-recall/runner.ts
 import { randomUUID as randomUUID22 } from "crypto";
-import { mkdtemp as mkdtemp6, writeFile as writeFile10, rm as rm7, mkdir as mkdir10, realpath as realpath5 } from "fs/promises";
+import { mkdtemp as mkdtemp7, writeFile as writeFile10, rm as rm8, mkdir as mkdir10, realpath as realpath5 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import path24 from "path";
+import path25 from "path";
 
 // src/ingestion-scorer.ts
 function normalize(value) {
@@ -26524,12 +27874,12 @@ async function runIngestionEntityRecallBenchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp6(path24.join(tmpdir2(), "bench-email-"));
+  const fixtureDir = await mkdtemp7(path25.join(tmpdir2(), "bench-email-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path24.join(fixtureDir, file.relativePath);
-      await mkdir10(path24.dirname(filePath), { recursive: true });
+      const filePath = path25.join(fixtureDir, file.relativePath);
+      await mkdir10(path25.dirname(filePath), { recursive: true });
       await writeFile10(filePath, file.content, "utf8");
     }
     const { result: ingestionLog, durationMs } = await timed(
@@ -26611,7 +27961,7 @@ async function runIngestionEntityRecallBenchmark(options) {
     ];
     return buildResult(options, tasks, durationMs);
   } finally {
-    await rm7(fixtureDir, { recursive: true, force: true });
+    await rm8(fixtureDir, { recursive: true, force: true });
   }
 }
 async function buildResult(options, tasks, totalLatencyMs) {
@@ -26657,9 +28007,9 @@ async function buildResult(options, tasks, totalLatencyMs) {
 
 // src/benchmarks/remnic/ingestion-schema-completeness/runner.ts
 import { randomUUID as randomUUID23 } from "crypto";
-import { mkdtemp as mkdtemp7, writeFile as writeFile11, rm as rm8, mkdir as mkdir11, realpath as realpath6 } from "fs/promises";
+import { mkdtemp as mkdtemp8, writeFile as writeFile11, rm as rm9, mkdir as mkdir11, realpath as realpath6 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import path25 from "path";
+import path26 from "path";
 var ingestionSchemaCompletenessDefinition = {
   id: "ingestion-schema-completeness",
   title: "Ingestion: Schema Completeness",
@@ -26678,12 +28028,12 @@ async function runIngestionSchemaCompletenessBenchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp7(path25.join(tmpdir3(), "bench-email-"));
+  const fixtureDir = await mkdtemp8(path26.join(tmpdir3(), "bench-email-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path25.join(fixtureDir, file.relativePath);
-      await mkdir11(path25.dirname(filePath), { recursive: true });
+      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(
@@ -26824,15 +28174,15 @@ async function runIngestionSchemaCompletenessBenchmark(options) {
       }
     };
   } finally {
-    await rm8(fixtureDir, { recursive: true, force: true });
+    await rm9(fixtureDir, { recursive: true, force: true });
   }
 }
 
 // src/benchmarks/remnic/ingestion-backlink-f1/runner.ts
 import { randomUUID as randomUUID24 } from "crypto";
-import { mkdtemp as mkdtemp8, writeFile as writeFile12, rm as rm9, mkdir as mkdir12, realpath as realpath7 } from "fs/promises";
+import { mkdtemp as mkdtemp9, writeFile as writeFile12, rm as rm10, mkdir as mkdir12, realpath as realpath7 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import path26 from "path";
+import path27 from "path";
 var ingestionBacklinkF1Definition = {
   id: "ingestion-backlink-f1",
   title: "Ingestion: Backlink F1",
@@ -26851,12 +28201,12 @@ async function runIngestionBacklinkF1Benchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp8(path26.join(tmpdir4(), "bench-email-"));
+  const fixtureDir = await mkdtemp9(path27.join(tmpdir4(), "bench-email-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path26.join(fixtureDir, file.relativePath);
-      await mkdir12(path26.dirname(filePath), { recursive: true });
+      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(
@@ -26925,15 +28275,15 @@ async function runIngestionBacklinkF1Benchmark(options) {
       }
     };
   } finally {
-    await rm9(fixtureDir, { recursive: true, force: true });
+    await rm10(fixtureDir, { recursive: true, force: true });
   }
 }
 
 // src/benchmarks/remnic/ingestion-setup-friction/runner.ts
 import { randomUUID as randomUUID25 } from "crypto";
-import { mkdtemp as mkdtemp9, writeFile as writeFile13, rm as rm10, mkdir as mkdir13, realpath as realpath8 } from "fs/promises";
+import { mkdtemp as mkdtemp10, writeFile as writeFile13, rm as rm11, mkdir as mkdir13, realpath as realpath8 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
-import path27 from "path";
+import path28 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",
@@ -26953,12 +28303,12 @@ async function runIngestionSetupFrictionBenchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp9(path27.join(tmpdir5(), "bench-friction-"));
+  const fixtureDir = await mkdtemp10(path28.join(tmpdir5(), "bench-friction-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path27.join(fixtureDir, file.relativePath);
-      await mkdir13(path27.dirname(filePath), { recursive: true });
+      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(
@@ -27031,15 +28381,15 @@ async function runIngestionSetupFrictionBenchmark(options) {
       }
     };
   } finally {
-    await rm10(fixtureDir, { recursive: true, force: true });
+    await rm11(fixtureDir, { recursive: true, force: true });
   }
 }
 
 // src/benchmarks/remnic/ingestion-citation-accuracy/runner.ts
 import { randomUUID as randomUUID26 } from "crypto";
-import { mkdtemp as mkdtemp10, writeFile as writeFile14, rm as rm11, mkdir as mkdir14, realpath as realpath9 } from "fs/promises";
+import { mkdtemp as mkdtemp11, writeFile as writeFile14, rm as rm12, mkdir as mkdir14, realpath as realpath9 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import path28 from "path";
+import path29 from "path";
 var CITATION_SUPPORT_THRESHOLD = 0.72;
 var ingestionCitationAccuracyDefinition = {
   id: "ingestion-citation-accuracy",
@@ -27098,10 +28448,10 @@ function resolveCitedSources(sourceRefs, seeAlso, pageRef, sourceContentMap) {
     return "";
   }
   for (const ref of normalizedRefs) {
-    const refBase = path28.basename(ref).toLowerCase();
+    const refBase = path29.basename(ref).toLowerCase();
     let matched = false;
     for (const [relativePath, content] of sourceContentMap) {
-      if (relativePath === ref || relativePath.endsWith(ref) || path28.basename(relativePath).toLowerCase() === refBase) {
+      if (relativePath === ref || relativePath.endsWith(ref) || path29.basename(relativePath).toLowerCase() === refBase) {
         resolved.push(content);
         matched = true;
         break;
@@ -27117,9 +28467,9 @@ function resolveCitedSources(sourceRefs, seeAlso, pageRef, sourceContentMap) {
   if (normalizedRefs.length > 0) {
     return "";
   }
-  const pageBase = path28.basename(pageRef).toLowerCase();
+  const pageBase = path29.basename(pageRef).toLowerCase();
   for (const [relativePath, content] of sourceContentMap) {
-    if (path28.basename(relativePath).toLowerCase() === pageBase) {
+    if (path29.basename(relativePath).toLowerCase() === pageBase) {
       return content;
     }
   }
@@ -27130,12 +28480,12 @@ async function runIngestionCitationAccuracyBenchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp10(path28.join(tmpdir6(), "bench-citation-"));
+  const fixtureDir = await mkdtemp11(path29.join(tmpdir6(), "bench-citation-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path28.join(fixtureDir, file.relativePath);
-      await mkdir14(path28.dirname(filePath), { recursive: true });
+      const filePath = path29.join(fixtureDir, file.relativePath);
+      await mkdir14(path29.dirname(filePath), { recursive: true });
       await writeFile14(filePath, file.content, "utf8");
     }
     const benchmarkStart = performance.now();
@@ -27333,7 +28683,7 @@ async function runIngestionCitationAccuracyBenchmark(options) {
       }
     };
   } finally {
-    await rm11(fixtureDir, { recursive: true, force: true });
+    await rm12(fixtureDir, { recursive: true, force: true });
   }
 }
 function citationSupportScore(claim, citedSources) {
@@ -27521,7 +28871,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 path30 from "path";
+import path31 from "path";
 
 // src/run-seeds.ts
 function buildBenchmarkRunSeeds(runCount, baseSeed) {
@@ -27613,7 +28963,7 @@ function pairedDeltaConfidenceInterval(candidateValues, baselineValues, options
 // src/judges/sealed-rubric.ts
 import { createHash as createHash8 } from "crypto";
 import { appendFileSync, mkdirSync } from "fs";
-import path29 from "path";
+import path30 from "path";
 
 // src/judges/sealed-prompts/assistant-rubric-v1.ts
 var ASSISTANT_RUBRIC_V1 = `# Assistant rubric v1 (sealed)
@@ -27893,7 +29243,7 @@ function createSpotCheckFileLogger(options) {
     return { log() {
     } };
   }
-  const logPath = path29.join(directory, `${runId}.jsonl`);
+  const logPath = path30.join(directory, `${runId}.jsonl`);
   let written = 0;
   let warnedOnWriteFailure = false;
   const cap = typeof sampleSize === "number" && sampleSize > 0 ? sampleSize : 5;
@@ -27982,7 +29332,7 @@ async function runAssistantBenchmark(definition, scenarios, resolved, runnerOpti
   const runId = buildRunId(definition.id);
   const spotCheckLogger = createSpotCheckFileLogger({
     runId,
-    directory: runnerOptions.spotCheckDir ?? path30.join(process.cwd(), "benchmarks", "results", "spot-checks"),
+    directory: runnerOptions.spotCheckDir ?? path31.join(process.cwd(), "benchmarks", "results", "spot-checks"),
     sampleRate: 0.35,
     sampleSize: 5
   });
@@ -28631,9 +29981,9 @@ async function runAssistantSynthesisBenchmark(options) {
 
 // src/benchmarks/remnic/buffer-surprise-trigger/runner.ts
 import { randomUUID as randomUUID28 } from "crypto";
-import path31 from "path";
-import os8 from "os";
-import { mkdir as mkdir15, rm as rm12 } from "fs/promises";
+import path32 from "path";
+import os9 from "os";
+import { mkdir as mkdir15, rm as rm13 } from "fs/promises";
 import {
   SmartBuffer,
   computeSurprise,
@@ -28862,8 +30212,8 @@ function hasExplicitTopicPivotCue(text) {
 }
 async function runBufferSurpriseTriggerBenchmark(options) {
   const cases = loadCases10(options.mode, options.limit);
-  const tmpRoot = path31.join(
-    os8.tmpdir(),
+  const tmpRoot = path32.join(
+    os9.tmpdir(),
     `remnic-bench-buffer-surprise-${randomUUID28()}`
   );
   await mkdir15(tmpRoot, { recursive: true });
@@ -28884,7 +30234,7 @@ async function runBufferSurpriseTriggerBenchmark(options) {
       tasks.push(buildTaskResult(caseDef, control, candidate));
     }
   } finally {
-    await rm12(tmpRoot, { recursive: true, force: true });
+    await rm13(tmpRoot, { recursive: true, force: true });
   }
   const totalLatencyMs = Math.round(performance.now() - startedAt);
   const aggregates = buildAggregates2(tasks);
@@ -28931,11 +30281,11 @@ async function runBufferSurpriseTriggerBenchmark(options) {
   };
 }
 async function runSingleCase(caseDef, options) {
-  const memoryDir = path31.join(
+  const memoryDir = path32.join(
     options.tmpRoot,
     `${caseDef.id}-${options.label}`
   );
-  const workspaceDir = path31.join(memoryDir, "workspace");
+  const workspaceDir = path32.join(memoryDir, "workspace");
   await mkdir15(workspaceDir, { recursive: true });
   const config = parseConfig4({
     memoryDir,
@@ -30978,7 +32328,7 @@ 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 path32 from "path";
+import path33 from "path";
 
 // src/benchmarks/remnic/bounded-memory-contracts/fixture.ts
 import { createHash as createHash10 } from "crypto";
@@ -31463,17 +32813,7 @@ var BOUNDED_MEMORY_SMOKE_FIXTURE = [
 ];
 function fixtureHash(tasks) {
   const source = tasks ?? BOUNDED_MEMORY_FIXTURE;
-  const payload = source.map(
-    (t) => [
-      t.id,
-      t.family,
-      t.expectedAnswer,
-      t.scope,
-      t.shouldAsk === void 0 ? "-" : String(t.shouldAsk),
-      t.memoryItems.map((m) => `${m.id}:${m.status}:${m.scope}`).join(","),
-      t.skills.map((s) => s.id).join(",")
-    ].join("|")
-  ).join("\n");
+  const payload = JSON.stringify(source);
   return createHash10("sha256").update(payload, "utf8").digest("hex");
 }
 
@@ -31869,7 +33209,7 @@ function aggregateCondition(condition, scored, skillLog) {
   const tp = injected.filter((e) => e.outcome === "helped").length;
   const fp = injected.filter((e) => e.outcome === "harmed").length;
   const notInjected = considered.filter((e) => !e.injected);
-  const fn = notInjected.filter((e) => e.outcome === "harmed").length;
+  const fn = skillLog.filter((e) => !e.injected && e.outcome === "harmed").length;
   const tn = notInjected.filter((e) => e.outcome === "irrelevant").length;
   return {
     condition,
@@ -32220,23 +33560,23 @@ async function runBoundedMemoryContractsBenchmark(options) {
   };
 }
 async function writeArtifacts(outputDir, byCondition, conditionAggregates, tasks) {
-  const root = path32.resolve(outputDir);
-  await mkdir16(path32.join(root, "conditions"), { recursive: true });
-  await mkdir16(path32.join(root, "prompts"), { recursive: true });
-  await mkdir16(path32.join(root, "retrieval"), { recursive: true });
-  await mkdir16(path32.join(root, "scores"), { recursive: true });
+  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 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 = path32.join(root, "conditions", condition);
+    const condDir = path33.join(root, "conditions", condition);
     await mkdir16(condDir, { recursive: true });
     for (const { task, pack, decision } of results) {
       const scores = scoreTaskPair(task, pack, decision);
       const promptMd = renderPromptPack(task, condition, pack);
-      const promptPath = path32.join(root, "prompts", `${task.id}.${condition}.md`);
-      await mkdir16(path32.dirname(promptPath), { recursive: true });
+      const promptPath = path33.join(root, "prompts", `${task.id}.${condition}.md`);
+      await mkdir16(path33.dirname(promptPath), { recursive: true });
       await writeFile15(promptPath, promptMd, "utf8");
       const retrievalJson = `${JSON.stringify(
         {
@@ -32260,7 +33600,7 @@ async function writeArtifacts(outputDir, byCondition, conditionAggregates, tasks
         2
       )}
 `;
-      const retrievalPath = path32.join(root, "retrieval", `${task.id}.${condition}.json`);
+      const retrievalPath = path33.join(root, "retrieval", `${task.id}.${condition}.json`);
       await writeFile15(retrievalPath, retrievalJson, "utf8");
       csvRows.push(
         [
@@ -32282,23 +33622,23 @@ async function writeArtifacts(outputDir, byCondition, conditionAggregates, tasks
       );
     }
     await writeFile15(
-      path32.join(condDir, "summary.json"),
+      path33.join(condDir, "summary.json"),
       `${JSON.stringify(conditionAggregates[condition], null, 2)}
 `,
       "utf8"
     );
   }
-  await writeFile15(path32.join(root, "scores", "per-task.csv"), `${csvRows.join("\n")}
+  await writeFile15(path33.join(root, "scores", "per-task.csv"), `${csvRows.join("\n")}
 `, "utf8");
   await writeFile15(
-    path32.join(root, "scores", "aggregate.json"),
+    path33.join(root, "scores", "aggregate.json"),
     `${JSON.stringify(conditionAggregates, null, 2)}
 `,
     "utf8"
   );
   const report = renderReportMarkdown(tasks, conditionAggregates);
-  await writeFile15(path32.join(root, "report.md"), report, "utf8");
-  return path32.join(root, "report.md");
+  await writeFile15(path33.join(root, "report.md"), report, "utf8");
+  return path33.join(root, "report.md");
 }
 function renderPromptPack(task, condition, pack) {
   const lines = [];
@@ -32523,8 +33863,8 @@ function finalizeBenchmarkResultConfig(result, options) {
 }
 
 // src/benchmark.ts
-var DEFAULT_BASELINE_PATH = path33.join(process.cwd(), "benchmarks", "baseline.json");
-var DEFAULT_REPORT_PATH = path33.join(process.cwd(), "benchmarks", "report.json");
+var DEFAULT_BASELINE_PATH = path34.join(process.cwd(), "benchmarks", "baseline.json");
+var DEFAULT_REPORT_PATH = path34.join(process.cwd(), "benchmarks", "report.json");
 var BASELINE_VERSION = 1;
 var DEFAULT_TOLERANCE = 10;
 var DEFAULT_FULL_RUN_COUNT = 5;
@@ -32602,7 +33942,7 @@ async function runBenchmark(benchmarkId, options) {
     if (!willWrapPrimary && !willWrapCross) {
       return void 0;
     }
-    const cacheDir = options.judgeCacheDir ? path33.resolve(expandTildePath3(options.judgeCacheDir)) : options.outputDir ? path33.join(path33.resolve(expandTildePath3(options.outputDir)), "judge-cache") : void 0;
+    const cacheDir = options.judgeCacheDir ? path34.resolve(expandTildePath3(options.judgeCacheDir)) : options.outputDir ? path34.join(path34.resolve(expandTildePath3(options.outputDir)), "judge-cache") : void 0;
     if (cacheDir === void 0) {
       return void 0;
     }
@@ -32791,7 +34131,7 @@ function loadBaseline(baselinePath) {
   return raw;
 }
 function saveBaseline(baselinePath, baseline) {
-  fs2.mkdirSync(path33.dirname(baselinePath), { recursive: true });
+  fs2.mkdirSync(path34.dirname(baselinePath), { recursive: true });
   fs2.writeFileSync(baselinePath, `${JSON.stringify(baseline, null, 2)}
 `);
 }
@@ -33021,7 +34361,7 @@ function generateReport(results, reportPath) {
     totalDurationMs: results.reduce((sum, result) => sum + result.totalDurationMs, 0)
   };
   if (reportPath) {
-    fs2.mkdirSync(path33.dirname(reportPath), { recursive: true });
+    fs2.mkdirSync(path34.dirname(reportPath), { recursive: true });
     fs2.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}
 `);
   }
@@ -33487,7 +34827,7 @@ function formatError(error) {
 
 // src/benchmarks/custom/runner.ts
 import { randomUUID as randomUUID33 } from "crypto";
-import path34 from "path";
+import path35 from "path";
 import { expandTildePath as expandTildePath4 } from "@remnic/core";
 async function runCustomBenchmarkFile(filePath, options) {
   const spec = await loadCustomBenchmarkFile(filePath);
@@ -33500,7 +34840,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 ? path34.resolve(expandTildePath4(runOptions.judgeCacheDir)) : runOptions.outputDir ? path34.join(path34.resolve(expandTildePath4(runOptions.outputDir)), "judge-cache") : void 0;
+    const cacheDir = runOptions.judgeCacheDir ? path35.resolve(expandTildePath4(runOptions.judgeCacheDir)) : runOptions.outputDir ? path35.join(path35.resolve(expandTildePath4(runOptions.outputDir)), "judge-cache") : void 0;
     if (cacheDir !== void 0) {
       const originalJudge = runOptions.system.judge;
       const wrapped = wrapJudgeWithCache({
@@ -33701,7 +35041,7 @@ async function scoreTask(scoring, options, question, actual, expected) {
   }
 }
 function createCustomBenchmarkDefinition(benchmark, filePath) {
-  const id = `custom:${slugify(path34.basename(filePath, path34.extname(filePath)) || benchmark.name)}`;
+  const id = `custom:${slugify(path35.basename(filePath, path35.extname(filePath)) || benchmark.name)}`;
   return {
     id,
     title: benchmark.name,
@@ -34573,7 +35913,7 @@ 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 path35 from "path";
+import path36 from "path";
 
 // src/judges/cohen-kappa.ts
 function computeCohensKappa(raterA, raterB) {
@@ -34710,7 +36050,7 @@ async function writeJudgeCalibrationState(result, calibrationDir, identities) {
     warning: result.warning,
     ...identities ? identities : {}
   };
-  const filePath = path35.join(calibrationDir, `${sanitizeCalibrationSegment(result.benchmarkId)}.json`);
+  const filePath = path36.join(calibrationDir, `${sanitizeCalibrationSegment(result.benchmarkId)}.json`);
   const tempPath = `${filePath}.${randomBytes3(6).toString("hex")}.tmp`;
   await writeFile16(tempPath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
@@ -34723,7 +36063,7 @@ async function writeJudgeCalibrationState(result, calibrationDir, identities) {
   return filePath;
 }
 async function loadJudgeCalibrationState(benchmarkId, calibrationDir) {
-  const filePath = path35.join(calibrationDir, `${sanitizeCalibrationSegment(benchmarkId)}.json`);
+  const filePath = path36.join(calibrationDir, `${sanitizeCalibrationSegment(benchmarkId)}.json`);
   let raw;
   try {
     raw = await readFile21(filePath, "utf8");
@@ -34797,9 +36137,9 @@ function sanitizeCalibrationSegment(value) {
 }
 
 // src/benchmarks/remnic/procedural-recall/ablation.ts
-import { mkdir as mkdir18, mkdtemp as mkdtemp11, rm as rm13, writeFile as writeFile17, readFile as readFile22 } from "fs/promises";
-import os9 from "os";
-import path36 from "path";
+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 {
   StorageManager as StorageManager3,
   parseConfig as parseConfig5,
@@ -34829,8 +36169,8 @@ function fixtureToAblationScenarios(fixture) {
 async function runSide(scenarios, proceduralEnabled) {
   const observed = [];
   for (const scenario of scenarios) {
-    const dir = await mkdtemp11(
-      path36.join(os9.tmpdir(), "remnic-bench-proc-ablation-")
+    const dir = await mkdtemp12(
+      path37.join(os10.tmpdir(), "remnic-bench-proc-ablation-")
     );
     try {
       const storage = new StorageManager3(dir);
@@ -34845,7 +36185,7 @@ ${body}`,
       );
       const config = parseConfig5({
         memoryDir: dir,
-        workspaceDir: path36.join(dir, "ws"),
+        workspaceDir: path37.join(dir, "ws"),
         openaiApiKey: "bench-key",
         procedural: {
           enabled: proceduralEnabled,
@@ -34859,7 +36199,7 @@ ${body}`,
       );
       observed.push(section !== null && section.length > 0);
     } finally {
-      await rm13(dir, { recursive: true, force: true });
+      await rm14(dir, { recursive: true, force: true });
     }
   }
   return observed;
@@ -35016,12 +36356,61 @@ async function runProceduralAblationCli(args) {
     random: args.random,
     seed: args.seed
   });
-  const outDir = path36.dirname(path36.resolve(args.outPath));
+  const outDir = path37.dirname(path37.resolve(args.outPath));
   await mkdir18(outDir, { recursive: true });
   await writeFile17(args.outPath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
   return artifact;
 }
 
+// src/ablations/single-flag-matrix.ts
+var SINGLE_FLAG_ABLATION_MATRIX = [
+  {
+    id: "memory-worth-off",
+    label: "Memory Worth multiplier OFF",
+    axis: "memory-worth",
+    description: "Disables the Memory Worth recall multiplier (recallMemoryWorthFilterEnabled=false). Baseline (#1574) ran with it ON via the config.ts default; this cell measures the cost of removing it.",
+    baselineState: "recallMemoryWorthFilterEnabled defaults true in config.ts; baseline ran ON.",
+    configOverrides: {
+      recallMemoryWorthFilterEnabled: false
+    },
+    primaryFlag: "recallMemoryWorthFilterEnabled"
+  },
+  {
+    id: "contradiction-scan-on",
+    label: "Contradiction scan ON",
+    axis: "contradiction-scan",
+    description: "Enables inline contradiction detection on the write path (contradictionDetectionEnabled=true) so supersessions land at ingest time, before answering. The batch contradictionScan cron is a no-op during a bench replay (it only registers a scheduled job), so the measurable axis is the inline write-path gate (orchestrator \xA715667); contradictionAutoResolve defaults true so detected contradictions are applied. Baseline (#1574) ran with it OFF.",
+    baselineState: "contradictionDetectionEnabled defaults false (config.ts \xA72078); baseline ran OFF.",
+    configOverrides: {
+      contradictionDetectionEnabled: true
+    },
+    primaryFlag: "contradictionDetectionEnabled"
+  },
+  {
+    id: "graph-recall-on",
+    label: "Graph / temporal recall ON",
+    axis: "graph-recall",
+    description: "Enables graph recall + full-mode graph assist (graphRecallEnabled=true, graphAssistInFullModeEnabled=true, multiGraphMemoryEnabled=true). orchestrator.ts \xA71379 skips graph_mode unless BOTH graphRecallEnabled AND multiGraphMemoryEnabled are set, so the cell carries both gates (plus the full-mode assist) or it measures nothing. Baseline (#1574) ran with graph recall OFF; this cell measures the benefit of causal/timeline expansion.",
+    baselineState: "graphRecallEnabled, graphAssistInFullModeEnabled, multiGraphMemoryEnabled all default false; baseline ran OFF.",
+    configOverrides: {
+      graphRecallEnabled: true,
+      graphAssistInFullModeEnabled: true,
+      multiGraphMemoryEnabled: true
+    },
+    primaryFlag: "graphRecallEnabled"
+  }
+];
+var DEFAULT_ABLATION_BENCHMARK = "locomo";
+function getAblationCell(id) {
+  const cell = SINGLE_FLAG_ABLATION_MATRIX.find((c) => c.id === id);
+  if (!cell) {
+    throw new Error(
+      `Unknown ablation cell id "${id}". Known ids: ${SINGLE_FLAG_ABLATION_MATRIX.map((c) => c.id).join(", ")}.`
+    );
+  }
+  return cell;
+}
+
 // src/benchmarks/remnic/procedural-recall/real-scenarios.ts
 var PROCEDURAL_REAL_SCENARIOS = [
   // --- exact-re-run (5) ---------------------------------------------------
@@ -36207,11 +37596,11 @@ function pickStableQualifiedName(repo, index) {
 
 // src/coding-graph/harness.ts
 import { performance as performance2 } from "perf_hooks";
-import { mkdtemp as mkdtemp12, rm as rm14 } from "fs/promises";
+import { mkdtemp as mkdtemp13, rm as rm15 } from "fs/promises";
 import { statSync } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import path37 from "path";
-import os10 from "os";
+import path38 from "path";
+import os11 from "os";
 import {
   GraphStore
 } from "@remnic/coding-graph";
@@ -36237,14 +37626,14 @@ var CODING_GRAPH_BENCH_SCHEMA_VERSION = 2;
 
 // src/coding-graph/harness.ts
 function captureMachineFingerprint() {
-  const cpus = os10.cpus();
+  const cpus = os11.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(os10.totalmem() / (1024 * 1024))
+    totalMemoryMb: Math.round(os11.totalmem() / (1024 * 1024))
   };
 }
 function percentile2(sorted, p) {
@@ -36307,8 +37696,8 @@ async function runCodingGraphBenchmark(config = {}) {
   const sampleRss = () => {
     peakRss = Math.max(peakRss, process.memoryUsage().rss);
   };
-  const dir = await mkdtemp12(path37.join(tmpdir7(), "coding-graph-bench-"));
-  const dbPath = path37.join(dir, "bench.sqlite");
+  const dir = await mkdtemp13(path38.join(tmpdir7(), "coding-graph-bench-"));
+  const dbPath = path38.join(dir, "bench.sqlite");
   try {
     const store = await GraphStore.open({ dbPath });
     try {
@@ -36444,7 +37833,7 @@ async function runCodingGraphBenchmark(config = {}) {
       await store.close();
     }
   } finally {
-    await rm14(dir, { recursive: true, force: true });
+    await rm15(dir, { recursive: true, force: true });
   }
 }
 
@@ -36652,6 +38041,7 @@ export {
   DEFAULT_TOLERANCE_PERCENT as CODING_GRAPH_DEFAULT_TOLERANCE,
   MIN_ITERATIONS as CODING_GRAPH_MIN_ITERATIONS,
   DEFAULT_SMOKE_FIXTURE as CODING_GRAPH_SMOKE_FIXTURE,
+  DEFAULT_ABLATION_BENCHMARK,
   DEFAULT_ABLATION_BOOTSTRAP_SEED,
   DEFAULT_ASSISTANT_RUBRIC_ID,
   DEFAULT_BASELINE_SCENARIOS,
@@ -36664,11 +38054,14 @@ export {
   LOCAL_LAB_PROVIDER_KINDS,
   LOCOMO_DATASET_FILENAMES,
   LONG_MEM_EVAL_DATASET_FILENAMES,
+  LettaMemCorrectAdapter,
   LocalLabPreflightError,
   MEMORY_EVAL_DIMENSIONS,
   MEMORY_EVAL_PUBLIC_LINE,
   MIN_CALIBRATION_SOURCE_TASKS,
   MITIGATED_BASELINE_SCENARIOS,
+  Mem0MemCorrectAdapter,
+  MissingCredentialError,
   OTHER_NAMESPACE_MEMORIES,
   PROCEDURAL_REAL_SCENARIOS,
   PROCEDURAL_REAL_SCENARIOS_SMOKE,
@@ -36677,7 +38070,9 @@ export {
   SCHEMA_TIER_FIXTURE,
   SCHEMA_TIER_SMOKE_FIXTURE,
   SEALED_PROMPT_REGISTRY,
+  SINGLE_FLAG_ABLATION_MATRIX,
   SYNTHETIC_MEMORIES,
+  ZepMemCorrectAdapter,
   addContaminationEntry,
   aggregateTaskScores,
   answerBenchmarkQuestion,
@@ -36722,6 +38117,7 @@ export {
   createAmaBenchDiagnosticAdapter,
   createAnthropicProvider,
   createCanaryAdapter,
+  createClaudeCliProvider,
   createCodexCliProvider,
   createSeededRng3 as createCodingGraphSeededRng,
   createDeterministicSpotCheckLogger,
@@ -36762,6 +38158,7 @@ export {
   formatMissingDatasetError,
   generateReport,
   generateSyntheticRepo,
+  getAblationCell,
   getBenchmark,
   getBenchmarkLowerIsBetter,
   getMemoryEvalDimension,