crosscheck-mcp 0.1.11 → 0.1.13

package/dist/node-stdio.js

@@ -918,155 +918,11 @@ var init_better_sqlite3 = __esm({
 
 // src/entrypoints/node-stdio.ts
 init_esm_shims();
-import { existsSync as existsSync11, mkdirSync as mkdirSync9 } from "fs";
-import path12 from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync9 } from "fs";
+import path14 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-// src/bridge/index.ts
-init_esm_shims();
-
-// src/bridge/python-bridge.ts
-init_esm_shims();
-import path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-function defaultServerPath() {
-  let here;
-  try {
-    here = path2.dirname(fileURLToPath2(import.meta.url));
-  } catch {
-    here = __dirname;
-  }
-  const upToPkg = here.includes(`${path2.sep}src${path2.sep}bridge`) ? "../.." : "..";
-  return path2.resolve(here, upToPkg, "..", "python", "crosscheck_server.py");
-}
-async function spawnPythonBridge(opts = {}) {
-  const pythonPath = opts.pythonPath ?? "python3";
-  const serverPath = opts.serverPath ?? defaultServerPath();
-  const args = [...opts.extraArgs ?? [], serverPath];
-  const transport = new StdioClientTransport({
-    command: pythonPath,
-    args,
-    env: { ...process.env, ...opts.env ?? {} }
-  });
-  const client = new Client(
-    { name: "crosscheck-agent-bridge", version: "0.1.0" },
-    { capabilities: {} }
-  );
-  const initDeadline = opts.initTimeoutMs ?? 3e4;
-  await Promise.race([
-    client.connect(transport),
-    new Promise(
-      (_, rej) => setTimeout(
-        () => rej(new Error(`bridge: handshake timeout after ${initDeadline}ms`)),
-        initDeadline
-      )
-    )
-  ]);
-  let toolNames = await fetchToolNames(client, initDeadline);
-  let closed = false;
-  return {
-    get toolNames() {
-      return toolNames;
-    },
-    get pid() {
-      const p = transport.pid;
-      return typeof p === "number" ? p : null;
-    },
-    async callTool(name, callArgs) {
-      const r = await client.callTool({ name, arguments: callArgs });
-      const content = r.content;
-      if (!Array.isArray(content)) {
-        throw new Error(
-          `bridge: tools/call(${name}) returned a malformed envelope: ${JSON.stringify(r).slice(0, 200)}`
-        );
-      }
-      const out = [];
-      for (const c of content) {
-        if (c && typeof c === "object") {
-          const co = c;
-          out.push({
-            type: String(co["type"] ?? "text"),
-            text: typeof co["text"] === "string" ? co["text"] : JSON.stringify(co["text"])
-          });
-        }
-      }
-      const isError = r.isError;
-      return isError !== void 0 ? { content: out, isError } : { content: out };
-    },
-    async refreshTools() {
-      toolNames = await fetchToolNames(client, initDeadline);
-      return toolNames;
-    },
-    async close() {
-      if (closed) return;
-      closed = true;
-      try {
-        await client.close();
-      } catch {
-      }
-    }
-  };
-}
-async function fetchToolNames(client, timeoutMs) {
-  const r = await Promise.race([
-    client.listTools(),
-    new Promise(
-      (_, rej) => setTimeout(
-        () => rej(new Error(`bridge: tools/list timeout after ${timeoutMs}ms`)),
-        timeoutMs
-      )
-    )
-  ]);
-  const tools = r.tools ?? [];
-  return new Set(
-    tools.map((t) => String(t?.name ?? "")).filter((n) => n.length > 0)
-  );
-}
-
-// src/bridge/proxy-tools.ts
-init_esm_shims();
-function buildPythonProxies(bridge) {
-  const proxies = /* @__PURE__ */ new Map();
-  for (const name of bridge.toolNames) {
-    proxies.set(name, makeProxy(bridge, name));
-  }
-  return proxies;
-}
-function makeProxy(bridge, name) {
-  return {
-    name,
-    description: `(forwarded to Python crosscheck-agent) ${name}`,
-    // We don't carry the per-tool input schema across the bridge in
-    // route-all mode — the TS server is a transparent forwarder, so
-    // arg validation happens on the Python side. inputSchema is left
-    // permissive; the Python validator throws structured errors that
-    // tunnel back through `callTool()`.
-    inputSchema: {
-      type: "object",
-      additionalProperties: true,
-      description: `Forwarded to Python \u2014 see Python tool '${name}' for full schema.`
-    },
-    handler: async (args) => {
-      const r = await bridge.callTool(name, args);
-      if (!r.content.length) {
-        return {};
-      }
-      const first = r.content[0];
-      if (first.type === "text" && first.text) {
-        try {
-          return JSON.parse(first.text);
-        } catch {
-          return { text: first.text };
-        }
-      }
-      return { content: r.content };
-    }
-  };
-}
-
 // src/core/events.ts
 init_esm_shims();
 import { appendFileSync, mkdirSync } from "fs";
@@ -1080,10 +936,10 @@ var StderrEmitter = class {
   }
 };
 var FileEmitter = class {
-  constructor(path13) {
-    this.path = path13;
+  constructor(path15) {
+    this.path = path15;
     try {
-      mkdirSync(dirname(path13), { recursive: true });
+      mkdirSync(dirname(path15), { recursive: true });
     } catch {
     }
   }
@@ -1116,13 +972,13 @@ var NullEmitter = class {
 function buildDefaultEmitter(env) {
   const mode = (env["CROSSCHECK_EVENTS"] ?? "stderr").toLowerCase();
   if (mode === "off") return new NullEmitter();
-  const path13 = env["CROSSCHECK_EVENTS_PATH"];
+  const path15 = env["CROSSCHECK_EVENTS_PATH"];
   if (mode === "file") {
-    return path13 ? new FileEmitter(path13) : new NullEmitter();
+    return path15 ? new FileEmitter(path15) : new NullEmitter();
   }
   if (mode === "both") {
     const ems = [new StderrEmitter()];
-    if (path13) ems.push(new FileEmitter(path13));
+    if (path15) ems.push(new FileEmitter(path15));
     return new TeeEmitter(ems);
   }
   return new StderrEmitter();
@@ -1171,10 +1027,10 @@ function envelopeBytes(v) {
 // src/core/pricing.ts
 init_esm_shims();
 import { readFileSync } from "fs";
-function loadPricing(path13) {
+function loadPricing(path15) {
   let raw;
   try {
-    raw = readFileSync(path13, "utf8");
+    raw = readFileSync(path15, "utf8");
   } catch {
     return {};
   }
@@ -1304,7 +1160,7 @@ function isCreditsFailure(status, bodyText) {
   }
   return false;
 }
-function httpFailureToProviderError(provider, status, bodyText) {
+function httpFailureToProviderError(provider, status, bodyText, retryAfterS) {
   const detail = bodyText.slice(0, 512);
   if (isCreditsFailure(status, bodyText)) {
     return new ProviderError(
@@ -1324,14 +1180,14 @@ function httpFailureToProviderError(provider, status, bodyText) {
     return new ProviderError(
       "rate_limit",
       `${provider}: rate limited (HTTP 429). Detail: ${detail}`,
-      { status }
+      { status, ...retryAfterS !== void 0 ? { retryAfterS } : {} }
     );
   }
   if (status >= 500 && status <= 599) {
     return new ProviderError(
       "server",
       `${provider}: upstream server error (HTTP ${status}). Detail: ${detail}`,
-      { status }
+      { status, ...retryAfterS !== void 0 ? { retryAfterS } : {} }
     );
   }
   return new ProviderError(
@@ -1341,6 +1197,156 @@ function httpFailureToProviderError(provider, status, bodyText) {
   );
 }
 
+// src/providers/retry.ts
+init_esm_shims();
+var override = null;
+function setRetryConfig(cfg) {
+  override = cfg;
+}
+function resolveRetryConfig() {
+  const envInt = (k, d) => {
+    const n = Number(process.env[k]);
+    return Number.isFinite(n) && n >= 0 ? Math.trunc(n) : d;
+  };
+  const envSecMs = (k, dMs) => {
+    const n = Number(process.env[k]);
+    return Number.isFinite(n) && n >= 0 ? Math.round(n * 1e3) : dMs;
+  };
+  return {
+    maxAttempts: Math.max(1, override?.maxAttempts ?? envInt("CROSSCHECK_RETRY_MAX_ATTEMPTS", 3)),
+    backoffBaseMs: override?.backoffBaseMs ?? envSecMs("CROSSCHECK_RETRY_BACKOFF_BASE_S", 750),
+    maxBackoffMs: override?.maxBackoffMs ?? 2e4
+  };
+}
+function parseRetryAfter(respLike) {
+  try {
+    const h = respLike?.headers;
+    if (!h) return void 0;
+    let raw = null;
+    const getter = h.get;
+    if (typeof getter === "function") {
+      raw = getter.call(h, "retry-after");
+    } else if (typeof h === "object") {
+      const rec = h;
+      raw = rec["retry-after"] ?? rec["Retry-After"] ?? null;
+    }
+    if (!raw) return void 0;
+    const secs = Number(raw);
+    if (Number.isFinite(secs) && secs >= 0) return secs;
+    const dateMs = Date.parse(raw);
+    if (Number.isFinite(dateMs)) {
+      const delta = (dateMs - Date.now()) / 1e3;
+      return delta > 0 ? delta : 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function defaultSleep(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted) {
+      reject(new ProviderError("network", "request aborted", { transient: false }));
+      return;
+    }
+    const cleanup = () => {
+      clearTimeout(t);
+      signal?.removeEventListener?.("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(new ProviderError("network", "request aborted", { transient: false }));
+    };
+    const t = setTimeout(() => {
+      cleanup();
+      resolve2();
+    }, ms);
+    signal?.addEventListener?.("abort", onAbort);
+  });
+}
+async function sendWithRetry(attemptOnce, cfg, signal, deps) {
+  const sleep = deps?.sleepImpl ?? ((ms) => defaultSleep(ms, signal));
+  const rand = deps?.random ?? Math.random;
+  let lastErr;
+  for (let attempt = 1; attempt <= cfg.maxAttempts; attempt += 1) {
+    try {
+      const result = await attemptOnce();
+      return { ...result, attempts: attempt };
+    } catch (e) {
+      lastErr = e;
+      const pe = e instanceof ProviderError ? e : null;
+      if (pe?.transient !== true || attempt >= cfg.maxAttempts) throw e;
+      let backoffMs = pe.retryAfterS !== void 0 ? pe.retryAfterS * 1e3 : cfg.backoffBaseMs * 2 ** (attempt - 1);
+      backoffMs += rand() * cfg.backoffBaseMs;
+      backoffMs = Math.min(backoffMs, cfg.maxBackoffMs);
+      await sleep(backoffMs);
+    }
+  }
+  throw lastErr;
+}
+
+// src/providers/rate-limit.ts
+init_esm_shims();
+var DEFAULT_SPEC = { capacity: 5, refillPerSec: 5 };
+var MAX_WAIT_SLICE_MS = 250;
+var override2 = null;
+function setRateLimitConfig(cfg) {
+  override2 = cfg;
+  buckets.clear();
+}
+function disabled() {
+  return process.env["CROSSCHECK_RATE_LIMIT"] === "off";
+}
+function specFor(provider) {
+  const fromCfg = override2?.[provider] ?? override2?.["default"];
+  const spec = fromCfg ?? DEFAULT_SPEC;
+  const capacity = Number.isFinite(spec.capacity) && spec.capacity > 0 ? spec.capacity : DEFAULT_SPEC.capacity;
+  const refillPerSec = Number.isFinite(spec.refillPerSec) && spec.refillPerSec > 0 ? spec.refillPerSec : capacity;
+  return { capacity, refillPerSec };
+}
+var Bucket = class {
+  constructor(spec, now) {
+    this.spec = spec;
+    this.tokens = spec.capacity;
+    this.last = now();
+  }
+  spec;
+  tokens;
+  last;
+  refill(now) {
+    const elapsed = (now - this.last) / 1e3;
+    this.tokens = Math.min(this.spec.capacity, this.tokens + elapsed * this.spec.refillPerSec);
+    this.last = now;
+  }
+  async acquire(deps) {
+    for (; ; ) {
+      this.refill(deps.now());
+      if (this.tokens >= 1) {
+        this.tokens -= 1;
+        return;
+      }
+      if (deps.signal?.aborted) {
+        throw new ProviderError("network", "request aborted while rate-limited", { transient: false });
+      }
+      const needed = 1 - this.tokens;
+      const waitMs = needed / Math.max(this.spec.refillPerSec, 1e-6) * 1e3;
+      await deps.sleep(Math.min(waitMs, MAX_WAIT_SLICE_MS));
+    }
+  }
+};
+var buckets = /* @__PURE__ */ new Map();
+var realSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function acquireRateLimit(provider, deps) {
+  if (disabled()) return;
+  const now = deps?.now ?? Date.now;
+  const sleep = deps?.sleep ?? realSleep;
+  let bucket = buckets.get(provider);
+  if (!bucket) {
+    bucket = new Bucket(specFor(provider), now);
+    buckets.set(provider, bucket);
+  }
+  await bucket.acquire({ now, sleep, ...deps?.signal ? { signal: deps.signal } : {} });
+}
+
 // src/providers/anthropic.ts
 var ANTHROPIC_API_URL = "https://api.anthropic.com/v1/messages";
 var ANTHROPIC_VERSION_HEADER = "2023-06-01";
@@ -1467,29 +1473,33 @@ async function sendAnthropic(args) {
     body: JSON.stringify(body)
   };
   if (args.signal) init.signal = args.signal;
-  let respLike;
-  try {
-    respLike = await doFetch(url, init);
-  } catch (e) {
-    throw new ProviderError("network", `anthropic: fetch failed: ${e.message}`);
-  }
-  const status = respLike.status;
-  if (status >= 200 && status < 300) {
-    let parsed;
+  const attemptOnce = async () => {
+    let respLike;
     try {
-      parsed = await respLike.json();
+      respLike = await doFetch(url, init);
     } catch (e) {
-      throw new ProviderError("parse", `anthropic: response body not JSON: ${e.message}`);
+      throw new ProviderError("network", `anthropic: fetch failed: ${e.message}`);
     }
-    const { text, usage } = parseAnthropicResponse({
-      resp: parsed,
-      model: args.model,
-      purpose: args.purpose ?? "worker"
-    });
-    return { text, attempts: 1, usage: applyPricing(usage, args.pricing) };
-  }
-  const bodyText = await respLike.text().catch(() => "");
-  throw httpFailureToProviderError("anthropic", status, bodyText);
+    const status = respLike.status;
+    if (status >= 200 && status < 300) {
+      let parsed;
+      try {
+        parsed = await respLike.json();
+      } catch (e) {
+        throw new ProviderError("parse", `anthropic: response body not JSON: ${e.message}`);
+      }
+      const { text, usage } = parseAnthropicResponse({
+        resp: parsed,
+        model: args.model,
+        purpose: args.purpose ?? "worker"
+      });
+      return { text, attempts: 1, usage: applyPricing(usage, args.pricing) };
+    }
+    const bodyText = await respLike.text().catch(() => "");
+    throw httpFailureToProviderError("anthropic", status, bodyText, parseRetryAfter(respLike));
+  };
+  await acquireRateLimit("anthropic", args.signal ? { signal: args.signal } : void 0);
+  return sendWithRetry(attemptOnce, resolveRetryConfig(), args.signal);
 }
 
 // src/providers/gemini.ts
@@ -1641,29 +1651,33 @@ async function sendGemini(args) {
     body: JSON.stringify(body)
   };
   if (args.signal) init.signal = args.signal;
-  let respLike;
-  try {
-    respLike = await doFetch(url, init);
-  } catch (e) {
-    throw new ProviderError("network", `gemini: fetch failed: ${e.message}`);
-  }
-  const status = respLike.status;
-  if (status >= 200 && status < 300) {
-    let parsed;
+  const attemptOnce = async () => {
+    let respLike;
     try {
-      parsed = await respLike.json();
+      respLike = await doFetch(url, init);
     } catch (e) {
-      throw new ProviderError("parse", `gemini: response body not JSON: ${e.message}`);
+      throw new ProviderError("network", `gemini: fetch failed: ${e.message}`);
     }
-    const { text, usage } = parseGeminiResponse({
-      resp: parsed,
-      model: args.model,
-      purpose: args.purpose ?? "worker"
-    });
-    return { text, attempts: 1, usage: applyPricing2(usage, args.pricing) };
-  }
-  const bodyText = await respLike.text().catch(() => "");
-  throw httpFailureToProviderError("gemini", status, bodyText);
+    const status = respLike.status;
+    if (status >= 200 && status < 300) {
+      let parsed;
+      try {
+        parsed = await respLike.json();
+      } catch (e) {
+        throw new ProviderError("parse", `gemini: response body not JSON: ${e.message}`);
+      }
+      const { text, usage } = parseGeminiResponse({
+        resp: parsed,
+        model: args.model,
+        purpose: args.purpose ?? "worker"
+      });
+      return { text, attempts: 1, usage: applyPricing2(usage, args.pricing) };
+    }
+    const bodyText = await respLike.text().catch(() => "");
+    throw httpFailureToProviderError("gemini", status, bodyText, parseRetryAfter(respLike));
+  };
+  await acquireRateLimit("gemini", args.signal ? { signal: args.signal } : void 0);
+  return sendWithRetry(attemptOnce, resolveRetryConfig(), args.signal);
 }
 
 // src/providers/openai-compatible.ts
@@ -1803,30 +1817,34 @@ async function sendOpenAICompatible(args) {
     body: JSON.stringify(body)
   };
   if (args.signal) init.signal = args.signal;
-  let respLike;
-  try {
-    respLike = await doFetch(url, init);
-  } catch (e) {
-    throw new ProviderError("network", `${args.provider}: fetch failed: ${e.message}`);
-  }
-  const status = respLike.status;
-  if (status >= 200 && status < 300) {
-    let parsed;
+  const attemptOnce = async () => {
+    let respLike;
     try {
-      parsed = await respLike.json();
+      respLike = await doFetch(url, init);
     } catch (e) {
-      throw new ProviderError("parse", `${args.provider}: response body not JSON: ${e.message}`);
+      throw new ProviderError("network", `${args.provider}: fetch failed: ${e.message}`);
     }
-    const { text, usage } = parseOpenAICompatibleResponse({
-      resp: parsed,
-      provider: args.provider,
-      model: args.model,
-      purpose: args.purpose ?? "worker"
-    });
-    return { text, attempts: 1, usage: applyPricing3(usage, args.pricing) };
-  }
-  const bodyText = await respLike.text().catch(() => "");
-  throw httpFailureToProviderError(args.provider, status, bodyText);
+    const status = respLike.status;
+    if (status >= 200 && status < 300) {
+      let parsed;
+      try {
+        parsed = await respLike.json();
+      } catch (e) {
+        throw new ProviderError("parse", `${args.provider}: response body not JSON: ${e.message}`);
+      }
+      const { text, usage } = parseOpenAICompatibleResponse({
+        resp: parsed,
+        provider: args.provider,
+        model: args.model,
+        purpose: args.purpose ?? "worker"
+      });
+      return { text, attempts: 1, usage: applyPricing3(usage, args.pricing) };
+    }
+    const bodyText = await respLike.text().catch(() => "");
+    throw httpFailureToProviderError(args.provider, status, bodyText, parseRetryAfter(respLike));
+  };
+  await acquireRateLimit(args.provider, args.signal ? { signal: args.signal } : void 0);
+  return sendWithRetry(attemptOnce, resolveRetryConfig(), args.signal);
 }
 
 // src/providers/registry.ts
@@ -1926,6 +1944,50 @@ import {
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 
+// src/bridge/index.ts
+init_esm_shims();
+
+// src/bridge/proxy-tools.ts
+init_esm_shims();
+function buildPythonProxies(bridge) {
+  const proxies = /* @__PURE__ */ new Map();
+  for (const name of bridge.toolNames) {
+    proxies.set(name, makeProxy(bridge, name));
+  }
+  return proxies;
+}
+function makeProxy(bridge, name) {
+  return {
+    name,
+    description: `(forwarded to Python crosscheck-agent) ${name}`,
+    // We don't carry the per-tool input schema across the bridge in
+    // route-all mode — the TS server is a transparent forwarder, so
+    // arg validation happens on the Python side. inputSchema is left
+    // permissive; the Python validator throws structured errors that
+    // tunnel back through `callTool()`.
+    inputSchema: {
+      type: "object",
+      additionalProperties: true,
+      description: `Forwarded to Python \u2014 see Python tool '${name}' for full schema.`
+    },
+    handler: async (args) => {
+      const r = await bridge.callTool(name, args);
+      if (!r.content.length) {
+        return {};
+      }
+      const first = r.content[0];
+      if (first.type === "text" && first.text) {
+        try {
+          return JSON.parse(first.text);
+        } catch {
+          return { text: first.text };
+        }
+      }
+      return { content: r.content };
+    }
+  };
+}
+
 // src/instructions.ts
 init_esm_shims();
 var ROUTABLE_TOOLS = [
@@ -1991,7 +2053,7 @@ import { z } from "zod";
 
 // src/tools/audit.ts
 init_esm_shims();
-import { readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { readdirSync, readFileSync as readFileSync3, statSync } from "fs";
 import { join } from "path";
 
 // src/core/structured.ts
@@ -2054,27 +2116,27 @@ function extractJson(text) {
 
 // src/core/json-schema.ts
 init_esm_shims();
-function validateSchema(value, schema, path13 = "") {
+function validateSchema(value, schema, path15 = "") {
   const errs = [];
   if ("anyOf" in schema) {
     const subs = schema["anyOf"].map(
-      (s) => validateSchema(value, s, path13)
+      (s) => validateSchema(value, s, path15)
     );
     if (!subs.some((e) => e.length === 0)) {
-      errs.push(`${path13 || "<root>"}: did not match anyOf`);
+      errs.push(`${path15 || "<root>"}: did not match anyOf`);
     }
     return errs;
   }
   if ("oneOf" in schema) {
-    const passed = schema["oneOf"].filter((s) => validateSchema(value, s, path13).length === 0).length;
+    const passed = schema["oneOf"].filter((s) => validateSchema(value, s, path15).length === 0).length;
     if (passed !== 1) {
-      errs.push(`${path13 || "<root>"}: matched ${passed} of oneOf, expected 1`);
+      errs.push(`${path15 || "<root>"}: matched ${passed} of oneOf, expected 1`);
     }
     return errs;
   }
   if ("const" in schema && !deepEqual(value, schema["const"])) {
     errs.push(
-      `${path13 || "<root>"}: expected const ${pyRepr(schema["const"])}, got ${pyRepr(value)}`
+      `${path15 || "<root>"}: expected const ${pyRepr(schema["const"])}, got ${pyRepr(value)}`
     );
     return errs;
   }
@@ -2084,7 +2146,7 @@ function validateSchema(value, schema, path13 = "") {
     const ok = types.some((tt) => matchesType(value, String(tt)));
     if (!ok) {
       errs.push(
-        `${path13 || "<root>"}: expected type ${pyReprType(t)}, got ${pyTypeName(value)}`
+        `${path15 || "<root>"}: expected type ${pyReprType(t)}, got ${pyTypeName(value)}`
       );
       return errs;
     }
@@ -2093,29 +2155,29 @@ function validateSchema(value, schema, path13 = "") {
     if ("enum" in schema) {
       const en = schema["enum"];
       if (!en.some((x) => deepEqual(x, value))) {
-        errs.push(`${path13 || "<root>"}: value ${pyRepr(value)} not in enum`);
+        errs.push(`${path15 || "<root>"}: value ${pyRepr(value)} not in enum`);
       }
     }
     if ("minLength" in schema && value.length < schema["minLength"]) {
-      errs.push(`${path13 || "<root>"}: shorter than minLength ${schema["minLength"]}`);
+      errs.push(`${path15 || "<root>"}: shorter than minLength ${schema["minLength"]}`);
     }
   }
   if (typeof value === "number" && !Number.isNaN(value)) {
     if ("minimum" in schema && value < schema["minimum"]) {
-      errs.push(`${path13 || "<root>"}: ${value} < minimum ${schema["minimum"]}`);
+      errs.push(`${path15 || "<root>"}: ${value} < minimum ${schema["minimum"]}`);
     }
     if ("maximum" in schema && value > schema["maximum"]) {
-      errs.push(`${path13 || "<root>"}: ${value} > maximum ${schema["maximum"]}`);
+      errs.push(`${path15 || "<root>"}: ${value} > maximum ${schema["maximum"]}`);
     }
   }
   if (Array.isArray(value)) {
     if ("minItems" in schema && value.length < schema["minItems"]) {
-      errs.push(`${path13 || "<root>"}: fewer items than minItems ${schema["minItems"]}`);
+      errs.push(`${path15 || "<root>"}: fewer items than minItems ${schema["minItems"]}`);
     }
     const itemSchema = schema["items"];
     if (isObj(itemSchema)) {
       for (let i = 0; i < value.length; i++) {
-        errs.push(...validateSchema(value[i], itemSchema, `${path13}[${i}]`));
+        errs.push(...validateSchema(value[i], itemSchema, `${path15}[${i}]`));
       }
     }
   }
@@ -2124,19 +2186,19 @@ function validateSchema(value, schema, path13 = "") {
     const required = schema["required"] ?? [];
     for (const r of required) {
       if (!(r in value)) {
-        errs.push(`${path13 || "<root>"}: missing required key ${pyRepr(r)}`);
+        errs.push(`${path15 || "<root>"}: missing required key ${pyRepr(r)}`);
       }
     }
     if (schema["additionalProperties"] === false) {
       for (const k of Object.keys(value)) {
         if (!(k in props)) {
-          errs.push(`${path13 || "<root>"}: unknown key ${pyRepr(k)}`);
+          errs.push(`${path15 || "<root>"}: unknown key ${pyRepr(k)}`);
         }
       }
     }
     for (const [k, v] of Object.entries(value)) {
       const ps = props[k];
-      if (ps) errs.push(...validateSchema(v, ps, path13 ? `${path13}.${k}` : k));
+      if (ps) errs.push(...validateSchema(v, ps, path15 ? `${path15}.${k}` : k));
     }
   }
   return errs;
@@ -2525,6 +2587,21 @@ async function recordSessionCall(storage, sessionId, answers, wallMs, cpuMs, now
   }
 }
 
+// src/core/budgets.ts
+init_esm_shims();
+var operatorBudgets = null;
+function setOperatorBudgets(cfg) {
+  operatorBudgets = cfg;
+}
+function operatorCeiling(purpose, provider) {
+  const direct = operatorBudgets?.token_budgets?.[purpose];
+  if (typeof direct === "number" && direct > 0) return Math.trunc(direct);
+  const byProv = operatorBudgets?.token_budgets_by_provider?.[provider.toLowerCase()];
+  const pv = byProv?.[purpose];
+  if (typeof pv === "number" && pv > 0) return Math.trunc(pv);
+  return null;
+}
+
 // src/core/structured.ts
 async function requestStructured(provider, baseMessages, schema, opts) {
   const maxRetries = opts.maxRetries ?? 1;
@@ -2599,10 +2676,13 @@ ${schemaText}`;
 async function askOne(provider, messages, opts) {
   const startedWall = performance.now();
   const startedCpu = process.cpuUsage();
+  let maxTokens = opts.maxTokens;
+  const ceiling = operatorCeiling(opts.purpose, provider.name);
+  if (ceiling !== null && ceiling < maxTokens) maxTokens = ceiling;
   try {
     const r = await provider.send({
       messages,
-      maxTokens: opts.maxTokens,
+      maxTokens,
       temperature: opts.temperature,
       purpose: opts.purpose,
       ...opts.signal ? { signal: opts.signal } : {},
@@ -2643,6 +2723,191 @@ async function askOne(provider, messages, opts) {
   }
 }
 
+// src/core/personas.ts
+init_esm_shims();
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var PERSONA_IDS = [
+  "engineering",
+  "research",
+  "auditor-security",
+  "auditor-finance",
+  "finance",
+  "design"
+];
+function isPersonaId(s) {
+  return PERSONA_IDS.includes(s);
+}
+var personaConfig = null;
+function setPersonaConfig(cfg) {
+  personaConfig = cfg;
+}
+var processFirstCallConsumed = false;
+var sessionsSeen = /* @__PURE__ */ new Set();
+function consumeFirstCall(sessionId) {
+  if (sessionId) {
+    if (sessionsSeen.has(sessionId)) return false;
+    sessionsSeen.add(sessionId);
+    return true;
+  }
+  if (processFirstCallConsumed) return false;
+  processFirstCallConsumed = true;
+  return true;
+}
+var TOOL_PRIORS = {
+  // The audit tool is for auditing — lean to security audit by default (prior
+  // clears the >=2 margin on its own), while finance keywords still flip it to
+  // auditor-finance.
+  audit: { "auditor-security": 3, "auditor-finance": 1 }
+};
+var TERMS = {
+  "auditor-security": [
+    [/\b(vuln(erabilit|)|cve|cwe|exploit|owasp|injection|sql\s*i|xss|csrf|ssrf|rce|deserializ|auth[zn]|secret|threat\s*model|attack\s*surface|privilege)\b/i, 3],
+    [/\b(security|hardening|pentest|malicious|sandbox\s*escape)\b/i, 1]
+  ],
+  "auditor-finance": [
+    [/\b(gaap|ifrs|sox|materiality|reconcil|ledger|accrual|audit\s*trail|segregation\s*of\s*duties|internal\s*control|journal\s*entry)\b/i, 3],
+    [/\b(audit|invoice|p&l|balance\s*sheet)\b/i, 1]
+  ],
+  finance: [
+    [/\b(valuation|dcf|npv|irr|cash\s*flow|unit\s*economics|burn\s*rate|runway|cap\s*table|forecast|p&l|ebitda|cohort|ltv|cac)\b/i, 3],
+    [/\b(budget|revenue|margin|pricing|financial\s*model)\b/i, 1]
+  ],
+  research: [
+    [/\b(literature|hypothes(is|es)|methodology|empirical|citation|peer[-\s]?review|ablation|systematic\s*review|meta[-\s]?analysis)\b/i, 3],
+    [/\b(research|study|survey|evidence|paper|findings)\b/i, 1]
+  ],
+  design: [
+    [/\b(ux|usability|wireframe|figma|interaction\s*design|user\s*journey|design\s*system|a11y|accessibilit|heuristic\s*evaluation|information\s*architecture)\b/i, 3],
+    [/\b(design|layout|visual|prototype|onboarding\s*flow)\b/i, 1]
+  ]
+};
+function routePersona(prompt, toolName) {
+  const text = String(prompt ?? "");
+  const scores = { engineering: 1 };
+  const priors = TOOL_PRIORS[toolName] ?? {};
+  for (const id of PERSONA_IDS) {
+    if (id === "engineering") continue;
+    let s = priors[id] ?? 0;
+    for (const [re, w] of TERMS[id]) {
+      if (re.test(text)) s += w;
+    }
+    scores[id] = s;
+  }
+  let bestId = "engineering";
+  let bestScore = -Infinity;
+  for (const id of PERSONA_IDS) {
+    if (id === "engineering") continue;
+    if (scores[id] > bestScore) {
+      bestScore = scores[id];
+      bestId = id;
+    }
+  }
+  if (bestScore - (scores["engineering"] ?? 0) >= 2) return { id: bestId, scores };
+  return { id: "engineering", scores };
+}
+function resolvePersona(opts) {
+  const cfg = opts.config ?? personaConfig;
+  if (cfg?.enabled === false) return { id: null, source: "disabled", bypassed: true };
+  const explicit = opts.explicit?.trim().toLowerCase();
+  if (explicit === "none" || explicit === "off") {
+    return { id: null, source: "none", bypassed: true };
+  }
+  if (explicit && explicit !== "auto" && isPersonaId(explicit)) {
+    return { id: explicit, source: "explicit", bypassed: false };
+  }
+  const envPin = (opts.envPin ?? process.env["CROSSCHECK_PERSONA"])?.trim().toLowerCase();
+  if (envPin && isPersonaId(envPin)) {
+    return { id: envPin, source: "env", bypassed: false };
+  }
+  const routed = routePersona(opts.prompt, opts.toolName);
+  if (routed.id !== "engineering") {
+    return { id: routed.id, source: "heuristic", scores: routed.scores, bypassed: false };
+  }
+  if (opts.firstCall) {
+    return { id: "engineering", source: "default-first-call", scores: routed.scores, bypassed: false };
+  }
+  return { id: null, source: "heuristic", scores: routed.scores, bypassed: true };
+}
+var bodyCache = /* @__PURE__ */ new Map();
+function bundledPersonasDir() {
+  let dir;
+  try {
+    dir = path2.dirname(fileURLToPath2(import.meta.url));
+  } catch {
+    dir = process.cwd();
+  }
+  for (let i = 0; i < 8; i += 1) {
+    const cand = path2.join(dir, "personas");
+    if (existsSync(path2.join(cand, "engineering.md"))) return cand;
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+function readIfExists(p) {
+  try {
+    return existsSync(p) ? readFileSync2(p, "utf8") : null;
+  } catch {
+    return null;
+  }
+}
+function loadPersonaBody(id, opts) {
+  const cfg = opts?.config ?? personaConfig;
+  const cacheKey = `${id}|${opts?.repoRoot ?? ""}|${cfg?.dir ?? ""}`;
+  const cached = bodyCache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  const candidates = [];
+  if (cfg?.dir) candidates.push(path2.join(cfg.dir, `${id}.md`));
+  if (opts?.repoRoot) candidates.push(path2.join(opts.repoRoot, ".crosscheck", "personas", `${id}.md`));
+  if (id === "engineering" && opts?.repoRoot) candidates.push(path2.join(opts.repoRoot, "CLAUDE.md"));
+  const bundled = bundledPersonasDir();
+  if (bundled) candidates.push(path2.join(bundled, `${id}.md`));
+  for (const c of candidates) {
+    const body = readIfExists(c);
+    if (body && body.trim()) {
+      const trimmed = body.trim();
+      bodyCache.set(cacheKey, trimmed);
+      return trimmed;
+    }
+  }
+  return null;
+}
+function renderPersonaBlock(id, body) {
+  return `<operating-context source="${id}">
+${body}
+</operating-context>`;
+}
+function buildPersonaInjection(opts) {
+  try {
+    const firstCall = consumeFirstCall(opts.sessionId);
+    const res = resolvePersona({
+      toolName: opts.toolName,
+      prompt: opts.prompt,
+      explicit: opts.explicit,
+      firstCall,
+      config: personaConfig
+    });
+    const meta = {
+      used: res.id,
+      source: res.source,
+      injected_into: res.id ? ["moderator"] : [],
+      bypassed: res.bypassed,
+      ...res.scores ? { scores: res.scores } : {}
+    };
+    if (!res.id) return { block: null, meta };
+    const body = loadPersonaBody(res.id, { repoRoot: opts.repoRoot });
+    if (!body) {
+      return { block: null, meta: { ...meta, injected_into: [], bypassed: true } };
+    }
+    return { block: renderPersonaBlock(res.id, body), meta };
+  } catch {
+    return { block: null, meta: { used: null, source: "none", injected_into: [], bypassed: true } };
+  }
+}
+
 // src/core/utils.ts
 init_esm_shims();
 function checkSessionBreakers(session, cfg) {
@@ -2860,6 +3125,13 @@ function redactObj(obj, cfg) {
   }
   return obj;
 }
+var globalRedaction = null;
+function setRedactionConfig(cfg) {
+  globalRedaction = cfg;
+}
+function getRedactionConfig() {
+  return globalRedaction ?? void 0;
+}
 
 // src/core/transcripts.ts
 var FTS_INDEX_MAX_CHARS = 64 * 1024;
@@ -2917,7 +3189,7 @@ async function writeTranscript(opts) {
   const now = opts.nowMs ? opts.nowMs() : Date.now();
   const stampMs = Math.trunc(now);
   const fileName = `${stampMs}-${opts.kind}.json`;
-  const redacted = redactObj(opts.payload, opts.redact);
+  const redacted = redactObj(opts.payload, opts.redact ?? getRedactionConfig());
   let absPath;
   try {
     mkdirSync2(opts.transcriptsDir, { recursive: true });
@@ -3414,7 +3686,18 @@ async function runAudit(args, opts) {
     for (const r2 of DEFAULT_AUDIT_RUBRICS) rubricItems.push({ ...r2 });
   }
   const rubricText = rubricItems.map((it) => `- ${it.id} (severity=${it.severity}): ${it.description}`).join("\n");
-  const sysMsg = "You are an independent auditor. Score the OUTPUT against each rubric item on a 0..1 likelihood that the rubric is satisfied. Set pass=true iff score >= 0.7. Be concise in `rationale` (1-2 sentences each).";
+  const persona = buildPersonaInjection({
+    toolName: "audit",
+    prompt: `${userConstraints ?? ""}
+${outputResolved}`,
+    ...typeof args["persona"] === "string" ? { explicit: args["persona"] } : {},
+    ...opts.repoRoot ? { repoRoot: opts.repoRoot } : {},
+    sessionId: typeof args["session_id"] === "string" ? args["session_id"] : null
+  });
+  const auditorSys = "You are an independent auditor. Score the OUTPUT against each rubric item on a 0..1 likelihood that the rubric is satisfied. Set pass=true iff score >= 0.7. Be concise in `rationale` (1-2 sentences each).";
+  const sysMsg = persona.block ? `${persona.block}
+
+${auditorSys}` : auditorSys;
   const userMsg = (userConstraints ? `USER CONSTRAINTS:
 ${userConstraints}
 
@@ -3511,6 +3794,7 @@ ${rubricText}`;
       audit_process_failure: flags.audit_process_failure,
       judges_stats: flags.judges_stats
     };
+    if (persona.meta.used !== null) coalesceResult["persona"] = persona.meta;
     if (!allPass2 && opts.storage && typeof sessionId === "string" && sessionId) {
       const marked = await markStaleOnAuditFailure(
         opts.storage,
@@ -3591,6 +3875,7 @@ ${rubricText}`;
     overall_score: overall,
     passed: allPass
   };
+  if (persona.meta.used !== null) result["persona"] = persona.meta;
   if (errs.length > 0) result["validation_errors"] = errs;
   if (!allPass && opts.storage && typeof sessionId === "string" && sessionId) {
     const marked = await markStaleOnAuditFailure(
@@ -3887,7 +4172,7 @@ function loadAuditTextFromSession(sessionId, transcriptsDir) {
     const p = join(transcriptsDir, name);
     let doc2;
     try {
-      doc2 = JSON.parse(readFileSync2(p, "utf8"));
+      doc2 = JSON.parse(readFileSync3(p, "utf8"));
     } catch {
       continue;
     }
@@ -3907,7 +4192,7 @@ function loadAuditTextFromSession(sessionId, transcriptsDir) {
   if (bestPath === null) return "";
   let doc;
   try {
-    doc = JSON.parse(readFileSync2(bestPath, "utf8"));
+    doc = JSON.parse(readFileSync3(bestPath, "utf8"));
   } catch {
     return "";
   }
@@ -3940,7 +4225,7 @@ function boolArg(v, defaultVal) {
 
 // src/tools/bench.ts
 init_esm_shims();
-import { existsSync, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
 import path4 from "path";
 
 // src/tools/confer.ts
@@ -4477,21 +4762,21 @@ function extractToolCall(text) {
   return { call, parseError: null };
 }
 function wrapToolResult(name, content) {
-  let str;
-  if (typeof content === "string") str = content;
+  let str2;
+  if (typeof content === "string") str2 = content;
   else {
     try {
-      str = JSON.stringify(content);
+      str2 = JSON.stringify(content);
     } catch {
-      str = String(content);
+      str2 = String(content);
     }
   }
-  if (str.length > WORKER_TOOLS_MAX_RESULT_CHARS) {
-    str = str.slice(0, WORKER_TOOLS_MAX_RESULT_CHARS) + "\n... (truncated)";
+  if (str2.length > WORKER_TOOLS_MAX_RESULT_CHARS) {
+    str2 = str2.slice(0, WORKER_TOOLS_MAX_RESULT_CHARS) + "\n... (truncated)";
   }
   return `<tool_result name="${name}">
 <untrusted_input>
-${neutralizeInjection(str)}
+${neutralizeInjection(str2)}
 </untrusted_input>
 </tool_result>`;
 }
@@ -5056,8 +5341,18 @@ async function runConfer(args, opts) {
   const untrusted = Boolean(args["untrusted_input"]);
   const canary = untrusted ? mintCanary() : null;
   const baseSys = "You are part of a panel of LLMs consulted by an engineer working inside Claude Code. Answer directly, cite assumptions, and keep it crisp.";
-  const sysMsg = untrusted ? `${baseSys}
-${UNTRUSTED_SYSTEM_NOTE}` : baseSys;
+  const persona = buildPersonaInjection({
+    toolName: "confer",
+    prompt: question,
+    ...typeof args["persona"] === "string" ? { explicit: args["persona"] } : {},
+    ...opts.repoRoot ? { repoRoot: opts.repoRoot } : {},
+    sessionId: typeof args["session_id"] === "string" ? args["session_id"] : null
+  });
+  const baseSysP = persona.block ? `${persona.block}
+
+${baseSys}` : baseSys;
+  const sysMsg = untrusted ? `${baseSysP}
+${UNTRUSTED_SYSTEM_NOTE}` : baseSysP;
   const messages = [{ role: "system", content: sysMsg }];
   if (context) {
     const ctxBody = untrusted ? wrapUntrusted(context, canary) : context;
@@ -5171,6 +5466,7 @@ ${ctxBody}` });
     question,
     answers: sanitized
   };
+  if (persona.meta.used !== null) result["persona"] = persona.meta;
   if (earlyStopped) {
     result["early_stopped"] = true;
     result["skipped_providers"] = skippedProviders;
@@ -5390,9 +5686,19 @@ async function runSandboxed(args) {
       }
       resolve2(result);
     };
+    const memKb = isUnix && args.memoryMb && args.memoryMb > 0 ? Math.trunc(args.memoryMb * 1024) : 0;
+    const cpuS = isUnix && args.cpuSeconds && args.cpuSeconds > 0 ? Math.trunc(args.cpuSeconds) : 0;
+    const useUlimit = memKb > 0 || cpuS > 0;
+    const spawnBin = useUlimit ? "/bin/sh" : args.cmd[0];
+    const spawnArgv = useUlimit ? [
+      "-c",
+      `${[memKb > 0 ? `ulimit -v ${memKb}` : "", cpuS > 0 ? `ulimit -t ${cpuS}` : ""].filter(Boolean).join("; ")} 2>/dev/null; exec "$@"`,
+      "sh",
+      ...args.cmd
+    ] : args.cmd.slice(1);
     let child;
     try {
-      child = spawn(args.cmd[0], args.cmd.slice(1), {
+      child = spawn(spawnBin, spawnArgv, {
         cwd: tempCwd ?? process.cwd(),
         env,
         // detached: own process-group on Unix (equivalent to setsid).
@@ -6081,7 +6387,7 @@ async function runBench(args, opts) {
   return result;
 }
 function loadGoldens(dirPath, filter) {
-  if (!existsSync(dirPath)) return [];
+  if (!existsSync2(dirPath)) return [];
   let entries;
   try {
     entries = readdirSync2(dirPath);
@@ -6099,7 +6405,7 @@ function loadGoldens(dirPath, filter) {
     }
     let doc;
     try {
-      doc = JSON.parse(readFileSync3(p, "utf8"));
+      doc = JSON.parse(readFileSync4(p, "utf8"));
     } catch {
       continue;
     }
@@ -6180,9 +6486,9 @@ function isObj4(v) {
 init_esm_shims();
 import { createHash as createHash2 } from "crypto";
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   statSync as statSync3,
   unlinkSync,
   writeFileSync as writeFileSync2
@@ -6259,7 +6565,7 @@ async function runConfigPin(args, opts) {
     };
   }
   const absPath = resolvePinPath(opts);
-  const existed = existsSync2(absPath);
+  const existed = existsSync3(absPath);
   if (existed) {
     try {
       unlinkSync(absPath);
@@ -6297,7 +6603,7 @@ function computeDrift(opts) {
     missing_files: missingFiles.sort(),
     pin_file: relPath(opts, absPath),
     pinned_at: Number(doc?.["pinned_at"] ?? 0) || 0,
-    has_pin_file: existsSync2(absPath)
+    has_pin_file: existsSync3(absPath)
   };
 }
 function shouldBlock(opts, drift) {
@@ -6322,7 +6628,7 @@ function resolveTargets(opts) {
   const out = [];
   for (const p of list) {
     const abs = path5.isAbsolute(p) ? p : path5.join(opts.repoRoot, p);
-    if (existsSync2(abs)) {
+    if (existsSync3(abs)) {
       try {
         const st = statSync3(abs);
         if (st.isFile()) out.push(abs);
@@ -6335,7 +6641,7 @@ function resolveTargets(opts) {
 function hashFile(abs) {
   let raw;
   try {
-    raw = readFileSync4(abs);
+    raw = readFileSync5(abs);
   } catch {
     return "";
   }
@@ -6355,9 +6661,9 @@ function resolvePinPath(opts) {
   return path5.isAbsolute(raw) ? raw : path5.join(opts.repoRoot, raw);
 }
 function loadDoc(absPath) {
-  if (!existsSync2(absPath)) return null;
+  if (!existsSync3(absPath)) return null;
   try {
-    const txt = readFileSync4(absPath, "utf8");
+    const txt = readFileSync5(absPath, "utf8");
     const doc = JSON.parse(txt);
     return doc && typeof doc === "object" && !Array.isArray(doc) ? doc : null;
   } catch {
@@ -6419,7 +6725,7 @@ function pyRepr2(v) {
 // src/tools/create.ts
 init_esm_shims();
 import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
 import path7 from "path";
 
 // src/tools/orchestrate.ts
@@ -6523,9 +6829,9 @@ function isDeadModelError(err) {
 init_esm_shims();
 import { createHash as createHash3 } from "crypto";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   renameSync,
   statSync as statSync4,
   utimesSync,
@@ -6597,7 +6903,7 @@ function cachePath(cfg, repoRoot, key) {
 function getNodeCache(cfg, repoRoot, key, nowMs) {
   if (!cfg || cfg.enabled === false) return null;
   const p = cachePath(cfg, repoRoot, key);
-  if (!existsSync3(p)) return null;
+  if (!existsSync4(p)) return null;
   const ttlS = cfg.ttl_seconds ?? 604800;
   try {
     const st = statSync4(p);
@@ -6605,7 +6911,7 @@ function getNodeCache(cfg, repoRoot, key, nowMs) {
       const now = nowMs ?? Date.now();
       if ((now - st.mtimeMs) / 1e3 > ttlS) return null;
     }
-    const data = JSON.parse(readFileSync5(p, "utf8"));
+    const data = JSON.parse(readFileSync6(p, "utf8"));
     try {
       const t = (nowMs ?? Date.now()) / 1e3;
       utimesSync(p, t, t);
@@ -6616,11 +6922,11 @@ function getNodeCache(cfg, repoRoot, key, nowMs) {
     return null;
   }
 }
-function atomicWriteJson(path13, payload) {
-  mkdirSync4(dirname2(path13), { recursive: true });
-  const tmp = `${path13}.${process.pid}.${Date.now()}.tmp`;
+function atomicWriteJson(path15, payload) {
+  mkdirSync4(dirname2(path15), { recursive: true });
+  const tmp = `${path15}.${process.pid}.${Date.now()}.tmp`;
   writeFileSync3(tmp, JSON.stringify(payload), "utf8");
-  renameSync(tmp, path13);
+  renameSync(tmp, path15);
 }
 function putNodeCache(cfg, repoRoot, key, value) {
   if (!cfg || cfg.enabled === false) return;
@@ -6631,7 +6937,7 @@ function putNodeCache(cfg, repoRoot, key, value) {
     const maxBytes = cfg.max_cache_bytes ?? 100 * 1024 * 1024;
     if (maxEntries <= 0 && maxBytes <= 0) return;
     const base = resolveCacheDir(cfg, repoRoot);
-    if (!existsSync3(base)) return;
+    if (!existsSync4(base)) return;
     const entries = [];
     let totalBytes = 0;
     for (const shard of readdirSync3(base)) {
@@ -7223,8 +7529,19 @@ NODE OUTPUTS:
 ${recombineLines.join("\n\n")}
 
 Synthesize the node outputs into a single coherent deliverable. Preserve any [MISSING: ...] markers verbatim where the upstream node failed so the caller sees what is incomplete.`;
+  const persona = buildPersonaInjection({
+    toolName: "orchestrate",
+    prompt: goal ?? recombinePrompt,
+    ...typeof args["persona"] === "string" ? { explicit: args["persona"] } : {},
+    ...opts.repoRoot ? { repoRoot: opts.repoRoot } : {},
+    sessionId: typeof args["session_id"] === "string" ? args["session_id"] : null
+  });
+  const personaMeta = persona.meta;
+  const recombineSys = "You are the orchestrator. Combine node outputs into the final result.";
   const recMsgs = [
-    { role: "system", content: "You are the orchestrator. Combine node outputs into the final result." },
+    { role: "system", content: persona.block ? `${persona.block}
+
+${recombineSys}` : recombineSys },
     { role: "user", content: recombinePrompt }
   ];
   let synthProvider = moderator;
@@ -7297,6 +7614,7 @@ Synthesize the node outputs into a single coherent deliverable. Preserve any [MI
     fail_fast: failFast,
     cheap_mode: cheapMode
   };
+  if (personaMeta.used !== null) result["persona"] = personaMeta;
   if (synthModel) result["synth_model"] = synthModel;
   if (synthErr) result["synth_error"] = synthErr;
   if (plannerErrors.length > 0) result["planner_errors"] = plannerErrors;
@@ -7688,7 +8006,7 @@ function pyRound6(x) {
 // src/tools/fetch.ts
 init_esm_shims();
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import path6 from "path";
 var DEFAULT_CONFIG = {
   enabled: true,
@@ -7770,9 +8088,9 @@ async function runFetch(args, opts) {
   const evDir = resolveEvidenceDir(cfg.evidence_dir, opts.repoRoot);
   const urlHash16 = sha256Hex2(url).slice(0, 16);
   const metaPath = path6.join(evDir, `by-url-${urlHash16}.json`);
-  if (existsSync4(metaPath) && !force) {
+  if (existsSync5(metaPath) && !force) {
     try {
-      const meta2 = JSON.parse(readFileSync6(metaPath, "utf8"));
+      const meta2 = JSON.parse(readFileSync7(metaPath, "utf8"));
       return {
         ...base,
         accepted: true,
@@ -7812,15 +8130,41 @@ async function runFetch(args, opts) {
   }
   let data;
   try {
-    const buf = await response.arrayBuffer();
-    if (buf.byteLength > cfg.max_bytes) {
-      return {
-        ...base,
-        accepted: false,
-        reason: `response exceeds max_bytes=${cfg.max_bytes}`
-      };
+    const reader = response.body?.getReader?.();
+    if (!reader) {
+      const buf = await response.arrayBuffer();
+      if (buf.byteLength > cfg.max_bytes) {
+        return { ...base, accepted: false, reason: `response exceeds max_bytes=${cfg.max_bytes}` };
+      }
+      data = new Uint8Array(buf);
+    } else {
+      const chunks = [];
+      let total = 0;
+      let exceeded = false;
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) {
+          total += value.byteLength;
+          if (total > cfg.max_bytes) {
+            exceeded = true;
+            await reader.cancel().catch(() => {
+            });
+            break;
+          }
+          chunks.push(value);
+        }
+      }
+      if (exceeded) {
+        return { ...base, accepted: false, reason: `response exceeds max_bytes=${cfg.max_bytes}` };
+      }
+      data = new Uint8Array(total);
+      let offset = 0;
+      for (const c of chunks) {
+        data.set(c, offset);
+        offset += c.byteLength;
+      }
     }
-    data = new Uint8Array(buf);
   } catch (e) {
     return {
       ...base,
@@ -8199,7 +8543,7 @@ async function ingestDocuments(documents, sessionId, opts) {
       if (typeof evidencePath === "string" && evidencePath) {
         const abs = path7.isAbsolute(evidencePath) ? evidencePath : opts.repoRoot ? path7.join(opts.repoRoot, evidencePath) : evidencePath;
         try {
-          text = readFileSync7(abs, "utf8");
+          text = readFileSync8(abs, "utf8");
         } catch {
           text = "";
         }
@@ -8213,7 +8557,7 @@ async function ingestDocuments(documents, sessionId, opts) {
       }, text));
     } else {
       const abs = path7.isAbsolute(ref) ? ref : opts.repoRoot ? path7.join(opts.repoRoot, ref) : path7.resolve(ref);
-      if (!existsSync5(abs)) {
+      if (!existsSync6(abs)) {
         out.push({
           source: ref,
           type: "file",
@@ -8225,7 +8569,7 @@ async function ingestDocuments(documents, sessionId, opts) {
       }
       let text = "";
       try {
-        text = readFileSync7(abs, "utf8");
+        text = readFileSync8(abs, "utf8");
       } catch (e) {
         out.push({
           source: ref,
@@ -9240,15 +9584,27 @@ ${prior}` });
   let synthesis = null;
   let synthesisStructured = null;
   let synthesisErrors = [];
+  let personaMeta = null;
   if (moderator) {
     const condensed = transcript.map(
       (e) => `[${e.provider} \u2014 round ${e.round}]
 ${e.response ?? "(error)"}`
     ).join("\n\n");
+    const persona = buildPersonaInjection({
+      toolName: "debate",
+      prompt: topic,
+      ...typeof args["persona"] === "string" ? { explicit: args["persona"] } : {},
+      ...opts.repoRoot ? { repoRoot: opts.repoRoot } : {},
+      sessionId: typeof args["session_id"] === "string" ? args["session_id"] : null
+    });
+    personaMeta = persona.meta;
+    const synthSys = "You are the moderator. Synthesise the debate into a single grounded recommendation.";
     const synthMessages = [
       {
         role: "system",
-        content: "You are the moderator. Synthesise the debate into a single grounded recommendation."
+        content: persona.block ? `${persona.block}
+
+${synthSys}` : synthSys
       },
       {
         role: "user",
@@ -9300,6 +9656,7 @@ ${condensed}`
     transcript,
     synthesis
   };
+  if (personaMeta && personaMeta.used !== null) result["persona"] = personaMeta;
   if (synthesisStructured !== null) {
     result["synthesis_structured"] = synthesisStructured;
   }
@@ -9459,9 +9816,9 @@ async function runDelegate(args, opts) {
       return await deferDelegate(args, opts.bridge);
     }
     return errorEnvelope10(
-      "DELEGATE_STORAGE_NOT_NATIVE",
-      "delegate requires a wired Storage adapter (for quota) or the Python bridge",
-      "Set CROSSCHECK_BRIDGE_PYTHON=1 to use the Python implementation, or wire a Storage adapter into the entrypoint."
+      "DELEGATE_STORAGE_UNAVAILABLE",
+      "delegate needs the local database (for quota tracking), which isn't available",
+      "The engine stores data at <data dir>/db.sqlite (default ~/.crosscheck/db.sqlite). This usually means the native better-sqlite3 module failed to load \u2014 run `npx -y crosscheck-cli@latest doctor`, or set CROSSCHECK_DB_PATH to a writable location, then reconnect."
     );
   }
   const storage = opts.storage;
@@ -9614,7 +9971,7 @@ function pyListRepr2(xs) {
 
 // src/tools/explain.ts
 init_esm_shims();
-import { readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync5, existsSync as existsSync6 } from "fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync5, existsSync as existsSync7 } from "fs";
 import path8 from "path";
 async function runExplain(args, opts) {
   const sessionId = args["session_id"];
@@ -9630,9 +9987,9 @@ async function runExplain(args, opts) {
       return await deferExplain(args, opts.bridge);
     }
     return errorEnvelope11(
-      "EXPLAIN_STORAGE_NOT_NATIVE",
-      "explain requires a wired Storage adapter or the Python bridge",
-      "Set CROSSCHECK_BRIDGE_PYTHON=1 to use the Python implementation, or wire a Storage adapter into the entrypoint."
+      "EXPLAIN_STORAGE_UNAVAILABLE",
+      "explain needs the local transcript/stats database, which isn't available",
+      "The engine stores data at <data dir>/db.sqlite (default ~/.crosscheck/db.sqlite). This usually means the native better-sqlite3 module failed to load \u2014 run `npx -y crosscheck-cli@latest doctor`, or set CROSSCHECK_DB_PATH to a writable location, then reconnect."
     );
   }
   const storage = opts.storage;
@@ -9716,7 +10073,7 @@ async function runExplain(args, opts) {
   return result;
 }
 function loadTranscriptsForSession(dir, sessionId) {
-  if (!existsSync6(dir)) return [];
+  if (!existsSync7(dir)) return [];
   let names;
   try {
     names = readdirSync4(dir);
@@ -9735,7 +10092,7 @@ function loadTranscriptsForSession(dir, sessionId) {
     }
     let doc;
     try {
-      doc = JSON.parse(readFileSync8(p, "utf8"));
+      doc = JSON.parse(readFileSync9(p, "utf8"));
     } catch {
       continue;
     }
@@ -10395,9 +10752,9 @@ async function runRecall(args, opts) {
       return await deferRecall(args, opts.bridge);
     }
     return errorEnvelope12(
-      "RECALL_STORAGE_NOT_NATIVE",
-      "recall requires a wired Storage adapter or the Python bridge",
-      "Set CROSSCHECK_BRIDGE_PYTHON=1 to use the Python implementation, or wire a Storage adapter into the entrypoint."
+      "RECALL_STORAGE_UNAVAILABLE",
+      "recall needs the local database, which isn't available",
+      "The engine stores data at <data dir>/db.sqlite (default ~/.crosscheck/db.sqlite). This usually means the native better-sqlite3 module failed to load \u2014 run `npx -y crosscheck-cli@latest doctor`, or set CROSSCHECK_DB_PATH to a writable location, then reconnect."
     );
   }
   const filter = {};
@@ -10488,9 +10845,9 @@ async function runRecommendPanel(args, opts) {
       return await deferRecommendPanel(args, opts.bridge);
     }
     return errorEnvelope13(
-      "RECOMMEND_PANEL_STORAGE_NOT_NATIVE",
-      "recommend_panel requires a wired Storage adapter or the Python bridge",
-      "Set CROSSCHECK_BRIDGE_PYTHON=1 to use the Python implementation, or wire a Storage adapter into the entrypoint."
+      "RECOMMEND_PANEL_STORAGE_UNAVAILABLE",
+      "recommend_panel needs the local stats database, which isn't available",
+      "The engine stores stats at <data dir>/db.sqlite (default ~/.crosscheck/db.sqlite). This usually means the native better-sqlite3 module failed to load \u2014 run `npx -y crosscheck-cli@latest doctor`, or set CROSSCHECK_DB_PATH to a writable location, then reconnect."
     );
   }
   const n = Math.max(1, clampInt2(args["n"], 1, 100, 2));
@@ -10591,16 +10948,16 @@ function toStringArray3(v) {
 
 // src/tools/scoreboard.ts
 init_esm_shims();
-import { readFileSync as readFileSync9, existsSync as existsSync7 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync8 } from "fs";
 async function runScoreboard(args, opts) {
   if (!opts.storage) {
     if (opts.bridge && opts.bridge.toolNames.has("scoreboard")) {
       return await deferScoreboard(args, opts.bridge);
     }
     return errorEnvelope14(
-      "SCOREBOARD_STORAGE_NOT_NATIVE",
-      "scoreboard requires a wired Storage adapter or the Python bridge",
-      "Set CROSSCHECK_BRIDGE_PYTHON=1 to use the Python implementation, or wire a Storage adapter into the entrypoint."
+      "SCOREBOARD_STORAGE_UNAVAILABLE",
+      "scoreboard needs the local stats database, which isn't available",
+      "The engine stores stats at <data dir>/db.sqlite (default ~/.crosscheck/db.sqlite). This usually means the native better-sqlite3 module failed to load \u2014 run `npx -y crosscheck-cli@latest doctor`, or set CROSSCHECK_DB_PATH to a writable location, then reconnect."
     );
   }
   const topK = Math.max(1, clampInt3(args["top_k"], 1, 1e4, 20));
@@ -10674,9 +11031,9 @@ async function runScoreboard(args, opts) {
   }
   usageTotals.cost_usd = Number(usageTotals.cost_usd.toFixed(8));
   let recentEvents = [];
-  if (recentLimit > 0 && opts.eventsPath && existsSync7(opts.eventsPath)) {
+  if (recentLimit > 0 && opts.eventsPath && existsSync8(opts.eventsPath)) {
     try {
-      const lines = readFileSync9(opts.eventsPath, "utf8").split("\n").filter((l) => l.length > 0);
+      const lines = readFileSync10(opts.eventsPath, "utf8").split("\n").filter((l) => l.length > 0);
       const tail = lines.slice(-recentLimit);
       for (const ln of tail) {
         try {
@@ -10775,9 +11132,9 @@ async function runSessionMemory(args, opts) {
       return await deferSessionMemory(args, opts.bridge);
     }
     return errorEnvelope15(
-      "SESSION_MEMORY_STORAGE_NOT_NATIVE",
-      "session_memory requires a wired Storage adapter or the Python bridge",
-      "Set CROSSCHECK_BRIDGE_PYTHON=1 to use the Python implementation, or wire a Storage adapter into the entrypoint."
+      "SESSION_MEMORY_STORAGE_UNAVAILABLE",
+      "session_memory needs the local database, which isn't available",
+      "The engine stores data at <data dir>/db.sqlite (default ~/.crosscheck/db.sqlite). This usually means the native better-sqlite3 module failed to load \u2014 run `npx -y crosscheck-cli@latest doctor`, or set CROSSCHECK_DB_PATH to a writable location, then reconnect."
     );
   }
   const storage = opts.storage;
@@ -10925,6 +11282,122 @@ function pyRepr6(v) {
 // src/tools/solve.ts
 init_esm_shims();
 import { performance as performance12 } from "perf_hooks";
+import { readFileSync as readFileSync11 } from "fs";
+import path9 from "path";
+
+// src/core/unified-diff.ts
+init_esm_shims();
+function diffLines(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i2 = n - 1; i2 >= 0; i2 -= 1) {
+    for (let j2 = m - 1; j2 >= 0; j2 -= 1) {
+      dp[i2][j2] = a[i2] === b[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+    }
+  }
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      ops.push({ type: "eq", line: a[i] });
+      i += 1;
+      j += 1;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      ops.push({ type: "del", line: a[i] });
+      i += 1;
+    } else {
+      ops.push({ type: "ins", line: b[j] });
+      j += 1;
+    }
+  }
+  while (i < n) {
+    ops.push({ type: "del", line: a[i] });
+    i += 1;
+  }
+  while (j < m) {
+    ops.push({ type: "ins", line: b[j] });
+    j += 1;
+  }
+  return ops;
+}
+function unifiedDiff(oldText, newText, opts) {
+  if (oldText === newText) return "";
+  const context = Math.max(0, opts?.context ?? 3);
+  const a = oldText.split("\n");
+  const b = newText.split("\n");
+  const ops = diffLines(a, b);
+  const indexed = [];
+  let ai = 0;
+  let bi = 0;
+  for (const op of ops) {
+    if (op.type === "eq") {
+      indexed.push({ ...op, aIdx: ai, bIdx: bi });
+      ai += 1;
+      bi += 1;
+    } else if (op.type === "del") {
+      indexed.push({ ...op, aIdx: ai, bIdx: bi });
+      ai += 1;
+    } else {
+      indexed.push({ ...op, aIdx: ai, bIdx: bi });
+      bi += 1;
+    }
+  }
+  const changeIdx = indexed.map((o, k) => o.type === "eq" ? -1 : k).filter((k) => k >= 0);
+  if (changeIdx.length === 0) return "";
+  const groups = [];
+  let gStart = changeIdx[0];
+  let gEnd = changeIdx[0];
+  for (let k = 1; k < changeIdx.length; k += 1) {
+    const idx = changeIdx[k];
+    if (idx - gEnd <= 2 * context + 1) {
+      gEnd = idx;
+    } else {
+      groups.push([gStart, gEnd]);
+      gStart = idx;
+      gEnd = idx;
+    }
+  }
+  groups.push([gStart, gEnd]);
+  const lines = [];
+  lines.push(`--- ${opts?.fromFile ?? "a"}`);
+  lines.push(`+++ ${opts?.toFile ?? "b"}`);
+  for (const [start, end] of groups) {
+    const from = Math.max(0, start - context);
+    const to = Math.min(indexed.length - 1, end + context);
+    let aCount = 0;
+    let bCount = 0;
+    let aStart = -1;
+    let bStart = -1;
+    const body = [];
+    for (let k = from; k <= to; k += 1) {
+      const o = indexed[k];
+      if (o.type === "eq") {
+        if (aStart < 0) aStart = o.aIdx;
+        if (bStart < 0) bStart = o.bIdx;
+        aCount += 1;
+        bCount += 1;
+        body.push(` ${o.line}`);
+      } else if (o.type === "del") {
+        if (aStart < 0) aStart = o.aIdx;
+        aCount += 1;
+        body.push(`-${o.line}`);
+      } else {
+        if (bStart < 0) bStart = o.bIdx;
+        bCount += 1;
+        body.push(`+${o.line}`);
+      }
+    }
+    const aHdr = aCount === 0 ? 0 : aStart + 1;
+    const bHdr = bCount === 0 ? 0 : bStart + 1;
+    lines.push(`@@ -${aHdr},${aCount} +${bHdr},${bCount} @@`);
+    lines.push(...body);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/tools/solve.ts
 async function runSolve(args, opts) {
   const problem = typeof args["problem"] === "string" ? args["problem"] : String(args["problem"] ?? "");
   if (!problem) {
@@ -11066,7 +11539,23 @@ Re-emit the FULL solution. No commentary.`
   const targetPath = args["target_path"];
   if (typeof targetPath === "string" && targetPath) {
     result["target_path"] = targetPath;
-    result["patch"] = null;
+    if (solved && typeof finalProposal === "string") {
+      const abs = path9.isAbsolute(targetPath) ? targetPath : path9.join(opts.repoRoot ?? process.cwd(), targetPath);
+      let oldText = "";
+      try {
+        oldText = readFileSync11(abs, "utf8");
+      } catch {
+        oldText = "";
+      }
+      const newText = finalProposal.endsWith("\n") ? finalProposal : `${finalProposal}
+`;
+      result["patch"] = unifiedDiff(oldText, newText, {
+        fromFile: `a/${targetPath}`,
+        toFile: `b/${targetPath}`
+      }) || null;
+    } else {
+      result["patch"] = null;
+    }
   }
   if (unknownNames.length > 0) result["skipped_unknown_providers"] = unknownNames;
   if (blocked.length > 0) result["blocked_by_allowlist"] = blocked;
@@ -11152,6 +11641,8 @@ async function verifyProposalShell(verifier, proposal) {
   }
   const argv = cmd.map((x) => String(x));
   const timeoutS = numberArg2(verifier["timeout_s"], 10);
+  const memoryMb = numberArg2(verifier["memory_mb"], 0);
+  const cpuSeconds = numberArg2(verifier["cpu_seconds"], 0);
   const expectExit = pyIntCoerce2(verifier["expect_exit_code"], 0);
   const expectContains = typeof verifier["expect_stdout_contains"] === "string" ? verifier["expect_stdout_contains"] : null;
   const expectRegex = typeof verifier["expect_stdout_regex"] === "string" ? verifier["expect_stdout_regex"] : null;
@@ -11161,7 +11652,9 @@ async function verifyProposalShell(verifier, proposal) {
     input: proposal,
     // proposal piped to stdin
     stdoutTailBytes: 2048,
-    stderrTailBytes: 2048
+    stderrTailBytes: 2048,
+    ...memoryMb > 0 ? { memoryMb } : {},
+    ...cpuSeconds > 0 ? { cpuSeconds } : {}
   });
   if (r.status === "timeout") {
     return {
@@ -11331,24 +11824,24 @@ function pyRepr7(v) {
 // src/tools/update-crosscheck.ts
 init_esm_shims();
 import { spawnSync } from "child_process";
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, writeFileSync as writeFileSync7 } from "fs";
-import path10 from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, writeFileSync as writeFileSync7 } from "fs";
+import path11 from "path";
 
 // src/core/update-notify.ts
 init_esm_shims();
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "fs";
 import os from "os";
-import path9 from "path";
+import path10 from "path";
 var NPM_REGISTRY = "https://registry.npmjs.org";
 var CHECK_INTERVAL_SECONDS = 3 * 24 * 60 * 60;
 var DEFAULT_PACKAGE = "crosscheck-cli";
 var FETCH_TIMEOUT_MS = 3e3;
 function engineVersion() {
-  return true ? "0.1.11" : "0.0.0-dev";
+  return true ? "0.1.13" : "0.0.0-dev";
 }
 function defaultUpdateCachePath() {
-  const base = process.env["CROSSCHECK_DATA_DIR"] || path9.join(os.homedir() || os.tmpdir(), ".crosscheck");
-  return path9.join(base, "update_check.json");
+  const base = process.env["CROSSCHECK_DATA_DIR"] || path10.join(os.homedir() || os.tmpdir(), ".crosscheck");
+  return path10.join(base, "update_check.json");
 }
 function isNewer(latest, current) {
   const a = parseTriple(latest);
@@ -11378,8 +11871,8 @@ then reconnect the crosscheck MCP server (run \`/mcp\` in Claude Code, or restar
 }
 function readCache(cachePath2) {
   try {
-    if (!existsSync8(cachePath2)) return null;
-    const data = JSON.parse(readFileSync10(cachePath2, "utf8"));
+    if (!existsSync9(cachePath2)) return null;
+    const data = JSON.parse(readFileSync12(cachePath2, "utf8"));
     if (data && typeof data === "object" && !Array.isArray(data)) {
       return data;
     }
@@ -11390,7 +11883,7 @@ function readCache(cachePath2) {
 }
 function writeCache(cachePath2, record2) {
   try {
-    mkdirSync7(path9.dirname(cachePath2), { recursive: true });
+    mkdirSync7(path10.dirname(cachePath2), { recursive: true });
     writeFileSync6(cachePath2, JSON.stringify(record2, null, 2), "utf8");
   } catch {
   }
@@ -11444,7 +11937,7 @@ async function runUpdateCrosscheck(args, opts) {
   const gitRun = opts.gitRun ?? defaultGitRun(opts.repoRoot);
   const fetchFn = opts.httpFetch ?? globalThis.fetch;
   const now = opts.nowEpochSeconds ? opts.nowEpochSeconds() : Math.floor(Date.now() / 1e3);
-  const cachePath2 = opts.cachePath ?? path10.join(opts.repoRoot, ".crosscheck", "update_check.json");
+  const cachePath2 = opts.cachePath ?? path11.join(opts.repoRoot, ".crosscheck", "update_check.json");
   const local = readLocalSha(gitRun);
   if (!local) {
     return {
@@ -11616,7 +12109,7 @@ function gitRelationship(gitRun, local, remote) {
 }
 function writeUpdateCache(p, payload) {
   try {
-    mkdirSync8(path10.dirname(p), { recursive: true });
+    mkdirSync8(path11.dirname(p), { recursive: true });
     writeFileSync7(p, JSON.stringify(payload, null, 2), "utf8");
   } catch {
   }
@@ -11964,7 +12457,7 @@ function createTool(o, toolName, cheapDefault) {
 function orchestrateTool(providers, allowlist, bridge, moderator, storage, pricing, breakers, transcriptsDir, repoRoot, nodeCache) {
   return {
     name: "orchestrate",
-    description: "Plan and execute a DAG of LLM subtasks. Either supply a `goal` (planner will draft the DAG) OR a hand-authored `dag`. Workers run topologically; recombine produces a single `final`. v1 native covers the plain sequential flow + cheap_mode (per-node tier picking); reactive (mid-flight DAG updates) still requires the Python bridge.",
+    description: "Plan and execute a DAG of LLM subtasks. Either supply a `goal` (planner will draft the DAG) OR a hand-authored `dag`. Workers run topologically; recombine produces a single `final`. Covers the sequential flow, cheap_mode (per-node tier picking), and reactive (mid-flight DAG updates) \u2014 all native.",
     inputSchema: {
       type: "object",
       additionalProperties: true,
@@ -11998,7 +12491,7 @@ function orchestrateTool(providers, allowlist, bridge, moderator, storage, prici
 function solveTool(providers, allowlist, bridge, storage, breakers, transcriptsDir, repoRoot) {
   return {
     name: "solve",
-    description: "Iterative LLM solver. Generates a proposal, verifies it against the supplied verifier, and retries with feedback up to max_attempts. Native verifier kinds: regex_response. shell-kind verifiers require the Python bridge for sandboxing.",
+    description: "Iterative LLM solver. Generates a proposal, verifies it against the supplied verifier, and retries with feedback up to max_attempts. Verifier kinds: regex_response and shell (run in a native sandbox with wall-clock + optional memory/CPU limits). With target_path, returns a unified-diff patch.",
     inputSchema: {
       type: "object",
       additionalProperties: true,
@@ -12196,7 +12689,7 @@ function explainTool(storage, bridge, transcriptsDir) {
 function scoreboardTool(storage, bridge, eventsPath) {
   return {
     name: "scoreboard",
-    description: "Aggregate provider ballot stats + delegation counts + table totals. Supports top_k (rank limit) and recent_limit (tail of events.jsonl when configured). Requires a wired Storage adapter; falls back to the Python bridge when not available.",
+    description: "Aggregate provider ballot stats + delegation counts + table totals. Supports top_k (rank limit) and recent_limit (tail of events.jsonl when configured). Reads the engine's local stats database (auto-created at <data dir>/db.sqlite).",
     inputSchema: {
       type: "object",
       additionalProperties: true,
@@ -12215,7 +12708,7 @@ function scoreboardTool(storage, bridge, eventsPath) {
 function sessionMemoryTool(storage, bridge) {
   return {
     name: "session_memory",
-    description: "CRUD over the per-session working memory ledger. Actions: list, add, mark_stale, clear. Requires a wired Storage adapter; falls back to the Python bridge when not available.",
+    description: "CRUD over the per-session working memory ledger. Actions: list, add, mark_stale, clear. Uses the engine's local database (auto-created at <data dir>/db.sqlite).",
     inputSchema: {
       type: "object",
       additionalProperties: true,
@@ -12632,8 +13125,8 @@ function pingTool() {
 
 // src/core/wrappers.ts
 init_esm_shims();
-import { existsSync as existsSync10, readFileSync as readFileSync11 } from "fs";
-import path11 from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
+import path12 from "path";
 function configPinGate(toolName, opts) {
   if (toolName === "config_pin") return null;
   if (!opts || !opts.repoRoot) return null;
@@ -12665,8 +13158,8 @@ function configPinGate(toolName, opts) {
 var cachedUpdateNotice = null;
 function readUpdateCache(cachePath2) {
   try {
-    if (!existsSync10(cachePath2)) return null;
-    const data = JSON.parse(readFileSync11(cachePath2, "utf8"));
+    if (!existsSync11(cachePath2)) return null;
+    const data = JSON.parse(readFileSync13(cachePath2, "utf8"));
     if (data && typeof data === "object" && !Array.isArray(data)) return data;
     return null;
   } catch {
@@ -12678,7 +13171,7 @@ function attachUpdateNotice(result, toolName, opts) {
   if (toolName === "update_crosscheck") return;
   if ("update_notice" in result) return;
   if (cachedUpdateNotice === null) {
-    const cachePath2 = opts?.cachePath ?? (opts?.repoRoot ? path11.join(opts.repoRoot, ".crosscheck", "update_check.json") : defaultUpdateCachePath());
+    const cachePath2 = opts?.cachePath ?? (opts?.repoRoot ? path12.join(opts.repoRoot, ".crosscheck", "update_check.json") : defaultUpdateCachePath());
     const cached = readUpdateCache(cachePath2);
     if (cached && cached.update_available && cached.notice && typeof cached.notice === "object") {
       cachedUpdateNotice = cached.notice;
@@ -12876,7 +13369,7 @@ async function flush() {
 
 // src/server.ts
 var SERVER_NAME = "crosscheck-agent";
-var SERVER_VERSION = true ? "0.1.11" : "0.0.0-dev";
+var SERVER_VERSION = true ? "0.1.13" : "0.0.0-dev";
 function extractRunSummaryText(out) {
   if (out === null || typeof out !== "object" || Array.isArray(out)) return void 0;
   const rs = out["run_summary"];
@@ -13029,6 +13522,10 @@ function buildToolRegistry(opts) {
   if (opts.nodeCache) registerOpts.nodeCache = opts.nodeCache;
   if (opts.configPinning) registerOpts.configPinning = opts.configPinning;
   if (opts.rejectConfigDriftEnv) registerOpts.rejectConfigDriftEnv = opts.rejectConfigDriftEnv;
+  if (opts.fetchConfig) registerOpts.fetchConfig = opts.fetchConfig;
+  if (opts.moderatorDefault) registerOpts.moderatorDefault = opts.moderatorDefault;
+  if (opts.benchGoldensDir) registerOpts.benchGoldensDir = opts.benchGoldensDir;
+  if (opts.eventsPath) registerOpts.eventsPath = opts.eventsPath;
   const tools = registerCoreTools(registerOpts);
   if (!opts.bridge) return tools;
   const proxies = buildPythonProxies(opts.bridge);
@@ -13038,29 +13535,207 @@ function buildToolRegistry(opts) {
   return tools;
 }
 
+// src/core/config-file.ts
+init_esm_shims();
+import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
+import path13 from "path";
+import { randomBytes as randomBytes2 } from "crypto";
+function asObj(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+}
+function num(v) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
+}
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function bool(v) {
+  return typeof v === "boolean" ? v : void 0;
+}
+function strArr(v) {
+  return Array.isArray(v) ? v.filter((x) => typeof x === "string") : void 0;
+}
+function pickNums(src, keys) {
+  const out = {};
+  for (const k of keys) {
+    const n = num(src[k]);
+    if (n !== void 0) out[k] = n;
+  }
+  return out;
+}
+function findConfigFile(opts) {
+  const direct = opts.explicitPath ?? process.env["CROSSCHECK_CONFIG_PATH"];
+  if (direct) return existsSync12(direct) ? direct : void 0;
+  const candidates = [];
+  let dir = opts.startDir;
+  for (let i = 0; dir && i < 8; i += 1) {
+    candidates.push(path13.join(dir, "crosscheck.config.json"));
+    const parent = path13.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (opts.repoRoot) candidates.push(path13.join(opts.repoRoot, "crosscheck.config.json"));
+  if (opts.dataDir) candidates.push(path13.join(opts.dataDir, "crosscheck.config.json"));
+  return candidates.find((p) => existsSync12(p));
+}
+function mapConfig(raw, sourcePath) {
+  const result = { sourcePath };
+  const cb = asObj(raw["circuit_breakers"]);
+  if (cb) {
+    const picked = pickNums(cb, [
+      "max_session_cost_usd",
+      "max_session_tokens",
+      "max_session_wall_seconds",
+      "max_dag_nodes",
+      "max_dag_depth"
+    ]);
+    if (Object.keys(picked).length > 0) result.circuitBreakers = picked;
+  }
+  const nc = asObj(raw["node_cache"]);
+  if (nc) {
+    const cfg = {
+      ...pickNums(nc, ["ttl_seconds", "max_entries", "max_cache_bytes"])
+    };
+    if (bool(nc["enabled"]) !== void 0) cfg.enabled = bool(nc["enabled"]);
+    if (str(nc["dir"]) !== void 0) cfg.dir = str(nc["dir"]);
+    result.nodeCache = cfg;
+  }
+  const f = asObj(raw["fetch"]);
+  if (f) {
+    const cfg = {
+      ...pickNums(f, [
+        "max_bytes",
+        "max_bytes_per_session",
+        "max_unique_hosts_per_session",
+        "timeout_s"
+      ])
+    };
+    if (bool(f["enabled"]) !== void 0) cfg.enabled = bool(f["enabled"]);
+    if (strArr(f["url_allowlist"]) !== void 0) cfg.url_allowlist = strArr(f["url_allowlist"]);
+    if (str(f["evidence_dir"]) !== void 0) cfg.evidence_dir = str(f["evidence_dir"]);
+    result.fetchConfig = cfg;
+  }
+  if ("provider_allowlist" in raw) {
+    const pa = raw["provider_allowlist"];
+    if (pa === null) result.providerAllowlist = null;
+    else if (strArr(pa) !== void 0) result.providerAllowlist = strArr(pa);
+  }
+  const moderator = str(raw["moderator"]);
+  if (moderator) result.moderatorDefault = moderator.toLowerCase();
+  const bench = asObj(raw["bench"]);
+  const goldens = bench ? str(bench["goldens_dir"]) : void 0;
+  if (goldens) result.benchGoldensDir = goldens;
+  const td = str(raw["transcript_dir"]);
+  if (td) result.transcriptsDir = td;
+  const ev = str(raw["events_log"]);
+  if (ev) result.eventsPath = ev;
+  const db = str(raw["session_db"]);
+  if (db) result.dbPath = db;
+  const lt = bool(raw["log_transcripts"]);
+  if (lt !== void 0) result.logTranscripts = lt;
+  const retries = asObj(raw["retries"]);
+  if (retries) {
+    const maxAttempts = num(retries["max_attempts"]);
+    const baseS = num(retries["backoff_base_s"]);
+    const cfg = {};
+    if (maxAttempts !== void 0) cfg.maxAttempts = Math.max(1, Math.trunc(maxAttempts));
+    if (baseS !== void 0) cfg.backoffBaseMs = Math.round(baseS * 1e3);
+    if (Object.keys(cfg).length > 0) setRetryConfig(cfg);
+  }
+  const rl = asObj(raw["rate_limits"]);
+  if (rl) {
+    const mapped = {};
+    for (const [provider, spec] of Object.entries(rl)) {
+      const s = asObj(spec);
+      const capacity = s ? num(s["capacity"]) : void 0;
+      const refill = s ? num(s["refill_per_sec"]) : void 0;
+      if (capacity !== void 0 && refill !== void 0) {
+        mapped[provider] = { capacity, refillPerSec: refill };
+      }
+    }
+    if (Object.keys(mapped).length > 0) setRateLimitConfig(mapped);
+  }
+  const tb = asObj(raw["token_budgets"]);
+  if (tb) {
+    const budgets = {};
+    for (const [purpose, v] of Object.entries(tb)) {
+      const n = num(v);
+      if (n !== void 0 && n > 0) budgets[purpose] = Math.trunc(n);
+    }
+    if (Object.keys(budgets).length > 0) setOperatorBudgets({ token_budgets: budgets });
+  }
+  const red = asObj(raw["redaction"]);
+  if (red) {
+    const cfg = {};
+    if (bool(red["enabled"]) !== void 0) cfg.enabled = bool(red["enabled"]);
+    const extras = strArr(red["patterns_extra"]);
+    if (extras && extras.length > 0) cfg.patterns_extra = extras;
+    if (bool(red["hmac_tokens"]) === true) {
+      cfg.hmac_tokens = true;
+      cfg.hmac_secret = randomBytes2(32);
+    }
+    if (Object.keys(cfg).length > 0) setRedactionConfig(cfg);
+  }
+  const personas = asObj(raw["personas"]);
+  if (personas) {
+    const cfg = {};
+    if (bool(personas["enabled"]) !== void 0) cfg.enabled = bool(personas["enabled"]);
+    if (str(personas["dir"]) !== void 0) cfg.dir = str(personas["dir"]);
+    if (Object.keys(cfg).length > 0) setPersonaConfig(cfg);
+  }
+  return result;
+}
+function loadConfigFile(opts) {
+  const file = findConfigFile(opts);
+  if (!file) return null;
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync14(file, "utf8"));
+  } catch (e) {
+    try {
+      process.stderr.write(
+        `crosscheck-agent: failed to parse ${file} (${e.message}); using defaults
+`
+      );
+    } catch {
+    }
+    return null;
+  }
+  const obj = asObj(raw);
+  if (!obj) return null;
+  return mapConfig(obj, file);
+}
+
 // src/entrypoints/node-stdio.ts
 var SHUTDOWN_TIMEOUT_MS = 2e3;
 async function main() {
+  const cfgDataDir = process.env["CROSSCHECK_DATA_DIR"] || path14.join(process.env["HOME"] ?? process.env["USERPROFILE"] ?? "", ".crosscheck");
+  const configFile = loadConfigFile({
+    startDir: process.cwd(),
+    repoRoot: findGitRoot(__dirname),
+    dataDir: cfgDataDir
+  });
+  if (configFile) {
+    if (configFile.eventsPath && !process.env["CROSSCHECK_EVENTS_PATH"]) {
+      process.env["CROSSCHECK_EVENTS_PATH"] = configFile.eventsPath;
+    }
+    if (configFile.dbPath && !process.env["CROSSCHECK_DB_PATH"]) {
+      process.env["CROSSCHECK_DB_PATH"] = configFile.dbPath;
+    }
+    process.stderr.write(`crosscheck-agent: loaded config from ${configFile.sourcePath}
+`);
+  }
   setEventEmitter(buildDefaultEmitter(process.env));
-  let bridge;
   if (process.env["CROSSCHECK_BRIDGE_PYTHON"] === "1") {
-    bridge = await spawnPythonBridge({
-      ...process.env["CROSSCHECK_PYTHON_PATH"] ? { pythonPath: process.env["CROSSCHECK_PYTHON_PATH"] } : {},
-      ...process.env["CROSSCHECK_PYTHON_SERVER"] ? { serverPath: process.env["CROSSCHECK_PYTHON_SERVER"] } : {}
-    });
-    process.stderr.write(
-      `crosscheck-agent: bridge online (pid=${bridge.pid ?? "?"}); proxying ${bridge.toolNames.size} Python tool(s)
-`
-    );
-  } else {
     process.stderr.write(
-      "crosscheck-agent: native-only mode (set CROSSCHECK_BRIDGE_PYTHON=1 to enable the optional Python backstop)\n"
+      "crosscheck-agent: CROSSCHECK_BRIDGE_PYTHON is deprecated and ignored \u2014 the engine is native-only.\n"
     );
   }
-  installShutdownHandlers(bridge);
+  installShutdownHandlers();
   const bundledPricing = (() => {
     try {
-      return path12.join(path12.dirname(fileURLToPath3(import.meta.url)), "pricing.json");
+      return path14.join(path14.dirname(fileURLToPath3(import.meta.url)), "pricing.json");
     } catch {
       return void 0;
     }
@@ -13069,7 +13744,7 @@ async function main() {
     process.env["CROSSCHECK_PRICING_PATH"],
     resolveRepoFile("config/pricing.json"),
     bundledPricing
-  ].find((p) => p && existsSync11(p));
+  ].find((p) => p && existsSync13(p));
   const pricing = pricingPath ? loadPricing(pricingPath) : {};
   const providers = buildProviders({ env: process.env, pricing });
   if (Object.keys(providers).length > 0) {
@@ -13080,10 +13755,10 @@ async function main() {
   }
   let storage;
   if (process.env["CROSSCHECK_DB_DISABLED"] !== "1") {
-    const dbPath = process.env["CROSSCHECK_DB_PATH"] ?? resolveRepoFile(".crosscheck/db.sqlite");
+    const dbPath = process.env["CROSSCHECK_DB_PATH"] ?? resolveRepoFile(".crosscheck/db.sqlite") ?? path14.join(cfgDataDir, "db.sqlite");
     if (dbPath) {
       try {
-        mkdirSync9(path12.dirname(dbPath), { recursive: true });
+        mkdirSync9(path14.dirname(dbPath), { recursive: true });
         const { openBetterSqliteStorage: openBetterSqliteStorage2 } = await Promise.resolve().then(() => (init_better_sqlite3(), better_sqlite3_exports));
         storage = openBetterSqliteStorage2({ path: dbPath });
         await storage.migrate();
@@ -13093,40 +13768,39 @@ async function main() {
         );
       } catch (e) {
         process.stderr.write(
-          `crosscheck-agent: storage init failed (${e.message}); storage tools will defer to bridge
+          `crosscheck-agent: storage init failed (${e.message}); storage-backed tools (recall, scoreboard, recommend_panel, session_memory, explain) will be unavailable
 `
         );
         storage = void 0;
       }
     }
   }
-  const transcriptsDir = process.env["CROSSCHECK_TRANSCRIPTS_DIR"] ?? resolveRepoFile(".crosscheck/transcripts");
+  const transcriptsDir = configFile?.logTranscripts === false ? void 0 : process.env["CROSSCHECK_TRANSCRIPTS_DIR"] ?? configFile?.transcriptsDir ?? resolveRepoFile(".crosscheck/transcripts");
   const repoRoot = process.env["CROSSCHECK_REPO_ROOT"] ?? findGitRoot(__dirname);
   const transport = new StdioServerTransport();
   const serverOpts = { providers };
-  if (bridge) serverOpts.bridge = bridge;
   if (storage) serverOpts.storage = storage;
   if (transcriptsDir) serverOpts.transcriptsDir = transcriptsDir;
   if (repoRoot) serverOpts.repoRoot = repoRoot;
   if (pricing && Object.keys(pricing).length > 0) {
     serverOpts.pricing = pricing;
   }
+  if (configFile?.circuitBreakers) serverOpts.circuitBreakers = configFile.circuitBreakers;
+  if (configFile?.nodeCache) serverOpts.nodeCache = configFile.nodeCache;
+  if (configFile?.fetchConfig) serverOpts.fetchConfig = configFile.fetchConfig;
+  if (configFile?.providerAllowlist !== void 0) {
+    serverOpts.providerAllowlist = configFile.providerAllowlist;
+  }
+  if (configFile?.moderatorDefault) serverOpts.moderatorDefault = configFile.moderatorDefault;
+  if (configFile?.benchGoldensDir) serverOpts.benchGoldensDir = configFile.benchGoldensDir;
+  if (configFile?.eventsPath) serverOpts.eventsPath = configFile.eventsPath;
   await connectAndServe(transport, serverOpts);
 }
-function installShutdownHandlers(bridge) {
+function installShutdownHandlers() {
   let shuttingDown = false;
   const shutdown = async (reason) => {
     if (shuttingDown) return;
     shuttingDown = true;
-    if (bridge) {
-      await Promise.race([
-        bridge.close(),
-        new Promise(
-          (resolve2) => setTimeout(resolve2, SHUTDOWN_TIMEOUT_MS)
-        )
-      ]).catch(() => {
-      });
-    }
     await Promise.race([
       flush(),
       new Promise((resolve2) => setTimeout(resolve2, SHUTDOWN_TIMEOUT_MS))
@@ -13152,9 +13826,9 @@ function installShutdownHandlers(bridge) {
 function resolveRepoFile(rel) {
   let dir = __dirname;
   for (let i = 0; i < 8; i++) {
-    const candidate = path12.join(dir, rel);
-    if (existsSync11(candidate)) return candidate;
-    const parent = path12.dirname(dir);
+    const candidate = path14.join(dir, rel);
+    if (existsSync13(candidate)) return candidate;
+    const parent = path14.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -13163,8 +13837,8 @@ function resolveRepoFile(rel) {
 function findGitRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 12; i++) {
-    if (existsSync11(path12.join(dir, ".git"))) return dir;
-    const parent = path12.dirname(dir);
+    if (existsSync13(path14.join(dir, ".git"))) return dir;
+    const parent = path14.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }