braintrust-lite 0.1.6 → 0.1.7

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "braintrust-lite",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Lightweight multi-model advisor for Claude Code — parallel Codex + Gemini consultation via MCP",
   "type": "module",
   "bin": {
     "consult": "bin/consult",
-    "braintrust-lite": "src/server.js"
+    "braintrust-lite": "src/server.js",
+    "braintrust-setup": "scripts/setup.js"
   },
   "scripts": {
-    "start": "node src/server.js"
+    "start": "node src/server.js",
+    "setup": "node scripts/setup.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.10.2"
@@ -28,5 +30,11 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/HongjieRen/braintrust-lite.git"
-  }
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "scripts/",
+    "skills/"
+  ]
 }

package/scripts/setup.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import { mkdirSync, writeFileSync, existsSync, readFileSync, copyFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { spawnSync } from 'child_process';
+import https from 'https';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SKILL_DIR  = join(process.env.HOME || '/tmp', '.claude', 'skills', 'consult');
+const SKILL_PATH = join(SKILL_DIR, 'SKILL.md');
+const SKILL_URL  = 'https://raw.githubusercontent.com/HongjieRen/braintrust-lite/main/skills/consult/SKILL.md';
+const G = '\x1b[32m✓\x1b[0m', R = '\x1b[31m✗\x1b[0m';
+
+function fetch(url) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { timeout: 10000 }, res => {
+      if (res.statusCode === 301 || res.statusCode === 302) return fetch(res.headers.location).then(resolve).catch(reject);
+      if (res.statusCode !== 200) return reject(new Error(`HTTP ${res.statusCode}`));
+      let body = ''; res.on('data', d => { body += d; }); res.on('end', () => resolve(body));
+    });
+    req.on('error', reject); req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+  });
+}
+
+function getVersion(p) { try { return (readFileSync(p,'utf8').match(/^version:\s*(.+)$/m)||[])[1]?.trim(); } catch { return null; } }
+
+console.log('\nbraintrust-lite setup\n');
+console.log('Installing consult skill:');
+mkdirSync(SKILL_DIR, { recursive: true });
+if (existsSync(SKILL_PATH)) copyFileSync(SKILL_PATH, SKILL_PATH + '.bak');
+
+const bundled = join(__dirname, '..', 'skills', 'consult', 'SKILL.md');
+if (existsSync(bundled)) {
+  copyFileSync(bundled, SKILL_PATH);
+  console.log(`  ${G}  SKILL.md installed  (v${getVersion(SKILL_PATH)})`);
+} else {
+  try {
+    const content = await fetch(SKILL_URL);
+    writeFileSync(SKILL_PATH, content, 'utf8');
+    console.log(`  ${G}  SKILL.md downloaded from GitHub  (v${getVersion(SKILL_PATH)})`);
+  } catch(e) {
+    console.log(`  ${R}  SKILL.md download failed: ${e.message}`);
+    process.exitCode = 1;
+  }
+}
+
+console.log('\nRegistering MCP server:');
+const claudeOk = spawnSync('claude', ['--version'], { timeout: 5000 }).status === 0;
+if (!claudeOk) {
+  console.log(`  ${R}  claude CLI not found — install Claude Code first`);
+  console.log(`       Then: claude mcp add braintrust-lite -- npx -y braintrust-lite@~0.1`);
+  process.exitCode = 1;
+} else {
+  const list = spawnSync('claude', ['mcp', 'list'], { encoding: 'utf8', timeout: 5000 });
+  if ((list.stdout || '').includes('braintrust-lite')) {
+    console.log(`  ${G}  MCP server already registered`);
+  } else {
+    const r = spawnSync('claude', ['mcp', 'add', 'braintrust-lite', '--', 'npx', '-y', 'braintrust-lite@~0.1'], { encoding: 'utf8', timeout: 10000 });
+    if (r.status === 0) console.log(`  ${G}  MCP server registered  (npx braintrust-lite@~0.1)`);
+    else { console.log(`  ${R}  MCP registration failed`); console.log(`       Manual: claude mcp add braintrust-lite -- npx -y braintrust-lite@~0.1`); process.exitCode = 1; }
+  }
+}
+
+console.log();
+console.log(process.exitCode ? '  \x1b[33mSetup done with warnings — fix issues above.\x1b[0m' : '  \x1b[32mDone! Restart Claude Code, then use /consult.\x1b[0m');
+console.log();

