@antonbabenko/deliberation-mcp 3.5.3 → 3.6.0

package/dist/index.js

@@ -520,7 +520,14 @@ var require_orchestrate = __commonJS({
       } catch {
       }
     }
-    async function callProvider(provider, req, logger, tool, cache) {
+    function withOrientation(provider, req, orientationFiles) {
+      if (Array.isArray(orientationFiles) && orientationFiles.length && !(Array.isArray(req.files) && req.files.length) && provider.capabilities && provider.capabilities.walksFilesystem === false) {
+        return { ...req, files: orientationFiles };
+      }
+      return req;
+    }
+    async function callProvider(provider, req, logger, tool, cache, orientationFiles) {
+      req = withOrientation(provider, req, orientationFiles);
       const useCache = cache && !(Array.isArray(req.files) && req.files.length);
       if (useCache) {
         const hit = cache.get(provider.name, req);
@@ -553,7 +560,7 @@ var require_orchestrate = __commonJS({
       const logger = opts.logger || NULL_LOGGER;
       const tool = opts.tool || "ask-all";
       const settled = await Promise.allSettled(
-        providers.map((p) => callProvider(p, req, logger, tool, opts.cache))
+        providers.map((p) => callProvider(p, req, logger, tool, opts.cache, opts.orientationFiles))
       );
       return settled.map(
         (s, i) => s.status === "fulfilled" ? s.value : {
@@ -568,7 +575,7 @@ var require_orchestrate = __commonJS({
       );
     }
     async function askOne2(provider, req, opts = {}) {
-      return callProvider(provider, req, opts.logger || NULL_LOGGER, opts.tool || "ask-one", opts.cache);
+      return callProvider(provider, req, opts.logger || NULL_LOGGER, opts.tool || "ask-one", opts.cache, opts.orientationFiles);
     }
     function buildArbiterPrompt(question, opinions) {
       const blocks = opinions.map((o, i) => `### Opinion ${i + 1}
@@ -593,17 +600,17 @@ ${blocks}`,
         // Promise.resolve().then(...) so even a SYNCHRONOUS throw in ask() is caught
         // by the rejection handler (a bare arbiter.ask() could throw before awaiting).
         Promise.resolve().then(
-          () => arbiter.ask({
+          () => arbiter.ask(withOrientation(arbiter, {
             ...req,
             files: req.files ? req.files.map((f) => ({ ...f })) : void 0,
             developerInstructions: opts.arbiterInstructions || req.developerInstructions
-          })
+          }, opts.orientationFiles))
         ).then((v) => v, () => null)
       ) : Promise.resolve(
         /** @type {DelegationResult|null} */
         null
       );
-      const [opinions, blindVerdict] = await Promise.all([askAll2(providers, req, { logger: opts.logger, tool: "consensus" }), blindPromise]);
+      const [opinions, blindVerdict] = await Promise.all([askAll2(providers, req, { logger: opts.logger, tool: "consensus", orientationFiles: opts.orientationFiles }), blindPromise]);
       const ok = (
         /** @type {DelegationSuccess[]} */
         opinions.filter((o) => !o.isError)
@@ -666,8 +673,8 @@ ${feedback || "(reviewers gave no specific issues; tighten the weakest part)"}`
           const { peerPrompt, blindPrompt } = loop.prepareRound(state);
           const roundNo = state.round;
           const [blindRes, peerResults] = await Promise.all([
-            Promise.resolve().then(() => arbiter.ask({ ...req, prompt: blindPrompt })).then((r) => r, () => null),
-            askAll2(providers, { ...req, prompt: peerPrompt }, { logger, tool: "consensus" })
+            Promise.resolve().then(() => arbiter.ask(withOrientation(arbiter, { ...req, prompt: blindPrompt }, opts.orientationFiles))).then((r) => r, () => null),
+            askAll2(providers, { ...req, prompt: peerPrompt }, { logger, tool: "consensus", orientationFiles: opts.orientationFiles })
           ]);
           state = loop.recordBlindVerdict(state, okText(blindRes) || "(blind pass unavailable)");
           lastResults = peerResults.map(
@@ -732,6 +739,52 @@ ${feedback || "(reviewers gave no specific issues; tighten the weakest part)"}`
   }
 });
 
+// ../../core/orientation.js
+var require_orientation = __commonJS({
+  "../../core/orientation.js"(exports2, module2) {
+    "use strict";
+    var fs = require("node:fs");
+    var path = require("node:path");
+    var ORIENTATION_CANDIDATES = [
+      "CLAUDE.md",
+      "AGENTS.md",
+      "README.md",
+      "package.json",
+      "pyproject.toml",
+      "Cargo.toml",
+      "go.mod",
+      "tsconfig.json",
+      "main.tf"
+    ];
+    var DEFAULT_MAX_FILES = 6;
+    function resolveOrientationFiles(cwd, opts = {}) {
+      const base = cwd || process.cwd();
+      const max = Number.isInteger(opts.maxFiles) && /** @type {number} */
+      opts.maxFiles > 0 ? (
+        /** @type {number} */
+        opts.maxFiles
+      ) : DEFAULT_MAX_FILES;
+      const candidates = opts.candidates || ORIENTATION_CANDIDATES;
+      const out = [];
+      for (const name of candidates) {
+        if (out.length >= max) break;
+        const abs = path.join(base, name);
+        try {
+          if (fs.statSync(abs).isFile()) out.push({ path: abs });
+        } catch {
+        }
+      }
+      return out;
+    }
+    function orientationFilesFor2(config, cwd) {
+      const o = config && config.orientation;
+      if (!o || o.enabled !== true) return void 0;
+      return resolveOrientationFiles(cwd, { maxFiles: o.maxFiles });
+    }
+    module2.exports = { resolveOrientationFiles, orientationFilesFor: orientationFilesFor2, ORIENTATION_CANDIDATES, DEFAULT_MAX_FILES };
+  }
+});
+
 // ../../core/prompts/index.js
 var require_prompts = __commonJS({
   "../../core/prompts/index.js"(exports2, module2) {
@@ -1443,7 +1496,7 @@ var require_openai_compatible = __commonJS({
         /** @type {any} */
         {
           name,
-          capabilities: { canImplement: false, fileUpload: false, multiTurn: true },
+          capabilities: { canImplement: false, fileUpload: false, multiTurn: true, walksFilesystem: false },
           /** Test-only: current number of cached sessions. */
           get __sessionCount() {
             return sessions.size;
@@ -1525,7 +1578,7 @@ var require_grok = __commonJS({
         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 },
+        capabilities: { canImplement: false, fileUpload: true, multiTurn: false, walksFilesystem: false },
         async health() {
           return process.env.XAI_API_KEY ? { ok: true } : { ok: false, reason: "XAI_API_KEY unset" };
         },
@@ -1585,22 +1638,23 @@ var require_antigravity = __commonJS({
       const model = opts.model || process.env.GEMINI_DEFAULT_MODEL || "auto-gemini-3";
       return {
         name: "gemini",
-        capabilities: { canImplement: true, fileUpload: false, multiTurn: true },
+        capabilities: { canImplement: true, fileUpload: false, multiTurn: true, walksFilesystem: true },
         async health() {
           return typeof bridge.runGemini === "function" ? { ok: true } : { ok: false, reason: "agy bridge unavailable" };
         },
         async ask(req) {
           const started = Date.now();
+          const includeDirs = (req.files || []).filter((f) => f.dir).map((f) => f.dir);
           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)
+            includeDirs
           });
           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, reasoningEffort: null };
+            const out = await bridge.runGemini(args, req.cwd, req.timeoutMs, void 0, { readOnly: true, includeDirs });
+            return { provider: "gemini", model, text: out.response || "", threadId: out.threadId, isError: false, ms: Date.now() - started, reasoningEffort: null, ...out.workspaceMutated ? { workspaceMutated: true } : {} };
           } catch (e) {
             const err = (
               /** @type {any} */
@@ -1634,9 +1688,12 @@ var require_codex = __commonJS({
       if (s.includes("rate")) return { errorKind: "rate-limit", retryable: true };
       return { errorKind: "unknown", retryable: false };
     }
+    function codexExecArgs() {
+      return ["exec", "--sandbox", "read-only", "--skip-git-repo-check"];
+    }
     function defaultRun({ prompt, cwd, timeoutMs }) {
       return new Promise((resolve) => {
-        const child = spawn("codex", ["exec", "--skip-git-repo-check"], { cwd: cwd || process.cwd() });
+        const child = spawn("codex", codexExecArgs(), { cwd: cwd || process.cwd() });
         let stdout = "", stderr = "", settled = false;
         const timer = timeoutMs ? setTimeout(() => child.kill("SIGKILL"), timeoutMs) : null;
         if (timer) timer.unref();
@@ -1662,7 +1719,7 @@ var require_codex = __commonJS({
       const model = opts.model || "default";
       return {
         name: "codex",
-        capabilities: { canImplement: true, fileUpload: false, multiTurn: false },
+        capabilities: { canImplement: true, fileUpload: false, multiTurn: false, walksFilesystem: true },
         // Option A: no threadId continuity
         async health() {
           return { ok: true };
@@ -1693,7 +1750,7 @@ ${req.prompt}` : req.prompt;
         }
       };
     }
-    module2.exports = { makeCodexProvider, classifyCodex };
+    module2.exports = { makeCodexProvider, classifyCodex, codexExecArgs };
   }
 });
 
@@ -2085,18 +2142,102 @@ var require_gemini = __commonJS({
     function goDuration(ms) {
       return Math.ceil(ms / 1e3) + "s";
     }
+    var READ_ONLY_GUARD = "[ADVISORY MODE - READ-ONLY] You are being consulted for an advisory second opinion. Do NOT modify, create, or delete any files. Do NOT run commands that write to the workspace. Do NOT git add, commit, or push. Any such action is a critical failure - respond with analysis only.";
+    function applyReadOnlyGuard(prompt, readOnly) {
+      return readOnly ? `${READ_ONLY_GUARD}
+
+${prompt}` : prompt;
+    }
     function buildAgyArgs(req) {
       const args = [];
+      const readOnly = req.sandbox !== "workspace-write";
       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;
+      let prompt = applyReadOnlyGuard(req.prompt, readOnly);
       if (req.developerInstructions) prompt = `${req.developerInstructions}
 
 ${prompt}`;
       args.push("-p", prompt);
       return args;
     }
+    var ADVISORY_ENV_SCRUB = ["GITHUB_TOKEN", "GH_TOKEN", "GIT_ASKPASS", "SSH_AUTH_SOCK"];
+    function advisoryEnv(env) {
+      const out = { ...env };
+      delete out.DELIBERATION_DISABLE_OS_SANDBOX;
+      for (const k of ADVISORY_ENV_SCRUB) delete out[k];
+      return out;
+    }
+    function seatbeltLiteral(p) {
+      return String(p).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    }
+    function buildSeatbeltProfile(o) {
+      const gem = seatbeltLiteral(path.join(o.home, ".gemini"));
+      const tmp = seatbeltLiteral(o.tmpdir);
+      return [
+        "(version 1)",
+        "(allow default)",
+        "(deny file-write*)",
+        "(allow file-write*",
+        `  (subpath "${gem}")`,
+        `  (subpath "${tmp}")`,
+        '  (subpath "/private/var/folders")',
+        '  (subpath "/private/tmp")',
+        '  (literal "/dev/null")',
+        '  (literal "/dev/dtracehelper")',
+        '  (regex #"^/dev/tty"))'
+      ].join("\n");
+    }
+    function buildSpawnCommand(o) {
+      const platform = o.platform || process.platform;
+      const unwrapped = { cmd: o.bin, argv: o.args, osSandbox: false };
+      if (!o.readOnly || o.disabled === true || platform !== "darwin" || !o.sandboxExecPath) {
+        return unwrapped;
+      }
+      const profile = buildSeatbeltProfile({ home: o.home, tmpdir: o.tmpdir });
+      return { cmd: o.sandboxExecPath, argv: ["-p", profile, o.bin, ...o.args], osSandbox: true };
+    }
+    function resolveSandboxExecPath() {
+      try {
+        fs.accessSync("/usr/bin/sandbox-exec", fs.constants.X_OK);
+        return "/usr/bin/sandbox-exec";
+      } catch (_) {
+        return null;
+      }
+    }
+    function captureGitState(cwd) {
+      const opts = { cwd, encoding: "utf8", timeout: 1e4, stdio: ["ignore", "pipe", "ignore"] };
+      try {
+        const head = execFileSync("git", ["rev-parse", "HEAD"], opts).trim();
+        const status = execFileSync("git", ["status", "--porcelain"], opts);
+        return { head, status };
+      } catch (_) {
+        return null;
+      }
+    }
+    function diffGitState(pre, post) {
+      if (!pre || !post) return false;
+      return pre.head !== post.head || pre.status !== post.status;
+    }
+    function captureRoots(dirs) {
+      const seen = /* @__PURE__ */ new Set();
+      const states = [];
+      for (const d of dirs) {
+        if (!d || seen.has(d)) continue;
+        seen.add(d);
+        states.push([d, captureGitState(d)]);
+      }
+      return states;
+    }
+    function rootsMutated(preStates) {
+      for (const [dir, pre] of preStates) {
+        if (diffGitState(pre, captureGitState(dir))) return true;
+      }
+      return false;
+    }
+    function workspaceMutationWarning(dir) {
+      return "WORKSPACE MUTATION DETECTED\nThis advisory (read-only) run changed the workspace at " + dir + " (git HEAD and/or working-tree status changed during the run). Review `git status` / `git log` before continuing - nothing was auto-reverted, and the result below should be treated as tainted.\n---\n";
+    }
     function sendResponse(id, result) {
       process.stdout.write(JSON.stringify({
         jsonrpc: "2.0",
@@ -2150,11 +2291,13 @@ ${prompt}`;
         return null;
       }
     }
-    async function runGemini(args, cwd, timeoutMs, recoveryGraceMs) {
+    async function runGemini(args, cwd, timeoutMs, recoveryGraceMs, opts = {}) {
       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 readOnly = opts.readOnly === true;
+        const preRoots = readOnly ? captureRoots([effCwd, ...opts.includeDirs || []]) : [];
         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;
@@ -2165,8 +2308,27 @@ ${prompt}`;
         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,
+        const spawnPlan = buildSpawnCommand({
+          bin: AGY_BIN,
+          args: agyArgs,
+          readOnly,
+          platform: process.platform,
+          home: os.homedir(),
+          tmpdir: (() => {
+            try {
+              return fs.realpathSync(os.tmpdir());
+            } catch (_) {
+              return os.tmpdir();
+            }
+          })(),
+          sandboxExecPath: readOnly ? resolveSandboxExecPath() : null,
+          disabled: process.env.DELIBERATION_DISABLE_OS_SANDBOX === "1"
+        });
+        if (spawnPlan.osSandbox) {
+          process.stderr.write("[deliberation] agy read-only run wrapped in sandbox-exec (workspace writes denied)\n");
+        }
+        const agyProcess = spawn(spawnPlan.cmd, spawnPlan.argv, {
+          env: readOnly ? advisoryEnv(process.env) : process.env,
           shell: false,
           cwd: effCwd,
           // agy -p (print mode) waits for stdin EOF before returning; if the stdin
@@ -2274,7 +2436,9 @@ ${prompt}`;
               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 });
+              const mutated = readOnly && rootsMutated(preRoots);
+              const text = mutated ? workspaceMutationWarning(effCwd) + out : out;
+              return resolve({ response: text, threadId: resolveConversationId(effCwd) || "unknown", recovered: true, ...mutated ? { workspaceMutated: true } : {} });
             }
             return finishTimeout();
           }
@@ -2287,7 +2451,9 @@ ${prompt}`;
                 "[deliberation] no conversation id found for cwd " + effCwd + '; returning threadId:"unknown" (resume will be unavailable)\n'
               );
             }
-            return resolve({ response: out, threadId: threadId || "unknown" });
+            const mutated = readOnly && rootsMutated(preRoots);
+            const text = mutated ? workspaceMutationWarning(effCwd) + out : out;
+            return resolve({ response: text, threadId: threadId || "unknown", ...mutated ? { workspaceMutated: true } : {} });
           }
           let message;
           if (trimmedErr) message = trimmedErr;
@@ -2454,19 +2620,27 @@ ${prompt}`;
               return;
             }
             agyArgs.push("--conversation", threadId2, ...sandboxFlags, ...addDirFlags);
-            agyArgs.push("-p", args.prompt);
+            agyArgs.push("-p", applyReadOnlyGuard(args.prompt, args.sandbox !== "workspace-write"));
           } 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);
+          const readOnly = args.sandbox !== "workspace-write";
+          const { response, threadId, recovered, workspaceMutated } = await runGemini(
+            agyArgs,
+            args.cwd,
+            timeoutMs,
+            recoveryGraceMs,
+            { readOnly, includeDirs: args["include-directories"] || [] }
+          );
           if (shouldRespond) {
             sendResponse(id, {
               content: [{ type: "text", text: response }],
               threadId,
-              ...recovered ? { recovered: true } : {}
+              ...recovered ? { recovered: true } : {},
+              ...workspaceMutated ? { workspaceMutated: true } : {}
             });
           }
         } catch (e) {
@@ -2532,6 +2706,12 @@ ${prompt}`;
       module2.exports.stdoutIsError = stdoutIsError;
       module2.exports.runGemini = runGemini;
       module2.exports.buildAgyArgs = buildAgyArgs;
+      module2.exports.READ_ONLY_GUARD = READ_ONLY_GUARD;
+      module2.exports.applyReadOnlyGuard = applyReadOnlyGuard;
+      module2.exports.advisoryEnv = advisoryEnv;
+      module2.exports.buildSeatbeltProfile = buildSeatbeltProfile;
+      module2.exports.buildSpawnCommand = buildSpawnCommand;
+      module2.exports.diffGitState = diffGitState;
     }
   }
 });
@@ -4398,6 +4578,7 @@ var require_openrouter = __commonJS({
 // index.js
 var { makeRegistry, pinAlias } = require_registry();
 var { askAll, askOne, consensus, runToConvergence } = require_orchestrate();
+var { orientationFilesFor } = require_orientation();
 var { PROMPTS } = require_prompts();
 var analyzeCore = require_analyze();
 var ADVISORY = { readOnlyHint: true };
@@ -4674,6 +4855,9 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir, notify
     if (!persona) return request;
     return { ...request, developerInstructions: persona };
   }
+  function orient(req) {
+    return orientationFilesFor(getConfig(), req && req.cwd);
+  }
   function sessionsCfg() {
     const c = getConfig() || {};
     const s = c.sessions || {};
@@ -4771,7 +4955,7 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir, notify
       lg.logEvent({ event: "dispatch_start", at: Date.now(), tool: "ask-all", voices: selected.length });
     } catch {
     }
-    const results = await askAll(selected, withPersona(req, expert), { logger: lg, tool: "ask-all", cache: opts.noCache ? void 0 : resultCache });
+    const results = await askAll(selected, withPersona(req, expert), { logger: lg, tool: "ask-all", cache: opts.noCache ? void 0 : resultCache, orientationFiles: orient(req) });
     return {
       payload: { results, omitted },
       parts: { opinions: results, blindVerdict: null, verdict: null, arbiter: null, warnings: [] }
@@ -4789,13 +4973,13 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir, notify
     const resolved = await resolveArbiter(arbiterSpec, selected, registry, getConfig);
     if (resolved.warning) warnings.push(resolved.warning);
     if (resolved.mode === "host") {
-      const opinions = await askAll(selected, withPersona(req, expert), { logger: currentLogger(), tool: "consensus" });
+      const opinions = await askAll(selected, withPersona(req, expert), { logger: currentLogger(), tool: "consensus", orientationFiles: orient(req) });
       const arbiter2 = { mode: "host" };
       const body = { opinions, blindVerdict: null, verdict: null, arbiter: arbiter2, warnings };
       return { payload: body, parts: body };
     }
     if (!resolved.provider) {
-      const out2 = await consensus(selected, withPersona(req, expert), { arbiterInstructions: PROMPTS.arbiter, logger: currentLogger() });
+      const out2 = await consensus(selected, withPersona(req, expert), { arbiterInstructions: PROMPTS.arbiter, logger: currentLogger(), orientationFiles: orient(req) });
       const arbiter2 = { mode: "server", provider: null };
       return {
         payload: { opinions: out2.opinions, blindVerdict: out2.blindVerdict, verdict: out2.verdict, error: out2.error, arbiter: arbiter2, warnings },
@@ -4808,7 +4992,7 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir, notify
       peers = selected;
       warnings.push(`panel too small to exclude arbiter '${arbiterP.name}'; kept it in the peer panel (floor of 2)`);
     }
-    const out = await consensus(peers, withPersona(req, expert), { arbiter: arbiterP, arbiterInstructions: PROMPTS.arbiter, blindVote, logger: currentLogger() });
+    const out = await consensus(peers, withPersona(req, expert), { arbiter: arbiterP, arbiterInstructions: PROMPTS.arbiter, blindVote, logger: currentLogger(), orientationFiles: orient(req) });
     const arbiter = { mode: "server", provider: arbiterP.name };
     return {
       payload: { opinions: out.opinions, blindVerdict: out.blindVerdict, verdict: out.verdict, error: out.error, arbiter, warnings },
@@ -4838,7 +5022,7 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir, notify
       }
       const maxRounds = Number.isInteger(maxRoundsOverride) && /** @type {number} */
       maxRoundsOverride > 0 ? maxRoundsOverride : Number.isInteger(cc.maxRounds) && cc.maxRounds > 0 ? cc.maxRounds : void 0;
-      const out = await runToConvergence(peers, withPersona(req, expert), { arbiter: arbiterP, maxRounds, logger: currentLogger() });
+      const out = await runToConvergence(peers, withPersona(req, expert), { arbiter: arbiterP, maxRounds, logger: currentLogger(), orientationFiles: orient(req) });
       const allWarnings = out.error ? warnings.concat([`loop: ${out.error}`]) : warnings;
       const rounds = Array.isArray(out.rounds) ? out.rounds.length : 0;
       const arbiter = { mode: "server", provider: arbiterP.name };
@@ -4979,7 +5163,7 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir, notify
           lg.logEvent({ event: "dispatch_start", at: Date.now(), tool: "consensus", round: cur.round, voices: selected.length });
         } catch {
         }
-        const peerResults = await askAll(selected, withPersona(peerReq, ex), { logger: lg, tool: "consensus" });
+        const peerResults = await askAll(selected, withPersona(peerReq, ex), { logger: lg, tool: "consensus", orientationFiles: orient(peerReq) });
         const results = peerResults.map(
           (r) => r.isError ? { source: r.provider, isError: true, errorKind: r.errorKind, verdict: null, criticalIssues: [], model: r.model, reasoningEffort: r.reasoningEffort ?? null, ms: r.ms } : { ...parseReview(typeof r.text === "string" ? r.text : ""), source: r.provider, isError: false, model: r.model, reasoningEffort: r.reasoningEffort ?? null, ms: r.ms }
         );
@@ -5103,7 +5287,7 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir, notify
       if (!p) {
         return jsonResult({ error: `provider "${want}" is not in the active panel`, panel: selected.map((x) => x.name) });
       }
-      const result = await askOne(p, withPersona(req, expert), { logger: currentLogger(), tool: "ask-one", cache: resultCache });
+      const result = await askOne(p, withPersona(req, expert), { logger: currentLogger(), tool: "ask-one", cache: resultCache, orientationFiles: orient(req) });
       return jsonResult({ result });
     }
     if (name === "analyze") {
@@ -5172,12 +5356,12 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir, notify
     if (Object.prototype.hasOwnProperty.call(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, withPersona(req, expert), { logger: currentLogger(), tool: "ask-one", cache: resultCache });
+      const result = await askOne(p, withPersona(req, expert), { logger: currentLogger(), tool: "ask-one", cache: resultCache, orientationFiles: orient(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, withPersona({ ...req, expert: name }, expert), { logger: currentLogger(), tool: name, cache: resultCache });
+      const results = await askAll(selected, withPersona({ ...req, expert: name }, expert), { logger: currentLogger(), tool: name, cache: resultCache, orientationFiles: orient(req) });
       return { content: [{ type: "text", text: JSON.stringify({ results }) }] };
     }
     throw new Error(`unknown tool: ${name}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antonbabenko/deliberation-mcp",
-  "version": "3.5.3",
+  "version": "3.6.0",
   "description": "Deliberation for Claude Code and any MCP host - GPT, Gemini, Grok, and OpenRouter expert subagents.",
   "mcpName": "io.github.antonbabenko/deliberation",
   "repository": { "type": "git", "url": "git+https://github.com/antonbabenko/deliberation.git", "directory": "server/mcp" },