@antonbabenko/deliberation-mcp 3.1.1 → 3.2.0

package/dist/index.js

@@ -87,9 +87,9 @@ var require_registry = __commonJS({
 var require_provider = __commonJS({
   "../../core/provider.js"(exports2, module2) {
     "use strict";
-    function toErrorResult(name, model, started, err, classify) {
+    function toErrorResult(name, model, started, err, classify, extra) {
       const { errorKind, retryable } = classify(err && err.status, err && err.code);
-      return { provider: name, model, isError: true, errorKind, retryable, ms: Date.now() - started };
+      return { ...extra && typeof extra === "object" ? extra : {}, provider: name, model, isError: true, errorKind, retryable, ms: Date.now() - started };
     }
     function deepFreeze(o) {
       if (o && typeof o === "object" && !Object.isFrozen(o)) {
@@ -430,17 +430,130 @@ ${state.currentPlan}`
   }
 });
 
+// ../../core/debug-log.js
+var require_debug_log = __commonJS({
+  "../../core/debug-log.js"(exports2, module2) {
+    "use strict";
+    var NULL_LOGGER = Object.freeze({ logEvent(_event) {
+    } });
+    var ALLOWED_KEYS = Object.freeze([
+      "event",
+      "at",
+      "tool",
+      "provider",
+      "model",
+      "reasoningEffort",
+      "ms",
+      "isError",
+      "errorKind",
+      "usage",
+      "round",
+      "verdict",
+      "blindVerdict",
+      "converged",
+      "acceptedCritical",
+      "voices"
+    ]);
+    function sanitizeEvent(event) {
+      const out = {};
+      if (!event || typeof event !== "object") return out;
+      for (const k of ALLOWED_KEYS) {
+        const v = (
+          /** @type {Record<string, unknown>} */
+          event[k]
+        );
+        if (v !== void 0) out[k] = v;
+      }
+      return out;
+    }
+    function createFileLogger(path) {
+      const fs = require("node:fs");
+      return {
+        logEvent(event) {
+          try {
+            fs.appendFileSync(path, JSON.stringify(sanitizeEvent(event)) + "\n");
+          } catch {
+          }
+        }
+      };
+    }
+    function composeLoggers(sinks) {
+      const real = (Array.isArray(sinks) ? sinks : []).filter((s) => s && typeof s.logEvent === "function");
+      if (!real.length) return NULL_LOGGER;
+      if (real.length === 1) return real[0];
+      return {
+        logEvent(event) {
+          for (const s of real) {
+            try {
+              s.logEvent(event);
+            } catch {
+            }
+          }
+        }
+      };
+    }
+    module2.exports = { NULL_LOGGER, createFileLogger, composeLoggers, sanitizeEvent, ALLOWED_KEYS };
+  }
+});
+
 // ../../core/orchestrate.js
 var require_orchestrate = __commonJS({
   "../../core/orchestrate.js"(exports2, module2) {
     "use strict";
     var { parseReview } = require_provider();
     var loop = require_consensus_loop();
-    async function askAll2(providers, req) {
+    var { NULL_LOGGER } = require_debug_log();
+    function logProviderResult(logger, tool, r) {
+      try {
+        logger.logEvent({
+          event: "provider_result",
+          at: Date.now(),
+          tool,
+          provider: r.provider,
+          model: r.model,
+          reasoningEffort: r.reasoningEffort ?? null,
+          ms: r.ms,
+          isError: r.isError,
+          errorKind: r.isError ? r.errorKind : void 0,
+          usage: r.isError ? void 0 : r.usage
+        });
+      } catch {
+      }
+    }
+    async function callProvider(provider, req, logger, tool, cache) {
+      const useCache = cache && !(Array.isArray(req.files) && req.files.length);
+      if (useCache) {
+        const hit = cache.get(provider.name, req);
+        if (hit) {
+          logProviderResult(logger, tool, hit);
+          return hit;
+        }
+      }
+      const started = Date.now();
+      let r;
+      try {
+        r = await provider.ask({ ...req, files: req.files ? req.files.map((f) => ({ ...f })) : void 0 });
+      } catch (e) {
+        r = {
+          provider: provider.name,
+          model: "unknown",
+          isError: true,
+          errorKind: "unknown",
+          retryable: false,
+          message: String(e && /** @type {any} */
+          e.message || e),
+          ms: Date.now() - started
+        };
+      }
+      logProviderResult(logger, tool, r);
+      if (useCache) cache.set(provider.name, req, r);
+      return r;
+    }
+    async function askAll2(providers, req, opts = {}) {
+      const logger = opts.logger || NULL_LOGGER;
+      const tool = opts.tool || "ask-all";
       const settled = await Promise.allSettled(
-        providers.map(
-          (p) => p.ask({ ...req, files: req.files ? req.files.map((f) => ({ ...f })) : void 0 })
-        )
+        providers.map((p) => callProvider(p, req, logger, tool, opts.cache))
       );
       return settled.map(
         (s, i) => s.status === "fulfilled" ? s.value : {
@@ -454,8 +567,8 @@ var require_orchestrate = __commonJS({
         }
       );
     }
-    async function askOne2(provider, req) {
-      return provider.ask({ ...req, files: req.files ? req.files.map((f) => ({ ...f })) : void 0 });
+    async function askOne2(provider, req, opts = {}) {
+      return callProvider(provider, req, opts.logger || NULL_LOGGER, opts.tool || "ask-one", opts.cache);
     }
     function buildArbiterPrompt(question, opinions) {
       const blocks = opinions.map((o, i) => `### Opinion ${i + 1}
@@ -490,7 +603,7 @@ ${blocks}`,
         /** @type {DelegationResult|null} */
         null
       );
-      const [opinions, blindVerdict] = await Promise.all([askAll2(providers, req), blindPromise]);
+      const [opinions, blindVerdict] = await Promise.all([askAll2(providers, req, { logger: opts.logger, tool: "consensus" }), blindPromise]);
       const ok = (
         /** @type {DelegationSuccess[]} */
         opinions.filter((o) => !o.isError)
@@ -539,6 +652,7 @@ ${feedback || "(reviewers gave no specific issues; tighten the weakest part)"}`
     }
     async function runToConvergence2(providers, req, opts = {}) {
       const arbiter = opts.arbiter;
+      const logger = opts.logger || NULL_LOGGER;
       if (!arbiter) return { converged: false, verdict: null, confidence: "none", rounds: [], opinions: [], error: "no-arbiter" };
       let state = loop.initConsensusLoop({
         plan: typeof req.prompt === "string" ? req.prompt : "",
@@ -550,9 +664,10 @@ ${feedback || "(reviewers gave no specific issues; tighten the weakest part)"}`
       try {
         while (state.status !== "converged" && state.status !== "unresolved") {
           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 })
+            askAll2(providers, { ...req, prompt: peerPrompt }, { logger, tool: "consensus" })
           ]);
           state = loop.recordBlindVerdict(state, okText(blindRes) || "(blind pass unavailable)");
           lastResults = peerResults.map(
@@ -570,6 +685,19 @@ ${feedback || "(reviewers gave no specific issues; tighten the weakest part)"}`
           } catch {
           }
           state = loop.submitAdjudication(state, { verdict, decisions: [] });
+          try {
+            logger.logEvent({
+              event: "round",
+              at: Date.now(),
+              tool: "consensus",
+              round: roundNo,
+              verdict,
+              converged: state.status === "converged",
+              blindVerdict: okText(blindRes) ? "(recorded)" : null,
+              voices: lastResults.length
+            });
+          } catch {
+          }
           if (state.status === "converged") break;
           let revised = state.currentPlan;
           try {
@@ -918,6 +1046,147 @@ var require_loop_store = __commonJS({
   }
 });
 
+// ../../core/result-cache.js
+var require_result_cache = __commonJS({
+  "../../core/result-cache.js"(exports2, module2) {
+    "use strict";
+    var DEFAULT_MAX = 100;
+    var DEFAULT_TTL_MS = 6e5;
+    function keyFor(providerName, req) {
+      const files = Array.isArray(req.files) ? req.files.map((f) => `${f.path || ""}|${f.dir || ""}|${f.file_id || ""}|${f.file_url || ""}|${f.mode || ""}`) : [];
+      return JSON.stringify([
+        providerName,
+        req.model || "",
+        req.reasoningEffort || "",
+        typeof req.temperature === "number" ? req.temperature : "",
+        req.developerInstructions || "",
+        req.prompt || "",
+        files
+      ]);
+    }
+    function makeResultCache(opts = {}) {
+      const max = Number.isInteger(opts.max) && /** @type {number} */
+      opts.max > 0 ? (
+        /** @type {number} */
+        opts.max
+      ) : DEFAULT_MAX;
+      const ttlMs = Number.isInteger(opts.ttlMs) && /** @type {number} */
+      opts.ttlMs > 0 ? (
+        /** @type {number} */
+        opts.ttlMs
+      ) : DEFAULT_TTL_MS;
+      const map = /* @__PURE__ */ new Map();
+      return {
+        get(providerName, req) {
+          const k = keyFor(providerName, req);
+          const e = map.get(k);
+          if (!e) return void 0;
+          if (Date.now() - e.at > ttlMs) {
+            map.delete(k);
+            return void 0;
+          }
+          map.delete(k);
+          map.set(k, e);
+          return e.result;
+        },
+        set(providerName, req, result) {
+          if (!result || result.isError) return;
+          const k = keyFor(providerName, req);
+          map.set(k, { result: { .../** @type {DelegationSuccess} */
+          result, cached: true, ms: 0 }, at: Date.now() });
+          if (map.size > max) {
+            const oldest = map.keys().next().value;
+            if (oldest !== void 0) map.delete(oldest);
+          }
+        },
+        get size() {
+          return map.size;
+        }
+      };
+    }
+    module2.exports = { makeResultCache, keyFor, DEFAULT_MAX, DEFAULT_TTL_MS };
+  }
+});
+
+// ../../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 resolveInjection(opts) {
+      return {
+        home: opts && opts.home || os.homedir(),
+        env: opts && opts.env || process.env,
+        platform: opts && opts.platform || process.platform
+      };
+    }
+    function isUsableBase(value, platform) {
+      if (typeof value !== "string" || value.length === 0) return false;
+      const impl = platform === "win32" ? path.win32 : path.posix;
+      return impl.isAbsolute(value);
+    }
+    function canonicalConfigDir(home, env, platform) {
+      if (platform === "win32") {
+        const appData = env.APPDATA;
+        const base2 = isUsableBase(appData, platform) ? appData : path.join(home, "AppData", "Roaming");
+        return path.join(base2, "deliberation");
+      }
+      const xdg = env.XDG_CONFIG_HOME;
+      const base = isUsableBase(xdg, platform) ? xdg : path.join(home, ".config");
+      return path.join(base, "deliberation");
+    }
+    function resolveConfigPath(opts) {
+      const { home, env, platform } = resolveInjection(opts);
+      const override = env.DELIBERATION_CONFIG;
+      if (typeof override === "string" && override.length > 0) {
+        return override;
+      }
+      return path.join(canonicalConfigDir(home, env, platform), "config.json");
+    }
+    function canonicalCacheDir(home, env, platform) {
+      if (platform === "win32") {
+        const localAppData = env.LOCALAPPDATA;
+        const base2 = isUsableBase(localAppData, platform) ? localAppData : path.join(home, "AppData", "Local");
+        return path.join(base2, "deliberation");
+      }
+      const xdg = env.XDG_CACHE_HOME;
+      const base = isUsableBase(xdg, platform) ? xdg : path.join(home, ".cache");
+      return path.join(base, "deliberation");
+    }
+    function resolveGrokCachePath(opts) {
+      const { home, env, platform } = resolveInjection(opts);
+      const override = env.DELIBERATION_CACHE;
+      if (typeof override === "string" && override.length > 0) {
+        return override;
+      }
+      return path.join(canonicalCacheDir(home, env, platform), "grok-files.json");
+    }
+    function resolveSessionsDir(opts) {
+      const { home, env, platform } = resolveInjection(opts);
+      const override = env.DELIBERATION_SESSIONS;
+      if (typeof override === "string" && override.length > 0) {
+        return override;
+      }
+      return path.join(canonicalCacheDir(home, env, platform), "sessions");
+    }
+    function resolveDebugLogPath(opts) {
+      const { home, env, platform } = resolveInjection(opts);
+      const override = env.DELIBERATION_DEBUG_LOG;
+      if (typeof override === "string" && override.length > 0) {
+        return override;
+      }
+      return path.join(canonicalCacheDir(home, env, platform), "debug.jsonl");
+    }
+    module2.exports = {
+      resolveConfigPath,
+      resolveGrokCachePath,
+      resolveSessionsDir,
+      resolveDebugLogPath
+    };
+  }
+});
+
 // ../../core/providers/openai-compatible.js
 var require_openai_compatible = __commonJS({
   "../../core/providers/openai-compatible.js"(exports2, module2) {
@@ -960,13 +1229,14 @@ var require_openai_compatible = __commonJS({
                   started,
                   /** @type {any} */
                   e,
-                  () => ({ errorKind: "config", retryable: false })
+                  () => ({ errorKind: "config", retryable: false }),
+                  { reasoningEffort: req.reasoningEffort ?? null }
                 );
               }
             }
             const turns = prior ? [...prior, { role: "user", text: req.prompt, inlineBlocks: blocks }] : bridge.buildInitialTurns(req.developerInstructions, req.prompt, blocks);
             try {
-              const { text } = await bridge.callOpenRouter({
+              const { text, usage } = await bridge.callOpenRouter({
                 apiBase,
                 apiKey: req && req.apiKey || process.env[apiKeyEnv],
                 model,
@@ -981,7 +1251,7 @@ var require_openai_compatible = __commonJS({
               const outText = notes.length ? `${text}
 
 [files] ${notes.join("; ")}` : text;
-              return { provider: name, model, text: outText, threadId, isError: false, ms: Date.now() - started };
+              return { provider: name, model, text: outText, threadId, isError: false, ms: Date.now() - started, reasoningEffort: req.reasoningEffort ?? null, usage };
             } catch (e) {
               return toErrorResult(
                 name,
@@ -989,7 +1259,8 @@ var require_openai_compatible = __commonJS({
                 started,
                 /** @type {any} */
                 e,
-                bridge.classifyError
+                bridge.classifyError,
+                { reasoningEffort: req.reasoningEffort ?? null }
               );
             }
           }
@@ -1044,7 +1315,7 @@ var require_grok = __commonJS({
               reasoningEffort,
               timeoutMs: req.timeoutMs
             });
-            return { provider: "grok", model, text: out.text || "", isError: false, ms: Date.now() - started };
+            return { provider: "grok", model, text: out.text || "", isError: false, ms: Date.now() - started, reasoningEffort: reasoningEffort ?? null, usage: out.usage };
           } catch (e) {
             return toErrorResult(
               "grok",
@@ -1052,7 +1323,8 @@ var require_grok = __commonJS({
               started,
               /** @type {any} */
               e,
-              bridge.classifyGrokError
+              bridge.classifyGrokError,
+              { reasoningEffort: reasoningEffort ?? null }
             );
           }
         }
@@ -1091,7 +1363,7 @@ var require_antigravity = __commonJS({
           });
           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 };
+            return { provider: "gemini", model, text: out.response || "", threadId: out.threadId, isError: false, ms: Date.now() - started, reasoningEffort: null };
           } catch (e) {
             const err = (
               /** @type {any} */
@@ -1102,7 +1374,8 @@ var require_antigravity = __commonJS({
               model,
               started,
               err,
-              (_status, code) => bridge.classifyGeminiError(err && err.message || "", code)
+              (_status, code) => bridge.classifyGeminiError(err && err.message || "", code),
+              { reasoningEffort: null }
             );
           }
         }
@@ -1166,7 +1439,7 @@ var require_codex = __commonJS({
 ${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 };
+            return { provider: "codex", model, text: stdout.trim(), isError: false, ms: Date.now() - started, reasoningEffort: null };
           }
           const { errorKind, retryable } = classifyCodex(stderr);
           return {
@@ -1177,7 +1450,8 @@ ${req.prompt}` : req.prompt;
             retryable,
             // Error results carry no text; surface stdout/stderr diagnostics in message.
             message: stdout && stdout.trim() || stderr || void 0,
-            ms: Date.now() - started
+            ms: Date.now() - started,
+            reasoningEffort: null
           };
         }
       };
@@ -1243,6 +1517,7 @@ var require_config = __commonJS({
       const invalidModels = enabled ? parsed.invalidModels : [];
       const { consensus: consensus2, warnings } = resolveConsensus(raw.consensus, models);
       const { sessions, warnings: sessionsWarnings } = resolveSessions(raw.sessions);
+      const { debug, warnings: debugWarnings } = resolveDebug(raw.debug);
       return {
         ok: true,
         error: null,
@@ -1252,13 +1527,32 @@ var require_config = __commonJS({
           openrouter: { enabled, apiKeyEnv, apiBase, allowRawModel, maxFanout, defaultModel, defaults, models, invalidModels },
           consensus: consensus2,
           sessions,
-          // Defaults- and sessions-validation warnings ride the same consensusWarnings
-          // channel the bridge already surfaces, so a dropped/degraded value is
-          // visible, not silent.
-          consensusWarnings: [...defaultsWarnings, ...warnings, ...sessionsWarnings]
+          debug,
+          // Defaults-, sessions-, and debug-validation warnings ride the same
+          // consensusWarnings channel the bridge already surfaces, so a dropped/degraded
+          // value is visible, not silent.
+          consensusWarnings: [...defaultsWarnings, ...warnings, ...sessionsWarnings, ...debugWarnings]
         }
       };
     }
+    function resolveDebug(raw) {
+      const warnings = [];
+      const out = { enabled: false, path: null };
+      if (raw === void 0) return { debug: out, warnings };
+      if (!isObject(raw)) {
+        warnings.push(`debug must be an object (got ${JSON.stringify(raw)}); debug logging disabled`);
+        return { debug: out, warnings };
+      }
+      if (raw.enabled !== void 0) {
+        if (typeof raw.enabled === "boolean") out.enabled = raw.enabled;
+        else warnings.push(`debug.enabled must be a boolean (got ${JSON.stringify(raw.enabled)}); using false`);
+      }
+      if (raw.path !== void 0) {
+        if (typeof raw.path === "string" && raw.path.trim()) out.path = raw.path.trim();
+        else warnings.push(`debug.path must be a non-empty string (got ${JSON.stringify(raw.path)}); using the default cache-dir path`);
+      }
+      return { debug: out, warnings };
+    }
     function resolveSessions(raw) {
       const warnings = [];
       const out = { persist: false, maxRecords: DEFAULT_SESSIONS_MAX_RECORDS, maxAgeDays: DEFAULT_SESSIONS_MAX_AGE_DAYS };
@@ -1537,76 +1831,6 @@ var require_config = __commonJS({
   }
 });
 
-// ../../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 resolveInjection(opts) {
-      return {
-        home: opts && opts.home || os.homedir(),
-        env: opts && opts.env || process.env,
-        platform: opts && opts.platform || process.platform
-      };
-    }
-    function isUsableBase(value, platform) {
-      if (typeof value !== "string" || value.length === 0) return false;
-      const impl = platform === "win32" ? path.win32 : path.posix;
-      return impl.isAbsolute(value);
-    }
-    function canonicalConfigDir(home, env, platform) {
-      if (platform === "win32") {
-        const appData = env.APPDATA;
-        const base2 = isUsableBase(appData, platform) ? appData : path.join(home, "AppData", "Roaming");
-        return path.join(base2, "deliberation");
-      }
-      const xdg = env.XDG_CONFIG_HOME;
-      const base = isUsableBase(xdg, platform) ? xdg : path.join(home, ".config");
-      return path.join(base, "deliberation");
-    }
-    function resolveConfigPath(opts) {
-      const { home, env, platform } = resolveInjection(opts);
-      const override = env.DELIBERATION_CONFIG;
-      if (typeof override === "string" && override.length > 0) {
-        return override;
-      }
-      return path.join(canonicalConfigDir(home, env, platform), "config.json");
-    }
-    function canonicalCacheDir(home, env, platform) {
-      if (platform === "win32") {
-        const localAppData = env.LOCALAPPDATA;
-        const base2 = isUsableBase(localAppData, platform) ? localAppData : path.join(home, "AppData", "Local");
-        return path.join(base2, "deliberation");
-      }
-      const xdg = env.XDG_CACHE_HOME;
-      const base = isUsableBase(xdg, platform) ? xdg : path.join(home, ".cache");
-      return path.join(base, "deliberation");
-    }
-    function resolveGrokCachePath(opts) {
-      const { home, env, platform } = resolveInjection(opts);
-      const override = env.DELIBERATION_CACHE;
-      if (typeof override === "string" && override.length > 0) {
-        return override;
-      }
-      return path.join(canonicalCacheDir(home, env, platform), "grok-files.json");
-    }
-    function resolveSessionsDir(opts) {
-      const { home, env, platform } = resolveInjection(opts);
-      const override = env.DELIBERATION_SESSIONS;
-      if (typeof override === "string" && override.length > 0) {
-        return override;
-      }
-      return path.join(canonicalCacheDir(home, env, platform), "sessions");
-    }
-    module2.exports = {
-      resolveConfigPath,
-      resolveGrokCachePath,
-      resolveSessionsDir
-    };
-  }
-});
-
 // ../gemini/index.js
 var require_gemini = __commonJS({
   "../gemini/index.js"(exports2, module2) {
@@ -2931,7 +3155,19 @@ ${ref.inline_text}` });
         throw e;
       }
       const text = parseResponsesOutput(data);
-      return { text, output: Array.isArray(data.output) ? data.output : null };
+      return { text, output: Array.isArray(data.output) ? data.output : null, usage: normalizeUsage(data.usage) };
+    }
+    function normalizeUsage(u) {
+      if (!u || typeof u !== "object") return void 0;
+      const prompt = typeof u.prompt_tokens === "number" ? u.prompt_tokens : typeof u.input_tokens === "number" ? u.input_tokens : void 0;
+      const completion = typeof u.completion_tokens === "number" ? u.completion_tokens : typeof u.output_tokens === "number" ? u.output_tokens : void 0;
+      const total = typeof u.total_tokens === "number" ? u.total_tokens : void 0;
+      if (prompt === void 0 && completion === void 0 && total === void 0) return void 0;
+      const out = {};
+      if (prompt !== void 0) out.promptTokens = prompt;
+      if (completion !== void 0) out.completionTokens = completion;
+      if (total !== void 0) out.totalTokens = total;
+      return out;
     }
     var STALE_FILE_ID_TEST = /file[-_][A-Za-z0-9_-]+/;
     var STALE_FILE_ID_EXTRACT = /file[-_][A-Za-z0-9_-]+/g;
@@ -2966,7 +3202,7 @@ ${ref.inline_text}` });
       }
       try {
         const out = await attempt(buildTurns(refs));
-        return { text: out.text, output: out.output, refs, ownedIds };
+        return { text: out.text, output: out.output, refs, ownedIds, usage: out.usage };
       } catch (e) {
         if (!isStaleFileError(e)) throw e;
         const matches = (e.message || "").match(STALE_FILE_ID_EXTRACT) || [];
@@ -2998,7 +3234,7 @@ ${ref.inline_text}` });
           if (!reuploaded._fromCache) ownedIds.push(reuploaded.id);
         }
         const out = await attempt(buildTurns(refs));
-        return { text: out.text, output: out.output, refs, ownedIds };
+        return { text: out.text, output: out.output, refs, ownedIds, usage: out.usage };
       }
     }
     function validateRoots(roots) {
@@ -3643,7 +3879,15 @@ var require_openrouter = __commonJS({
         e.code = "parse";
         throw e;
       }
-      return { text: parseCompletion(data) };
+      return { text: parseCompletion(data), usage: normalizeUsage(data.usage) };
+    }
+    function normalizeUsage(u) {
+      if (!u || typeof u !== "object") return void 0;
+      const out = {};
+      if (typeof u.prompt_tokens === "number") out.promptTokens = u.prompt_tokens;
+      if (typeof u.completion_tokens === "number") out.completionTokens = u.completion_tokens;
+      if (typeof u.total_tokens === "number") out.totalTokens = u.total_tokens;
+      return Object.keys(out).length ? out : void 0;
     }
     var crypto = require("node:crypto");
     var { makeConfigReader } = require_config();
@@ -3930,6 +4174,42 @@ var EXPERT_DESCRIPTIONS = {
   "researcher": "Research specialist for external libraries, frameworks, APIs, and open-source code. Use for 'how do I use X', best-practice, or 'why does this dependency behave this way' questions, with evidence and honest unverified flags.",
   "debugger": "Debugging specialist that produces ranked root-cause hypotheses and the smallest safe fix from a bug report, logs, and code - or says honestly that the evidence shows no bug. Use for crashes, failing tests, or wrong output."
 };
+function panelInputSchema() {
+  return {
+    type: "object",
+    properties: {
+      expert: { type: "string" },
+      cwd: { type: "string" }
+    }
+  };
+}
+function askOneInputSchema() {
+  return {
+    type: "object",
+    required: ["provider", "prompt"],
+    properties: {
+      provider: { type: "string", description: 'A name from `panel` (e.g. "codex", "openrouter:<alias>")' },
+      prompt: { type: "string" },
+      expert: { type: "string" },
+      developerInstructions: { type: "string" },
+      cwd: { type: "string" },
+      reasoningEffort: { type: "string", enum: ["low", "medium", "high", "none"] },
+      files: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            path: { type: "string" },
+            dir: { type: "string" },
+            file_id: { type: "string" },
+            file_url: { type: "string" },
+            mode: { type: "string", enum: ["auto", "inline", "upload"] }
+          }
+        }
+      }
+    }
+  };
+}
 function inputSchema() {
   return {
     type: "object",
@@ -4012,7 +4292,9 @@ function toolList() {
   const tools = [
     { name: "ask-all", description: "Fan out one question to GPT, Gemini, Grok, and any configured OpenRouter models in parallel for independent second opinions, then return all results (advisory, no cross-contamination). Pass `expert` to apply a persona to every delegate.", inputSchema: inputSchema(), annotations: ADVISORY },
     { name: "consensus", description: "Run the FULL multi-round consensus convergence loop server-side with a provider arbiter (blind pass + peer fan-out -> adjudicate -> revise) and return the converged verdict. Default depth is `consensus.maxRounds` (config, default 5); pass `maxRounds` to override. Pass `synthesizeAlways:true` for a SINGLE arbiter synthesis pass instead of the loop (best for open questions, not plan convergence): it returns a free-text `synthesis` and `maxRounds` is ignored. Configure the arbiter via `consensus.arbiter` - a concrete provider/openrouter alias runs server-side; `host` mode returns the opinions for YOU to synthesize. Advisory; pass `expert` to apply a persona. NOTE (Claude Code): use the `/consensus` slash command for the transcript-visible host-arbiter loop (it drives `consensus-step`); this tool is the provider-arbiter path for any host.", inputSchema: consensusInputSchema(), annotations: ADVISORY },
-    { name: "consensus-step", description: "Client-driven consensus loop where YOU (the host model) are the arbiter, one step per call: action=init (start, returns sessionId + blind prompt) -> record_blind (your pre-commit verdict) -> dispatch_peers (server fans out to the providers) -> submit_adjudication (your verdict + per-issue accept/dismiss/defer) -> submit_revision (your revised plan), looping until converged or consensus.maxRounds rounds (default 5). State is held server-side by sessionId. Advisory.", inputSchema: consensusStepInputSchema(), annotations: ADVISORY }
+    { name: "consensus-step", description: "Client-driven consensus loop where YOU (the host model) are the arbiter, one step per call: action=init (start, returns sessionId + blind prompt) -> record_blind (your pre-commit verdict) -> dispatch_peers (server fans out to the providers) -> submit_adjudication (your verdict + per-issue accept/dismiss/defer) -> submit_revision (your revised plan), looping until converged or consensus.maxRounds rounds (default 5). State is held server-side by sessionId. Advisory.", inputSchema: consensusStepInputSchema(), annotations: ADVISORY },
+    { name: "panel", description: "Return the names of the providers `ask-all` WOULD dispatch for the current config + expert (enabled built-ins + eligible OpenRouter aliases, fanout cap applied), WITHOUT calling them. Use this to discover the panel, then issue one `ask-one` call per provider in parallel for visible per-provider progress. Advisory, read-only.", inputSchema: panelInputSchema(), annotations: ADVISORY },
+    { name: "ask-one", description: "Second opinion from ONE named provider in the active panel (e.g. `codex`, `gemini`, `grok`, `openrouter:<alias>` - get the names from `panel`). Returns the standard result envelope. Issue N of these in parallel (one per `panel` name) so each renders independently as it lands. Advisory, single-shot.", inputSchema: askOneInputSchema(), annotations: ADVISORY }
   ];
   for (const t of Object.keys(ASK_PROVIDER)) {
     tools.push({ name: t, description: `Single-provider second opinion via ${ASK_PROVIDER[t]} (advisory, single-shot). Pass \`expert\` to apply one of the expert personas.`, inputSchema: inputSchema(), annotations: ADVISORY });
@@ -4068,8 +4350,10 @@ async function isHealthy(p) {
     return false;
   }
 }
-function buildServer({ providers, getConfig, getConfigError, sessionsDir }) {
+function buildServer({ providers, getConfig, getConfigError, sessionsDir, notify }) {
   const registry = makeRegistry(providers);
+  const sendNotify = typeof notify === "function" ? notify : (_m, _p) => {
+  };
   const sessions = (
     /** @type {any} */
     require_sessions()
@@ -4081,6 +4365,52 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir }) {
   const { parseReview } = require_provider();
   const { makeLoopStore } = require_loop_store();
   const loopStore = makeLoopStore();
+  const { makeResultCache } = require_result_cache();
+  const resultCache = makeResultCache();
+  const debugLog = require_debug_log();
+  const { resolveDebugLogPath } = require_paths();
+  let _fileCache = { key: "", logger: debugLog.NULL_LOGGER };
+  function fileSink() {
+    const dbg = (getConfig() || {}).debug || { enabled: false, path: null };
+    if (!dbg.enabled) {
+      _fileCache = { key: "", logger: debugLog.NULL_LOGGER };
+      return debugLog.NULL_LOGGER;
+    }
+    const path = typeof dbg.path === "string" && dbg.path || resolveDebugLogPath();
+    const key = `file:${path}`;
+    if (_fileCache.key !== key) _fileCache = { key, logger: debugLog.createFileLogger(path) };
+    return _fileCache.logger;
+  }
+  const LEVEL_RANK = Object.freeze({ debug: 0, info: 1, notice: 2, warning: 3, error: 4, critical: 5, alert: 6, emergency: 7 });
+  let notifyMinLevel = (
+    /** @type {keyof typeof LEVEL_RANK} */
+    "info"
+  );
+  const notifySink = {
+    /** @param {import("../../core/debug-log.js").DebugEvent} e */
+    logEvent(e) {
+      if (LEVEL_RANK.info < LEVEL_RANK[notifyMinLevel]) return;
+      try {
+        sendNotify("notifications/message", {
+          level: "info",
+          logger: "deliberation",
+          data: { event: e.event, tool: e.tool, provider: e.provider, ms: e.ms, round: e.round, verdict: e.verdict, isError: e.isError, errorKind: e.errorKind }
+        });
+      } catch {
+      }
+    }
+  };
+  function setLogLevel(level) {
+    if (typeof level === "string" && Object.prototype.hasOwnProperty.call(LEVEL_RANK, level)) {
+      notifyMinLevel = /** @type {keyof typeof LEVEL_RANK} */
+      level;
+      return true;
+    }
+    return false;
+  }
+  function currentLogger() {
+    return debugLog.composeLoggers([fileSink(), notifySink]);
+  }
   let clientName = (
     /** @type {string|null} */
     null
@@ -4183,9 +4513,17 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir }) {
       return null;
     }
   }
-  async function runAskAll(req, expert) {
+  async function runAskAll(req, expert, opts = (
+    /** @type {{noCache?:boolean}} */
+    {}
+  )) {
     const { providers: selected, omitted } = registry.selectForAskAll({ config: getConfig(), expert: expert || "" });
-    const results = await askAll(selected, withPersona(req, expert));
+    const lg = currentLogger();
+    try {
+      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 });
     return {
       payload: { results, omitted },
       parts: { opinions: results, blindVerdict: null, verdict: null, arbiter: null, warnings: [] }
@@ -4203,13 +4541,13 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir }) {
     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));
+      const opinions = await askAll(selected, withPersona(req, expert), { logger: currentLogger(), tool: "consensus" });
       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 });
+      const out2 = await consensus(selected, withPersona(req, expert), { arbiterInstructions: PROMPTS.arbiter, logger: currentLogger() });
       const arbiter2 = { mode: "server", provider: null };
       return {
         payload: { opinions: out2.opinions, blindVerdict: out2.blindVerdict, verdict: out2.verdict, error: out2.error, arbiter: arbiter2, warnings },
@@ -4222,7 +4560,7 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir }) {
       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 });
+    const out = await consensus(peers, withPersona(req, expert), { arbiter: arbiterP, arbiterInstructions: PROMPTS.arbiter, blindVote, logger: currentLogger() });
     const arbiter = { mode: "server", provider: arbiterP.name };
     return {
       payload: { opinions: out.opinions, blindVerdict: out.blindVerdict, verdict: out.verdict, error: out.error, arbiter, warnings },
@@ -4252,7 +4590,7 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir }) {
       }
       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 });
+      const out = await runToConvergence(peers, withPersona(req, expert), { arbiter: arbiterP, maxRounds, logger: currentLogger() });
       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 };
@@ -4388,9 +4726,14 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir }) {
         const ex = cur.expert || expert || void 0;
         const { providers: selected } = registry.selectForConsensus({ config: getConfig() || {}, expert: ex || "" });
         const peerReq = { prompt: peerPrompt, expert: ex, cwd: typeof args.cwd === "string" ? args.cwd : void 0 };
-        const peerResults = await askAll(selected, withPersona(peerReq, ex));
+        const lg = currentLogger();
+        try {
+          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 results = peerResults.map(
-          (r) => r.isError ? { source: r.provider, isError: true, errorKind: r.errorKind, verdict: null, criticalIssues: [] } : { ...parseReview(typeof r.text === "string" ? r.text : ""), source: r.provider, isError: false }
+          (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 }
         );
         const next = loop.addOpinions(cur, results);
         loopStore.put(sid, next);
@@ -4398,13 +4741,28 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir }) {
           sessionId: sid,
           status: next.status,
           round: next.round,
-          opinions: results.map((r) => ({ source: r.source, isError: r.isError, verdict: r.verdict, criticalIssues: r.criticalIssues })),
+          // model + reasoningEffort + ms ride along so the command can show real
+          // reasoning effort per voice (no more hardcoded "n/a") and a time footer.
+          opinions: results.map((r) => ({ source: r.source, isError: r.isError, errorKind: r.errorKind, verdict: r.verdict, criticalIssues: r.criticalIssues, model: r.model, reasoningEffort: r.reasoningEffort, ms: r.ms })),
           note: "adjudicate the opinions, then call submit_adjudication with your verdict + per-issue decisions"
         };
       }
       if (action === "submit_adjudication") {
         const decisions = Array.isArray(args.decisions) ? args.decisions : [];
         const next = loop.submitAdjudication(cur, { verdict: args.verdict, decisions });
+        try {
+          currentLogger().logEvent({
+            event: "round",
+            at: Date.now(),
+            tool: "consensus",
+            round: cur.round,
+            verdict: typeof args.verdict === "string" ? args.verdict : null,
+            converged: next.status === "converged",
+            acceptedCritical: decisions.filter((d) => d && d.action === "accept").length,
+            voices: Array.isArray(cur.results) ? cur.results.length : void 0
+          });
+        } catch {
+        }
         if (next.status === "converged") {
           const { finalReport, confidence } = loop.finalize(next);
           loopStore.delete(sid);
@@ -4443,6 +4801,23 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir }) {
       reasoningEffort: args.reasoningEffort,
       files: args.files
     };
+    if (name === "panel") {
+      const { providers: selected, omitted } = registry.selectForAskAll({ config: getConfig(), expert: expert || "" });
+      return jsonResult({
+        providers: selected.map((p) => p.name),
+        omitted: (Array.isArray(omitted) ? omitted : []).map((o) => o && o.alias || String(o))
+      });
+    }
+    if (name === "ask-one") {
+      const want = typeof args.provider === "string" ? args.provider : "";
+      const { providers: selected } = registry.selectForAskAll({ config: getConfig(), expert: expert || "" });
+      const p = selected.find((x) => x.name === want);
+      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 });
+      return jsonResult({ result });
+    }
     if (name === "ask-all") {
       const { payload, parts } = await runAskAll(req, expert);
       const sid = persistRun("ask-all", req, expert, parts);
@@ -4495,7 +4870,7 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir }) {
         cwd: typeof args.cwd === "string" ? args.cwd : void 0
       };
       const tool = rec.tool === "ask-all" ? "ask-all" : "consensus";
-      const { payload, parts } = tool === "ask-all" ? await runAskAll(childReq, childExpert) : await runConsensusTool(childReq, childExpert, { synthesizeAlways: rec.synthesizeAlways === true });
+      const { payload, parts } = tool === "ask-all" ? await runAskAll(childReq, childExpert, { noCache: true }) : await runConsensusTool(childReq, childExpert, { synthesizeAlways: rec.synthesizeAlways === true });
       if (parts) {
         const sid = persistRun(tool, childReq, childExpert, { ...parts, parentId: rec.id });
         if (sid) payload.sessionId = sid;
@@ -4506,12 +4881,12 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir }) {
     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));
+      const result = await askOne(p, withPersona(req, expert), { logger: currentLogger(), tool: "ask-one", cache: resultCache });
       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));
+      const results = await askAll(selected, withPersona({ ...req, expert: name }, expert), { logger: currentLogger(), tool: name, cache: resultCache });
       return { content: [{ type: "text", text: JSON.stringify({ results }) }] };
     }
     throw new Error(`unknown tool: ${name}`);
@@ -4521,7 +4896,12 @@ function buildServer({ providers, getConfig, getConfigError, sessionsDir }) {
       if (msg.method === "initialize") {
         const ci = msg.params && msg.params.clientInfo;
         if (ci && typeof ci.name === "string") clientName = ci.name;
-        return { jsonrpc: "2.0", id: msg.id, result: { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "deliberation-mcp", version: "0.1.0" } } };
+        return { jsonrpc: "2.0", id: msg.id, result: { protocolVersion: "2024-11-05", capabilities: { tools: {}, logging: {} }, serverInfo: { name: "deliberation-mcp", version: "0.1.0" } } };
+      }
+      if (msg.method === "logging/setLevel") {
+        const level = msg.params && msg.params.level;
+        if (!setLogLevel(level)) return { jsonrpc: "2.0", id: msg.id, error: { code: -32602, message: `invalid log level: ${String(level)}` } };
+        return { jsonrpc: "2.0", id: msg.id, result: {} };
       }
       if (msg.method === "tools/list") return { jsonrpc: "2.0", id: msg.id, result: { tools: toolList() } };
       if (msg.method === "tools/call") {
@@ -4569,7 +4949,8 @@ function startStdio() {
     })
   ];
   const sessionsDir = require_paths().resolveSessionsDir();
-  const srv = buildServer({ providers, getConfig, getConfigError, sessionsDir });
+  const notify = (method, params) => process.stdout.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
+  const srv = buildServer({ providers, getConfig, getConfigError, sessionsDir, notify });
   if (typeof globalThis.fetch !== "function") {
     console.error("deliberation-mcp requires Node 18+ (global fetch unavailable).");
     process.exit(1);

package/dist/setup.js

@@ -67,10 +67,19 @@ var require_paths = __commonJS({
       }
       return path2.join(canonicalCacheDir(home, env, platform), "sessions");
     }
+    function resolveDebugLogPath(opts) {
+      const { home, env, platform } = resolveInjection(opts);
+      const override = env.DELIBERATION_DEBUG_LOG;
+      if (typeof override === "string" && override.length > 0) {
+        return override;
+      }
+      return path2.join(canonicalCacheDir(home, env, platform), "debug.jsonl");
+    }
     module2.exports = {
       resolveConfigPath: resolveConfigPath2,
       resolveGrokCachePath,
-      resolveSessionsDir
+      resolveSessionsDir,
+      resolveDebugLogPath
     };
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antonbabenko/deliberation-mcp",
-  "version": "3.1.1",
+  "version": "3.2.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" },