package/skills/consult/SKILL.md

@@ -0,0 +1,213 @@
+---
+name: consult
+version: 1.4.0
+description: 在处理规划/设计/架构/调研类任务时，并发调用 codex + gemini + claude 获取多视角，主 Claude 担任 Judge 盲评综合输出。支持渐进式多轮对话和自动更新。
+---
+
+# consult — 多模型旁路军师
+
+## Preamble（每次调用前先执行）
+
+```bash
+_REMOTE_VER=$(curl -sf --max-time 3 "https://raw.githubusercontent.com/HongjieRen/braintrust-lite/main/skills/consult/SKILL.md" | awk '/^version:/ {print $2; exit}')
+_LOCAL_VER=$(awk '/^version:/ {print $2; exit}' ~/.claude/skills/consult/SKILL.md 2>/dev/null)
+[ -n "$_REMOTE_VER" ] && [ "$_REMOTE_VER" != "$_LOCAL_VER" ] && echo "UPGRADE_AVAILABLE $_LOCAL_VER $_REMOTE_VER" || echo "UP_TO_DATE $_LOCAL_VER"
+```
+
+**如果输出 `UPGRADE_AVAILABLE <old> <new>`**：静默自动更新，不打断用户：
+```bash
+cp ~/.claude/skills/consult/SKILL.md ~/.claude/skills/consult/SKILL.md.bak 2>/dev/null || true
+curl -fsSL "https://raw.githubusercontent.com/HongjieRen/braintrust-lite/main/skills/consult/SKILL.md" \
+  -o ~/.claude/skills/consult/SKILL.md && echo "Updated consult skill $_old → $_new"
+```
+更新完成后继续执行本次任务，在最终回复末尾附一行：`*(consult skill 已自动更新 v{old} → v{new})*`
+
+**如果输出 `UP_TO_DATE`**：直接继续，无需提示。  
+**如果 curl 失败**：忽略，继续执行，不提示用户。
+
+---
+
+## 这是什么
+
+`braintrust-lite` 提供的 MCP tool `mcp__braintrust_lite__consult` 会在后台并发调用 **Codex CLI**、**Gemini CLI** 和 **Claude CLI**，把三个顶尖模型的独立回答以匿名形式（Model A/B/C）交回给你。
+
+你（主 Claude）负责担任 Judge——盲评内容，提炼共识、标注独特洞见、裁决分歧，输出集大成方案。
+
+## 何时使用
+
+对以下类型的任务，**在启动子 agent 的同时并行调用 consult**：
+
+- 架构选型、技术选型、框架比较
+- 方案设计（新功能、重大重构、系统集成）
+- 复杂 bug 根因分析（多种假设并存时）
+- 非显而易见的技术决策（有明显 trade-off 的场景）
+- 安全或性能评审
+
+## 何时跳过
+
+- typo 修复、单行改动、简单 rename
+- 只读信息查询（用 Grep / Read 就够）
+- 用户已经明确指定方案，不需要二次意见
+- 已知有标准答案的操作性任务
+
+---
+
+## 工作流：单轮
+
+```
+1. 发一条 message，同时 parallel call：
+   ├─ Task(subagent_type=Plan/Explore/..., prompt=X)
+   └─ mcp__braintrust_lite__consult(prompt=X, timeout_sec=<见下表>)
+
+2. 等两者都返回后，你亲自担任 Judge（盲评流程）：
+
+   步骤一：只看 Model A/B/C 内容，按结构完成评估（见下方 Judge 输出格式）
+
+   步骤二：读 REVEAL 映射表
+
+   步骤三：在回复末尾揭晓：
+   "揭晓：Model A = Gemini，Model B = Claude，Model C = Codex"
+```
+
+### Judge 输出格式（必须分节，供多轮渐进加载）
+
+每轮 Judge 输出**强制使用以下四节**，不可合并：
+
+```
+### VERDICT
+<核心结论，1-3句，永远保留进历史>
+
+### REASONING
+<关键推理和裁决依据，有追问才加载>
+
+### TRADEOFFS
+<权衡分析、已排除方案及理由，用户问"有没有其他方案"时加载>
+
+### OPEN_QUESTIONS
+<未解决的分歧或待确认的假设，用户问"还有什么不确定"时加载>
+```
+
+---
+
+## 工作流：多轮对话（会话模式）
+
+### 进入信号
+
+`/consult` 触发后，第一轮回复顶部显示：
+
+```
+┌─ Consult 会话已启动 ──────────────────────────┐
+│ 模型：Codex · Gemini · Claude CLI              │
+│ 记忆：Balanced（可用 !brief / !deep 切换）      │
+│ 输入问题继续追问，或输入 /done 退出             │
+└────────────────────────────────────────────────┘
+```
+
+### 每轮状态栏（**每轮回复第一行**，始终显示）
+
+每轮 Judge 输出**最开始**，必须先输出这一行状态栏，再输出任何正文：
+
+```
+[Consult·R{N} | 3 models | Consensus: {High/Split}]
+```
+
+- `R{N}` = 第几轮，帮助用户感知多轮积累
+- `Consensus: Split` 时额外显示一行分歧摘要：`Note: split on <主要分歧点>`
+- 平时无分歧则只显示 `High`，不展开
+- 若模型降级（实际跑了少于 3 个），显示 `⚠ 2/3 models` 代替 `3 models`
+
+### 多轮上下文：渐进式加载（核心设计）
+
+**设计原则：不预先决定压缩多少，而是根据 follow-up 意图决定加载什么。**
+
+每轮结束后维护一个**会话状态对象**（始终随 prompt 携带，~100 token）：
+
+```
+[Session State]
+Goal: <用户核心目标>
+Constraints: <已确认约束>
+Decisions: <已做决策及理由>
+Rejected: <已排除选项>
+Open: <未解决问题>
+Current best: <当前推荐方案一句话>
+```
+
+历史内容**按意图懒加载**，不机械按轮次：
+
+| follow-up 意图 | 加载的历史内容 |
+|---------------|--------------|
+| 普通追问、深入某方向 | Session State + 所有历史 VERDICT |
+| "为什么这样判断" | + 最近1轮 REASONING |
+| "有没有其他方案" | + 最近1轮 TRADEOFFS |
+| "还有什么不确定" | + 最近1轮 OPEN_QUESTIONS |
+| "刚才某模型说的那个点" | + 按需检索原文片段（Model A/B/C 原始回答存档备查） |
+
+历史 VERDICT 全部保留（每条 ~50 token），其余节只保留最近1-2轮，更老的丢弃。
+
+### 自动降级
+
+用户回复是简单确认时（"好的"、"谢谢"、"明白了"等），**不触发三模型并发**，由主 Claude 直接响应，节省成本和延迟。
+
+判断标准：用户回复 < 20 字且不含实质性新问题。
+
+### 多轮终止条件
+
+- 用户输入 `/done`（或 `!stop`）
+- 用户明确表示满意（"好了"、"没问题了"）
+- 用户切换到无关新话题
+- 已进行 5 轮（自动退出，告知用户可重新 `/consult`）
+
+退出时显示：`── Consult 会话结束（共 {N} 轮）──`
+
+### 用户控制命令
+
+```
+!brief    切换到精简记忆（只带 VERDICT，适合快速迭代）
+!deep     切换到完整记忆（带最近1轮 REASONING + TRADEOFFS，适合复杂设计）
+/done     退出 Consult 会话模式（!stop 同效）
+!deltas   展开本轮三模型核心主张各一句（不显示原文全文）
+!raw      展开本轮三模型完整原始回答
+```
+
+---
+
+## consult tool 参数
+
+```
+prompt      (必须) 问题，建议精炼、自包含，含必要上下文
+only        (可选) "codex" | "gemini" | "claude" — 只调用一个
+skip        (可选) ["codex"] | ["gemini"] | ["claude"] — 跳过某个
+timeout_sec (可选) 每个模型超时秒数，默认 90；传 0 = 不限时等待完成
+blind       (可选) 默认 true；传 false 可直接看真实模型名称
+cwd         (可选) 子进程工作目录
+```
+
+## timeout 选择策略
+
+**你（主 Claude）负责决定 timeout_sec：**
+
+| 任务类型 | timeout_sec |
+|---------|------------|
+| 深度调研、市场分析、可行性研究 | **0**（不限时） |
+| 架构设计、复杂方案对比 | **0**（不限时） |
+| 代码审查、技术选型 | 180 |
+| 简单问答、快速决策 | 90（默认） |
+
+调研类任务一律传 `timeout_sec: 0`。
+
+## 成本与延迟
+
+- 每次 consult = 3 次 API 调用（codex + gemini + claude）
+- 延迟 = `max(三者响应时间)`（并发）
+- 简单问题 ~$0.05–0.20，中等 ~$0.20–0.50
+- 自动降级（简单确认）= 0 次额外 API 调用
+
+## 终端 fallback
+
+```bash
+consult "你的问题"
+consult --only codex "快速问题"
+consult --timeout 0 "深度调研问题"
+consult --dir /your/project "review this project"
+cat file.ts | consult "review this code"
+```

package/src/consult.js

@@ -1,37 +1,18 @@
 import {
   runProcess,
-  adaptCodex,
-  adaptGemini,
-  adaptClaude,
-  CODEX_ARGS_PREFIX,
-  GEMINI_ARGS_PREFIX,
-  CLAUDE_ARGS_PREFIX,
+  adaptCodex, adaptGemini, adaptClaude,
+  CODEX_ARGS_PREFIX, GEMINI_ARGS_PREFIX, CLAUDE_ARGS_PREFIX,
 } from './providers.js';
 
 const SYSTEM_PROMPT = `你是一个独立思考的高级专家。请基于自己的判断给出高质量、可执行的回答。
 要求：独立思考，不假设其他专家会补充；区分结论、依据、假设、风险；简洁但完整。`;
 
 const PROVIDERS = {
-  codex: {
-    cmd: 'codex',
-    buildArgs: prompt => [...CODEX_ARGS_PREFIX, `${SYSTEM_PROMPT}\n\n${prompt}`],
-    adapt: adaptCodex,
-  },
-  gemini: {
-    cmd: 'gemini',
-    buildArgs: prompt => ['-p', `${SYSTEM_PROMPT}\n\n${prompt}`, ...GEMINI_ARGS_PREFIX],
-    adapt: adaptGemini,
-  },
-  claude: {
-    cmd: 'claude',
-    buildArgs: prompt => [...CLAUDE_ARGS_PREFIX, `${SYSTEM_PROMPT}\n\n${prompt}`],
-    adapt: adaptClaude,
-  },
+  codex:  { cmd: 'codex',  buildArgs: p => [...CODEX_ARGS_PREFIX,  `${SYSTEM_PROMPT}\n\n${p}`], adapt: adaptCodex  },
+  gemini: { cmd: 'gemini', buildArgs: p => ['-p', `${SYSTEM_PROMPT}\n\n${p}`, ...GEMINI_ARGS_PREFIX], adapt: adaptGemini },
+  claude: { cmd: 'claude', buildArgs: p => [...CLAUDE_ARGS_PREFIX,  `${SYSTEM_PROMPT}\n\n${p}`], adapt: adaptClaude },
 };
 
