crosscheck-mcp 0.1.10 → 0.1.12

package/dist/node-stdio.cjs

@@ -942,159 +942,15 @@ __export(node_stdio_exports, {
 });
 module.exports = __toCommonJS(node_stdio_exports);
 init_cjs_shims();
-var import_node_fs15 = require("fs");
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_fs18 = require("fs");
+var import_node_path17 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
-var import_stdio2 = require("@modelcontextprotocol/sdk/server/stdio.js");
-
-// src/bridge/index.ts
-init_cjs_shims();
-
-// src/bridge/python-bridge.ts
-init_cjs_shims();
-var import_node_path = __toESM(require("path"), 1);
-var import_node_url = require("url");
-var import_client = require("@modelcontextprotocol/sdk/client/index.js");
-var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
-function defaultServerPath() {
-  let here;
-  try {
-    here = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
-  } catch {
-    here = __dirname;
-  }
-  const upToPkg = here.includes(`${import_node_path.default.sep}src${import_node_path.default.sep}bridge`) ? "../.." : "..";
-  return import_node_path.default.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 import_stdio.StdioClientTransport({
-    command: pythonPath,
-    args,
-    env: { ...process.env, ...opts.env ?? {} }
-  });
-  const client = new import_client.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_cjs_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 };
-    }
-  };
-}
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 // src/core/events.ts
 init_cjs_shims();
 var import_node_fs = require("fs");
