@antonbabenko/deliberation-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,3106 @@
+#!/usr/bin/env node
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// ../../core/registry.js
+var require_registry = __commonJS({
+  "../../core/registry.js"(exports2, module2) {
+    "use strict";
+    function eligibleForExpert(model, expert) {
+      if (model.experts === null || model.experts === void 0) return true;
+      if (model.experts.length === 0) return false;
+      return model.experts.includes(expert);
+    }
+    function askAllDelegates(or, expert) {
+      const pool = (or.models || []).filter((m) => m.askAll !== false && eligibleForExpert(m, expert));
+      const cap = Number.isInteger(or.maxFanout) && /** @type {number} */
+      or.maxFanout >= 1 ? (
+        /** @type {number} */
+        or.maxFanout
+      ) : 3;
+      return { selected: pool.slice(0, cap), omitted: pool.slice(cap) };
+    }
+    function consensusDelegates(or, expert) {
+      return (or.models || []).filter((m) => m.consensus === true && eligibleForExpert(m, expert));
+    }
+    var BUILTINS = ["codex", "gemini", "grok"];
+    function pinAlias(orProvider, delegate) {
+      return {
+        name: `openrouter:${delegate.alias}`,
+        capabilities: orProvider.capabilities,
+        health: orProvider.health.bind(orProvider),
+        async ask(req) {
+          const r = await orProvider.ask({ ...req, model: delegate.model });
+          return { ...r, provider: `openrouter:${delegate.alias}` };
+        }
+      };
+    }
+    function makeRegistry2(providers) {
+      const byName = new Map(providers.map((p) => [p.name, p]));
+      const enabled = (config, name) => {
+        const p = config && config.providers && config.providers[name];
+        return !p || p.enabled !== false;
+      };
+      const builtinsFor = (config) => BUILTINS.filter((n) => byName.has(n) && enabled(config, n)).map((n) => (
+        /** @type {Provider} */
+        byName.get(n)
+      ));
+      const pinDelegates = (delegates) => {
+        const orProvider = byName.get("openrouter");
+        return orProvider ? delegates.map((d) => pinAlias(orProvider, d)) : [];
+      };
+      return {
+        /** @param {string} n */
+        get: (n) => byName.get(n),
+        // Flat provider list ready for askAll(): built-ins + per-alias OR wrappers.
+        /** @param {{config: RegistryConfig, expert: string}} args */
+        selectForAskAll({ config, expert }) {
+          const or = config && config.openrouter || {};
+          const { selected, omitted } = askAllDelegates(or, expert);
+          return { providers: [...builtinsFor(config), ...pinDelegates(selected)], omitted };
+        },
+        // Uncapped: built-ins + per-alias OR consensus delegates.
+        /** @param {{config: RegistryConfig, expert: string}} args */
+        selectForConsensus({ config, expert }) {
+          const or = config && config.openrouter || {};
+          return { providers: [...builtinsFor(config), ...pinDelegates(consensusDelegates(or, expert))] };
+        }
+      };
+    }
+    module2.exports = { makeRegistry: makeRegistry2, eligibleForExpert, askAllDelegates, consensusDelegates, pinAlias };
+  }
+});
+
+// ../../core/orchestrate.js
+var require_orchestrate = __commonJS({
+  "../../core/orchestrate.js"(exports2, module2) {
+    "use strict";
+    async function askAll2(providers, req) {
+      const settled = await Promise.allSettled(
+        providers.map(
+          (p) => p.ask({ ...req, files: req.files ? req.files.map((f) => ({ ...f })) : void 0 })
+        )
+      );
+      return settled.map(
+        (s, i) => s.status === "fulfilled" ? s.value : {
+          provider: providers[i].name,
+          model: "unknown",
+          isError: true,
+          errorKind: "unknown",
+          retryable: false,
+          message: String(s.reason && s.reason.message || s.reason || "rejected"),
+          ms: 0
+        }
+      );
+    }
+    async function askOne2(provider, req) {
+      return provider.ask({ ...req, files: req.files ? req.files.map((f) => ({ ...f })) : void 0 });
+    }
+    function buildArbiterPrompt(question, opinions) {
+      const blocks = opinions.map((o, i) => `### Opinion ${i + 1} - ${o.provider}
+${o.text}`).join("\n\n");
+      return [
+        "You are the arbiter. Below are independent expert opinions on the same question.",
+        "Cross-review them: note where they agree, where they disagree, and which view is best supported.",
+        "Then produce ONE synthesized verdict.",
+        "",
+        `## Original question
+${question}`,
+        "",
+        `## Opinions
+${blocks}`,
+        "",
+        "## Your verdict\nBottom line, points of agreement, points of disagreement, final recommendation."
+      ].join("\n");
+    }
+    async function consensus2(providers, req, opts = {}) {
+      const opinions = await askAll2(providers, req);
+      const ok = (
+        /** @type {DelegationSuccess[]} */
+        opinions.filter((o) => !o.isError)
+      );
+      if (!ok.length) return { opinions, verdict: null, error: "all-providers-failed" };
+      const arbiter = opts.arbiter || providers[0];
+      if (!arbiter) return { opinions, verdict: null, error: "no-arbiter" };
+      try {
+        const verdict = await arbiter.ask({
+          ...req,
+          files: req.files ? req.files.map((f) => ({ ...f })) : void 0,
+          prompt: buildArbiterPrompt(req.prompt, ok),
+          developerInstructions: opts.arbiterInstructions || req.developerInstructions
+        });
+        return { opinions, verdict };
+      } catch {
+        return { opinions, verdict: null, error: "arbiter-failed" };
+      }
+    }
+    module2.exports = { askAll: askAll2, askOne: askOne2, consensus: consensus2, buildArbiterPrompt };
+  }
+});
+
+// ../../core/provider.js
+var require_provider = __commonJS({
+  "../../core/provider.js"(exports2, module2) {
+    "use strict";
+    function toErrorResult(name, model, started, err, classify) {
+      const { errorKind, retryable } = classify(err && err.status, err && err.code);
+      return { provider: name, model, isError: true, errorKind, retryable, ms: Date.now() - started };
+    }
+    var OPINION_SCHEMA = Object.freeze({
+      type: "object",
+      required: ["recommendation", "confidence"],
+      properties: {
+        recommendation: { type: "string" },
+        confidence: { type: "string", enum: ["low", "medium", "high"] },
+        reasoning: { type: "string" }
+      }
+    });
+    function validateOpinion(o) {
+      if (!o || typeof o !== "object") return { ok: false, reason: "opinion is not an object" };
+      for (const k of OPINION_SCHEMA.required) {
+        if (!(k in o)) return { ok: false, reason: `missing required field: ${k}` };
+      }
+      return { ok: true };
+    }
+    module2.exports = { toErrorResult, OPINION_SCHEMA, validateOpinion };
+  }
+});
+
+// ../openrouter/config.js
+var require_config = __commonJS({
+  "../openrouter/config.js"(exports2, module2) {
+    "use strict";
+    var fs = require("node:fs");
+    var EXPERT_KEYS = /* @__PURE__ */ new Set([
+      "architect",
+      "plan-reviewer",
+      "scope-analyst",
+      "code-reviewer",
+      "security-analyst",
+      "researcher",
+      "debugger"
+    ]);
+    var RESERVED_ALIAS = "openrouter-default";
+    var ALIAS_RE = /^[a-z0-9-]+$/;
+    var SUPPORTED_MAJOR = 1;
+    var DEFAULT_API_BASE = "https://openrouter.ai/api/v1";
+    var DEFAULT_API_KEY_ENV = "OPENROUTER_API_KEY";
+    var DEFAULT_MAX_FANOUT = 3;
+    function isObject(v) {
+      return v !== null && typeof v === "object" && !Array.isArray(v);
+    }
+    function sanitizeAlias(raw) {
+      if (typeof raw !== "string") return "";
+      return raw.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+    }
+    function validateConfig(raw) {
+      if (!isObject(raw)) return fail("config root must be a JSON object");
+      const version = raw.version === void 0 ? 1 : raw.version;
+      if (!Number.isInteger(version) || version < 1 || version > SUPPORTED_MAJOR) {
+        return fail(`unsupported config version ${version}; this build supports version <= ${SUPPORTED_MAJOR}`);
+      }
+      const providers = isObject(raw.providers) ? raw.providers : {};
+      const orRaw = isObject(raw.openrouter) ? raw.openrouter : null;
+      if (!orRaw) {
+        return { ok: true, resolved: { version, providers, openrouter: disabledOpenRouter() }, error: null };
+      }
+      const enabled = orRaw.enabled !== false;
+      const apiKeyEnv = orRaw.apiKeyEnv || DEFAULT_API_KEY_ENV;
+      const apiBase = orRaw.apiBase || DEFAULT_API_BASE;
+      const allowRawModel = orRaw.allowRawModel === true;
+      const maxFanout = orRaw.maxFanout === void 0 ? DEFAULT_MAX_FANOUT : orRaw.maxFanout;
+      if (!Number.isInteger(maxFanout) || maxFanout < 1) {
+        return fail(`maxFanout must be an integer >= 1 (got ${String(maxFanout)})`);
+      }
+      const defaultModel = typeof orRaw.defaultModel === "string" && orRaw.defaultModel.trim() ? orRaw.defaultModel.trim() : null;
+      const defaults = isObject(orRaw.defaults) ? orRaw.defaults : {};
+      const modelsRaw = Array.isArray(orRaw.models) ? orRaw.models : [];
+      const models = [];
+      const invalidModels = [];
+      const seen = /* @__PURE__ */ new Set();
+      const taken = /* @__PURE__ */ new Set([RESERVED_ALIAS]);
+      for (const m of modelsRaw) {
+        if (isObject(m) && typeof m.alias === "string") taken.add(m.alias);
+      }
+      function suggestFree(candidate) {
+        if (!candidate || candidate === RESERVED_ALIAS) return void 0;
+        let chosen = candidate;
+        if (taken.has(chosen)) {
+          chosen = void 0;
+          for (let n = 2; n <= 99; n++) {
+            if (!taken.has(`${candidate}-${n}`)) {
+              chosen = `${candidate}-${n}`;
+              break;
+            }
+          }
+          if (!chosen) return void 0;
+        }
+        taken.add(chosen);
+        return chosen;
+      }
+      function addInvalid(i, alias, reason, suggestedAlias) {
+        const entry = { index: i, alias: alias === void 0 ? null : alias, reason };
+        if (suggestedAlias) entry.suggestedAlias = suggestedAlias;
+        invalidModels.push(entry);
+      }
+      for (let i = 0; i < modelsRaw.length; i++) {
+        const m = modelsRaw[i];
+        if (!isObject(m)) {
+          addInvalid(i, null, `models[${i}] must be an object`);
+          continue;
+        }
+        const rawAlias = typeof m.alias === "string" ? m.alias : null;
+        if (typeof m.alias !== "string" || !ALIAS_RE.test(m.alias)) {
+          const sanitized = sanitizeAlias(m.alias);
+          addInvalid(
+            i,
+            rawAlias,
+            `models[${i}] alias must match [a-z0-9-]+ (got ${JSON.stringify(m.alias)})`,
+            sanitized ? suggestFree(sanitized) : void 0
+          );
+          continue;
+        }
+        if (m.alias === RESERVED_ALIAS) {
+          addInvalid(i, m.alias, `alias "${RESERVED_ALIAS}" is reserved`);
+          continue;
+        }
+        if (seen.has(m.alias)) {
+          addInvalid(i, m.alias, `duplicate alias "${m.alias}"`, suggestFree(m.alias));
+          continue;
+        }
+        if (typeof m.model !== "string" || !m.model.trim()) {
+          addInvalid(i, m.alias, `models[${i}] (${m.alias}) needs a non-empty model slug`);
+          continue;
+        }
+        let experts = null;
+        if (m.experts !== void 0) {
+          if (!Array.isArray(m.experts)) {
+            addInvalid(i, m.alias, `models[${i}] (${m.alias}) experts must be an array`);
+            continue;
+          }
+          let badExpert = null;
+          for (const e of m.experts) {
+            if (!EXPERT_KEYS.has(e)) {
+              badExpert = e;
+              break;
+            }
+          }
+          if (badExpert !== null) {
+            addInvalid(i, m.alias, `models[${i}] (${m.alias}) unknown expert "${badExpert}"`);
+            continue;
+          }
+          experts = m.experts.slice();
+        }
+        if (m.reasoning_effort !== void 0 && typeof m.reasoning_effort !== "string") {
+          addInvalid(i, m.alias, `models[${i}] (${m.alias}) reasoning_effort must be a string`);
+          continue;
+        }
+        if (m.timeout !== void 0 && !(Number.isInteger(m.timeout) && m.timeout > 0)) {
+          addInvalid(i, m.alias, `models[${i}] (${m.alias}) timeout must be a positive integer`);
+          continue;
+        }
+        if (m.temperature !== void 0 && !(typeof m.temperature === "number" && Number.isFinite(m.temperature))) {
+          addInvalid(i, m.alias, `models[${i}] (${m.alias}) temperature must be a finite number`);
+          continue;
+        }
+        if (m.apiBase !== void 0 && !(typeof m.apiBase === "string" && m.apiBase.trim())) {
+          addInvalid(i, m.alias, `models[${i}] (${m.alias}) apiBase must be a non-empty string`);
+          continue;
+        }
+        seen.add(m.alias);
+        models.push({
+          alias: m.alias,
+          model: m.model.trim(),
+          experts,
+          askAll: m.askAll !== false,
+          consensus: m.consensus === true,
+          reasoning_effort: m.reasoning_effort,
+          timeout: m.timeout,
+          temperature: m.temperature,
+          apiBase: m.apiBase
+        });
+      }
+      return {
+        ok: true,
+        error: null,
+        resolved: {
+          version,
+          providers,
+          openrouter: { enabled, apiKeyEnv, apiBase, allowRawModel, maxFanout, defaultModel, defaults, models, invalidModels }
+        }
+      };
+    }
+    function disabledOpenRouter() {
+      return {
+        enabled: false,
+        apiKeyEnv: DEFAULT_API_KEY_ENV,
+        apiBase: DEFAULT_API_BASE,
+        allowRawModel: false,
+        maxFanout: DEFAULT_MAX_FANOUT,
+        defaultModel: null,
+        defaults: {},
+        models: [],
+        invalidModels: []
+      };
+    }
+    function fail(message) {
+      return { ok: false, resolved: null, error: message };
+    }
+    function makeConfigReader(filePath) {
+      let cachedMtimeMs = null;
+      let cachedResult = null;
+      function read() {
+        let text;
+        try {
+          text = fs.readFileSync(filePath, "utf8");
+        } catch (_) {
+          return { ok: true, error: null, resolved: { version: 1, providers: {}, openrouter: disabledOpenRouter() } };
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(text);
+        } catch (e) {
+          return { ok: false, resolved: null, error: `config JSON parse error: ${e.message}` };
+        }
+        return validateConfig(parsed);
+      }
+      return {
+        get() {
+          let mtimeMs = null;
+          try {
+            mtimeMs = fs.statSync(filePath).mtimeMs;
+          } catch (_) {
+            mtimeMs = null;
+          }
+          if (cachedResult === null || mtimeMs !== cachedMtimeMs) {
+            cachedResult = read();
+            cachedMtimeMs = mtimeMs;
+          }
+          return cachedResult;
+        }
+      };
+    }
+    module2.exports = { validateConfig, makeConfigReader, EXPERT_KEYS, RESERVED_ALIAS, DEFAULT_API_BASE, DEFAULT_API_KEY_ENV };
+  }
+});
+
+// ../openrouter/routing.js
+var require_routing = __commonJS({
+  "../openrouter/routing.js"(exports2, module2) {
+    "use strict";
+    var RESERVED_ALIAS = "openrouter-default";
+    function eligibleForExpert(model, expert) {
+      if (model.experts === null || model.experts === void 0) return true;
+      if (model.experts.length === 0) return false;
+      return model.experts.includes(expert);
+    }
+    function askAllDelegates(or, expert) {
+      const pool = (or.models || []).filter((m) => m.askAll !== false && eligibleForExpert(m, expert));
+      const cap = Number.isInteger(or.maxFanout) && or.maxFanout >= 1 ? or.maxFanout : 3;
+      return { selected: pool.slice(0, cap), omitted: pool.slice(cap) };
+    }
+    function consensusDelegates(or, expert) {
+      return (or.models || []).filter((m) => m.consensus === true && eligibleForExpert(m, expert));
+    }
+    function resolveAlias(or, alias) {
+      if (alias === RESERVED_ALIAS) {
+        return or.defaultModel ? { alias: RESERVED_ALIAS, model: or.defaultModel, experts: null } : null;
+      }
+      return (or.models || []).find((m) => m.alias === alias) || null;
+    }
+    module2.exports = { eligibleForExpert, askAllDelegates, consensusDelegates, resolveAlias, RESERVED_ALIAS };
+  }
+});
+
+// ../grok/glob.js
+var require_glob = __commonJS({
+  "../grok/glob.js"(exports2, module2) {
+    "use strict";
+    function rejectBackslashes(pattern) {
+      if (typeof pattern === "string" && pattern.includes("\\")) {
+        throw new Error(`glob pattern "${pattern}" contains backslashes; v1 patterns are POSIX-only (use /)`);
+      }
+    }
+    function patternToRegex(pattern) {
+      let i = 0;
+      let out = "";
+      while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === "*") {
+          if (pattern[i + 1] === "*") {
+            if (pattern[i + 2] === "/") {
+              out += "(?:.*/)?";
+              i += 3;
+            } else {
+              out += ".*";
+              i += 2;
+            }
+          } else {
+            out += "[^/]*";
+            i += 1;
+          }
+        } else if (ch === "?") {
+          out += "[^/]";
+          i += 1;
+        } else if (ch === "[") {
+          const end = pattern.indexOf("]", i);
+          if (end === -1) {
+            out += "\\[";
+            i += 1;
+          } else {
+            out += pattern.slice(i, end + 1);
+            i = end + 1;
+          }
+        } else if ("\\^$.|+(){}".includes(ch)) {
+          out += "\\" + ch;
+          i += 1;
+        } else {
+          out += ch;
+          i += 1;
+        }
+      }
+      return out;
+    }
+    function compile(pattern) {
+      rejectBackslashes(pattern);
+      if (!pattern.includes("/")) {
+        const re = patternToRegex(pattern);
+        const hasWildcard = pattern.includes("*") || pattern.includes("?") || pattern.includes("[");
+        const regex = hasWildcard ? new RegExp(`^${re}$`) : new RegExp(`(?:^|/)${re}$`);
+        return { kind: "bare", re: regex };
+      }
+      return { kind: "path", re: new RegExp(`^${patternToRegex(pattern)}$`) };
+    }
+    function matchPattern(pattern, relPath) {
+      return compile(pattern).re.test(relPath);
+    }
+    function matchAny(patterns, relPath) {
+      for (const p of patterns) if (matchPattern(p, relPath)) return true;
+      return false;
+    }
+    var fs = require("node:fs");
+    var path = require("node:path");
+    function walk(rootAbs, { include, exclude, maxFiles, maxBytes }) {
+      const includeRes = include.map((p) => compile(p));
+      const excludeRes = exclude.map((p) => compile(p));
+      const files = [];
+      let totalBytes = 0;
+      function matches(res, rel) {
+        for (const c of res) if (c.re.test(rel)) return true;
+        return false;
+      }
+      function descend(absDir, relDir) {
+        let entries;
+        try {
+          entries = fs.readdirSync(absDir, { withFileTypes: true });
+        } catch (_) {
+          return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name, "en"));
+        for (const ent of entries) {
+          const absChild = path.join(absDir, ent.name);
+          const relChild = (relDir ? relDir + "/" : "") + ent.name;
+          const relPosix = relChild.replace(/\\/g, "/");
+          if (ent.isSymbolicLink()) {
+            let realTarget;
+            try {
+              realTarget = fs.realpathSync(absChild);
+            } catch (_) {
+              continue;
+            }
+            const relReal = path.relative(rootAbs, realTarget);
+            if (relReal.startsWith("..") || path.isAbsolute(relReal)) continue;
+            let st;
+            try {
+              st = fs.statSync(realTarget);
+            } catch (_) {
+              continue;
+            }
+            if (st.isDirectory()) continue;
+            if (!st.isFile()) continue;
+            if (matches(excludeRes, relPosix)) continue;
+            if (!matches(includeRes, relPosix)) continue;
+            files.push({ rel: relPosix, abs: realTarget, size: st.size });
+            totalBytes += st.size;
+          } else if (ent.isDirectory()) {
+            if (matches(excludeRes, relPosix) || matches(excludeRes, relPosix + "/**")) continue;
+            descend(absChild, relPosix);
+          } else if (ent.isFile()) {
+            if (matches(excludeRes, relPosix)) continue;
+            if (!matches(includeRes, relPosix)) continue;
+            let st;
+            try {
+              st = fs.statSync(absChild);
+            } catch (_) {
+              continue;
+            }
+            files.push({ rel: relPosix, abs: absChild, size: st.size });
+            totalBytes += st.size;
+          }
+        }
+      }
+      descend(rootAbs, "");
+      if (files.length > maxFiles) {
+        throw new Error(`directory expansion selected ${files.length} files; exceeds maxFiles=${maxFiles}. Narrow include or raise the limit.`);
+      }
+      if (totalBytes > maxBytes) {
+        throw new Error(`directory expansion selected ${totalBytes} bytes; exceeds maxBytes=${maxBytes}. Narrow include or raise the limit.`);
+      }
+      files.sort((a, b) => a.rel.localeCompare(b.rel, "en"));
+      return { files, totalBytes };
+    }
+    module2.exports = { matchPattern, matchAny, rejectBackslashes, compile, walk };
+  }
+});
+
+// ../openrouter/files.js
+var require_files = __commonJS({
+  "../openrouter/files.js"(exports2, module2) {
+    "use strict";
+    var fs = require("node:fs");
+    var path = require("node:path");
+    var glob = require_glob();
+    var DEFAULT_PER_FILE_CAP = Number(process.env.OPENROUTER_INLINE_MAX_BYTES) > 0 ? Math.floor(Number(process.env.OPENROUTER_INLINE_MAX_BYTES)) : 256 * 1024;
+    var DEFAULT_TOTAL_CAP = Number(process.env.OPENROUTER_INLINE_MAX_TOTAL_BYTES) > 0 ? Math.floor(Number(process.env.OPENROUTER_INLINE_MAX_TOTAL_BYTES)) : 1024 * 1024;
+    var DEFAULT_EXCLUDE = [
+      ".git",
+      "node_modules",
+      "**/dist/**",
+      "**/build/**",
+      "**/.venv/**",
+      "**/venv/**",
+      "**/__pycache__/**",
+      "**/target/**",
+      "**/vendor/**",
+      "**/*.lock",
+      "**/*.tfstate*",
+      "**/.env",
+      "**/.env.local",
+      "**/.ssh/**",
+      "**/*.pem",
+      "**/*.key"
+    ];
+    function isProbablyText(buf) {
+      if (!buf || buf.length === 0) return true;
+      const slice = buf.subarray(0, Math.min(buf.length, 4096));
+      if (slice.includes(0)) return false;
+      let np = 0;
+      for (const b of slice) {
+        if (b === 9 || b === 10 || b === 13) continue;
+        if (b >= 32 && b <= 126) continue;
+        if (b >= 128) continue;
+        np++;
+      }
+      return np / slice.length < 0.05;
+    }
+    function resolveUnderRoots(p, roots) {
+      const isAbs = path.isAbsolute(p);
+      for (const root of roots) {
+        const abs = isAbs ? p : path.join(root, p);
+        try {
+          const realRoot = fs.realpathSync(root);
+          const realAbs = fs.realpathSync(abs);
+          const rel = path.relative(realRoot, realAbs);
+          if (rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel)) return realAbs;
+        } catch (_) {
+        }
+      }
+      return null;
+    }
+    function inlineFiles(files, opts = {}) {
+      const roots = opts.roots && opts.roots.length ? opts.roots : [process.cwd()];
+      const perFileCap = opts.perFileCap != null ? opts.perFileCap : DEFAULT_PER_FILE_CAP;
+      const totalCap = opts.totalCap != null ? opts.totalCap : DEFAULT_TOTAL_CAP;
+      const blocks = [];
+      const notes = [];
+      let total = 0;
+      function addFile(abs, label) {
+        let st;
+        try {
+          st = fs.statSync(abs);
+        } catch (e) {
+          notes.push(`${label}: skipped (stat error: ${e.message})`);
+          return;
+        }
+        if (st.size > perFileCap) {
+          notes.push(`${label}: skipped (${st.size} bytes > per-file cap ${perFileCap})`);
+          return;
+        }
+        let buf;
+        try {
+          buf = fs.readFileSync(abs);
+        } catch (e) {
+          notes.push(`${label}: skipped (read error: ${e.message})`);
+          return;
+        }
+        if (!isProbablyText(buf)) {
+          notes.push(`${label}: skipped (binary)`);
+          return;
+        }
+        if (total + buf.length > totalCap) {
+          notes.push(`${label}: omitted (aggregate inline budget ${totalCap} bytes exceeded)`);
+          return;
+        }
+        total += buf.length;
+        blocks.push(`=== ${label} ===
+${buf.toString("utf8")}`);
+      }
+      for (const entry of files || []) {
+        if (entry.file_id !== void 0 || entry.file_url !== void 0) {
+          throw new Error("file_id / file_url are not supported by the OpenRouter bridge (text-inline only)");
+        }
+        if (entry.path) {
+          const abs = resolveUnderRoots(entry.path, roots);
+          if (!abs) {
+            notes.push(`${entry.path}: skipped (not found under roots)`);
+            continue;
+          }
+          addFile(abs, path.basename(entry.path));
+        } else if (entry.dir) {
+          const absDir = resolveUnderRoots(entry.dir, roots);
+          if (!absDir) {
+            notes.push(`${entry.dir}: skipped (dir not found under roots)`);
+            continue;
+          }
+          const exclude = entry.excludeReset === true ? entry.exclude || [] : [...DEFAULT_EXCLUDE, ...entry.exclude || []];
+          let walked;
+          try {
+            ({ files: walked } = glob.walk(absDir, {
+              include: entry.include || ["**/*"],
+              exclude,
+              maxFiles: entry.maxFiles || 50,
+              maxBytes: entry.maxBytes || 128 * 1024 * 1024
+            }));
+          } catch (e) {
+            notes.push(`${entry.dir}: skipped (${e.message})`);
+            continue;
+          }
+          for (const w of walked) addFile(w.abs, path.relative(absDir, w.abs) || path.basename(w.abs));
+        }
+      }
+      return { blocks, notes };
+    }
+    module2.exports = { inlineFiles, DEFAULT_PER_FILE_CAP, DEFAULT_TOTAL_CAP };
+  }
+});
+
+// ../../core/paths.js
+var require_paths = __commonJS({
+  "../../core/paths.js"(exports2, module2) {
+    "use strict";
+    var os = require("node:os");
+    var path = require("node:path");
+    function resolveConfigPath(opts) {
+      const home = opts && opts.home || os.homedir();
+      const env = opts && opts.env || process.env;
+      const override = env.DELIBERATION_CONFIG;
+      if (typeof override === "string" && override.length > 0) {
+        return override;
+      }
+      return path.join(home, ".claude", "deliberation", "config.json");
+    }
+    function resolveGrokCachePath(opts) {
+      const home = opts && opts.home || os.homedir();
+      return path.join(home, ".claude", "cache", "deliberation", "grok-files.json");
+    }
+    module2.exports = {
+      resolveConfigPath,
+      resolveGrokCachePath
+    };
+  }
+});
+
+// ../openrouter/index.js
+var require_openrouter = __commonJS({
+  "../openrouter/index.js"(exports2, module2) {
+    "use strict";
+    var DEFAULT_TIMEOUT_MS = 18e4;
+    var MAX_MS = 6e5;
+    function isNonEmptyString(v) {
+      return typeof v === "string" && v.trim().length > 0;
+    }
+    function truncate(s, n) {
+      s = String(s == null ? "" : s);
+      return s.length > n ? s.slice(0, n) + "..." : s;
+    }
+    function buildMessages(turns) {
+      return (turns || []).map((t) => {
+        if (t.role === "user" && Array.isArray(t.inlineBlocks) && t.inlineBlocks.length) {
+          return { role: "user", content: [t.text, ...t.inlineBlocks].join("\n\n") };
+        }
+        return { role: t.role, content: t.text };
+      });
+    }
+    function classifyError(status, code) {
+      switch (code) {
+        case "missing-auth":
+          return { errorKind: "auth", retryable: false };
+        case "unknown-thread":
+          return { errorKind: "unknown-thread", retryable: false };
+        case "timeout":
+          return { errorKind: "timeout", retryable: true };
+        case "network":
+          return { errorKind: "network", retryable: true };
+        case "parse":
+          return { errorKind: "parse", retryable: false };
+        case "config":
+          return { errorKind: "config", retryable: false };
+        case "model-not-allowed":
+          return { errorKind: "model-not-allowed", retryable: false };
+      }
+      const s = Number(status);
+      if (s === 401 || s === 403) return { errorKind: "auth", retryable: false };
+      if (s === 429) return { errorKind: "rate-limit", retryable: true };
+      if (s >= 500 && s <= 599) return { errorKind: "upstream", retryable: true };
+      return { errorKind: "unknown", retryable: false };
+    }
+    function parseCompletion(data) {
+      const fail = (why) => {
+        const e = new Error(`Parse error: ${why}`);
+        e.code = "parse";
+        return e;
+      };
+      if (!data || typeof data !== "object") throw fail("body was not a JSON object");
+      const choice = Array.isArray(data.choices) ? data.choices[0] : null;
+      const content = choice && choice.message && choice.message.content;
+      if (typeof content === "string") return content;
+      if (Array.isArray(content)) {
+        const text = content.filter((p) => p && typeof p.text === "string").map((p) => p.text).join("");
+        if (text) return text;
+      }
+      throw fail("no assistant message content in choices[0]");
+    }
+    async function callOpenRouter({ apiBase, apiKey, model, messages, reasoningEffort, temperature, timeoutMs, fetchImpl }) {
+      const f = fetchImpl || globalThis.fetch;
+      if (typeof f !== "function") {
+        const e = new Error("global fetch unavailable; Node 18+ required");
+        e.code = "network";
+        throw e;
+      }
+      const base = (apiBase || "https://openrouter.ai/api/v1").replace(/\/+$/, "");
+      const url = `${base}/chat/completions`;
+      const payload = { model, messages, stream: false };
+      if (isNonEmptyString(reasoningEffort)) payload.reasoning = { effort: reasoningEffort };
+      if (typeof temperature === "number") payload.temperature = temperature;
+      const headers = {
+        "Content-Type": "application/json",
+        "HTTP-Referer": "https://github.com/antonbabenko/deliberation",
+        "X-Title": "deliberation"
+      };
+      if (isNonEmptyString(apiKey)) headers["Authorization"] = `Bearer ${apiKey}`;
+      const t = typeof timeoutMs === "number" && timeoutMs > 0 ? timeoutMs : DEFAULT_TIMEOUT_MS;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), t);
+      let res;
+      try {
+        res = await f(url, { method: "POST", headers, body: JSON.stringify(payload), signal: controller.signal });
+      } catch (err) {
+        const msg = String(err && err.message || err);
+        if (err && err.name === "AbortError" || /abort/i.test(msg)) {
+          const e2 = new Error(`OpenRouter timed out after ${Math.round(t / 1e3)}s`);
+          e2.code = "timeout";
+          throw e2;
+        }
+        const e = new Error(`Network error: ${msg}`);
+        e.code = "network";
+        throw e;
+      } finally {
+        clearTimeout(timer);
+      }
+      let bodyText = "";
+      try {
+        bodyText = await res.text();
+      } catch (_) {
+        bodyText = "";
+      }
+      if (!res.ok) {
+        const e = new Error(`OpenRouter API error ${res.status}: ${truncate(bodyText, 500)}`);
+        e.status = res.status;
+        throw e;
+      }
+      let data;
+      try {
+        data = JSON.parse(bodyText);
+      } catch (e2) {
+        const e = new Error(`Parse error: invalid JSON: ${e2.message}`);
+        e.code = "parse";
+        throw e;
+      }
+      return { text: parseCompletion(data) };
+    }
+    var crypto = require("node:crypto");
+    var { makeConfigReader } = require_config();
+    var { resolveAlias, RESERVED_ALIAS, askAllDelegates, consensusDelegates } = require_routing();
+    var { inlineFiles } = require_files();
+    var CONFIG_PATH = require_paths().resolveConfigPath();
+    var configReader = makeConfigReader(CONFIG_PATH);
+    var sessions = /* @__PURE__ */ new Map();
+    function sendResponse(id, result) {
+      process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
+    }
+    function sendError(id, code, message) {
+      process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }) + "\n");
+    }
+    function isObject(v) {
+      return v !== null && typeof v === "object" && !Array.isArray(v);
+    }
+    function hasRequestId(r) {
+      return isObject(r) && Object.prototype.hasOwnProperty.call(r, "id");
+    }
+    function logCall(cid, tool, outcome, ms) {
+      process.stderr.write(`[openrouter] ${cid} ${tool} -> ${outcome} in ${ms}ms
+`);
+    }
+    function pick(callArg, modelOverride, defaultsVal) {
+      if (callArg !== void 0) return callArg;
+      if (modelOverride !== void 0) return modelOverride;
+      return defaultsVal;
+    }
+    function errorResult(id, e, tool, startedAt) {
+      const { errorKind, retryable } = classifyError(e && e.status, e && e.code);
+      logCall(id, tool, errorKind, Date.now() - startedAt);
+      return { content: [{ type: "text", text: `Error: ${e && e.message || String(e)}` }], isError: true, errorKind, retryable };
+    }
+    function buildInitialTurns(developerInstructions, prompt, blocks) {
+      const turns = [];
+      if (isNonEmptyString(developerInstructions)) turns.push({ role: "system", text: developerInstructions });
+      turns.push({ role: "user", text: prompt, inlineBlocks: blocks || [] });
+      return turns;
+    }
+    function resolveDelegate(or, args) {
+      if (isNonEmptyString(args.alias)) {
+        return resolveAlias(or, args.alias) || { _error: "model-not-allowed" };
+      }
+      if (isNonEmptyString(args.model)) {
+        if (!or.allowRawModel) return { _error: "model-not-allowed" };
+        return { model: args.model.trim() };
+      }
+      return resolveAlias(or, RESERVED_ALIAS) || { _error: "model-not-allowed" };
+    }
+    var TOOL_PROPS = {
+      prompt: { type: "string", description: "The delegation prompt" },
+      "developer-instructions": { type: "string", description: "Expert system instructions" },
+      alias: { type: "string", description: "Configured delegate alias (preferred)" },
+      model: { type: "string", description: "Raw OpenRouter model slug; honored only when allowRawModel:true" },
+      reasoning_effort: { type: "string", description: "low|medium|high (provider-dependent)" },
+      temperature: { type: "number" },
+      timeout: { type: "number", description: "Soft timeout ms, 1..600000" },
+      files: { type: "array", description: "Text-inline files: each item has path or dir (file_id/file_url rejected)" },
+      roots: { type: "array", items: { type: "string" }, description: "Absolute dirs to resolve files[].path/dir" },
+      cwd: { type: "string" },
+      sandbox: { type: "string", description: "Accepted for parity; ignored." }
+    };
+    var handlers = {
+      initialize: (id, _p, respond) => {
+        if (!respond) return;
+        sendResponse(id, { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "deliberation-openrouter", version: "1.0.0" } });
+      },
+      "notifications/initialized": () => {
+      },
+      "tools/list": (id, _p, respond) => {
+        if (!respond) return;
+        sendResponse(id, { tools: [
+          { name: "openrouter", description: "Start an OpenRouter expert session (advisory only). Pick a configured `alias`.", inputSchema: { type: "object", properties: TOOL_PROPS, required: ["prompt"] } },
+          { name: "openrouter-reply", description: "Continue an OpenRouter session by threadId (in-memory; lost on restart).", inputSchema: { type: "object", properties: { threadId: { type: "string" }, prompt: { type: "string" }, files: TOOL_PROPS.files, roots: TOOL_PROPS.roots, alias: TOOL_PROPS.alias, model: TOOL_PROPS.model, reasoning_effort: TOOL_PROPS.reasoning_effort, temperature: TOOL_PROPS.temperature, timeout: TOOL_PROPS.timeout, cwd: TOOL_PROPS.cwd }, required: ["threadId", "prompt"] } },
+          { name: "openrouter-list", description: "List configured OpenRouter delegates and settings. Pass mode ('ask-all'|'consensus') + optional expert to also get the resolved `selected` delegate set (selection applied server-side from the live config).", inputSchema: { type: "object", properties: { mode: { type: "string", enum: ["ask-all", "consensus"] }, expert: { type: "string" } } } }
+        ] });
+      },
+      "tools/call": async (id, params, respond) => {
+        const startedAt = Date.now();
+        if (!isObject(params) || !isNonEmptyString(params.name)) {
+          if (respond) sendError(id, -32602, "Invalid params");
+          return;
+        }
+        const { name, arguments: args } = params;
+        if (!isObject(args)) {
+          if (respond) sendError(id, -32602, "Invalid params: arguments must be an object");
+          return;
+        }
+        const cfg = configReader.get();
+        if (!cfg.ok) {
+          if (name === "openrouter-list") {
+            const errPayload = { delegates: [], defaultModelSet: false, maxFanout: 3, maxFanoutHigh: false, error: cfg.error };
+            if (isObject(args) && (args.mode === "ask-all" || args.mode === "consensus")) {
+              errPayload.mode = args.mode;
+              if (typeof args.expert === "string") errPayload.expert = args.expert;
+              errPayload.selected = [];
+              if (args.mode === "ask-all") errPayload.omitted = [];
+            }
+            if (respond) sendResponse(id, { content: [{ type: "text", text: JSON.stringify(errPayload) }] });
+            logCall(id, name, "config", Date.now() - startedAt);
+            return;
+          }
+          if (respond) sendResponse(id, errorResult(id, { code: "config", message: cfg.error }, name, startedAt));
+          return;
+        }
+        const or = cfg.resolved.openrouter;
+        if (name === "openrouter-list") {
+          if (!respond) return;
+          const shape = (m) => ({
+            alias: m.alias,
+            model: m.model,
+            experts: m.experts,
+            askAll: m.askAll,
+            consensus: m.consensus,
+            // Resolved effort the bridge would use absent a per-call override: per-model > defaults > null.
+            reasoning_effort: pick(void 0, m.reasoning_effort, or.defaults.reasoning_effort) ?? null
+          });
+          const payload = {
+            delegates: or.models.map(shape),
+            defaultModelSet: !!or.defaultModel,
+            maxFanout: or.maxFanout,
+            maxFanoutHigh: or.maxFanout > 10,
+            // Per-entry validation failures (kept-valid delegates above; these were skipped).
+            // Each: { index, alias, reason, suggestedAlias? }. Empty when the config is clean.
+            invalidModels: or.invalidModels || []
+          };
+          const mode = args.mode;
+          if (mode === "ask-all" || mode === "consensus") {
+            const expert = typeof args.expert === "string" ? args.expert : void 0;
+            payload.mode = mode;
+            if (expert !== void 0) payload.expert = expert;
+            if (mode === "ask-all") {
+              const out = askAllDelegates(or, expert);
+              payload.selected = out.selected.map(shape);
+              payload.omitted = out.omitted.map(shape);
+            } else {
+              payload.selected = consensusDelegates(or, expert).map(shape);
+            }
+          }
+          sendResponse(id, { content: [{ type: "text", text: JSON.stringify(payload) }] });
+          logCall(id, name, "ok", Date.now() - startedAt);
+          return;
+        }
+        if (name !== "openrouter" && name !== "openrouter-reply") {
+          if (respond) sendError(id, -32601, `Tool not found: ${name}`);
+          return;
+        }
+        if (!isNonEmptyString(args.prompt)) {
+          if (respond) sendError(id, -32602, "Invalid params: 'prompt' is required");
+          return;
+        }
+        if (args.timeout !== void 0 && (typeof args.timeout !== "number" || args.timeout <= 0 || args.timeout > MAX_MS)) {
+          if (respond) sendError(id, -32602, "Invalid params: 'timeout' must be 1..600000");
+          return;
+        }
+        if (args.alias !== void 0 && args.model !== void 0) {
+          if (respond) sendResponse(id, errorResult(id, { code: "config", message: "pass at most one of alias/model" }, name, startedAt));
+          return;
+        }
+        if (args.roots !== void 0 && (!Array.isArray(args.roots) || args.roots.some((r) => typeof r !== "string"))) {
+          if (respond) sendError(id, -32602, "Invalid params: 'roots' must be an array of strings");
+          return;
+        }
+        let delegate = null, priorSession = null, threadId;
+        if (name === "openrouter-reply") {
+          if (!isNonEmptyString(args.threadId)) {
+            if (respond) sendError(id, -32602, "Invalid params: 'threadId' required");
+            return;
+          }
+          threadId = args.threadId.trim();
+          priorSession = sessions.get(threadId);
+          if (!priorSession) {
+            if (respond) sendResponse(id, errorResult(id, { code: "unknown-thread", message: `unknown threadId "${threadId}"` }, name, startedAt));
+            return;
+          }
+          delegate = args.alias || args.model ? resolveDelegate(or, args) : { model: priorSession.model };
+        } else {
+          threadId = crypto.randomUUID();
+          delegate = resolveDelegate(or, args);
+        }
+        if (delegate && delegate._error) {
+          if (respond) sendResponse(id, errorResult(id, { code: delegate._error, message: "alias/model not in allowlist" }, name, startedAt));
+          return;
+        }
+        if (!delegate || !delegate.model) {
+          if (respond) sendResponse(id, errorResult(id, { code: "model-not-allowed", message: "no alias/model resolved and no defaultModel set" }, name, startedAt));
+          return;
+        }
+        let blocks = [], notes = [];
+        if (args.files) {
+          try {
+            const roots = Array.isArray(args.roots) && args.roots.length ? args.roots : [args.cwd || process.cwd()];
+            ({ blocks, notes } = inlineFiles(args.files, { roots }));
+          } catch (e) {
+            if (respond) sendResponse(id, errorResult(id, { code: "config", message: e.message }, name, startedAt));
+            return;
+          }
+        }
+        const reasoningEffort = pick(args.reasoning_effort, delegate.reasoning_effort, or.defaults.reasoning_effort);
+        const temperature = pick(args.temperature, delegate.temperature, or.defaults.temperature);
+        const timeoutMs = pick(args.timeout, delegate.timeout, or.defaults.timeout);
+        const apiBase = delegate.apiBase || or.apiBase;
+        const apiKey = process.env[or.apiKeyEnv] || "";
+        const turns = priorSession ? [...priorSession.turns, { role: "user", text: args.prompt, inlineBlocks: blocks }] : buildInitialTurns(args["developer-instructions"], args.prompt, blocks);
+        try {
+          const out = await callOpenRouter({ apiBase, apiKey, model: delegate.model, messages: buildMessages(turns), reasoningEffort, temperature, timeoutMs });
+          sessions.set(threadId, { turns: [...turns, { role: "assistant", text: out.text }], model: delegate.model, apiBase, reasoningEffort, temperature });
+          if (respond) {
+            const text = notes.length ? `${out.text}
+
+[files] ${notes.join("; ")}` : out.text;
+            sendResponse(id, { content: [{ type: "text", text }], threadId });
+          }
+          logCall(id, name, "ok", Date.now() - startedAt);
+        } catch (e) {
+          if (respond) sendResponse(id, errorResult(id, e, name, startedAt));
+        }
+      }
+    };
+    async function processLine(line) {
+      if (!line.trim()) return;
+      let request;
+      try {
+        request = JSON.parse(line);
+      } catch (_) {
+        return;
+      }
+      const respond = hasRequestId(request);
+      if (!isObject(request) || typeof request.method !== "string") {
+        if (respond) sendError(request.id, -32600, "Invalid Request");
+        return;
+      }
+      const handler = handlers[request.method];
+      if (!handler) {
+        if (respond) sendError(request.id, -32601, `Method not found: ${request.method}`);
+        return;
+      }
+      try {
+        await handler(request.id, request.params, respond);
+      } catch (e) {
+        if (respond) sendError(request.id, -32603, `Internal error: ${e.message}`);
+      }
+    }
+    if (require.main === module2) {
+      let buffer = "";
+      const enqueue = (line) => {
+        void processLine(line);
+      };
+      process.stdin.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop();
+        for (const l of lines) enqueue(l);
+      });
+      process.stdin.on("end", () => {
+        if (buffer) {
+          enqueue(buffer);
+          buffer = "";
+        }
+      });
+      if (typeof globalThis.fetch !== "function") {
+        console.error("OpenRouter bridge requires Node 18+ (global fetch unavailable).");
+        process.exit(1);
+      }
+    }
+    module2.exports = { buildMessages, classifyError, parseCompletion, callOpenRouter, buildInitialTurns, resolveDelegate, DEFAULT_TIMEOUT_MS, MAX_MS, isNonEmptyString, truncate };
+  }
+});
+
+// ../../core/providers/openai-compatible.js
+var require_openai_compatible = __commonJS({
+  "../../core/providers/openai-compatible.js"(exports2, module2) {
+    "use strict";
+    var crypto = require("node:crypto");
+    var { toErrorResult } = require_provider();
+    var MAX_SESSIONS = 100;
+    function makeOpenAICompatibleProvider(opts) {
+      const { name = "openrouter", apiBase, apiKeyEnv, resolveModel } = opts;
+      const bridge = (
+        /** @type {any} */
+        opts.bridge || require_openrouter()
+      );
+      const sessions = /* @__PURE__ */ new Map();
+      return (
+        /** @type {any} */
+        {
+          name,
+          capabilities: { canImplement: false, fileUpload: false, multiTurn: true },
+          /** Test-only: current number of cached sessions. */
+          get __sessionCount() {
+            return sessions.size;
+          },
+          async health() {
+            return process.env[apiKeyEnv] ? { ok: true } : { ok: false, reason: `${apiKeyEnv} unset` };
+          },
+          async ask(req) {
+            const started = Date.now();
+            const model = resolveModel(req);
+            const prior = req.threadId && sessions.get(req.threadId);
+            const turns = prior ? [...prior, { role: "user", text: req.prompt }] : bridge.buildInitialTurns(req.developerInstructions, req.prompt, req.files || []);
+            try {
+              const { text } = await bridge.callOpenRouter({
+                apiBase,
+                apiKey: process.env[apiKeyEnv],
+                model,
+                messages: bridge.buildMessages(turns),
+                reasoningEffort: req.reasoningEffort,
+                temperature: req.temperature,
+                timeoutMs: req.timeoutMs
+              });
+              const threadId = req.threadId || crypto.randomUUID();
+              sessions.set(threadId, [...turns, { role: "assistant", text }]);
+              if (sessions.size > MAX_SESSIONS) sessions.delete(sessions.keys().next().value);
+              return { provider: name, model, text, threadId, isError: false, ms: Date.now() - started };
+            } catch (e) {
+              return toErrorResult(
+                name,
+                model,
+                started,
+                /** @type {any} */
+                e,
+                bridge.classifyError
+              );
+            }
+          }
+        }
+      );
+    }
+    module2.exports = { makeOpenAICompatibleProvider, MAX_SESSIONS };
+  }
+});
+
+// ../grok/lock.js
+var require_lock = __commonJS({
+  "../grok/lock.js"(exports2, module2) {
+    "use strict";
+    var fs = require("node:fs");
+    var path = require("node:path");
+    var crypto = require("node:crypto");
+    var STALE_MS = 5e3;
+    var POLL_MS = 20;
+    function sleepSyncMs(ms) {
+      const until = Date.now() + ms;
+      while (Date.now() < until) {
+      }
+    }
+    function acquire(basePath, { maxWaitMs = 1e3 } = {}) {
+      const lockDir = `${basePath}.lock`;
+      const token = crypto.randomBytes(16).toString("hex");
+      const markerName = `owner.${token}.txt`;
+      const deadline = Date.now() + maxWaitMs;
+      try {
+        fs.mkdirSync(path.dirname(lockDir), { recursive: true });
+      } catch (_) {
+      }
+      while (true) {
+        try {
+          fs.mkdirSync(lockDir);
+          const markerPath = path.join(lockDir, markerName);
+          fs.writeFileSync(markerPath, JSON.stringify({ pid: process.pid, token, t: Date.now() }));
+          return { lockDir, markerPath, token };
+        } catch (e) {
+          if (e.code !== "EEXIST") throw e;
+          try {
+            const st = fs.statSync(lockDir);
+            if (Date.now() - st.mtimeMs > STALE_MS) {
+              const dead = `${lockDir}.dead.${process.pid}.${Date.now()}`;
+              try {
+                fs.renameSync(lockDir, dead);
+                fs.rmSync(dead, { recursive: true, force: true });
+                continue;
+              } catch (_) {
+              }
+            }
+          } catch (_) {
+          }
+        }
+        if (Date.now() >= deadline) return null;
+        sleepSyncMs(POLL_MS);
+      }
+    }
+    function release(handle) {
+      if (!handle) return;
+      try {
+        fs.unlinkSync(handle.markerPath);
+      } catch (_) {
+      }
+      try {
+        fs.rmdirSync(handle.lockDir);
+      } catch (_) {
+      }
+    }
+    function heartbeat(handle) {
+      if (!handle) return;
+      const now = /* @__PURE__ */ new Date();
+      try {
+        fs.utimesSync(handle.lockDir, now, now);
+      } catch (_) {
+      }
+    }
+    module2.exports = { acquire, release, heartbeat, STALE_MS, POLL_MS };
+  }
+});
+
+// ../grok/cache.js
+var require_cache = __commonJS({
+  "../grok/cache.js"(exports2, module2) {
+    "use strict";
+    var path = require("node:path");
+    var os = require("node:os");
+    var crypto = require("node:crypto");
+    var { mkdirSync, readFileSync, writeFileSync, renameSync } = require("node:fs");
+    var lock = require_lock();
+    var CACHE_FILE = require_paths().resolveGrokCachePath();
+    var CACHE_DIR = path.dirname(CACHE_FILE);
+    var CACHE_VERSION = 1;
+    function normalize(apiBase) {
+      let u;
+      try {
+        u = new URL(apiBase);
+      } catch (_) {
+        u = new URL(`https://${apiBase}`);
+      }
+      const proto = u.protocol.toLowerCase();
+      const host = u.host.toLowerCase();
+      let pathname = u.pathname;
+      if (pathname.length > 1 && pathname.endsWith("/")) pathname = pathname.slice(0, -1);
+      return `${proto}//${host}${pathname}`;
+    }
+    function buildCacheKey({ bytes, apiKey, apiBase, filename }) {
+      const contentHash = crypto.createHash("sha256").update(bytes).digest("hex");
+      const keyFp = crypto.createHash("sha256").update(String(apiKey)).digest("hex").slice(0, 16);
+      const baseNorm = normalize(apiBase);
+      return `${contentHash}@${keyFp}@${baseNorm}@${filename}`;
+    }
+    function readCache(file) {
+      try {
+        const raw = readFileSync(file, "utf8");
+        const obj = JSON.parse(raw);
+        if (obj && typeof obj === "object" && obj.entries && typeof obj.entries === "object") {
+          return { version: obj.version || CACHE_VERSION, entries: obj.entries };
+        }
+      } catch (e) {
+        if (e && e.code !== "ENOENT") {
+          process.stderr.write(`[grok] cache read failed (${e.message}); treating as empty
+`);
+        }
+      }
+      return { version: CACHE_VERSION, entries: {} };
+    }
+    function writeCache(file, data) {
+      mkdirSync(path.dirname(file), { recursive: true });
+      const tmp = `${file}.tmp.${process.pid}.${Date.now()}`;
+      writeFileSync(tmp, JSON.stringify(data));
+      renameSync(tmp, file);
+    }
+    var _inflight = /* @__PURE__ */ new Map();
+    function withInflight(key, worker) {
+      if (_inflight.has(key)) return _inflight.get(key);
+      const p = Promise.resolve().then(worker);
+      _inflight.set(key, p);
+      p.then(
+        () => {
+          _inflight.delete(key);
+        },
+        () => {
+          _inflight.delete(key);
+        }
+      );
+      return p;
+    }
+    function lookup(file, key, { apiBase, keyFp } = {}) {
+      const data = readCache(file);
+      const entry = data.entries[key];
+      if (!entry) return null;
+      const now = Math.floor(Date.now() / 1e3);
+      if (entry.expiresAt - now < 60) return null;
+      if (apiBase && entry.apiBase !== apiBase) return null;
+      if (keyFp && entry.keyFp !== keyFp) return null;
+      return entry;
+    }
+    async function store(file, key, entry) {
+      if (!file) return;
+      const handle = lock.acquire(file, { maxWaitMs: 1e3 });
+      if (!handle) {
+        process.stderr.write("[grok] cache lock contention; skipping persist\n");
+        return;
+      }
+      try {
+        const data = readCache(file);
+        data.entries[key] = entry;
+        writeCache(file, data);
+      } finally {
+        lock.release(handle);
+      }
+    }
+    async function evict(file, fileId) {
+      if (!file) return;
+      const handle = lock.acquire(file, { maxWaitMs: 1e3 });
+      if (!handle) return;
+      try {
+        const data = readCache(file);
+        for (const k of Object.keys(data.entries)) {
+          if (data.entries[k].fileId === fileId) delete data.entries[k];
+        }
+        writeCache(file, data);
+      } finally {
+        lock.release(handle);
+      }
+    }
+    module2.exports = { normalize, buildCacheKey, readCache, writeCache, withInflight, lookup, store, evict, CACHE_DIR, CACHE_FILE, CACHE_VERSION };
+  }
+});
+
+// ../grok/index.js
+var require_grok = __commonJS({
+  "../grok/index.js"(exports2, module2) {
+    "use strict";
+    var crypto = require("node:crypto");
+    var path = require("node:path");
+    var { stat, readFile } = require("node:fs/promises");
+    var DEFAULT_MODEL = process.env.GROK_DEFAULT_MODEL || "grok-4.3";
+    var DEFAULT_API_BASE = process.env.XAI_API_BASE || "https://api.x.ai/v1";
+    var DEFAULT_TIMEOUT_MS = 18e4;
+    var MAX_MS = 6e5;
+    var VALID_SANDBOX_VALUES = /* @__PURE__ */ new Set(["read-only", "workspace-write"]);
+    var FILE_TTL_MIN = 3600;
+    var FILE_TTL_MAX = 2592e3;
+    function resolveFileTtl() {
+      const raw = Number(process.env.GROK_FILE_TTL_SECONDS);
+      const v = Number.isFinite(raw) && raw > 0 ? raw : 604800;
+      return Math.min(FILE_TTL_MAX, Math.max(FILE_TTL_MIN, Math.round(v)));
+    }
+    var FILE_TTL_SECONDS = resolveFileTtl();
+    var MAX_FILE_BYTES = 48 * 1024 * 1024;
+    var FILE_PREFIX = "deliberation-";
+    var UPLOAD_PURPOSE = "assistants";
+    var cacheModule = require_cache();
+    var DEFAULT_CACHE_FILE = cacheModule.CACHE_FILE;
+    var globMod = require_glob();
+    var DEFAULT_INCLUDE = ["**/*"];
+    var DEFAULT_EXCLUDE = [
+      // VCS (bare = any-depth via (?:^|/) anchor in glob.js compile())
+      ".git",
+      // JS / Node ecosystems
+      "node_modules",
+      "**/dist/**",
+      "**/build/**",
+      "**/out/**",
+      "**/.next/**",
+      "**/.svelte-kit/**",
+      "**/.nuxt/**",
+      "**/.turbo/**",
+      "**/.cache/**",
+      "**/.parcel-cache/**",
+      "**/.pnpm-store/**",
+      // Yarn Berry caches (can run into thousands of files)
+      "**/.yarn/cache/**",
+      "**/.yarn/unplugged/**",
+      "**/.yarn/install-state.gz",
+      // Lockfiles
+      "**/*.lock",
+      // Python
+      "**/.venv/**",
+      "**/venv/**",
+      "**/__pycache__/**",
+      "**/.tox/**",
+      "**/.pytest_cache/**",
+      "**/.mypy_cache/**",
+      "**/.ruff_cache/**",
+      "**/.ipynb_checkpoints/**",
+      "**/.eggs/**",
+      "**/htmlcov/**",
+      // Coverage
+      "**/coverage/**",
+      "**/.nyc_output/**",
+      // Rust / Java / Gradle
+      "**/target/**",
+      "**/.gradle/**",
+      // Go / PHP
+      "**/vendor/**",
+      // Terraform
+      "**/.terraform/**",
+      "**/.terragrunt-cache/**",
+      // Security: Terraform state holds plaintext credentials and resource ARNs
+      "**/*.tfstate*",
+      "**/.terraform.tfstate.lock.info",
+      // Security: dotenv (granular - keeps .env.example/.env.sample/.env.template readable)
+      "**/.env",
+      "**/.env.local",
+      "**/.env.development",
+      "**/.env.development.local",
+      "**/.env.dev",
+      "**/.env.dev.local",
+      "**/.env.production",
+      "**/.env.production.local",
+      "**/.env.prod",
+      "**/.env.prod.local",
+      "**/.env.test",
+      "**/.env.test.local",
+      "**/.env.staging",
+      "**/.env.staging.local",
+      "**/.env.stage",
+      "**/.env.stage.local",
+      // Security: SSH config + private keys
+      "**/.ssh/**",
+      "**/id_rsa",
+      "**/id_rsa.pub",
+      "**/id_ed25519",
+      "**/id_ed25519.pub",
+      "**/id_ecdsa",
+      "**/id_ecdsa.pub",
+      "**/id_dsa",
+      "**/id_dsa.pub",
+      "**/*.pem",
+      "**/*.key"
+    ];
+    var DEFAULT_MAX_FILES = 50;
+    var DEFAULT_MAX_BYTES = 128 * 1024 * 1024;
+    var DIR_UPLOAD_CONCURRENCY = 4;
+    var DEFAULT_REASONING_EFFORT = "high";
+    function resolveReasoningEffort(perCall) {
+      let raw = perCall;
+      if (raw === void 0 || raw === null) raw = process.env.GROK_REASONING_EFFORT;
+      if (raw === void 0 || raw === null) raw = DEFAULT_REASONING_EFFORT;
+      const v = String(raw).trim();
+      if (v === "" || v.toLowerCase() === "none" || v.toLowerCase() === "off") return null;
+      return v;
+    }
+    var sessions = /* @__PURE__ */ new Map();
+    function sendResponse(id, result) {
+      process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
+    }
+    function sendError(id, code, message) {
+      process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }) + "\n");
+    }
+    function isObject(value) {
+      return value !== null && typeof value === "object" && !Array.isArray(value);
+    }
+    function hasRequestId(request) {
+      return isObject(request) && Object.prototype.hasOwnProperty.call(request, "id");
+    }
+    function isNonEmptyString(value) {
+      return typeof value === "string" && value.trim().length > 0;
+    }
+    function truncate(str, max) {
+      const s = String(str == null ? "" : str);
+      return s.length > max ? s.slice(0, max) + "..." : s;
+    }
+    function logCall(cid, tool, outcome, ms) {
+      process.stderr.write(`[grok] ${cid} ${tool} -> ${outcome} in ${ms}ms
+`);
+    }
+    function classifyGrokError(status, errCode) {
+      switch (errCode) {
+        case "missing-auth":
+          return { errorKind: "missing-auth", retryable: false };
+        case "unknown-thread":
+          return { errorKind: "unknown-thread", retryable: false };
+        case "timeout":
+          return { errorKind: "timeout", retryable: true };
+        case "network":
+          return { errorKind: "network", retryable: true };
+        case "parse":
+          return { errorKind: "parse", retryable: false };
+        case "file-too-large":
+          return { errorKind: "file-too-large", retryable: false };
+        case "file-read":
+          return { errorKind: "file-read", retryable: false };
+        case "file-upload":
+          return { errorKind: "file-upload", retryable: true };
+      }
+      const s = Number(status);
+      if (s === 401 || s === 403) return { errorKind: "auth", retryable: false };
+      if (s === 429) return { errorKind: "rate-limit", retryable: true };
+      if (s >= 500 && s <= 599) return { errorKind: "upstream", retryable: true };
+      return { errorKind: "unknown", retryable: false };
+    }
+    function buildInitialTurns(developerInstructions, prompt, fileRefs) {
+      const turns = [];
+      if (isNonEmptyString(developerInstructions)) {
+        turns.push({ role: "system", text: developerInstructions });
+      }
+      turns.push({ role: "user", text: prompt, fileRefs: fileRefs || [] });
+      return turns;
+    }
+    function turnsToInput(turns) {
+      const input = [];
+      for (const turn of turns) {
+        if (turn.role === "assistant") {
+          if (Array.isArray(turn.items) && turn.items.length) {
+            for (const item of turn.items) input.push(item);
+          } else {
+            input.push({ role: "assistant", content: [{ type: "output_text", text: turn.text }] });
+          }
+          continue;
+        }
+        if (turn.role === "system") {
+          input.push({ role: "system", content: [{ type: "input_text", text: turn.text }] });
+          continue;
+        }
+        const content = [{ type: "input_text", text: turn.text }];
+        for (const ref of turn.fileRefs || []) {
+          if (ref.inline_text != null) {
+            const name = ref.inline_filename || "file";
+            content.push({ type: "input_text", text: `=== ${name} ===
+${ref.inline_text}` });
+          } else if (ref.file_id) content.push({ type: "input_file", file_id: ref.file_id });
+          else if (ref.file_url) content.push({ type: "input_file", file_url: ref.file_url });
+        }
+        input.push({ role: "user", content });
+      }
+      return input;
+    }
+    function parseResponsesOutput(data) {
+      const fail = (why) => {
+        const e = new Error(`Parse error: ${why}`);
+        e.code = "parse";
+        return e;
+      };
+      if (!isObject(data)) throw fail("response was not a JSON object");
+      if (isNonEmptyString(data.output_text)) return data.output_text;
+      const output = data.output;
+      if (!Array.isArray(output) || output.length === 0) throw fail("no output in response");
+      for (let i = output.length - 1; i >= 0; i--) {
+        const item = output[i];
+        const parts = item && item.content;
+        if (!Array.isArray(parts)) continue;
+        const texts = parts.filter((p) => p && typeof p.text === "string" && (p.type === "output_text" || p.type === "text" || p.type === void 0)).map((p) => p.text);
+        if (texts.length) return texts.join("");
+      }
+      throw fail("no text part found in output");
+    }
+    var INLINE_MAX_BYTES_DEFAULT = 256 * 1024;
+    function resolveInlineMaxBytes() {
+      const raw = Number(process.env.GROK_INLINE_MAX_BYTES);
+      return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : INLINE_MAX_BYTES_DEFAULT;
+    }
+    function isProbablyText(buf) {
+      if (!buf || buf.length === 0) return true;
+      const slice = buf.subarray(0, Math.min(buf.length, 4096));
+      if (slice.includes(0)) return false;
+      let np = 0;
+      for (const b of slice) {
+        if (b === 9 || b === 10 || b === 13) continue;
+        if (b >= 32 && b <= 126) continue;
+        if (b >= 128) continue;
+        np++;
+      }
+      return np / slice.length < 0.05;
+    }
+    function shouldInline(buf, mode) {
+      if (mode === "inline") return true;
+      if (mode === "auto") {
+        return buf.length <= resolveInlineMaxBytes() && isProbablyText(buf);
+      }
+      return false;
+    }
+    async function uploadFile({ filePath, filename, apiKey, apiBase, ttl, roots, cwd, fetchImpl, cacheFile, mode }) {
+      if (!isNonEmptyString(apiKey)) {
+        const e = new Error("XAI_API_KEY is not set; cannot upload files.");
+        e.code = "missing-auth";
+        throw e;
+      }
+      const f = fetchImpl || globalThis.fetch;
+      const base = (apiBase || DEFAULT_API_BASE).replace(/\/+$/, "");
+      const rootList = Array.isArray(roots) && roots.length ? roots : [require("node:fs").realpathSync(cwd || process.cwd())];
+      let resolved;
+      try {
+        resolved = resolvePathUnderRoots(filePath.replace(/\\/g, "/"), rootList, "file");
+      } catch (err) {
+        const e = new Error(`Cannot read file "${filePath}": ${err && err.message || err}`);
+        e.code = "file-read";
+        throw e;
+      }
+      if (resolved.size > MAX_FILE_BYTES) {
+        const e = new Error(`File "${filePath}" is ${resolved.size} bytes; exceeds the ${MAX_FILE_BYTES}-byte cap.`);
+        e.code = "file-too-large";
+        throw e;
+      }
+      let buf;
+      try {
+        buf = await require("node:fs/promises").readFile(resolved.abs);
+      } catch (err) {
+        const e = new Error(`Cannot read file "${filePath}": ${err && err.message || err}`);
+        e.code = "file-read";
+        throw e;
+      }
+      const cacheMod = require_cache();
+      const baseName = require("node:path").basename(filename || resolved.abs);
+      const effectiveFilename = baseName;
+      if (shouldInline(buf, mode)) {
+        return {
+          _inline: true,
+          inline_text: buf.toString("utf8"),
+          inline_filename: effectiveFilename,
+          _sourcePath: resolved.abs,
+          _sourceRoot: resolved.root,
+          _bytes: buf.length
+        };
+      }
+      const apiBaseNorm = cacheMod.normalize(base);
+      const cacheKey = cacheMod.buildCacheKey({ bytes: buf, apiKey, apiBase: base, filename: effectiveFilename });
+      const keyFp = require("node:crypto").createHash("sha256").update(apiKey).digest("hex").slice(0, 16);
+      const useCache = !process.env.XAI_DISABLE_FILE_CACHE && cacheFile;
+      if (useCache) {
+        const hit = cacheMod.lookup(cacheFile, cacheKey, { apiBase: apiBaseNorm, keyFp });
+        if (hit) return { id: hit.fileId, _fromCache: true, _cacheKey: cacheKey, _sourcePath: resolved.abs, _sourceRoot: resolved.root };
+      }
+      const work = async () => {
+        const contentHash = require("node:crypto").createHash("sha256").update(buf).digest("hex");
+        const storedName = `${FILE_PREFIX}${contentHash.slice(0, 16)}-${baseName}`;
+        const form = new FormData();
+        form.append("expires_after", String(ttl != null ? ttl : FILE_TTL_SECONDS));
+        form.append("purpose", UPLOAD_PURPOSE);
+        form.append("file", new Blob([buf]), storedName);
+        let res;
+        try {
+          res = await f(`${base}/files`, {
+            method: "POST",
+            headers: { "Authorization": `Bearer ${apiKey}` },
+            body: form
+          });
+        } catch (err) {
+          const e = new Error(`File upload network error: ${err && err.message || err}`);
+          e.code = "file-upload";
+          throw e;
+        }
+        let bodyText = "";
+        try {
+          bodyText = await res.text();
+        } catch (_) {
+          bodyText = "";
+        }
+        if (!res.ok) {
+          const e = new Error(`xAI file upload error ${res.status}: ${truncate(bodyText, 300)}`);
+          e.status = res.status;
+          if (res.status < 400 || res.status >= 500) e.code = "file-upload";
+          throw e;
+        }
+        let uploaded2;
+        try {
+          uploaded2 = JSON.parse(bodyText);
+        } catch (e2) {
+          const e = new Error(`File upload parse error: ${e2.message}`);
+          e.code = "parse";
+          throw e;
+        }
+        if (!isNonEmptyString(uploaded2 && uploaded2.id)) {
+          const e = new Error("File upload returned no file id");
+          e.code = "parse";
+          throw e;
+        }
+        if (useCache) {
+          const entry = {
+            fileId: uploaded2.id,
+            size: buf.length,
+            filename: effectiveFilename,
+            uploadedAt: Math.floor(Date.now() / 1e3),
+            expiresAt: Math.floor(Date.now() / 1e3) + (ttl != null ? ttl : FILE_TTL_SECONDS),
+            apiBase: apiBaseNorm,
+            keyFp
+          };
+          await cacheMod.store(cacheFile, cacheKey, entry);
+        }
+        return uploaded2;
+      };
+      const uploaded = useCache ? await cacheMod.withInflight(cacheKey, work) : await work();
+      return { ...uploaded, _cacheKey: cacheKey, _sourcePath: resolved.abs, _sourceRoot: resolved.root };
+    }
+    async function resolveFiles(files, opts) {
+      const refs = [];
+      const ownedIds = [];
+      const seen = /* @__PURE__ */ new Set();
+      const dedupKey = (single) => single._cacheKey || `inline:${single._sourcePath}`;
+      async function handlePath(entry) {
+        const uploaded = await uploadFile({
+          filePath: entry.path,
+          filename: entry.filename,
+          mode: entry.mode,
+          ...opts
+        });
+        if (uploaded && uploaded._inline) {
+          const k = dedupKey(uploaded);
+          if (seen.has(k)) return;
+          seen.add(k);
+          refs.push({
+            inline_text: uploaded.inline_text,
+            inline_filename: uploaded.inline_filename,
+            sourcePath: uploaded._sourcePath,
+            sourceRoot: uploaded._sourceRoot
+          });
+          return;
+        }
+        if (!isNonEmptyString(uploaded && uploaded.id)) {
+          const e = new Error("File upload returned no file id");
+          e.code = "parse";
+          throw e;
+        }
+        if (uploaded._cacheKey) {
+          if (seen.has(uploaded._cacheKey)) return;
+          seen.add(uploaded._cacheKey);
+        }
+        refs.push({
+          file_id: uploaded.id,
+          sourcePath: uploaded._sourcePath,
+          sourceRoot: uploaded._sourceRoot,
+          sourceCacheKey: uploaded._cacheKey
+        });
+        if (!uploaded._fromCache) ownedIds.push(uploaded.id);
+      }
+      async function handleDir(entry) {
+        const rootList = Array.isArray(opts.roots) && opts.roots.length ? opts.roots : [require("node:fs").realpathSync(opts.cwd || process.cwd())];
+        const resolved = resolvePathUnderRoots(entry.dir.replace(/\\/g, "/"), rootList, "dir");
+        const include = entry.include || DEFAULT_INCLUDE;
+        const exclude = entry.excludeReset === true ? entry.exclude || [] : [...DEFAULT_EXCLUDE, ...entry.exclude || []];
+        const maxFiles = entry.maxFiles || DEFAULT_MAX_FILES;
+        const maxBytes = entry.maxBytes || DEFAULT_MAX_BYTES;
+        const { files: walked } = globMod.walk(resolved.abs, { include, exclude, maxFiles, maxBytes });
+        let cached = 0, uploaded = 0, skipped = 0;
+        const queue = [...walked];
+        let inlined = 0;
+        async function worker() {
+          while (queue.length) {
+            const f = queue.shift();
+            const single = await uploadFile({
+              filePath: f.abs,
+              apiKey: opts.apiKey,
+              apiBase: opts.apiBase,
+              ttl: opts.ttl,
+              roots: [resolved.root],
+              fetchImpl: opts.fetchImpl,
+              cacheFile: opts.cacheFile,
+              mode: entry.mode
+            });
+            if (single && single._inline) {
+              const k = dedupKey(single);
+              if (seen.has(k)) {
+                skipped += 1;
+                continue;
+              }
+              seen.add(k);
+              inlined += 1;
+              refs.push({
+                inline_text: single.inline_text,
+                inline_filename: single.inline_filename,
+                sourcePath: single._sourcePath,
+                sourceRoot: single._sourceRoot
+              });
+              continue;
+            }
+            if (!isNonEmptyString(single && single.id)) continue;
+            if (seen.has(single._cacheKey)) {
+              skipped += 1;
+              continue;
+            }
+            seen.add(single._cacheKey);
+            if (single._fromCache) cached += 1;
+            else {
+              uploaded += 1;
+              ownedIds.push(single.id);
+            }
+            refs.push({
+              file_id: single.id,
+              sourcePath: single._sourcePath,
+              sourceRoot: single._sourceRoot,
+              sourceCacheKey: single._cacheKey
+            });
+          }
+        }
+        const N = Math.max(1, Math.min(DIR_UPLOAD_CONCURRENCY, walked.length));
+        await Promise.all(Array.from({ length: N }, () => worker()));
+        process.stderr.write(`[grok] ${opts.cid || "-"} expanded dir=${entry.dir} count=${walked.length} cached=${cached} uploaded=${uploaded} inlined=${inlined} skipped=${skipped}
+`);
+      }
+      for (const entry of files || []) {
+        if (entry.file_id) refs.push({ file_id: entry.file_id, sourcePath: null, sourceRoot: null });
+        else if (entry.file_url) refs.push({ file_url: entry.file_url, sourcePath: null, sourceRoot: null });
+        else if (entry.path) await handlePath(entry);
+        else if (entry.dir) await handleDir(entry);
+      }
+      return { refs, ownedIds };
+    }
+    async function runGrok({ turns, model, timeoutMs, apiKey, apiBase, fetchImpl, reasoningEffort }) {
+      if (!isNonEmptyString(apiKey)) {
+        const e = new Error("XAI_API_KEY is not set. Export it (export XAI_API_KEY=xai-...) or rerun /deliberation:setup.");
+        e.code = "missing-auth";
+        throw e;
+      }
+      const f = fetchImpl || globalThis.fetch;
+      if (typeof f !== "function") {
+        const e = new Error("global fetch is unavailable; Node 18+ is required for the Grok bridge.");
+        e.code = "network";
+        throw e;
+      }
+      const base = (apiBase || DEFAULT_API_BASE).replace(/\/+$/, "");
+      const url = `${base}/responses`;
+      const payload = { model: model || DEFAULT_MODEL, input: turnsToInput(turns), stream: false };
+      if (isNonEmptyString(reasoningEffort)) payload.reasoning_effort = reasoningEffort;
+      const t = typeof timeoutMs === "number" && timeoutMs > 0 ? timeoutMs : DEFAULT_TIMEOUT_MS;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), t);
+      let res;
+      try {
+        res = await f(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${apiKey}`
+          },
+          body: JSON.stringify(payload),
+          signal: controller.signal
+        });
+      } catch (err) {
+        const name = err && err.name;
+        const msg = String(err && err.message || err);
+        if (name === "AbortError" || /abort/i.test(msg)) {
+          const e2 = new Error(`Grok timed out after ${Math.round(t / 1e3)}s`);
+          e2.code = "timeout";
+          throw e2;
+        }
+        const e = new Error(`Network error: ${msg}`);
+        e.code = "network";
+        throw e;
+      } finally {
+        clearTimeout(timer);
+      }
+      let bodyText = "";
+      try {
+        bodyText = await res.text();
+      } catch (_) {
+        bodyText = "";
+      }
+      if (!res.ok) {
+        const e = new Error(`xAI API error ${res.status}: ${truncate(bodyText, 500)}`);
+        e.status = res.status;
+        throw e;
+      }
+      let data;
+      try {
+        data = JSON.parse(bodyText);
+      } catch (e2) {
+        const e = new Error(`Parse error: invalid JSON body: ${e2.message}`);
+        e.code = "parse";
+        throw e;
+      }
+      const text = parseResponsesOutput(data);
+      return { text, output: Array.isArray(data.output) ? data.output : null };
+    }
+    var STALE_FILE_ID_TEST = /file[-_][A-Za-z0-9_-]+/;
+    var STALE_FILE_ID_EXTRACT = /file[-_][A-Za-z0-9_-]+/g;
+    function isStaleFileError(err) {
+      if (!err) return false;
+      const msg = String(err.message || "");
+      if (!STALE_FILE_ID_TEST.test(msg)) return false;
+      if (err.status && err.status >= 400 && err.status < 500) return true;
+      return /invalid|not found|missing|expired/i.test(msg);
+    }
+    async function runWithFiles(args) {
+      const { refs, ownedIds } = await resolveFiles(args.files, args);
+      const developerInstructions = args["developer-instructions"];
+      const prompt = args.prompt;
+      const priorTurns = args.priorTurns || null;
+      function buildTurns(currentRefs) {
+        if (priorTurns) {
+          return [...priorTurns, { role: "user", text: prompt, fileRefs: currentRefs }];
+        }
+        return buildInitialTurns(developerInstructions, prompt, currentRefs);
+      }
+      async function attempt(currentTurns) {
+        return runGrok({
+          turns: currentTurns,
+          apiKey: args.apiKey,
+          apiBase: args.apiBase,
+          fetchImpl: args.fetchImpl,
+          timeoutMs: args.timeout,
+          model: args.model,
+          reasoningEffort: args.reasoningEffort
+        });
+      }
+      try {
+        const out = await attempt(buildTurns(refs));
+        return { text: out.text, output: out.output, refs, ownedIds };
+      } catch (e) {
+        if (!isStaleFileError(e)) throw e;
+        const matches = (e.message || "").match(STALE_FILE_ID_EXTRACT) || [];
+        const matchingRefs = refs.filter((r) => r.sourcePath && matches.includes(r.file_id));
+        if (matchingRefs.length === 0) throw e;
+        const cacheMod = require_cache();
+        if (args.cacheFile) {
+          for (const r of matchingRefs) {
+            await cacheMod.evict(args.cacheFile, r.file_id);
+          }
+        }
+        for (let i = 0; i < refs.length; i++) {
+          const r = refs[i];
+          if (!matchingRefs.includes(r)) continue;
+          const reuploaded = await uploadFile({
+            filePath: r.sourcePath,
+            apiKey: args.apiKey,
+            apiBase: args.apiBase,
+            ttl: args.ttl || FILE_TTL_SECONDS,
+            roots: [r.sourceRoot],
+            cacheFile: args.cacheFile,
+            fetchImpl: args.fetchImpl
+          });
+          refs[i] = {
+            ...r,
+            file_id: reuploaded.id,
+            sourceCacheKey: reuploaded._cacheKey
+          };
+          if (!reuploaded._fromCache) ownedIds.push(reuploaded.id);
+        }
+        const out = await attempt(buildTurns(refs));
+        return { text: out.text, output: out.output, refs, ownedIds };
+      }
+    }
+    function validateRoots(roots) {
+      const fsx = require("node:fs");
+      if (!Array.isArray(roots) || roots.length === 0) {
+        throw new Error("'roots' must be a non-empty array of absolute directory paths");
+      }
+      for (const r of roots) {
+        if (typeof r !== "string" || r.length === 0) {
+          throw new Error("'roots' entries must be non-empty strings");
+        }
+        if (!path.isAbsolute(r)) {
+          throw new Error(`'roots' entry "${r}" must be an absolute path`);
+        }
+        let st;
+        try {
+          st = fsx.statSync(r);
+        } catch (e) {
+          throw new Error(`'roots' entry "${r}" does not exist: ${e.message}`);
+        }
+        if (!st.isDirectory()) {
+          throw new Error(`'roots' entry "${r}" is not a directory`);
+        }
+      }
+    }
+    function resolvePathUnderRoots(p, roots, type) {
+      const fsx = require("node:fs");
+      const isAbs = path.isAbsolute(p);
+      for (const root of roots) {
+        const abs = isAbs ? p : path.join(root, p);
+        let realRoot, realAbs;
+        try {
+          realRoot = fsx.realpathSync(root);
+        } catch (_) {
+          continue;
+        }
+        try {
+          realAbs = fsx.realpathSync(abs);
+        } catch (_) {
+          continue;
+        }
+        const rel = path.relative(realRoot, realAbs);
+        if (rel !== "" && (rel.startsWith("..") || path.isAbsolute(rel))) continue;
+        let st;
+        try {
+          st = fsx.statSync(realAbs);
+        } catch (_) {
+          continue;
+        }
+        if (type === "file") {
+          if (!st.isFile()) continue;
+          return { root: realRoot, abs: realAbs, size: st.size };
+        }
+        if (type === "dir") {
+          if (!st.isDirectory()) continue;
+          return { root: realRoot, abs: realAbs, size: 0 };
+        }
+      }
+      if (isAbs) {
+        throw new Error(`"${p}" is outside all declared roots: ${roots.join(", ")}`);
+      }
+      throw new Error(`"${p}" not found in any root: ${roots.join(", ")}`);
+    }
+    var FILES_SCHEMA = {
+      type: "array",
+      description: "Optional files to attach. Each item has EXACTLY ONE of: path (local file; delivery controlled by mode = upload | inline | auto), file_id (an already-uploaded xAI file id), file_url (a public URL), or dir (recursive directory expansion; delivery controlled by mode). Optional filename overrides the stored upload name (applies only to path entries delivered via upload).",
+      items: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Local file path; bridge attaches it (resolved against roots[] or cwd). Delivery is controlled by mode: uploaded via the xAI Files API (default) or inlined as input_text." },
+          file_id: { type: "string", description: "Existing xAI file id" },
+          file_url: { type: "string", description: "Public URL to a file" },
+          dir: { type: "string", description: "Local directory to expand recursively (resolved against roots[] or cwd)" },
+          include: { type: "array", items: { type: "string" }, description: "POSIX glob patterns to include during dir expansion. Defaults to ['**/*']." },
+          exclude: { type: "array", items: { type: "string" }, description: "Additional POSIX glob patterns APPENDED to the bridge's safe defaults (.git, node_modules, .terraform, target, vendor, __pycache__, .yarn caches, *.tfstate, .env*, SSH keys, *.pem, *.key, framework build/cache dirs). To replace defaults entirely instead of appending, set excludeReset: true on the same dir entry." },
+          excludeReset: { type: "boolean", description: "If true, caller's exclude REPLACES bridge defaults. If omitted or false (default), caller's exclude is APPENDED to defaults. Use only when reviewing files defaults would block (e.g., Terraform state in a security audit, or *.pem certificates)." },
+          maxFiles: { type: "number", description: "Hard cap on files per dir expansion. Default 50." },
+          maxBytes: { type: "number", description: "Hard cap on bytes per dir expansion. Default 134217728 (128 MB)." },
+          filename: { type: "string", description: "Override stored filename for a path upload" },
+          mode: { type: "string", enum: ["auto", "inline", "upload"], default: "upload", description: "How to deliver this file to Grok. 'upload' (default) uses the xAI Files API (input_file); 'inline' embeds the file content directly as input_text (best for source code so Grok reads line-by-line); 'auto' inlines when the file is probably text and <= GROK_INLINE_MAX_BYTES (default 256 KB), otherwise uploads. For {dir} entries the mode is inherited by every walked file. Must NOT be set on file_id/file_url entries (those bypass the upload path; setting mode there returns -32602)." }
+        }
+      }
+    };
+    var GROK_PROPERTIES = {
+      prompt: { type: "string", description: "The delegation prompt" },
+      "developer-instructions": { type: "string", description: "Expert system instructions (sent as a system message)" },
+      model: { type: "string", description: "xAI model id. Defaults to GROK_DEFAULT_MODEL or grok-4.3.", default: DEFAULT_MODEL },
+      reasoning_effort: { type: "string", description: "Reasoning effort (low, medium, high). 'none' omits the field.", default: DEFAULT_REASONING_EFFORT },
+      timeout: { type: "number", description: "Soft timeout in ms. 1..600000. Default 180000.", default: DEFAULT_TIMEOUT_MS },
+      files: FILES_SCHEMA,
+      roots: { type: "array", items: { type: "string" }, description: "Optional absolute directory roots for resolving files[].path and files[].dir. Defaults to [cwd]." },
+      sandbox: { type: "string", enum: ["read-only", "workspace-write"], default: "read-only", description: "Accepted for call-shape parity; ignored." },
+      cwd: { type: "string", description: "Base dir for resolving relative paths. Defaults to server cwd." }
+    };
+    function validateFiles(files) {
+      if (files === void 0) return null;
+      if (!Array.isArray(files)) return "'files' must be an array when provided";
+      for (const entry of files) {
+        if (!isObject(entry)) return "each 'files' entry must be an object";
+        const keys = ["path", "file_id", "file_url", "dir"].filter((k) => entry[k] !== void 0);
+        if (keys.length !== 1) return "each 'files' entry needs exactly one of path, file_id, file_url, or dir";
+        if (!isNonEmptyString(entry[keys[0]])) return `'files' entry ${keys[0]} must be a non-empty string`;
+        if (entry.filename !== void 0 && !isNonEmptyString(entry.filename)) return "'files' entry filename must be a non-empty string when provided";
+        if (entry.mode !== void 0) {
+          if (typeof entry.mode !== "string") return "'files' entry mode must be a string when provided";
+          if (!["auto", "inline", "upload"].includes(entry.mode)) return `'files' entry mode "${entry.mode}" must be one of: auto, inline, upload`;
+          if (entry.file_id !== void 0 || entry.file_url !== void 0) return "'files' entry mode applies only to path/dir entries (not file_id/file_url)";
+        }
+        if (entry.excludeReset !== void 0 && typeof entry.excludeReset !== "boolean") {
+          return "'excludeReset' must be a boolean";
+        }
+        if (entry.dir !== void 0) {
+          for (const list of [entry.include, entry.exclude]) {
+            if (list === void 0) continue;
+            if (!Array.isArray(list)) return "'files' entry include/exclude must be arrays";
+            for (const p of list) {
+              if (typeof p !== "string" || p.length === 0) return "include/exclude patterns must be non-empty strings";
+              if (p.includes("\\")) return `glob pattern "${p}" contains backslashes; v1 patterns are POSIX-only (use /)`;
+            }
+          }
+          if (entry.maxFiles !== void 0 && (typeof entry.maxFiles !== "number" || entry.maxFiles <= 0)) return "'maxFiles' must be a positive number";
+          if (entry.maxBytes !== void 0 && (typeof entry.maxBytes !== "number" || entry.maxBytes <= 0)) return "'maxBytes' must be a positive number";
+        }
+      }
+      return null;
+    }
+    var handlers = {
+      "initialize": (id, _params, shouldRespond) => {
+        if (!shouldRespond) return;
+        sendResponse(id, {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: { name: "deliberation-grok", version: "1.8.0" }
+        });
+      },
+      "tools/list": (id, _params, shouldRespond) => {
+        if (!shouldRespond) return;
+        sendResponse(id, {
+          tools: [
+            {
+              name: "grok",
+              description: "Start a new Grok (xAI) expert session. Advisory only (no filesystem editing). Supports attaching files.",
+              inputSchema: { type: "object", properties: GROK_PROPERTIES, required: ["prompt"] }
+            },
+            {
+              name: "grok-reply",
+              description: "Continue an existing Grok session (in-memory; lost if the MCP server restarts).",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  threadId: { type: "string", description: "Session ID returned by a previous grok call" },
+                  prompt: { type: "string", description: "Follow-up prompt" },
+                  files: FILES_SCHEMA,
+                  roots: { type: "array", items: { type: "string" }, description: "Optional absolute directory roots for resolving files[].path and files[].dir." },
+                  model: { type: "string", default: DEFAULT_MODEL },
+                  reasoning_effort: { type: "string", default: DEFAULT_REASONING_EFFORT, description: "Reasoning effort; defaults to GROK_REASONING_EFFORT or high. Use 'none' to omit." },
+                  timeout: { type: "number", default: DEFAULT_TIMEOUT_MS },
+                  cwd: { type: "string", description: "Base directory for relative file path uploads" }
+                },
+                required: ["threadId", "prompt"]
+              }
+            }
+          ]
+        });
+      },
+      "tools/call": async (id, params, shouldRespond) => {
+        if (!isObject(params)) {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: expected an object");
+          return;
+        }
+        const { name, arguments: args } = params;
+        if (!isNonEmptyString(name)) {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: 'name' must be a non-empty string");
+          return;
+        }
+        if (!isObject(args)) {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: 'arguments' must be an object");
+          return;
+        }
+        if (args.sandbox !== void 0 && !VALID_SANDBOX_VALUES.has(args.sandbox)) {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: 'sandbox' must be 'read-only' or 'workspace-write'");
+          return;
+        }
+        if (args.cwd !== void 0 && !isNonEmptyString(args.cwd)) {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: 'cwd' must be a non-empty string when provided");
+          return;
+        }
+        if (args.model !== void 0 && !isNonEmptyString(args.model)) {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: 'model' must be a non-empty string when provided");
+          return;
+        }
+        if (args.reasoning_effort !== void 0 && typeof args.reasoning_effort !== "string") {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: 'reasoning_effort' must be a string when provided");
+          return;
+        }
+        if (args.timeout !== void 0) {
+          if (typeof args.timeout !== "number" || !Number.isFinite(args.timeout) || args.timeout <= 0 || args.timeout > MAX_MS) {
+            if (shouldRespond) sendError(id, -32602, "Invalid params: 'timeout' must be a number > 0 and <= 600000 milliseconds");
+            return;
+          }
+        }
+        const filesErr = validateFiles(args.files);
+        if (filesErr) {
+          if (shouldRespond) sendError(id, -32602, `Invalid params: ${filesErr}`);
+          return;
+        }
+        if (!isNonEmptyString(args.prompt)) {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: 'prompt' is required");
+          return;
+        }
+        let priorTurns = null;
+        let threadId;
+        if (name === "grok") {
+          if (args["developer-instructions"] !== void 0 && typeof args["developer-instructions"] !== "string") {
+            if (shouldRespond) sendError(id, -32602, "Invalid params: 'developer-instructions' must be a string when provided");
+            return;
+          }
+          threadId = crypto.randomUUID();
+        } else if (name === "grok-reply") {
+          if (!isNonEmptyString(args.threadId)) {
+            if (shouldRespond) sendError(id, -32602, "Invalid params: 'threadId' is required for grok-reply");
+            return;
+          }
+          threadId = args.threadId.trim();
+          priorTurns = sessions.get(threadId);
+          if (!priorTurns) {
+            const { errorKind, retryable } = classifyGrokError(null, "unknown-thread");
+            logCall(id != null ? id : threadId, "grok-reply", errorKind, 0);
+            if (shouldRespond) {
+              sendResponse(id, {
+                content: [{ type: "text", text: `Error: unknown threadId "${threadId}". Start a fresh grok call (in-memory sessions do not survive an MCP restart).` }],
+                isError: true,
+                errorKind,
+                retryable
+              });
+            }
+            return;
+          }
+        } else {
+          if (shouldRespond) sendError(id, -32601, `Tool not found: ${name}`);
+          return;
+        }
+        const startedAt = Date.now();
+        let outcome = "ok";
+        try {
+          let rootList;
+          if (Array.isArray(args.roots) && args.roots.length) {
+            try {
+              validateRoots(args.roots);
+            } catch (e) {
+              if (shouldRespond) sendError(id, -32602, `Invalid params: ${e.message}`);
+              return;
+            }
+            rootList = args.roots;
+          } else {
+            rootList = [require("node:fs").realpathSync(args.cwd || process.cwd())];
+          }
+          const out = await runWithFiles({
+            prompt: args.prompt,
+            "developer-instructions": args["developer-instructions"],
+            files: args.files,
+            priorTurns: priorTurns || null,
+            apiKey: process.env.XAI_API_KEY,
+            apiBase: DEFAULT_API_BASE,
+            ttl: FILE_TTL_SECONDS,
+            roots: rootList,
+            cwd: args.cwd,
+            cacheFile: process.env.XAI_DISABLE_FILE_CACHE ? null : DEFAULT_CACHE_FILE,
+            model: args.model,
+            reasoningEffort: resolveReasoningEffort(args.reasoning_effort),
+            timeout: args.timeout,
+            cid: id
+          });
+          const turnsForPersist = priorTurns ? [...priorTurns, { role: "user", text: args.prompt, fileRefs: out.refs }] : buildInitialTurns(args["developer-instructions"], args.prompt, out.refs);
+          sessions.set(threadId, [...turnsForPersist, { role: "assistant", text: out.text, items: out.output || void 0 }]);
+          if (shouldRespond) {
+            const result = { content: [{ type: "text", text: out.text }], threadId };
+            if (out.ownedIds.length) result.uploadedFileIds = out.ownedIds;
+            sendResponse(id, result);
+          }
+        } catch (e) {
+          const errMsg = e && e.message || String(e);
+          const { errorKind, retryable } = classifyGrokError(e && e.status, e && e.code);
+          outcome = errorKind;
+          if (shouldRespond) {
+            sendResponse(id, {
+              content: [{ type: "text", text: `Error: ${errMsg}` }],
+              isError: true,
+              errorKind,
+              retryable
+            });
+          }
+        } finally {
+          const cid = id != null ? id : threadId != null ? threadId : "-";
+          const toolName = isNonEmptyString(name) ? name : "unknown";
+          logCall(cid, toolName, outcome, Date.now() - startedAt);
+        }
+      },
+      "notifications/initialized": () => {
+      }
+    };
+    async function processLine(line) {
+      if (!line.trim()) return;
+      let request;
+      try {
+        request = JSON.parse(line);
+      } catch (e) {
+        return;
+      }
+      const shouldRespond = hasRequestId(request);
+      if (!isObject(request) || typeof request.method !== "string") {
+        if (shouldRespond) sendError(request.id, -32600, "Invalid Request");
+        return;
+      }
+      const handler = handlers[request.method];
+      if (!handler) {
+        if (shouldRespond) sendError(request.id, -32601, `Method not found: ${request.method}`);
+        return;
+      }
+      try {
+        await handler(request.id, request.params, shouldRespond);
+      } catch (e) {
+        if (shouldRespond) sendError(request.id, -32603, `Internal error: ${e.message}`);
+      }
+    }
+    if (require.main === module2) {
+      let buffer = "";
+      const enqueue = (line) => {
+        void processLine(line);
+      };
+      process.stdin.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop();
+        for (const line of lines) enqueue(line);
+      });
+      process.stdin.on("end", () => {
+        if (buffer) {
+          enqueue(buffer);
+          buffer = "";
+        }
+      });
+      if (typeof globalThis.fetch !== "function") {
+        console.error("Grok bridge requires Node 18+ (global fetch unavailable).");
+        process.exit(1);
+      }
+      if (!isNonEmptyString(process.env.XAI_API_KEY)) {
+        console.error("[deliberation] warning: XAI_API_KEY is not set; grok calls will return errorKind:missing-auth until it is.");
+      }
+    }
+    if (typeof module2 !== "undefined" && module2.exports) {
+      module2.exports.classifyGrokError = classifyGrokError;
+      module2.exports.resolveReasoningEffort = resolveReasoningEffort;
+      module2.exports.buildInitialTurns = buildInitialTurns;
+      module2.exports.turnsToInput = turnsToInput;
+      module2.exports.parseResponsesOutput = parseResponsesOutput;
+      module2.exports.runGrok = runGrok;
+      module2.exports.runWithFiles = runWithFiles;
+      module2.exports.uploadFile = uploadFile;
+      module2.exports.resolveFiles = resolveFiles;
+      module2.exports.validateFiles = validateFiles;
+      module2.exports.FILE_PREFIX = FILE_PREFIX;
+      module2.exports.FILE_TTL_SECONDS = FILE_TTL_SECONDS;
+    }
+    module2.exports.validateRoots = validateRoots;
+    module2.exports.resolvePathUnderRoots = resolvePathUnderRoots;
+  }
+});
+
+// ../../core/providers/grok.js
+var require_grok2 = __commonJS({
+  "../../core/providers/grok.js"(exports2, module2) {
+    "use strict";
+    var { toErrorResult } = require_provider();
+    function makeGrokProvider(opts = {}) {
+      const bridge = (
+        /** @type {any} */
+        opts.bridge || require_grok()
+      );
+      const model = opts.model || process.env.GROK_DEFAULT_MODEL || "grok-4.3";
+      const apiBase = opts.apiBase || process.env.XAI_API_BASE || "https://api.x.ai/v1";
+      return {
+        name: "grok",
+        // multiTurn is not wired through Core (runGrok/runWithFiles return no threadId),
+        // so report false to match reality.
+        capabilities: { canImplement: false, fileUpload: true, multiTurn: false },
+        async health() {
+          return process.env.XAI_API_KEY ? { ok: true } : { ok: false, reason: "XAI_API_KEY unset" };
+        },
+        async ask(req) {
+          const started = Date.now();
+          const reasoningEffort = bridge.resolveReasoningEffort(req.reasoningEffort);
+          const apiKey = process.env.XAI_API_KEY;
+          try {
+            const out = req.files && req.files.length ? await bridge.runWithFiles({
+              files: req.files,
+              prompt: req.prompt,
+              "developer-instructions": req.developerInstructions,
+              apiKey,
+              apiBase,
+              model,
+              reasoningEffort,
+              timeout: req.timeoutMs,
+              cwd: req.cwd
+            }) : await bridge.runGrok({
+              turns: bridge.buildInitialTurns(req.developerInstructions, req.prompt, []),
+              model,
+              apiKey,
+              apiBase,
+              reasoningEffort,
+              timeoutMs: req.timeoutMs
+            });
+            return { provider: "grok", model, text: out.text || "", isError: false, ms: Date.now() - started };
+          } catch (e) {
+            return toErrorResult(
+              "grok",
+              model,
+              started,
+              /** @type {any} */
+              e,
+              bridge.classifyGrokError
+            );
+          }
+        }
+      };
+    }
+    module2.exports = { makeGrokProvider };
+  }
+});
+
+// ../gemini/index.js
+var require_gemini = __commonJS({
+  "../gemini/index.js"(exports2, module2) {
+    "use strict";
+    var { spawn, execFileSync } = require("node:child_process");
+    var fs = require("node:fs");
+    var os = require("node:os");
+    var path = require("node:path");
+    var AGY_BIN = process.env.AGY_BIN || "agy";
+    var DEFAULT_MODEL = process.env.GEMINI_DEFAULT_MODEL || "auto-gemini-3";
+    var DEFAULT_TIMEOUT_MS = 3e5;
+    var DEFAULT_RECOVERY_GRACE_MS = 12e4;
+    var MAX_MS = 6e5;
+    var VALID_SANDBOX_VALUES = /* @__PURE__ */ new Set(["read-only", "workspace-write"]);
+    function goDuration(ms) {
+      return Math.ceil(ms / 1e3) + "s";
+    }
+    function buildAgyArgs(req) {
+      const args = [];
+      if (req.sandbox === "workspace-write") args.push("--dangerously-skip-permissions");
+      else args.push("--sandbox");
+      for (const d of req.includeDirs || []) args.push("--add-dir", d);
+      let prompt = req.prompt;
+      if (req.developerInstructions) prompt = `${req.developerInstructions}
+
+${prompt}`;
+      args.push("-p", prompt);
+      return args;
+    }
+    function sendResponse(id, result) {
+      process.stdout.write(JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        result
+      }) + "\n");
+    }
+    function sendError(id, code, message) {
+      process.stdout.write(JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        error: { code, message }
+      }) + "\n");
+    }
+    function isObject(value) {
+      return value !== null && typeof value === "object" && !Array.isArray(value);
+    }
+    function hasRequestId(request) {
+      return isObject(request) && Object.prototype.hasOwnProperty.call(request, "id");
+    }
+    function isNonEmptyString(value) {
+      return typeof value === "string" && value.trim().length > 0;
+    }
+    function stdoutIsError(s) {
+      return /^\s*Error:\s/m.test(s);
+    }
+    function classifyGeminiError(errMsg, errCode) {
+      const msg = String(errMsg || "");
+      const lower = msg.toLowerCase();
+      if (errCode === "timeout") return { errorKind: "timeout", retryable: true };
+      if (errCode === "parse") return { errorKind: "parse", retryable: false };
+      if (msg.includes("(agy) not found")) return { errorKind: "missing-cli", retryable: false };
+      if (lower.includes("aborterror") || lower.includes("aborted")) {
+        return { errorKind: "upstream-abort", retryable: true };
+      }
+      return { errorKind: "unknown", retryable: false };
+    }
+    function resolveConversationId(cwd) {
+      try {
+        const mapPath = process.env.AGY_LAST_CONVERSATIONS || path.join(os.homedir(), ".gemini", "antigravity-cli", "cache", "last_conversations.json");
+        const map = JSON.parse(fs.readFileSync(mapPath, "utf8"));
+        if (!map || typeof map !== "object") return null;
+        const resolved = path.resolve(cwd);
+        let real = resolved;
+        try {
+          real = fs.realpathSync(resolved);
+        } catch (_) {
+        }
+        return map[real] ?? map[resolved] ?? map[cwd] ?? null;
+      } catch (_) {
+        return null;
+      }
+    }
+    async function runGemini(args, cwd, timeoutMs, recoveryGraceMs) {
+      return new Promise((resolve, reject) => {
+        const t = typeof timeoutMs === "number" && timeoutMs > 0 ? timeoutMs : DEFAULT_TIMEOUT_MS;
+        const effCwd = cwd || process.cwd();
+        const spawnStartMs = Date.now();
+        const disableRecovery = process.env.GEMINI_DISABLE_TIMEOUT_RECOVERY === "1";
+        const grace = disableRecovery ? 0 : typeof recoveryGraceMs === "number" && recoveryGraceMs >= 0 ? recoveryGraceMs : DEFAULT_RECOVERY_GRACE_MS;
+        let killed = false;
+        let draining = false;
+        let settled = false;
+        let graceTimer = null;
+        const ptIdx = args.lastIndexOf("-p");
+        const head = ptIdx >= 0 ? args.slice(0, ptIdx) : args;
+        const tail = ptIdx >= 0 ? args.slice(ptIdx) : [];
+        const agyArgs = [...head, "--print-timeout", goDuration(t + grace + 3e4), ...tail];
+        const agyProcess = spawn(AGY_BIN, agyArgs, {
+          env: process.env,
+          shell: false,
+          cwd: effCwd,
+          // agy -p (print mode) waits for stdin EOF before returning; if the stdin
+          // pipe is left open it hangs until the timeout. Give it /dev/null so it
+          // sees EOF immediately and runs to completion.
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        function clearTimers() {
+          clearTimeout(killTimer);
+          if (graceTimer) clearTimeout(graceTimer);
+        }
+        function destroyStreams() {
+          try {
+            agyProcess.stdout.destroy();
+          } catch (_) {
+          }
+          try {
+            agyProcess.stderr.destroy();
+          } catch (_) {
+          }
+        }
+        function timeoutError() {
+          const tail2 = stderr && stderr.trim() ? "; last agy stderr: " + stderr.trim().slice(-500) : "";
+          const err = new Error("Gemini (agy) timed out after " + Math.round(t / 1e3) + "s" + tail2);
+          err.code = "timeout";
+          return err;
+        }
+        function finishTimeout() {
+          if (settled) return;
+          settled = true;
+          clearTimers();
+          try {
+            agyProcess.kill("SIGTERM");
+          } catch (_) {
+          }
+          setTimeout(() => {
+            try {
+              agyProcess.kill("SIGKILL");
+            } catch (_) {
+            }
+          }, 1e3);
+          destroyStreams();
+          reject(timeoutError());
+        }
+        const killTimer = setTimeout(() => {
+          if (settled) return;
+          if (grace > 0) {
+            draining = true;
+            graceTimer = setTimeout(() => finishTimeout(), grace);
+            return;
+          }
+          killed = true;
+          try {
+            agyProcess.kill("SIGTERM");
+          } catch (_) {
+          }
+          graceTimer = setTimeout(() => {
+            try {
+              agyProcess.kill("SIGKILL");
+            } catch (_) {
+            }
+          }, 1e3);
+        }, t);
+        agyProcess.on("close", clearTimers);
+        agyProcess.on("error", clearTimers);
+        agyProcess.on("exit", () => {
+          if (killed && !settled) {
+            settled = true;
+            clearTimers();
+            destroyStreams();
+            reject(timeoutError());
+          }
+        });
+        let stdout = "";
+        let stderr = "";
+        agyProcess.on("error", (err) => {
+          if (settled) return;
+          settled = true;
+          if (err.code === "ENOENT") {
+            reject(new Error("Antigravity CLI (agy) not found. Install from https://antigravity.google and run `agy` once to sign in."));
+          } else {
+            reject(err);
+          }
+        });
+        agyProcess.stdout.on("data", (data) => {
+          stdout += data.toString();
+        });
+        agyProcess.stderr.on("data", (data) => {
+          stderr += data.toString();
+        });
+        agyProcess.on("close", (code) => {
+          if (settled) return;
+          if (killed) {
+            settled = true;
+            clearTimers();
+            return reject(timeoutError());
+          }
+          const out = stdout.trim();
+          const trimmedErr = stderr.trim();
+          const success = code === 0 && out && !stdoutIsError(out);
+          if (draining) {
+            if (success) {
+              settled = true;
+              clearTimers();
+              process.stderr.write(
+                "[deliberation] recovered agy answer via stdout drain after soft timeout (" + Math.round((Date.now() - spawnStartMs) / 1e3) + "s)\n"
+              );
+              return resolve({ response: out, threadId: resolveConversationId(effCwd) || "unknown", recovered: true });
+            }
+            return finishTimeout();
+          }
+          settled = true;
+          clearTimers();
+          if (success) {
+            const threadId = resolveConversationId(effCwd);
+            if (threadId == null) {
+              process.stderr.write(
+                "[deliberation] no conversation id found for cwd " + effCwd + '; returning threadId:"unknown" (resume will be unavailable)\n'
+              );
+            }
+            return resolve({ response: out, threadId: threadId || "unknown" });
+          }
+          let message;
+          if (trimmedErr) message = trimmedErr;
+          else if (stdoutIsError(out)) message = out;
+          else if (!out) message = `No output from agy`;
+          else message = `agy exited with code ${code}`;
+          const err = new Error(message);
+          if (/timed out/i.test(message)) {
+            err.code = "timeout";
+          } else if (!trimmedErr && !out) {
+            err.code = "parse";
+          }
+          reject(err);
+        });
+      });
+    }
+    var handlers = {
+      "initialize": (id, _params, shouldRespond) => {
+        if (!shouldRespond) return;
+        sendResponse(id, {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: { name: "deliberation-gemini", version: "1.6.0" }
+        });
+      },
+      "tools/list": (id, _params, shouldRespond) => {
+        if (!shouldRespond) return;
+        sendResponse(id, {
+          tools: [
+            {
+              name: "gemini",
+              description: "Start a new Gemini expert session",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  prompt: { type: "string", description: "The delegation prompt" },
+                  "developer-instructions": { type: "string", description: "Expert system instructions" },
+                  sandbox: { type: "string", enum: ["read-only", "workspace-write"], default: "read-only" },
+                  cwd: { type: "string", description: "Current working directory" },
+                  model: { type: "string", default: DEFAULT_MODEL, description: "Advisory only; agy reads the model from ~/.gemini/settings.json (default auto-gemini-3)." },
+                  "include-directories": {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Additional workspace dirs; maps to repeated --add-dir on the Antigravity CLI (agy)."
+                  },
+                  timeout: { type: "number", description: "Soft timeout in ms. 1..600000. Default 300000. On expiry the bridge drains the streamed stdout and recovers a late answer instead of failing.", default: DEFAULT_TIMEOUT_MS },
+                  "recovery-grace": { type: "number", description: "Extra ms to keep agy alive after the soft timeout to drain a late answer from streamed stdout. 0..600000. Default 120000. 0 disables drain.", default: DEFAULT_RECOVERY_GRACE_MS }
+                },
+                required: ["prompt"]
+              }
+            },
+            {
+              name: "gemini-reply",
+              description: "Continue an existing Gemini session",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  threadId: { type: "string", description: "Conversation ID returned by a previous gemini call" },
+                  prompt: { type: "string", description: "Follow-up prompt" },
+                  sandbox: { type: "string", enum: ["read-only", "workspace-write"], default: "read-only" },
+                  cwd: { type: "string" },
+                  "include-directories": {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Additional workspace dirs; maps to repeated --add-dir on the Antigravity CLI (agy)."
+                  },
+                  timeout: { type: "number", description: "Soft timeout in ms. 1..600000. Default 300000. On expiry the bridge drains the streamed stdout and recovers a late answer instead of failing.", default: DEFAULT_TIMEOUT_MS },
+                  "recovery-grace": { type: "number", description: "Extra ms to keep agy alive after the soft timeout to drain a late answer from streamed stdout. 0..600000. Default 120000. 0 disables drain.", default: DEFAULT_RECOVERY_GRACE_MS }
+                },
+                required: ["threadId", "prompt"]
+              }
+            }
+          ]
+        });
+      },
+      "tools/call": async (id, params, shouldRespond) => {
+        if (!isObject(params)) {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: expected an object");
+          return;
+        }
+        const { name, arguments: args } = params;
+        if (!isNonEmptyString(name)) {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: 'name' must be a non-empty string");
+          return;
+        }
+        if (!isObject(args)) {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: 'arguments' must be an object");
+          return;
+        }
+        if (args.sandbox !== void 0 && !VALID_SANDBOX_VALUES.has(args.sandbox)) {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: 'sandbox' must be 'read-only' or 'workspace-write'");
+          return;
+        }
+        if (args.cwd !== void 0 && !isNonEmptyString(args.cwd)) {
+          if (shouldRespond) sendError(id, -32602, "Invalid params: 'cwd' must be a non-empty string when provided");
+          return;
+        }
+        if (args.timeout !== void 0) {
+          if (typeof args.timeout !== "number" || !Number.isFinite(args.timeout) || args.timeout <= 0 || args.timeout > MAX_MS) {
+            if (shouldRespond) sendError(id, -32602, "Invalid params: 'timeout' must be a number > 0 and <= 600000 milliseconds");
+            return;
+          }
+        }
+        if (args["recovery-grace"] !== void 0) {
+          const g = args["recovery-grace"];
+          if (typeof g !== "number" || !Number.isFinite(g) || g < 0 || g > MAX_MS) {
+            if (shouldRespond) sendError(id, -32602, "Invalid params: 'recovery-grace' must be a number >= 0 and <= 600000 milliseconds");
+            return;
+          }
+        }
+        if (args["include-directories"] !== void 0) {
+          if (!Array.isArray(args["include-directories"]) || args["include-directories"].length === 0) {
+            if (shouldRespond) sendError(id, -32602, "Invalid params: 'include-directories' must be a non-empty array of strings when provided");
+            return;
+          }
+          for (const dir of args["include-directories"]) {
+            if (!isNonEmptyString(dir)) {
+              if (shouldRespond) sendError(id, -32602, "Invalid params: each entry in 'include-directories' must be a non-empty string");
+              return;
+            }
+          }
+        }
+        try {
+          const agyArgs = [];
+          const sandboxFlags = [];
+          if (args.sandbox === "workspace-write") sandboxFlags.push("--dangerously-skip-permissions");
+          else sandboxFlags.push("--sandbox");
+          const addDirFlags = [];
+          if (args["include-directories"]) {
+            for (const dir of args["include-directories"]) addDirFlags.push("--add-dir", dir);
+          }
+          if (name === "gemini") {
+            if (args.model !== void 0 && !isNonEmptyString(args.model)) {
+              if (shouldRespond) sendError(id, -32602, "Invalid params: 'model' must be a non-empty string when provided");
+              return;
+            }
+            if (!isNonEmptyString(args.prompt)) {
+              if (shouldRespond) sendError(id, -32602, "Invalid params: 'prompt' is required");
+              return;
+            }
+            if (args["developer-instructions"] !== void 0 && typeof args["developer-instructions"] !== "string") {
+              if (shouldRespond) sendError(id, -32602, "Invalid params: 'developer-instructions' must be a string when provided");
+              return;
+            }
+            agyArgs.push(...buildAgyArgs({
+              prompt: args.prompt,
+              model: args.model,
+              includeDirs: args["include-directories"],
+              sandbox: args.sandbox,
+              developerInstructions: args["developer-instructions"]
+            }));
+          } else if (name === "gemini-reply") {
+            if (!isNonEmptyString(args.threadId)) {
+              if (shouldRespond) sendError(id, -32602, "Invalid params: 'threadId' is required for gemini-reply");
+              return;
+            }
+            const threadId2 = args.threadId.trim();
+            if (threadId2 === "" || threadId2 === "latest" || threadId2 === "unknown") {
+              if (shouldRespond) sendError(id, -32602, "Invalid params: 'threadId' must be an explicit conversation id, not '" + threadId2 + "'");
+              return;
+            }
+            if (!isNonEmptyString(args.prompt)) {
+              if (shouldRespond) sendError(id, -32602, "Invalid params: 'prompt' is required");
+              return;
+            }
+            agyArgs.push("--conversation", threadId2, ...sandboxFlags, ...addDirFlags);
+            agyArgs.push("-p", args.prompt);
+          } else {
+            if (shouldRespond) sendError(id, -32601, `Tool not found: ${name}`);
+            return;
+          }
+          const timeoutMs = typeof args.timeout === "number" && args.timeout > 0 ? args.timeout : DEFAULT_TIMEOUT_MS;
+          const recoveryGraceMs = typeof args["recovery-grace"] === "number" && args["recovery-grace"] >= 0 ? args["recovery-grace"] : DEFAULT_RECOVERY_GRACE_MS;
+          const { response, threadId, recovered } = await runGemini(agyArgs, args.cwd, timeoutMs, recoveryGraceMs);
+          if (shouldRespond) {
+            sendResponse(id, {
+              content: [{ type: "text", text: response }],
+              threadId,
+              ...recovered ? { recovered: true } : {}
+            });
+          }
+        } catch (e) {
+          const errMsg = e && e.message || String(e);
+          const errCode = e && e.code;
+          const { errorKind, retryable } = classifyGeminiError(errMsg, errCode);
+          if (shouldRespond) {
+            sendResponse(id, {
+              content: [{ type: "text", text: `Error: ${errMsg}` }],
+              isError: true,
+              errorKind,
+              retryable
+            });
+          }
+        }
+      },
+      "notifications/initialized": () => {
+      }
+    };
+    var buffer = "";
+    async function processLine(line) {
+      if (!line.trim()) return;
+      let request;
+      try {
+        request = JSON.parse(line);
+      } catch (e) {
+        return;
+      }
+      const shouldRespond = hasRequestId(request);
+      if (!isObject(request) || typeof request.method !== "string") {
+        if (shouldRespond) sendError(request.id, -32600, "Invalid Request");
+        return;
+      }
+      const handler = handlers[request.method];
+      if (!handler) {
+        if (shouldRespond) sendError(request.id, -32601, `Method not found: ${request.method}`);
+        return;
+      }
+      try {
+        await handler(request.id, request.params, shouldRespond);
+      } catch (e) {
+        if (shouldRespond) sendError(request.id, -32603, `Internal error: ${e.message}`);
+      }
+    }
+    if (require.main === module2) {
+      process.stdin.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop();
+        for (const line of lines) void processLine(line);
+      });
+      try {
+        execFileSync(AGY_BIN, ["--help"], { stdio: "ignore" });
+      } catch (e) {
+        console.error("Antigravity CLI (agy) not found. Install from https://antigravity.google and run `agy` once to sign in.");
+        process.exit(1);
+      }
+    }
+    if (typeof module2 !== "undefined" && module2.exports) {
+      module2.exports.classifyGeminiError = classifyGeminiError;
+      module2.exports.resolveConversationId = resolveConversationId;
+      module2.exports.goDuration = goDuration;
+      module2.exports.stdoutIsError = stdoutIsError;
+      module2.exports.runGemini = runGemini;
+      module2.exports.buildAgyArgs = buildAgyArgs;
+    }
+  }
+});
+
+// ../../core/providers/antigravity.js
+var require_antigravity = __commonJS({
+  "../../core/providers/antigravity.js"(exports2, module2) {
+    "use strict";
+    var { toErrorResult } = require_provider();
+    function makeAntigravityProvider(opts = {}) {
+      const bridge = (
+        /** @type {any} */
+        opts.bridge || require_gemini()
+      );
+      const model = opts.model || process.env.GEMINI_DEFAULT_MODEL || "auto-gemini-3";
+      return {
+        name: "gemini",
+        capabilities: { canImplement: true, fileUpload: false, multiTurn: true },
+        async health() {
+          return typeof bridge.runGemini === "function" ? { ok: true } : { ok: false, reason: "agy bridge unavailable" };
+        },
+        async ask(req) {
+          const started = Date.now();
+          const args = bridge.buildAgyArgs({
+            prompt: req.prompt,
+            model,
+            sandbox: "read-only",
+            developerInstructions: req.developerInstructions,
+            includeDirs: (req.files || []).filter((f) => f.dir).map((f) => f.dir)
+          });
+          try {
+            const out = await bridge.runGemini(args, req.cwd, req.timeoutMs, void 0);
+            return { provider: "gemini", model, text: out.response || "", threadId: out.threadId, isError: false, ms: Date.now() - started };
+          } catch (e) {
+            const err = (
+              /** @type {any} */
+              e
+            );
+            return toErrorResult(
+              "gemini",
+              model,
+              started,
+              err,
+              (_status, code) => bridge.classifyGeminiError(err && err.message || "", code)
+            );
+          }
+        }
+      };
+    }
+    module2.exports = { makeAntigravityProvider };
+  }
+});
+
+// ../../core/providers/codex.js
+var require_codex = __commonJS({
+  "../../core/providers/codex.js"(exports2, module2) {
+    "use strict";
+    var { spawn } = require("node:child_process");
+    function classifyCodex(stderr) {
+      const s = (stderr || "").toLowerCase();
+      if (s.includes("auth") || s.includes("login")) return { errorKind: "auth", retryable: false };
+      if (s.includes("timeout")) return { errorKind: "timeout", retryable: true };
+      if (s.includes("rate")) return { errorKind: "rate-limit", retryable: true };
+      return { errorKind: "unknown", retryable: false };
+    }
+    function defaultRun({ prompt, cwd, timeoutMs }) {
+      return new Promise((resolve) => {
+        const child = spawn("codex", ["exec", "--skip-git-repo-check"], { cwd: cwd || process.cwd() });
+        let stdout = "", stderr = "", settled = false;
+        const timer = timeoutMs ? setTimeout(() => child.kill("SIGKILL"), timeoutMs) : null;
+        if (timer) timer.unref();
+        child.stdout.on("data", (d) => stdout += d);
+        child.stderr.on("data", (d) => stderr += d);
+        child.on("error", (e) => {
+          if (settled) return;
+          settled = true;
+          if (timer) clearTimeout(timer);
+          resolve({ code: 127, stdout: "", stderr: String(e && e.message || e) });
+        });
+        child.on("close", (code) => {
+          if (settled) return;
+          settled = true;
+          if (timer) clearTimeout(timer);
+          resolve({ code: code == null ? 1 : code, stdout, stderr });
+        });
+        child.stdin.end(prompt);
+      });
+    }
+    function makeCodexProvider(opts = {}) {
+      const run = opts.run || defaultRun;
+      const model = opts.model || "default";
+      return {
+        name: "codex",
+        capabilities: { canImplement: true, fileUpload: false, multiTurn: false },
+        // Option A: no threadId continuity
+        async health() {
+          return { ok: true };
+        },
+        async ask(req) {
+          const started = Date.now();
+          const full = req.developerInstructions ? `${req.developerInstructions}
+
+---
+
+${req.prompt}` : req.prompt;
+          const { code, stdout, stderr } = await run({ prompt: full, cwd: req.cwd, timeoutMs: req.timeoutMs });
+          if (code === 0) {
+            return { provider: "codex", model, text: stdout.trim(), isError: false, ms: Date.now() - started };
+          }
+          const { errorKind, retryable } = classifyCodex(stderr);
+          return {
+            provider: "codex",
+            model,
+            isError: true,
+            errorKind,
+            retryable,
+            // Error results carry no text; surface stdout/stderr diagnostics in message.
+            message: stdout && stdout.trim() || stderr || void 0,
+            ms: Date.now() - started
+          };
+        }
+      };
+    }
+    module2.exports = { makeCodexProvider, classifyCodex };
+  }
+});
+
+// index.js
+var { makeRegistry } = require_registry();
+var { askAll, askOne, consensus } = require_orchestrate();
+var ADVISORY = { readOnlyHint: true };
+var ASK_PROVIDER = { "ask-gpt": "codex", "ask-gemini": "gemini", "ask-grok": "grok", "ask-openrouter": "openrouter" };
+var EXPERTS = ["architect", "plan-reviewer", "scope-analyst", "code-reviewer", "security-analyst", "researcher", "debugger"];
+function inputSchema() {
+  return {
+    type: "object",
+    required: ["prompt"],
+    properties: {
+      prompt: { type: "string" },
+      expert: { type: "string" },
+      developerInstructions: { type: "string" },
+      cwd: { type: "string" },
+      reasoningEffort: { type: "string", enum: ["low", "medium", "high", "none"] }
+    }
+  };
+}
+function toolList() {
+  const tools = [
+    { name: "ask-all", description: "Fan out one question to all enabled providers in parallel (advisory).", inputSchema: inputSchema(), annotations: ADVISORY },
+    { name: "consensus", description: "Fan out then run one arbiter pass for a synthesized verdict (advisory).", inputSchema: inputSchema(), annotations: ADVISORY }
+  ];
+  for (const t of Object.keys(ASK_PROVIDER)) {
+    tools.push({ name: t, description: `Single-provider second opinion via ${ASK_PROVIDER[t]} (advisory).`, inputSchema: inputSchema(), annotations: ADVISORY });
+  }
+  for (const e of EXPERTS) {
+    tools.push({ name: e, description: `Direct ${e} expert (advisory).`, inputSchema: inputSchema(), annotations: ADVISORY });
+  }
+  return tools;
+}
+function buildServer({ providers, getConfig }) {
+  const registry = makeRegistry(providers);
+  async function call(name, args) {
+    const req = {
+      prompt: args.prompt,
+      expert: args.expert,
+      developerInstructions: args.developerInstructions,
+      cwd: args.cwd,
+      reasoningEffort: args.reasoningEffort,
+      files: args.files
+    };
+    if (name === "ask-all") {
+      const { providers: selected, omitted } = registry.selectForAskAll({ config: getConfig(), expert: req.expert || "" });
+      const results = await askAll(selected, req);
+      return { content: [{ type: "text", text: JSON.stringify({ results, omitted }) }] };
+    }
+    if (name === "consensus") {
+      const { providers: selected } = registry.selectForConsensus({ config: getConfig(), expert: req.expert || "" });
+      const out = await consensus(selected, req);
+      return { content: [{ type: "text", text: JSON.stringify(out) }] };
+    }
+    if (ASK_PROVIDER[name]) {
+      const p = registry.get(ASK_PROVIDER[name]);
+      if (!p) return { content: [{ type: "text", text: JSON.stringify({ error: `provider ${ASK_PROVIDER[name]} not registered` }) }] };
+      const result = await askOne(p, req);
+      return { content: [{ type: "text", text: JSON.stringify({ result }) }] };
+    }
+    if (EXPERTS.includes(name)) {
+      const { providers: selected } = registry.selectForAskAll({ config: getConfig(), expert: name });
+      const results = await askAll(selected, { ...req, expert: name });
+      return { content: [{ type: "text", text: JSON.stringify({ results }) }] };
+    }
+    throw new Error(`unknown tool: ${name}`);
+  }
+  async function handle(msg) {
+    try {
+      if (msg.method === "initialize") {
+        return { jsonrpc: "2.0", id: msg.id, result: { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "deliberation-mcp", version: "0.1.0" } } };
+      }
+      if (msg.method === "tools/list") return { jsonrpc: "2.0", id: msg.id, result: { tools: toolList() } };
+      if (msg.method === "tools/call") {
+        const result = await call(msg.params.name, msg.params.arguments || {});
+        return { jsonrpc: "2.0", id: msg.id, result };
+      }
+      return { jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: `method not found: ${msg.method}` } };
+    } catch (e) {
+      const err = (
+        /** @type {any} */
+        e
+      );
+      return { jsonrpc: "2.0", id: msg.id, error: { code: -32603, message: String(err && err.message || err) } };
+    }
+  }
+  return { handle, toolList };
+}
+function startStdio() {
+  const { makeOpenAICompatibleProvider } = require_openai_compatible();
+  const { makeGrokProvider } = require_grok2();
+  const { makeAntigravityProvider } = require_antigravity();
+  const { makeCodexProvider } = require_codex();
+  const configMod = (
+    /** @type {any} */
+    require_config()
+  );
+  const { makeConfigReader, DEFAULT_API_BASE, DEFAULT_API_KEY_ENV } = configMod;
+  const reader = makeConfigReader(require_paths().resolveConfigPath());
+  const getConfig = () => reader.get().resolved || { providers: {}, openrouter: {} };
+  const initialOr = getConfig().openrouter || {};
+  const providers = [
+    makeCodexProvider({}),
+    makeAntigravityProvider({}),
+    makeGrokProvider({}),
+    makeOpenAICompatibleProvider({
+      name: "openrouter",
+      apiBase: initialOr.apiBase || DEFAULT_API_BASE,
+      apiKeyEnv: DEFAULT_API_KEY_ENV,
+      resolveModel: (req) => req.model || getConfig().openrouter && getConfig().openrouter.defaultModel || ""
+    })
+  ];
+  const srv = buildServer({ providers, getConfig });
+  if (typeof globalThis.fetch !== "function") {
+    console.error("deliberation-mcp requires Node 18+ (global fetch unavailable).");
+    process.exit(1);
+  }
+  let buffer = "";
+  process.stdin.on("data", async (chunk) => {
+    buffer += chunk.toString();
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      const l = line.trim();
+      if (!l) continue;
+      let msg;
+      try {
+        msg = JSON.parse(l);
+      } catch {
+        continue;
+      }
+      const res = await srv.handle(msg);
+      if (msg.id !== void 0) process.stdout.write(JSON.stringify(res) + "\n");
+    }
+  });
+}
+if (require.main === module) startStdio();
+module.exports = { buildServer, toolList };