-/**
- * Shuffle an array in-place using Fisher-Yates and return it.
- */
 function shuffle(arr) {
   for (let i = arr.length - 1; i > 0; i--) {
     const j = Math.floor(Math.random() * (i + 1));
@@ -40,11 +21,6 @@ function shuffle(arr) {
   return arr;
 }
 
-/**
- * Replace provider names with anonymous labels (Model A, B, C…).
- * Order is randomised so the judge cannot infer identity from position.
- * Returns { results: anonymized array, mapping: { 'Model A': 'gemini', … } }
- */
 function anonymize(results) {
   const labels = ['Model A', 'Model B', 'Model C', 'Model D', 'Model E'];
   const shuffled = shuffle([...results]);
@@ -56,44 +32,33 @@ function anonymize(results) {
   return { results: anonymized, mapping };
 }
 
-/**
- * Run a single provider and return a normalized result object.
- * Never throws — errors are captured in the `error` field.
- */
 async function runOne(name, prompt, { cwd, timeoutMs }) {
   const p = PROVIDERS[name];
   const start = Date.now();
   const raw = await runProcess(p.cmd, p.buildArgs(prompt), { cwd, timeoutMs });
   const duration_ms = Date.now() - start;
 
-  const error = raw.code === 'timeout' ? 'timeout'
-    : raw.code !== 0 ? `exit ${raw.code}`
+  const error_type = raw.error_type || null;
+  const error = error_type === 'enoent' ? 'not installed'
+    : error_type === 'timeout' ? 'timeout'
+    : error_type === 'nonzero' ? `exit ${raw.code}`
+    : error_type ? error_type
     : null;
 
   const { content } = error ? { content: '' } : p.adapt(raw);
-  return { provider: name, content, duration_ms, error };
+  return { provider: name, content, duration_ms, error, error_type };
 }
 
 /**
  * Consult Codex, Gemini, and/or Claude in parallel.
- *
- * @param {object} opts
- * @param {string}   opts.prompt       - The question to ask.
- * @param {string}   [opts.only]       - 'codex' | 'gemini' | 'claude' — only run this one.
- * @param {string[]} [opts.skip]       - Providers to skip.
- * @param {number}   [opts.timeoutMs]  - Per-provider timeout in ms (default 90 000). 0 = no timeout.
- * @param {string}   [opts.cwd]        - Working directory for subprocesses.
- * @param {boolean}  [opts.blind]      - Anonymise provider names (default true).
- * @returns {Promise<{ results: Array, mapping: object|null }>}
+ * Returns { results, mapping, successCount, totalCount }
  */
 export async function consult({ prompt, only, skip = [], timeoutMs = 90_000, cwd, blind = true } = {}) {
   const targets = Object.keys(PROVIDERS)
     .filter(name => (only ? name === only : true))
     .filter(name => !skip.includes(name));
 
-  if (targets.length === 0) {
-    throw new Error('No providers selected — check --only / --skip flags.');
-  }
+  if (targets.length === 0) throw new Error('No providers selected — check --only / --skip flags.');
 
   const settled = await Promise.allSettled(
     targets.map(name => runOne(name, prompt, { cwd, timeoutMs }))
@@ -102,11 +67,15 @@ export async function consult({ prompt, only, skip = [], timeoutMs = 90_000, cwd
   const results = targets.map((name, i) =>
     settled[i].status === 'fulfilled'
       ? settled[i].value
-      : { provider: name, content: '', duration_ms: 0, error: settled[i].reason?.message ?? 'unknown' }
+      : { provider: name, content: '', duration_ms: 0, error: 'rejected', error_type: 'rejected' }
   );
 
+  const successCount = results.filter(r => !r.error).length;
+  const totalCount = results.length;
+
   if (blind) {
-    return anonymize(results);
+    const { results: anon, mapping } = anonymize(results);
+    return { results: anon, mapping, successCount, totalCount };
   }
-  return { results, mapping: null };
+  return { results, mapping: null, successCount, totalCount };
 }

package/src/format.js

@@ -1,12 +1,15 @@
 /**
- * Format an array of provider results as human-readable Markdown.
- * Each provider gets a ## header with timing (or error), then its content.
- *
- * When a mapping is provided (blind mode), a REVEAL section is appended
- * at the end so the Judge can disclose model identity to the user AFTER
- * completing their evaluation.
+ * Format provider results as human-readable Markdown with run manifest.
  */
-export function formatAsMarkdown(results, mapping = null) {
+export function formatAsMarkdown(results, mapping = null, { successCount, totalCount } = {}) {
+  const total = totalCount ?? results.length;
+  const succeeded = successCount ?? results.filter(r => !r.error).length;
+  const degraded = succeeded < total;
+
+  // Status line (mirrors SKILL.md status bar format)
+  const modelsLabel = degraded ? `⚠ ${succeeded}/${total} models` : `${total} models`;
+  const statusLine = `[Consult | ${modelsLabel} | responses below]\n`;
+
   const body = results.map(r => {
     const label = r.error
       ? `## ${r.provider} (${r.error})`
@@ -15,28 +18,36 @@ export function formatAsMarkdown(results, mapping = null) {
     return `${label}\n\n${content}`;
   }).join('\n\n---\n\n');
 
-  if (!mapping) return body;
+  const revealSection = mapping ? buildReveal(mapping) : '';
+  const manifest = buildManifest(results, { successCount: succeeded, totalCount: total });
+
+  return `${statusLine}\n${body}${revealSection}\n\n---\n\n${manifest}`;
+}
 
-  const reveal = Object.entries(mapping)
+function buildReveal(mapping) {
+  const rows = Object.entries(mapping)
     .map(([label, provider]) => `| ${label} | **${provider}** |`)
     .join('\n');
-
-  return `${body}
-
----
-
-## 🔒 REVEAL — 仅在完成评估后阅读
+  return `\n\n---\n\n## 🔒 REVEAL — 仅在完成评估后阅读
 
 > **Judge 指令**：请先完成你的完整评估和综合输出，再阅读以下映射表，并在回复末尾告知用户每个模型对应的真实身份。
 
 | 匿名标签 | 真实模型 |
 |---------|---------|
-${reveal}`;
+${rows}`;
+}
+
+function buildManifest(results, { successCount, totalCount }) {
+  const ts = new Date().toISOString().slice(0, 19) + 'Z';
+  const degraded = successCount < totalCount;
+  const lines = results.map(r =>
+    r.error
+      ? `  - ${r.provider}: ${r.error_type || r.error}`
+      : `  - ${r.provider}: ${(r.duration_ms / 1000).toFixed(1)}s`
+  ).join('\n');
+  return `**Run manifest** · \`${ts}\` · ${successCount}/${totalCount} models${degraded ? ' ⚠ degraded' : ''}\n${lines}`;
 }
 
-/**
- * Format results as a compact JSON string for programmatic consumption.
- */
 export function formatAsJson(prompt, results, mapping = null) {
   return JSON.stringify({ prompt, results, mapping }, null, 2);
 }

package/src/providers.js

@@ -10,7 +10,8 @@ export const CLAUDE_ARGS_PREFIX = ['--output-format', 'json', '-p'];
 
 /**
  * Spawn a subprocess with an AbortController-based timeout.
- * Returns { stdout, stderr, code } — never rejects.
+ * Returns { stdout, stderr, code, error_type } — never rejects.
+ * error_type: 'enoent' | 'timeout' | 'nonzero' | 'spawn_error' | null
  */
 export function runProcess(cmd, args, { cwd, timeoutMs } = {}) {
   const ac = new AbortController();
@@ -28,23 +29,28 @@ export function runProcess(cmd, args, { cwd, timeoutMs } = {}) {
   const timer = timeoutMs ? setTimeout(() => ac.abort(), timeoutMs) : null;
 
   return new Promise(resolve => {
-    const done = code => {
+    let resolved = false;
+    const done = (code, error_type = null) => {
+      if (resolved) return;
+      resolved = true;
       if (timer) clearTimeout(timer);
-      resolve({ stdout, stderr, code });
+      resolve({ stdout, stderr, code, error_type });
     };
-    proc.on('close', done);
-    proc.on('error', err => done(err.name === 'AbortError' ? 'timeout' : -1));
+    proc.on('close', code => done(code, code !== 0 ? 'nonzero' : null));
+    proc.on('error', err => {
+      if (err.name === 'AbortError') done('timeout', 'timeout');
+      else if (err.code === 'ENOENT') done(-1, 'enoent');
+      else done(-1, 'spawn_error');
+    });
   });
 }
 
 // ─── Adapters ─────────────────────────────────────────────────────────────────
 
-/** Last-resort: take the tail of raw stdout. */
 export function fallback(rawStdout) {
   return { content: rawStdout.slice(-2000).trim() || '[no output]', parse_mode: 'fallback' };
 }
 
-/** Parse Codex JSONL stream → extract the last agent_message text. */
 export function adaptCodex(raw) {
   try {
     const events = raw.stdout.trim().split('\n').flatMap(l => {
@@ -57,7 +63,6 @@ export function adaptCodex(raw) {
   return fallback(raw.stdout);
 }
 
-/** Skip any MCP startup noise before the first '{', then extract .response */
 export function parseGeminiResponse(stdout) {
   const jsonStart = stdout.indexOf('{');
   if (jsonStart === -1) return null;
@@ -69,7 +74,6 @@ export function parseGeminiResponse(stdout) {
   return null;
 }
 
-/** Parse Gemini JSON output → content string. */
 export function adaptGemini(raw) {
   try {
     const response = parseGeminiResponse(raw.stdout);
@@ -78,7 +82,6 @@ export function adaptGemini(raw) {
   return fallback(raw.stdout);
 }
 
-/** Parse Claude CLI JSON output → extract .result text. */
 export function adaptClaude(raw) {
   try {
     const j = JSON.parse(raw.stdout);

package/src/server.js

@@ -1,94 +1,60 @@
 #!/usr/bin/env node
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { consult } from './consult.js';
 import { formatAsMarkdown } from './format.js';
 
-// ─── Tool definition ──────────────────────────────────────────────────────────
-
 const CONSULT_TOOL = {
   name: 'consult',
-  description:
-    '并发调用 Codex 和 Gemini CLI，获取两个顶尖模型对同一问题的独立视角。' +
-    '适合架构选型、方案设计、技术决策、复杂调研。' +
-    '调用方（通常是主 Claude）负责综合融合输出，自己担任 Judge。' +
-    '不适合：typo 修复、单行改动、只读信息查询。',
+  description: '并发调用 Codex、Gemini、Claude CLI，获取三个模型的独立视角。适合架构选型、方案设计、技术决策、复杂调研。调用方担任 Judge 盲评综合输出。不适合：typo 修复、单行改动、只读查询。',
   inputSchema: {
     type: 'object',
     properties: {
-      prompt: {
-        type: 'string',
-        description: '要问两个模型的问题。建议精炼、自包含（含必要上下文）。',
-      },
-      only: {
-        type: 'string',
-        enum: ['codex', 'gemini', 'claude'],
-        description: '只调用指定一个模型（省成本或调试）。',
-      },
-      skip: {
-        type: 'array',
-        items: { type: 'string', enum: ['codex', 'gemini', 'claude'] },
-        description: '跳过指定模型列表。',
-      },
-      timeout_sec: {
-        type: 'number',
-        description: '每个模型的超时秒数，默认 90。传 0 表示不限时，等待直到完成。',
-      },
-      blind: {
-        type: 'boolean',
-        description: '匿名化 provider 名称（默认 true）。结果以 Model A/B/C 呈现，顺序随机打乱，Judge 无法通过名字或位置判断来源。传 false 可查看真实模型名称。',
-      },
-      cwd: {
-        type: 'string',
-        description: '子进程工作目录，默认继承 MCP server 的 cwd。',
-      },
+      prompt:      { type: 'string',  description: '要问各模型的问题，建议精炼自包含。' },
+      only:        { type: 'string',  enum: ['codex', 'gemini', 'claude'], description: '只调用指定一个模型。' },
+      skip:        { type: 'array',   items: { type: 'string', enum: ['codex', 'gemini', 'claude'] }, description: '跳过指定模型。' },
+      timeout_sec: { type: 'number',  description: '每个模型超时秒数，默认 90。0 = 不限时。' },
+      blind:       { type: 'boolean', description: '匿名化 provider 名称（默认 true）。' },
+      cwd:         { type: 'string',  description: '子进程工作目录。' },
     },
     required: ['prompt'],
   },
 };
 
-// ─── Server setup ─────────────────────────────────────────────────────────────
-
 const server = new Server(
-  { name: 'braintrust-lite', version: '0.1.0' },
+  { name: 'braintrust-lite', version: '0.1.7' },
   { capabilities: { tools: {} } }
 );
 
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [CONSULT_TOOL],
-}));
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [CONSULT_TOOL] }));
 
 server.setRequestHandler(CallToolRequestSchema, async req => {
-  if (req.params.name !== 'consult') {
-    throw new Error(`Unknown tool: ${req.params.name}`);
-  }
+  if (req.params.name !== 'consult') throw new Error(`Unknown tool: ${req.params.name}`);
 
   const args = req.params.arguments ?? {};
-  const { results, mapping } = await consult({
-    prompt: String(args.prompt ?? ''),
-    only: args.only,
-    skip: Array.isArray(args.skip) ? args.skip : [],
-    timeoutMs: args.timeout_sec != null ? Number(args.timeout_sec) * 1000 : 90_000,
-    blind: args.blind !== false,
-    cwd: args.cwd,
+  const timeoutMs = args.timeout_sec != null
+    ? (Number(args.timeout_sec) === 0 ? 0 : Number(args.timeout_sec) * 1000)
+    : 90_000;
+
+  const { results, mapping, successCount, totalCount } = await consult({
+    prompt:    String(args.prompt ?? ''),
+    only:      args.only,
+    skip:      Array.isArray(args.skip) ? args.skip : [],
+    timeoutMs,
+    blind:     args.blind !== false,
+    cwd:       args.cwd,
   });
 
   if (results.every(r => r.error)) {
-    throw new Error(
-      `All providers failed: ${results.map(r => `${r.provider}=${r.error}`).join(', ')}`
-    );
+    const detail = results.map(r => `${r.provider}=${r.error_type || r.error}`).join(', ');
+    throw new Error(`All providers failed: ${detail}`);
   }
 
   return {
-    content: [{ type: 'text', text: formatAsMarkdown(results, mapping) }],
+    content: [{ type: 'text', text: formatAsMarkdown(results, mapping, { successCount, totalCount }) }],
   };
 });
 
-// ─── Start ────────────────────────────────────────────────────────────────────
-
 const transport = new StdioServerTransport();
 await server.connect(transport);