-var import_node_path2 = require("path");
+var import_node_path = require("path");
 var StderrEmitter = class {
   emit(event) {
     try {
@@ -1104,10 +960,10 @@ var StderrEmitter = class {
   }
 };
 var FileEmitter = class {
-  constructor(path12) {
-    this.path = path12;
+  constructor(path14) {
+    this.path = path14;
     try {
-      (0, import_node_fs.mkdirSync)((0, import_node_path2.dirname)(path12), { recursive: true });
+      (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path14), { recursive: true });
     } catch {
     }
   }
@@ -1140,13 +996,13 @@ var NullEmitter = class {
 function buildDefaultEmitter(env) {
   const mode = (env["CROSSCHECK_EVENTS"] ?? "stderr").toLowerCase();
   if (mode === "off") return new NullEmitter();
-  const path12 = env["CROSSCHECK_EVENTS_PATH"];
+  const path14 = env["CROSSCHECK_EVENTS_PATH"];
   if (mode === "file") {
-    return path12 ? new FileEmitter(path12) : new NullEmitter();
+    return path14 ? new FileEmitter(path14) : new NullEmitter();
   }
   if (mode === "both") {
     const ems = [new StderrEmitter()];
-    if (path12) ems.push(new FileEmitter(path12));
+    if (path14) ems.push(new FileEmitter(path14));
     return new TeeEmitter(ems);
   }
   return new StderrEmitter();
@@ -1195,10 +1051,10 @@ function envelopeBytes(v) {
 // src/core/pricing.ts
 init_cjs_shims();
 var import_node_fs2 = require("fs");
-function loadPricing(path12) {
+function loadPricing(path14) {
   let raw;
   try {
-    raw = (0, import_node_fs2.readFileSync)(path12, "utf8");
+    raw = (0, import_node_fs2.readFileSync)(path14, "utf8");
   } catch {
     return {};
   }
@@ -1328,7 +1184,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(
@@ -1348,14 +1204,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(
@@ -1365,6 +1221,156 @@ function httpFailureToProviderError(provider, status, bodyText) {
   );
 }
 
+// src/providers/retry.ts
+init_cjs_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_cjs_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";
@@ -1491,29 +1497,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
@@ -1665,29 +1675,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
@@ -1815,6 +1829,11 @@ async function sendOpenAICompatible(args) {
       body.reasoning_effort = effort;
     }
   }
+  if (isReasoningModel(args.provider, args.model) && typeof body.max_completion_tokens === "number") {
+    const raw = Number(process.env["CROSSCHECK_OPENAI_REASONING_HEADROOM_TOKENS"]);
+    const headroom = Number.isFinite(raw) && raw >= 0 ? Math.trunc(raw) : 25e3;
+    body.max_completion_tokens += headroom;
+  }
   const doFetch = args.fetchImpl ?? globalThis.fetch;
   const init = {
     method: "POST",
@@ -1822,30 +1841,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
@@ -1940,7 +1963,51 @@ function makeGeminiProvider(model, apiKey, opts) {
 // src/server.ts
 init_cjs_shims();
 var import_server2 = require("@modelcontextprotocol/sdk/server/index.js");
-var import_types6 = require("@modelcontextprotocol/sdk/types.js");
+var import_types8 = require("@modelcontextprotocol/sdk/types.js");
+
+// src/bridge/index.ts
+init_cjs_shims();
+
+// src/bridge/proxy-tools.ts
+init_cjs_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_cjs_shims();
@@ -2007,7 +2074,7 @@ var import_zod = require("zod");
 
 // src/tools/audit.ts
 init_cjs_shims();
-var import_node_fs4 = require("fs");
+var import_node_fs5 = require("fs");
 var import_node_path4 = require("path");
 
 // src/core/structured.ts
@@ -2070,27 +2137,27 @@ function extractJson(text) {
 
 // src/core/json-schema.ts
 init_cjs_shims();
-function validateSchema(value, schema, path12 = "") {
+function validateSchema(value, schema, path14 = "") {
   const errs = [];
   if ("anyOf" in schema) {
     const subs = schema["anyOf"].map(
-      (s) => validateSchema(value, s, path12)
+      (s) => validateSchema(value, s, path14)
     );
     if (!subs.some((e) => e.length === 0)) {
-      errs.push(`${path12 || "<root>"}: did not match anyOf`);
+      errs.push(`${path14 || "<root>"}: did not match anyOf`);
     }
     return errs;
   }
   if ("oneOf" in schema) {
-    const passed = schema["oneOf"].filter((s) => validateSchema(value, s, path12).length === 0).length;
+    const passed = schema["oneOf"].filter((s) => validateSchema(value, s, path14).length === 0).length;
     if (passed !== 1) {
-      errs.push(`${path12 || "<root>"}: matched ${passed} of oneOf, expected 1`);
+      errs.push(`${path14 || "<root>"}: matched ${passed} of oneOf, expected 1`);
     }
     return errs;
   }
   if ("const" in schema && !deepEqual(value, schema["const"])) {
     errs.push(
-      `${path12 || "<root>"}: expected const ${pyRepr(schema["const"])}, got ${pyRepr(value)}`
+      `${path14 || "<root>"}: expected const ${pyRepr(schema["const"])}, got ${pyRepr(value)}`
     );
     return errs;
   }
@@ -2100,7 +2167,7 @@ function validateSchema(value, schema, path12 = "") {
     const ok = types.some((tt) => matchesType(value, String(tt)));
     if (!ok) {
       errs.push(
-        `${path12 || "<root>"}: expected type ${pyReprType(t)}, got ${pyTypeName(value)}`
+        `${path14 || "<root>"}: expected type ${pyReprType(t)}, got ${pyTypeName(value)}`
       );
       return errs;
     }
@@ -2109,29 +2176,29 @@ function validateSchema(value, schema, path12 = "") {
     if ("enum" in schema) {
       const en = schema["enum"];
       if (!en.some((x) => deepEqual(x, value))) {
-        errs.push(`${path12 || "<root>"}: value ${pyRepr(value)} not in enum`);
+        errs.push(`${path14 || "<root>"}: value ${pyRepr(value)} not in enum`);
       }
     }
     if ("minLength" in schema && value.length < schema["minLength"]) {
-      errs.push(`${path12 || "<root>"}: shorter than minLength ${schema["minLength"]}`);
+      errs.push(`${path14 || "<root>"}: shorter than minLength ${schema["minLength"]}`);
     }
   }
   if (typeof value === "number" && !Number.isNaN(value)) {
     if ("minimum" in schema && value < schema["minimum"]) {
-      errs.push(`${path12 || "<root>"}: ${value} < minimum ${schema["minimum"]}`);
+      errs.push(`${path14 || "<root>"}: ${value} < minimum ${schema["minimum"]}`);
     }
     if ("maximum" in schema && value > schema["maximum"]) {
-      errs.push(`${path12 || "<root>"}: ${value} > maximum ${schema["maximum"]}`);
+      errs.push(`${path14 || "<root>"}: ${value} > maximum ${schema["maximum"]}`);
     }
   }
   if (Array.isArray(value)) {
     if ("minItems" in schema && value.length < schema["minItems"]) {
-      errs.push(`${path12 || "<root>"}: fewer items than minItems ${schema["minItems"]}`);
+      errs.push(`${path14 || "<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, `${path12}[${i}]`));
+        errs.push(...validateSchema(value[i], itemSchema, `${path14}[${i}]`));
       }
     }
   }
@@ -2140,19 +2207,19 @@ function validateSchema(value, schema, path12 = "") {
     const required = schema["required"] ?? [];
     for (const r of required) {
       if (!(r in value)) {
-        errs.push(`${path12 || "<root>"}: missing required key ${pyRepr(r)}`);
+        errs.push(`${path14 || "<root>"}: missing required key ${pyRepr(r)}`);
       }
     }
     if (schema["additionalProperties"] === false) {
       for (const k of Object.keys(value)) {
         if (!(k in props)) {
-          errs.push(`${path12 || "<root>"}: unknown key ${pyRepr(k)}`);
+          errs.push(`${path14 || "<root>"}: unknown key ${pyRepr(k)}`);
         }
       }
     }
     for (const [k, v] of Object.entries(value)) {
       const ps = props[k];
-      if (ps) errs.push(...validateSchema(v, ps, path12 ? `${path12}.${k}` : k));
+      if (ps) errs.push(...validateSchema(v, ps, path14 ? `${path14}.${k}` : k));
     }
   }
   return errs;
@@ -2541,6 +2608,21 @@ async function recordSessionCall(storage, sessionId, answers, wallMs, cpuMs, now
   }
 }
 
+// src/core/budgets.ts
+init_cjs_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;
@@ -2615,10 +2697,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 } : {},
@@ -2659,6 +2744,191 @@ async function askOne(provider, messages, opts) {
   }
 }
 
+// src/core/personas.ts
+init_cjs_shims();
+var import_node_fs3 = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_url = require("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 = import_node_path2.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+  } catch {
+    dir = process.cwd();
+  }
+  for (let i = 0; i < 8; i += 1) {
+    const cand = import_node_path2.default.join(dir, "personas");
+    if ((0, import_node_fs3.existsSync)(import_node_path2.default.join(cand, "engineering.md"))) return cand;
+    const parent = import_node_path2.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+function readIfExists(p) {
+  try {
+    return (0, import_node_fs3.existsSync)(p) ? (0, import_node_fs3.readFileSync)(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(import_node_path2.default.join(cfg.dir, `${id}.md`));
+  if (opts?.repoRoot) candidates.push(import_node_path2.default.join(opts.repoRoot, ".crosscheck", "personas", `${id}.md`));
+  if (id === "engineering" && opts?.repoRoot) candidates.push(import_node_path2.default.join(opts.repoRoot, "CLAUDE.md"));
+  const bundled = bundledPersonasDir();
+  if (bundled) candidates.push(import_node_path2.default.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_cjs_shims();
 function checkSessionBreakers(session, cfg) {
@@ -2797,7 +3067,7 @@ function maybeDagBreakerEnvelope(dag, toolName, cfg, sessionId) {
 
 // src/core/transcripts.ts
 init_cjs_shims();
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_path3 = __toESM(require("path"), 1);
 
 // src/core/redact.ts
@@ -2876,6 +3146,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;
@@ -2933,12 +3210,12 @@ 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 {
-    (0, import_node_fs3.mkdirSync)(opts.transcriptsDir, { recursive: true });
+    (0, import_node_fs4.mkdirSync)(opts.transcriptsDir, { recursive: true });
     absPath = import_node_path3.default.resolve(opts.transcriptsDir, fileName);
-    (0, import_node_fs3.writeFileSync)(absPath, JSON.stringify(redacted, null, 2), "utf8");
+    (0, import_node_fs4.writeFileSync)(absPath, JSON.stringify(redacted, null, 2), "utf8");
   } catch {
     return null;
   }
@@ -3430,7 +3707,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}
 
@@ -3527,6 +3815,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,
@@ -3607,6 +3896,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(
@@ -3892,7 +4182,7 @@ function loadAuditTextFromSession(sessionId, transcriptsDir) {
   if (!transcriptsDir) return "";
   let entries;
   try {
-    entries = (0, import_node_fs4.readdirSync)(transcriptsDir);
+    entries = (0, import_node_fs5.readdirSync)(transcriptsDir);
   } catch {
     return "";
   }
@@ -3903,7 +4193,7 @@ function loadAuditTextFromSession(sessionId, transcriptsDir) {
     const p = (0, import_node_path4.join)(transcriptsDir, name);
     let doc2;
     try {
-      doc2 = JSON.parse((0, import_node_fs4.readFileSync)(p, "utf8"));
+      doc2 = JSON.parse((0, import_node_fs5.readFileSync)(p, "utf8"));
     } catch {
       continue;
     }
@@ -3911,7 +4201,7 @@ function loadAuditTextFromSession(sessionId, transcriptsDir) {
     if (sid !== sessionId) continue;
     let mtime;
     try {
-      mtime = (0, import_node_fs4.statSync)(p).mtimeMs;
+      mtime = (0, import_node_fs5.statSync)(p).mtimeMs;
     } catch {
       continue;
     }
@@ -3923,7 +4213,7 @@ function loadAuditTextFromSession(sessionId, transcriptsDir) {
   if (bestPath === null) return "";
   let doc;
   try {
-    doc = JSON.parse((0, import_node_fs4.readFileSync)(bestPath, "utf8"));
+    doc = JSON.parse((0, import_node_fs5.readFileSync)(bestPath, "utf8"));
   } catch {
     return "";
   }
@@ -3956,7 +4246,7 @@ function boolArg(v, defaultVal) {
 
 // src/tools/bench.ts
 init_cjs_shims();
-var import_node_fs5 = require("fs");
+var import_node_fs6 = require("fs");
 var import_node_path6 = __toESM(require("path"), 1);
 
 // src/tools/confer.ts
@@ -4493,21 +4783,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>`;
 }
@@ -5072,8 +5362,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;
@@ -5187,6 +5487,7 @@ ${ctxBody}` });
     question,
     answers: sanitized
   };
+  if (persona.meta.used !== null) result["persona"] = persona.meta;
   if (earlyStopped) {
     result["early_stopped"] = true;
     result["skipped_providers"] = skippedProviders;
@@ -5406,9 +5707,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 = (0, import_node_child_process.spawn)(args.cmd[0], args.cmd.slice(1), {
+      child = (0, import_node_child_process.spawn)(spawnBin, spawnArgv, {
         cwd: tempCwd ?? process.cwd(),
         env,
         // detached: own process-group on Unix (equivalent to setsid).
@@ -6097,10 +6408,10 @@ async function runBench(args, opts) {
   return result;
 }
 function loadGoldens(dirPath, filter) {
-  if (!(0, import_node_fs5.existsSync)(dirPath)) return [];
+  if (!(0, import_node_fs6.existsSync)(dirPath)) return [];
   let entries;
   try {
-    entries = (0, import_node_fs5.readdirSync)(dirPath);
+    entries = (0, import_node_fs6.readdirSync)(dirPath);
   } catch {
     return [];
   }
@@ -6109,13 +6420,13 @@ function loadGoldens(dirPath, filter) {
     if (!name.endsWith(".json")) continue;
     const p = import_node_path6.default.join(dirPath, name);
     try {
-      (0, import_node_fs5.statSync)(p);
+      (0, import_node_fs6.statSync)(p);
     } catch {
       continue;
     }
     let doc;
     try {
-      doc = JSON.parse((0, import_node_fs5.readFileSync)(p, "utf8"));
+      doc = JSON.parse((0, import_node_fs6.readFileSync)(p, "utf8"));
     } catch {
       continue;
     }
@@ -6195,7 +6506,7 @@ function isObj4(v) {
 // src/tools/config-pin.ts
 init_cjs_shims();
 var import_node_crypto3 = require("crypto");
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 var import_node_path7 = __toESM(require("path"), 1);
 var DEFAULT_PIN_PATH = ".crosscheck/config_pins.json";
 var DEFAULT_TARGETS = ["crosscheck.config.json", "config/pricing.json"];
@@ -6268,10 +6579,10 @@ async function runConfigPin(args, opts) {
     };
   }
   const absPath = resolvePinPath(opts);
-  const existed = (0, import_node_fs6.existsSync)(absPath);
+  const existed = (0, import_node_fs7.existsSync)(absPath);
   if (existed) {
     try {
-      (0, import_node_fs6.unlinkSync)(absPath);
+      (0, import_node_fs7.unlinkSync)(absPath);
     } catch (e) {
       return errorEnvelope4(
         "CONFIG_PIN_CLEAR_FAILED",
@@ -6306,7 +6617,7 @@ function computeDrift(opts) {
     missing_files: missingFiles.sort(),
     pin_file: relPath(opts, absPath),
     pinned_at: Number(doc?.["pinned_at"] ?? 0) || 0,
-    has_pin_file: (0, import_node_fs6.existsSync)(absPath)
+    has_pin_file: (0, import_node_fs7.existsSync)(absPath)
   };
 }
 function shouldBlock(opts, drift) {
@@ -6331,9 +6642,9 @@ function resolveTargets(opts) {
   const out = [];
   for (const p of list) {
     const abs = import_node_path7.default.isAbsolute(p) ? p : import_node_path7.default.join(opts.repoRoot, p);
-    if ((0, import_node_fs6.existsSync)(abs)) {
+    if ((0, import_node_fs7.existsSync)(abs)) {
       try {
-        const st = (0, import_node_fs6.statSync)(abs);
+        const st = (0, import_node_fs7.statSync)(abs);
         if (st.isFile()) out.push(abs);
       } catch {
       }
@@ -6344,7 +6655,7 @@ function resolveTargets(opts) {
 function hashFile(abs) {
   let raw;
   try {
-    raw = (0, import_node_fs6.readFileSync)(abs);
+    raw = (0, import_node_fs7.readFileSync)(abs);
   } catch {
     return "";
   }
@@ -6364,9 +6675,9 @@ function resolvePinPath(opts) {
   return import_node_path7.default.isAbsolute(raw) ? raw : import_node_path7.default.join(opts.repoRoot, raw);
 }
 function loadDoc(absPath) {
-  if (!(0, import_node_fs6.existsSync)(absPath)) return null;
+  if (!(0, import_node_fs7.existsSync)(absPath)) return null;
   try {
-    const txt = (0, import_node_fs6.readFileSync)(absPath, "utf8");
+    const txt = (0, import_node_fs7.readFileSync)(absPath, "utf8");
     const doc = JSON.parse(txt);
     return doc && typeof doc === "object" && !Array.isArray(doc) ? doc : null;
   } catch {
@@ -6375,11 +6686,11 @@ function loadDoc(absPath) {
 }
 function saveDoc(opts, doc) {
   const absPath = resolvePinPath(opts);
-  (0, import_node_fs6.mkdirSync)(import_node_path7.default.dirname(absPath), { recursive: true });
+  (0, import_node_fs7.mkdirSync)(import_node_path7.default.dirname(absPath), { recursive: true });
   const tmp = absPath + ".tmp";
-  (0, import_node_fs6.writeFileSync)(tmp, JSON.stringify(doc, null, 2), "utf8");
+  (0, import_node_fs7.writeFileSync)(tmp, JSON.stringify(doc, null, 2), "utf8");
   try {
-    (0, import_node_fs6.unlinkSync)(absPath);
+    (0, import_node_fs7.unlinkSync)(absPath);
   } catch {
   }
   const { renameSync: renameSync2 } = require("fs");
@@ -6428,7 +6739,7 @@ function pyRepr2(v) {
 // src/tools/create.ts
 init_cjs_shims();
 var import_node_crypto6 = require("crypto");
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var import_node_path10 = __toESM(require("path"), 1);
 
 // src/tools/orchestrate.ts
@@ -6531,7 +6842,7 @@ function isDeadModelError(err) {
 // src/core/node-cache.ts
 init_cjs_shims();
 var import_node_crypto4 = require("crypto");
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var import_node_path8 = require("path");
 var NODE_CACHE_KEY_VERSION = "v2";
 var CANON_PATTERNS = [
@@ -6596,18 +6907,18 @@ 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 (!(0, import_node_fs7.existsSync)(p)) return null;
+  if (!(0, import_node_fs8.existsSync)(p)) return null;
   const ttlS = cfg.ttl_seconds ?? 604800;
   try {
-    const st = (0, import_node_fs7.statSync)(p);
+    const st = (0, import_node_fs8.statSync)(p);
     if (ttlS > 0) {
       const now = nowMs ?? Date.now();
       if ((now - st.mtimeMs) / 1e3 > ttlS) return null;
     }
-    const data = JSON.parse((0, import_node_fs7.readFileSync)(p, "utf8"));
+    const data = JSON.parse((0, import_node_fs8.readFileSync)(p, "utf8"));
     try {
       const t = (nowMs ?? Date.now()) / 1e3;
-      (0, import_node_fs7.utimesSync)(p, t, t);
+      (0, import_node_fs8.utimesSync)(p, t, t);
     } catch {
     }
     return data;
@@ -6615,11 +6926,11 @@ function getNodeCache(cfg, repoRoot, key, nowMs) {
     return null;
   }
 }
-function atomicWriteJson(path12, payload) {
-  (0, import_node_fs7.mkdirSync)((0, import_node_path8.dirname)(path12), { recursive: true });
-  const tmp = `${path12}.${process.pid}.${Date.now()}.tmp`;
-  (0, import_node_fs7.writeFileSync)(tmp, JSON.stringify(payload), "utf8");
-  (0, import_node_fs7.renameSync)(tmp, path12);
+function atomicWriteJson(path14, payload) {
+  (0, import_node_fs8.mkdirSync)((0, import_node_path8.dirname)(path14), { recursive: true });
+  const tmp = `${path14}.${process.pid}.${Date.now()}.tmp`;
+  (0, import_node_fs8.writeFileSync)(tmp, JSON.stringify(payload), "utf8");
+  (0, import_node_fs8.renameSync)(tmp, path14);
 }
 function putNodeCache(cfg, repoRoot, key, value) {
   if (!cfg || cfg.enabled === false) return;
@@ -6630,23 +6941,23 @@ 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 (!(0, import_node_fs7.existsSync)(base)) return;
+    if (!(0, import_node_fs8.existsSync)(base)) return;
     const entries = [];
     let totalBytes = 0;
-    for (const shard of (0, import_node_fs7.readdirSync)(base)) {
+    for (const shard of (0, import_node_fs8.readdirSync)(base)) {
       const shardDir = (0, import_node_path8.join)(base, shard);
       let stShard;
       try {
-        stShard = (0, import_node_fs7.statSync)(shardDir);
+        stShard = (0, import_node_fs8.statSync)(shardDir);
       } catch {
         continue;
       }
       if (!stShard.isDirectory()) continue;
-      for (const f of (0, import_node_fs7.readdirSync)(shardDir)) {
+      for (const f of (0, import_node_fs8.readdirSync)(shardDir)) {
         if (!f.endsWith(".json")) continue;
         const fp = (0, import_node_path8.join)(shardDir, f);
         try {
-          const st = (0, import_node_fs7.statSync)(fp);
+          const st = (0, import_node_fs8.statSync)(fp);
           entries.push({ mtime: st.mtimeMs, size: st.size, path: fp });
           totalBytes += st.size;
         } catch {
@@ -6660,7 +6971,7 @@ function putNodeCache(cfg, repoRoot, key, value) {
     while (entries.length > 0 && (maxEntries > 0 && entries.length > maxEntries || maxBytes > 0 && totalBytes > maxBytes)) {
       const oldest = entries.shift();
       try {
-        (0, import_node_fs7.unlinkSync)(oldest.path);
+        (0, import_node_fs8.unlinkSync)(oldest.path);
         totalBytes -= oldest.size;
       } catch {
       }
@@ -7222,8 +7533,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;
@@ -7296,6 +7618,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;
@@ -7687,7 +8010,7 @@ function pyRound6(x) {
 // src/tools/fetch.ts
 init_cjs_shims();
 var import_node_crypto5 = require("crypto");
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var import_node_path9 = __toESM(require("path"), 1);
 var DEFAULT_CONFIG = {
   enabled: true,
@@ -7769,9 +8092,9 @@ async function runFetch(args, opts) {
   const evDir = resolveEvidenceDir(cfg.evidence_dir, opts.repoRoot);
   const urlHash16 = sha256Hex2(url).slice(0, 16);
   const metaPath = import_node_path9.default.join(evDir, `by-url-${urlHash16}.json`);
-  if ((0, import_node_fs8.existsSync)(metaPath) && !force) {
+  if ((0, import_node_fs9.existsSync)(metaPath) && !force) {
     try {
-      const meta2 = JSON.parse((0, import_node_fs8.readFileSync)(metaPath, "utf8"));
+      const meta2 = JSON.parse((0, import_node_fs9.readFileSync)(metaPath, "utf8"));
       return {
         ...base,
         accepted: true,
@@ -7811,15 +8134,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,
@@ -7831,8 +8180,8 @@ async function runFetch(args, opts) {
   const status = response.status;
   const sha = sha256HexBytes(data);
   const bodyPath = import_node_path9.default.join(evDir, `${sha}.bin`);
-  (0, import_node_fs8.mkdirSync)(evDir, { recursive: true });
-  (0, import_node_fs8.writeFileSync)(bodyPath, data);
+  (0, import_node_fs9.mkdirSync)(evDir, { recursive: true });
+  (0, import_node_fs9.writeFileSync)(bodyPath, data);
   const relBody = makeRelative2(bodyPath, opts.repoRoot);
   const now = opts.nowEpochSeconds ? opts.nowEpochSeconds() : Math.floor(Date.now() / 1e3);
   const meta = {
@@ -7844,7 +8193,7 @@ async function runFetch(args, opts) {
     status,
     fetched_at: now
   };
-  (0, import_node_fs8.writeFileSync)(metaPath, JSON.stringify(meta, null, 2));
+  (0, import_node_fs9.writeFileSync)(metaPath, JSON.stringify(meta, null, 2));
   if (sessionId && host && opts.storage) {
     try {
       await opts.storage.recordFetchEgress(sessionId, host, data.byteLength, now);
@@ -8127,8 +8476,8 @@ ${documentsPayload}`
   if (targetPath && !dryRun && typeof orchestration["final"] === "string" && orchestration["final"] && !blockWriteStatuses.has(status)) {
     try {
       const tp = import_node_path10.default.isAbsolute(targetPath) ? targetPath : opts.repoRoot ? import_node_path10.default.join(opts.repoRoot, targetPath) : import_node_path10.default.resolve(targetPath);
-      (0, import_node_fs9.mkdirSync)(import_node_path10.default.dirname(tp), { recursive: true });
-      (0, import_node_fs9.writeFileSync)(tp, orchestration["final"], "utf8");
+      (0, import_node_fs10.mkdirSync)(import_node_path10.default.dirname(tp), { recursive: true });
+      (0, import_node_fs10.writeFileSync)(tp, orchestration["final"], "utf8");
       artifacts.push({ path: targetPath, bytes: orchestration["final"].length });
       if (status === "audit_failed" || status === "audit_inconclusive") {
         warnings.push(
@@ -8198,7 +8547,7 @@ async function ingestDocuments(documents, sessionId, opts) {
       if (typeof evidencePath === "string" && evidencePath) {
         const abs = import_node_path10.default.isAbsolute(evidencePath) ? evidencePath : opts.repoRoot ? import_node_path10.default.join(opts.repoRoot, evidencePath) : evidencePath;
         try {
-          text = (0, import_node_fs9.readFileSync)(abs, "utf8");
+          text = (0, import_node_fs10.readFileSync)(abs, "utf8");
         } catch {
           text = "";
         }
@@ -8212,7 +8561,7 @@ async function ingestDocuments(documents, sessionId, opts) {
       }, text));
     } else {
       const abs = import_node_path10.default.isAbsolute(ref) ? ref : opts.repoRoot ? import_node_path10.default.join(opts.repoRoot, ref) : import_node_path10.default.resolve(ref);
-      if (!(0, import_node_fs9.existsSync)(abs)) {
+      if (!(0, import_node_fs10.existsSync)(abs)) {
         out.push({
           source: ref,
           type: "file",
@@ -8224,7 +8573,7 @@ async function ingestDocuments(documents, sessionId, opts) {
       }
       let text = "";
       try {
-        text = (0, import_node_fs9.readFileSync)(abs, "utf8");
+        text = (0, import_node_fs10.readFileSync)(abs, "utf8");
       } catch (e) {
         out.push({
           source: ref,
@@ -9239,15 +9588,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",
@@ -9299,6 +9660,7 @@ ${condensed}`
     transcript,
     synthesis
   };
+  if (personaMeta && personaMeta.used !== null) result["persona"] = personaMeta;
   if (synthesisStructured !== null) {
     result["synthesis_structured"] = synthesisStructured;
   }
@@ -9613,7 +9975,7 @@ function pyListRepr2(xs) {
 
 // src/tools/explain.ts
 init_cjs_shims();
-var import_node_fs10 = require("fs");
+var import_node_fs11 = require("fs");
 var import_node_path11 = __toESM(require("path"), 1);
 async function runExplain(args, opts) {
   const sessionId = args["session_id"];
@@ -9715,10 +10077,10 @@ async function runExplain(args, opts) {
   return result;
 }
 function loadTranscriptsForSession(dir, sessionId) {
-  if (!(0, import_node_fs10.existsSync)(dir)) return [];
+  if (!(0, import_node_fs11.existsSync)(dir)) return [];
   let names;
   try {
-    names = (0, import_node_fs10.readdirSync)(dir);
+    names = (0, import_node_fs11.readdirSync)(dir);
   } catch {
     return [];
   }
@@ -9728,13 +10090,13 @@ function loadTranscriptsForSession(dir, sessionId) {
     const p = import_node_path11.default.join(dir, name);
     let stat;
     try {
-      stat = (0, import_node_fs10.statSync)(p);
+      stat = (0, import_node_fs11.statSync)(p);
     } catch {
       continue;
     }
     let doc;
     try {
-      doc = JSON.parse((0, import_node_fs10.readFileSync)(p, "utf8"));
+      doc = JSON.parse((0, import_node_fs11.readFileSync)(p, "utf8"));
     } catch {
       continue;
     }
@@ -10590,7 +10952,7 @@ function toStringArray3(v) {
 
 // src/tools/scoreboard.ts
 init_cjs_shims();
-var import_node_fs11 = require("fs");
+var import_node_fs12 = require("fs");
 async function runScoreboard(args, opts) {
   if (!opts.storage) {
     if (opts.bridge && opts.bridge.toolNames.has("scoreboard")) {
@@ -10673,9 +11035,9 @@ async function runScoreboard(args, opts) {
   }
   usageTotals.cost_usd = Number(usageTotals.cost_usd.toFixed(8));
   let recentEvents = [];
-  if (recentLimit > 0 && opts.eventsPath && (0, import_node_fs11.existsSync)(opts.eventsPath)) {
+  if (recentLimit > 0 && opts.eventsPath && (0, import_node_fs12.existsSync)(opts.eventsPath)) {
     try {
-      const lines = (0, import_node_fs11.readFileSync)(opts.eventsPath, "utf8").split("\n").filter((l) => l.length > 0);
+      const lines = (0, import_node_fs12.readFileSync)(opts.eventsPath, "utf8").split("\n").filter((l) => l.length > 0);
       const tail = lines.slice(-recentLimit);
       for (const ln of tail) {
         try {
@@ -10924,6 +11286,122 @@ function pyRepr6(v) {
 // src/tools/solve.ts
 init_cjs_shims();
 var import_node_perf_hooks11 = require("perf_hooks");
+var import_node_fs13 = require("fs");
+var import_node_path12 = __toESM(require("path"), 1);
+
+// src/core/unified-diff.ts
+init_cjs_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) {
@@ -11065,7 +11543,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 = import_node_path12.default.isAbsolute(targetPath) ? targetPath : import_node_path12.default.join(opts.repoRoot ?? process.cwd(), targetPath);
+      let oldText = "";
+      try {
+        oldText = (0, import_node_fs13.readFileSync)(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;
@@ -11151,6 +11645,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;
@@ -11160,7 +11656,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 {
@@ -11330,24 +11828,24 @@ function pyRepr7(v) {
 // src/tools/update-crosscheck.ts
 init_cjs_shims();
 var import_node_child_process2 = require("child_process");
-var import_node_fs13 = require("fs");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_fs15 = require("fs");
+var import_node_path14 = __toESM(require("path"), 1);
 
 // src/core/update-notify.ts
 init_cjs_shims();
-var import_node_fs12 = require("fs");
+var import_node_fs14 = require("fs");
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 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.10" : "0.0.0-dev";
+  return true ? "0.1.12" : "0.0.0-dev";
 }
 function defaultUpdateCachePath() {
-  const base = process.env["CROSSCHECK_DATA_DIR"] || import_node_path12.default.join(import_node_os2.default.homedir() || import_node_os2.default.tmpdir(), ".crosscheck");
-  return import_node_path12.default.join(base, "update_check.json");
+  const base = process.env["CROSSCHECK_DATA_DIR"] || import_node_path13.default.join(import_node_os2.default.homedir() || import_node_os2.default.tmpdir(), ".crosscheck");
+  return import_node_path13.default.join(base, "update_check.json");
 }
 function isNewer(latest, current) {
   const a = parseTriple(latest);
@@ -11377,8 +11875,8 @@ then reconnect the crosscheck MCP server (run \`/mcp\` in Claude Code, or restar
 }
 function readCache(cachePath2) {
   try {
-    if (!(0, import_node_fs12.existsSync)(cachePath2)) return null;
-    const data = JSON.parse((0, import_node_fs12.readFileSync)(cachePath2, "utf8"));
+    if (!(0, import_node_fs14.existsSync)(cachePath2)) return null;
+    const data = JSON.parse((0, import_node_fs14.readFileSync)(cachePath2, "utf8"));
     if (data && typeof data === "object" && !Array.isArray(data)) {
       return data;
     }
@@ -11389,8 +11887,8 @@ function readCache(cachePath2) {
 }
 function writeCache(cachePath2, record2) {
   try {
-    (0, import_node_fs12.mkdirSync)(import_node_path12.default.dirname(cachePath2), { recursive: true });
-    (0, import_node_fs12.writeFileSync)(cachePath2, JSON.stringify(record2, null, 2), "utf8");
+    (0, import_node_fs14.mkdirSync)(import_node_path13.default.dirname(cachePath2), { recursive: true });
+    (0, import_node_fs14.writeFileSync)(cachePath2, JSON.stringify(record2, null, 2), "utf8");
   } catch {
   }
 }
@@ -11443,7 +11941,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 ?? import_node_path13.default.join(opts.repoRoot, ".crosscheck", "update_check.json");
+  const cachePath2 = opts.cachePath ?? import_node_path14.default.join(opts.repoRoot, ".crosscheck", "update_check.json");
   const local = readLocalSha(gitRun);
   if (!local) {
     return {
@@ -11615,8 +12113,8 @@ function gitRelationship(gitRun, local, remote) {
 }
 function writeUpdateCache(p, payload) {
   try {
-    (0, import_node_fs13.mkdirSync)(import_node_path13.default.dirname(p), { recursive: true });
-    (0, import_node_fs13.writeFileSync)(p, JSON.stringify(payload, null, 2), "utf8");
+    (0, import_node_fs15.mkdirSync)(import_node_path14.default.dirname(p), { recursive: true });
+    (0, import_node_fs15.writeFileSync)(p, JSON.stringify(payload, null, 2), "utf8");
   } catch {
   }
 }
@@ -12631,8 +13129,8 @@ function pingTool() {
 
 // src/core/wrappers.ts
 init_cjs_shims();
-var import_node_fs14 = require("fs");
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_fs16 = require("fs");
+var import_node_path15 = __toESM(require("path"), 1);
 function configPinGate(toolName, opts) {
   if (toolName === "config_pin") return null;
   if (!opts || !opts.repoRoot) return null;
@@ -12664,8 +13162,8 @@ function configPinGate(toolName, opts) {
 var cachedUpdateNotice = null;
 function readUpdateCache(cachePath2) {
   try {
-    if (!(0, import_node_fs14.existsSync)(cachePath2)) return null;
-    const data = JSON.parse((0, import_node_fs14.readFileSync)(cachePath2, "utf8"));
+    if (!(0, import_node_fs16.existsSync)(cachePath2)) return null;
+    const data = JSON.parse((0, import_node_fs16.readFileSync)(cachePath2, "utf8"));
     if (data && typeof data === "object" && !Array.isArray(data)) return data;
     return null;
   } catch {
@@ -12677,7 +13175,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 ? import_node_path14.default.join(opts.repoRoot, ".crosscheck", "update_check.json") : defaultUpdateCachePath());
+    const cachePath2 = opts?.cachePath ?? (opts?.repoRoot ? import_node_path15.default.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;
@@ -12875,7 +13373,7 @@ async function flush() {
 
 // src/server.ts
 var SERVER_NAME = "crosscheck-agent";
-var SERVER_VERSION = true ? "0.1.10" : "0.0.0-dev";
+var SERVER_VERSION = true ? "0.1.12" : "0.0.0-dev";
 function extractRunSummaryText(out) {
   if (out === null || typeof out !== "object" || Array.isArray(out)) return void 0;
   const rs = out["run_summary"];
@@ -12897,14 +13395,14 @@ function createServer(opts = {}) {
     }
   );
   const tools = buildToolRegistry(opts);
-  server.setRequestHandler(import_types6.ListToolsRequestSchema, async () => ({
+  server.setRequestHandler(import_types8.ListToolsRequestSchema, async () => ({
     tools: Array.from(tools.values()).map((t) => ({
       name: t.name,
       description: t.description,
       inputSchema: t.inputSchema
     }))
   }));
-  server.setRequestHandler(import_types6.CallToolRequestSchema, async (req) => {
+  server.setRequestHandler(import_types8.CallToolRequestSchema, async (req) => {
     const name = req.params.name;
     const tool = tools.get(name);
     if (!tool) {
@@ -13028,6 +13526,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);
@@ -13037,29 +13539,207 @@ function buildToolRegistry(opts) {
   return tools;
 }
 
+// src/core/config-file.ts
+init_cjs_shims();
+var import_node_fs17 = require("fs");
+var import_node_path16 = __toESM(require("path"), 1);
+var import_node_crypto8 = require("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 (0, import_node_fs17.existsSync)(direct) ? direct : void 0;
+  const candidates = [];
+  let dir = opts.startDir;
+  for (let i = 0; dir && i < 8; i += 1) {
+    candidates.push(import_node_path16.default.join(dir, "crosscheck.config.json"));
+    const parent = import_node_path16.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (opts.repoRoot) candidates.push(import_node_path16.default.join(opts.repoRoot, "crosscheck.config.json"));
+  if (opts.dataDir) candidates.push(import_node_path16.default.join(opts.dataDir, "crosscheck.config.json"));
+  return candidates.find((p) => (0, import_node_fs17.existsSync)(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 = (0, import_node_crypto8.randomBytes)(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((0, import_node_fs17.readFileSync)(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"] || import_node_path17.default.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 import_node_path15.default.join(import_node_path15.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl)), "pricing.json");
+      return import_node_path17.default.join(import_node_path17.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl)), "pricing.json");
     } catch {
       return void 0;
     }
@@ -13068,7 +13748,7 @@ async function main() {
     process.env["CROSSCHECK_PRICING_PATH"],
     resolveRepoFile("config/pricing.json"),
     bundledPricing
-  ].find((p) => p && (0, import_node_fs15.existsSync)(p));
+  ].find((p) => p && (0, import_node_fs18.existsSync)(p));
   const pricing = pricingPath ? loadPricing(pricingPath) : {};
   const providers = buildProviders({ env: process.env, pricing });
   if (Object.keys(providers).length > 0) {
@@ -13082,7 +13762,7 @@ async function main() {
     const dbPath = process.env["CROSSCHECK_DB_PATH"] ?? resolveRepoFile(".crosscheck/db.sqlite");
     if (dbPath) {
       try {
-        (0, import_node_fs15.mkdirSync)(import_node_path15.default.dirname(dbPath), { recursive: true });
+        (0, import_node_fs18.mkdirSync)(import_node_path17.default.dirname(dbPath), { recursive: true });
         const { openBetterSqliteStorage: openBetterSqliteStorage2 } = await Promise.resolve().then(() => (init_better_sqlite3(), better_sqlite3_exports));
         storage = openBetterSqliteStorage2({ path: dbPath });
         await storage.migrate();
@@ -13099,33 +13779,32 @@ async function main() {
       }
     }
   }
-  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 import_stdio2.StdioServerTransport();
+  const transport = new import_stdio.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))
@@ -13151,9 +13830,9 @@ function installShutdownHandlers(bridge) {
 function resolveRepoFile(rel) {
   let dir = __dirname;
   for (let i = 0; i < 8; i++) {
-    const candidate = import_node_path15.default.join(dir, rel);
-    if ((0, import_node_fs15.existsSync)(candidate)) return candidate;
-    const parent = import_node_path15.default.dirname(dir);
+    const candidate = import_node_path17.default.join(dir, rel);
+    if ((0, import_node_fs18.existsSync)(candidate)) return candidate;
+    const parent = import_node_path17.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -13162,8 +13841,8 @@ function resolveRepoFile(rel) {
 function findGitRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 12; i++) {
-    if ((0, import_node_fs15.existsSync)(import_node_path15.default.join(dir, ".git"))) return dir;
-    const parent = import_node_path15.default.dirname(dir);
+    if ((0, import_node_fs18.existsSync)(import_node_path17.default.join(dir, ".git"))) return dir;
+    const parent = import_node_path17.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }