@dmsdc-ai/aigentry-deliberation 0.0.18 → 0.0.20

package/doctor.js

@@ -0,0 +1,440 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Connection Doctor — aigentry-deliberation
+ *
+ * Triages MCP connection failures across all registered CLI environments:
+ *   - ~/.codex/config.toml   (Codex CLI)
+ *   - ~/.claude/.mcp.json    (Claude Code)
+ *   - ~/.gemini/settings.json (Gemini CLI)
+ *
+ * Checks:
+ *   1. Path existence for every mcp_servers.* entry
+ *   2. Temp-path detection (/var/folders, /tmp, /_npx)
+ *   3. MODULE_NOT_FOUND traces in logs
+ *
+ * Usage:
+ *   node doctor.js
+ *   npx @dmsdc-ai/aigentry-deliberation doctor
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+
+const HOME = process.env.HOME || process.env.USERPROFILE || "";
+const IS_WIN = process.platform === "win32";
+
+// ── Config file locations ──────────────────────────────────────
+
+const CONFIGS = [
+  {
+    name: "Codex CLI",
+    path: path.join(HOME, ".codex", "config.toml"),
+    format: "toml",
+  },
+  {
+    name: "Claude Code",
+    path: path.join(HOME, ".claude", ".mcp.json"),
+    format: "json",
+  },
+  {
+    name: "Gemini CLI",
+    path: path.join(HOME, ".gemini", "settings.json"),
+    format: "json",
+  },
+];
+
+// Temp path patterns that indicate npx/ephemeral installs
+const TEMP_PATTERNS = [
+  /[/\\]_npx[/\\]/,
+  /[/\\]\.npm[/\\]_npx[/\\]/,
+  /^\/var\/folders\//,
+  /^\/tmp\//,
+  /^\/private\/var\/folders\//,
+  /[/\\]Temp[/\\]/i,
+  /^C:\\Users\\[^\\]+\\AppData\\Local\\Temp\\/i,
+];
+
+// Log locations to scan for MODULE_NOT_FOUND
+const LOG_LOCATIONS = [
+  path.join(HOME, ".codex", "log"),
+  path.join(HOME, ".local", "lib", "mcp-deliberation", "runtime.log"),
+];
+
+// ── TOML parser (minimal, mcp_servers only) ────────────────────
+
+function parseMcpServersFromToml(content) {
+  const servers = {};
+  const lines = content.split("\n");
+  let currentServer = null;
+
+  for (const raw of lines) {
+    const line = raw.trim();
+
+    // Match [mcp_servers.NAME] or [mcp_servers.NAME.env]
+    const sectionMatch = line.match(/^\[mcp_servers\.([^\].]+)\]$/);
+    if (sectionMatch) {
+      currentServer = sectionMatch[1];
+      if (!servers[currentServer]) {
+        servers[currentServer] = { command: null, args: [] };
+      }
+      continue;
+    }
+
+    // Skip sub-sections like [mcp_servers.NAME.env]
+    if (/^\[/.test(line)) {
+      if (!/^\[mcp_servers\./.test(line)) currentServer = null;
+      continue;
+    }
+
+    if (!currentServer) continue;
+
+    // command = "node"
+    const cmdMatch = line.match(/^command\s*=\s*"([^"]+)"/);
+    if (cmdMatch) {
+      servers[currentServer].command = cmdMatch[1];
+      continue;
+    }
+
+    // args = ["path1", "path2"]
+    const argsMatch = line.match(/^args\s*=\s*\[([^\]]*)\]/);
+    if (argsMatch) {
+      servers[currentServer].args = argsMatch[1]
+        .split(",")
+        .map((s) => s.trim().replace(/^"|"$/g, ""))
+        .filter(Boolean);
+    }
+  }
+
+  return servers;
+}
+
+// ── JSON parser ────────────────────────────────────────────────
+
+function parseMcpServersFromJson(content) {
+  try {
+    const parsed = JSON.parse(content);
+    return parsed.mcpServers || {};
+  } catch {
+    return null; // parse error
+  }
+}
+
+// ── Path resolution ────────────────────────────────────────────
+
+function resolveServerPaths(server) {
+  const paths = [];
+
+  // Extract paths from args
+  if (Array.isArray(server.args)) {
+    for (const arg of server.args) {
+      // Skip flags and short args
+      if (arg.startsWith("-") || arg.startsWith("@")) continue;
+      // Skip bare package names (no path separator)
+      if (!arg.includes("/") && !arg.includes("\\")) continue;
+      // Expand ~
+      const resolved = arg.startsWith("~")
+        ? path.join(HOME, arg.slice(1))
+        : arg;
+      paths.push(resolved);
+    }
+  }
+
+  return paths;
+}
+
+// ── Checks ─────────────────────────────────────────────────────
+
+function checkPathExists(p) {
+  try {
+    return fs.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+
+function isTempPath(p) {
+  return TEMP_PATTERNS.some((re) => re.test(p));
+}
+
+function isNpxCommand(server) {
+  return server.command === "npx";
+}
+
+function scanLogsForModuleNotFound(logPaths, limit = 50) {
+  const findings = [];
+
+  for (const logPath of logPaths) {
+    if (!fs.existsSync(logPath)) continue;
+
+    // For directories, scan recent files
+    const stat = fs.statSync(logPath);
+    const files = stat.isDirectory()
+      ? fs
+          .readdirSync(logPath)
+          .filter((f) => f.endsWith(".log") || f.endsWith(".txt") || f.endsWith(".jsonl"))
+          .map((f) => path.join(logPath, f))
+      : [logPath];
+
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(file, "utf-8");
+        const lines = content.split("\n");
+        // Scan last N lines for "Cannot find module" (the actionable line)
+        // Skip bare "code: 'MODULE_NOT_FOUND'" lines — they duplicate the real error
+        const recent = lines.slice(-limit);
+        for (const line of recent) {
+          const cfm = line.match(/Cannot find module '([^']+)'/);
+          if (cfm) {
+            findings.push({
+              file: path.basename(file),
+              module: cfm[1],
+              line: line.trim().slice(0, 200),
+            });
+          }
+        }
+      } catch {
+        /* skip unreadable files */
+      }
+    }
+  }
+
+  return findings;
+}
+
+// ── Fix suggestions ────────────────────────────────────────────
+
+function suggestFix(serverName, server, issue) {
+  switch (issue) {
+    case "path_missing":
+      if (serverName === "deliberation" || serverName === "mcp-deliberation") {
+        return `npx @dmsdc-ai/aigentry-deliberation install`;
+      }
+      if (serverName.includes("brain") || serverName.includes("aigentry-brain")) {
+        return `npx @dmsdc-ai/aigentry-brain install`;
+      }
+      if (isNpxCommand(server)) {
+        const pkg = (server.args || []).find((a) => a.startsWith("@") || !a.startsWith("-"));
+        return pkg ? `npx -y ${pkg}  # npx 서버는 자동 설치됩니다` : null;
+      }
+      return `# ${serverName}: 서버 파일을 올바른 경로에 설치하세요`;
+
+    case "temp_path": {
+      const tempArg = (server.args || []).find((a) => isTempPath(a));
+      if (serverName === "deliberation" || serverName === "mcp-deliberation") {
+        return `npx @dmsdc-ai/aigentry-deliberation install  # 영구 경로로 재설치`;
+      }
+      if (serverName.includes("brain") || serverName.includes("aigentry-brain")) {
+        return `npx @dmsdc-ai/aigentry-brain install  # 영구 경로로 재설치`;
+      }
+      return `# ${serverName}: 임시 경로(${tempArg}) → 영구 경로로 변경 필요`;
+    }
+
+    case "module_not_found":
+      if (isNpxCommand(server)) {
+        const pkg = (server.args || []).find((a) => a.startsWith("@") || !a.startsWith("-"));
+        return pkg ? `npm install -g ${pkg}` : `# ${serverName}: 패키지를 전역 설치하세요`;
+      }
+      return `cd $(dirname "${(server.args || [])[0] || ""}") && npm install`;
+
+    default:
+      return null;
+  }
+}
+
+// ── Main diagnostic ────────────────────────────────────────────
+
+function runDiagnostics() {
+  console.log("\n🩺 MCP Connection Doctor — aigentry-deliberation\n");
+  console.log("━".repeat(60));
+
+  let totalServers = 0;
+  let totalIssues = 0;
+  const allIssues = [];
+
+  // ── Phase 1: Config file scanning ──
+
+  for (const cfg of CONFIGS) {
+    console.log(`\n📋 ${cfg.name}: ${cfg.path}`);
+
+    if (!fs.existsSync(cfg.path)) {
+      console.log("   ⚠️  설정 파일 없음 (스킵)");
+      continue;
+    }
+
+    const content = fs.readFileSync(cfg.path, "utf-8");
+    let servers;
+
+    if (cfg.format === "toml") {
+      servers = parseMcpServersFromToml(content);
+    } else {
+      servers = parseMcpServersFromJson(content);
+      if (servers === null) {
+        console.log("   ❌ JSON 파싱 실패");
+        totalIssues++;
+        allIssues.push({
+          config: cfg.name,
+          server: "(전체)",
+          issue: "JSON 파싱 실패",
+          fix: `# ${cfg.path} 파일의 JSON 문법을 확인하세요`,
+        });
+        continue;
+      }
+    }
+
+    const serverEntries = Object.entries(servers);
+    if (serverEntries.length === 0) {
+      console.log("   (등록된 MCP 서버 없음)");
+      continue;
+    }
+
+    for (const [name, server] of serverEntries) {
+      totalServers++;
+      const issues = [];
+      const filePaths = resolveServerPaths(server);
+
+      // Check 1: npx command (volatile but expected)
+      if (isNpxCommand(server)) {
+        console.log(`   ✅ ${name}: npx (자동 설치)`);
+        continue;
+      }
+
+      // Check paths: temp path (root cause) takes priority over missing
+      for (const p of filePaths) {
+        if (isTempPath(p)) {
+          issues.push({ type: "temp_path", detail: p });
+        } else if (!checkPathExists(p)) {
+          issues.push({ type: "path_missing", detail: p });
+        }
+      }
+
+      if (issues.length === 0) {
+        console.log(`   ✅ ${name}: 정상`);
+      } else {
+        for (const issue of issues) {
+          totalIssues++;
+          const fix = suggestFix(name, server, issue.type);
+          const label =
+            issue.type === "path_missing"
+              ? "❌ 경로 없음"
+              : "⚠️  임시 경로";
+          console.log(`   ${label}: ${name}`);
+          console.log(`      경로: ${issue.detail}`);
+          if (fix) console.log(`      복구: ${fix}`);
+          allIssues.push({
+            config: cfg.name,
+            server: name,
+            issue: label,
+            path: issue.detail,
+            fix,
+          });
+        }
+      }
+    }
+  }
+
+  // ── Phase 2: MODULE_NOT_FOUND log scan ──
+
+  console.log(`\n📜 로그 스캔 (MODULE_NOT_FOUND)`);
+  const moduleFindings = scanLogsForModuleNotFound(LOG_LOCATIONS);
+
+  if (moduleFindings.length === 0) {
+    console.log("   ✅ MODULE_NOT_FOUND 흔적 없음");
+  } else {
+    // Deduplicate by module path
+    const seen = new Set();
+    for (const f of moduleFindings) {
+      if (seen.has(f.module)) continue;
+      seen.add(f.module);
+      totalIssues++;
+      console.log(`   ❌ ${f.file}: Cannot find module '${f.module}'`);
+
+      // Generate smart fix based on module path
+      let fix;
+      const mod = f.module;
+      if (isTempPath(mod)) {
+        if (mod.includes("aigentry-brain") || mod.includes("brain")) {
+          fix = `npx @dmsdc-ai/aigentry-brain install  # 임시 경로 → 영구 설치`;
+        } else if (mod.includes("deliberation") || mod.includes("mcp-deliberation")) {
+          fix = `npx @dmsdc-ai/aigentry-deliberation install  # 임시 경로 → 영구 설치`;
+        } else {
+          fix = `# 임시 경로(${mod}) — MCP 설정에서 영구 경로로 변경 필요`;
+        }
+      } else {
+        fix = `# ${mod} 파일이 존재하지 않음 — 해당 MCP 서버 재설치 필요`;
+      }
+
+      console.log(`      복구: ${fix}`);
+      allIssues.push({ config: "logs", server: mod, issue: "MODULE_NOT_FOUND", fix });
+    }
+  }
+
+  // ── Phase 3: deliberation self-check ──
+
+  console.log(`\n🔍 deliberation 자체 점검`);
+  const installDir = IS_WIN
+    ? path.join(
+        process.env.LOCALAPPDATA ||
+          path.join(HOME, "AppData", "Local"),
+        "mcp-deliberation"
+      )
+    : path.join(HOME, ".local", "lib", "mcp-deliberation");
+
+  const selfPath = path.join(installDir, "index.js");
+  if (checkPathExists(selfPath)) {
+    console.log(`   ✅ 서버 파일: ${selfPath}`);
+  } else {
+    totalIssues++;
+    console.log(`   ❌ 서버 파일 없음: ${selfPath}`);
+    console.log(`      복구: npx @dmsdc-ai/aigentry-deliberation install`);
+  }
+
+  // Check node_modules
+  const nodeModules = path.join(installDir, "node_modules");
+  if (checkPathExists(nodeModules)) {
+    console.log(`   ✅ node_modules: 설치됨`);
+  } else {
+    totalIssues++;
+    console.log(`   ❌ node_modules 없음`);
+    console.log(`      복구: cd ${installDir} && npm install`);
+  }
+
+  // Syntax check
+  try {
+    execSync(`node --check "${selfPath}"`, { stdio: "pipe", timeout: 5000 });
+    console.log(`   ✅ 문법 검증: 통과`);
+  } catch {
+    totalIssues++;
+    console.log(`   ❌ 문법 오류 감지`);
+    console.log(`      복구: npx @dmsdc-ai/aigentry-deliberation install`);
+  }
+
+  // ── Summary ──
+
+  console.log("\n" + "━".repeat(60));
+  if (totalIssues === 0) {
+    console.log(`\n✅ 전체 정상 — ${totalServers}개 MCP 서버 점검 완료\n`);
+  } else {
+    console.log(`\n❌ ${totalIssues}개 문제 발견 (${totalServers}개 서버 점검)\n`);
+
+    if (allIssues.length > 0) {
+      console.log("📌 즉시 복구 커맨드:\n");
+      const fixSet = new Set();
+      for (const issue of allIssues) {
+        if (issue.fix && !fixSet.has(issue.fix)) {
+          fixSet.add(issue.fix);
+          console.log(`   ${issue.fix}`);
+        }
+      }
+      console.log();
+    }
+  }
+
+  return totalIssues === 0 ? 0 : 1;
+}
+
+// ── Entry point ────────────────────────────────────────────────
+
+const exitCode = runDiagnostics();
+process.exit(exitCode);

package/index.js

@@ -2515,19 +2515,11 @@ server.tool(
         nonLiveCli.push(s);
       }
     }
+    // Warn but proceed — user explicitly selected these speakers.
+    // cli_auto_turn will handle runtime errors per-turn.
+    let detectWarningLiveness = "";
     if (nonLiveCli.length > 0) {
-      const liveSpeakers = speakerOrder.filter(s => !nonLiveCli.includes(s));
-      const liveSnapshot = await collectSpeakerCandidates({ include_cli: true, include_browser: true });
-      const candidateText = formatSpeakerCandidatesReport(liveSnapshot);
-      const liveList = liveSpeakers.length > 0
-        ? `\n\n실행 가능한 스피커만으로 시작하려면:\ndeliberation_start(topic: "${topic.slice(0, 50)}...", speakers: ${JSON.stringify(liveSpeakers)})`
-        : "";
-      return {
-        content: [{
-          type: "text",
-          text: `⚠️ 일부 CLI 스피커가 현재 실행 불가합니다:\n${nonLiveCli.map(s => `  - \`${s}\` ❌`).join("\n")}\n\n실행 가능: ${liveSpeakers.length > 0 ? liveSpeakers.map(s => `\`${s}\``).join(", ") : "(없음)"}\n\n${candidateText}${liveList}\n\n실행 불가 원인: CLI가 설치되지 않았거나, 중첩 세션 제약, 또는 인증 만료일 수 있습니다.`,
-        }],
-      };
+      detectWarningLiveness = `\n\n⚠️ 일부 CLI가 현재 실행 불가 상태이지만 사용자 선택을 존중하여 진행합니다:\n${nonLiveCli.map(s => `  - \`${s}\` ❌`).join("\n")}\n턴 진행 시 CLI 실행을 재시도합니다. 실패 시 해당 턴에서 오류가 보고됩니다.`;
     }
 
     const participantMode = hasManualSpeakers
@@ -2622,7 +2614,7 @@ server.tool(
     return {
       content: [{
         type: "text",
-        text: `✅ Deliberation 시작! Forum이 생성되었습니다.\n\n**세션:** ${sessionId}\n**프로젝트:** ${state.project}\n**주제:** ${topic}\n**라운드:** ${rounds}\n**발언 순서:** ${state.ordering_strategy || "cyclic"}\n**참가자 구성:** ${participantMode}\n**참가자:** ${speakerOrder.join(", ")}\n**첫 발언:** ${state.current_speaker}\n**동시 진행 세션:** ${active.length}개${terminalMsg}${detectWarning}\n\n**역할 배정:**${role_preset ? ` (프리셋: ${role_preset})` : ""}\n${speakerOrder.map(s => `  - \`${s}\`: ${(state.speaker_roles || {})[s] || "free"}`).join("\n")}\n\n**환경 상태:**\n${formatDegradationReport(state.degradation)}\n\n**Transport 라우팅:**\n${transportSummary}\n\n💡 이후 도구 호출 시 session_id: "${sessionId}" 를 사용하세요.\n📋 Forum 상태 조회: \`deliberation_status(session_id: "${sessionId}")\``,
+        text: `✅ Deliberation 시작! Forum이 생성되었습니다.\n\n**세션:** ${sessionId}\n**프로젝트:** ${state.project}\n**주제:** ${topic}\n**라운드:** ${rounds}\n**발언 순서:** ${state.ordering_strategy || "cyclic"}\n**참가자 구성:** ${participantMode}\n**참가자:** ${speakerOrder.join(", ")}\n**첫 발언:** ${state.current_speaker}\n**동시 진행 세션:** ${active.length}개${terminalMsg}${detectWarning}${detectWarningLiveness}\n\n**역할 배정:**${role_preset ? ` (프리셋: ${role_preset})` : ""}\n${speakerOrder.map(s => `  - \`${s}\`: ${(state.speaker_roles || {})[s] || "free"}`).join("\n")}\n\n**환경 상태:**\n${formatDegradationReport(state.degradation)}\n\n**Transport 라우팅:**\n${transportSummary}\n\n💡 이후 도구 호출 시 session_id: "${sessionId}" 를 사용하세요.\n📋 Forum 상태 조회: \`deliberation_status(session_id: "${sessionId}")\``,
       }],
     };
   })
@@ -3697,6 +3689,23 @@ const __currentFile = new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "
 const __entryFile = process.argv[1] ? path.resolve(process.argv[1]) : null;
 if (__entryFile && path.resolve(__currentFile) === __entryFile) {
   const transport = new StdioServerTransport();
+
+  // ── Gemini CLI compatibility: strip $schema from tool inputSchemas ──
+  // Gemini CLI strictly validates MCP tool schemas and rejects $schema metadata
+  // that zod-to-json-schema adds. Intercept transport.send to patch tools/list responses.
+  const _origSend = transport.send.bind(transport);
+  transport.send = (message) => {
+    if (message.result && Array.isArray(message.result.tools)) {
+      for (const tool of message.result.tools) {
+        if (tool.inputSchema) {
+          delete tool.inputSchema["$schema"];
+          if (!tool.inputSchema.type) tool.inputSchema.type = "object";
+        }
+      }
+    }
+    return _origSend(message);
+  };
+
   await server.connect(transport);
 }
 

package/install.js

@@ -10,8 +10,9 @@
  * What it does:
  *   1. Copies server files to ~/.local/lib/mcp-deliberation/
  *   2. Installs npm dependencies
- *   3. Registers MCP server in ~/.claude/.mcp.json
- *   4. Ready to use — next Claude Code session will auto-load
+ *   3. Registers MCP server in ~/.claude/.mcp.json (Claude Code)
+ *   4. Registers MCP server in ~/.gemini/settings.json (Gemini CLI)
+ *   5. Ready to use — next Claude Code or Gemini CLI session will auto-load
  */
 
 import { execSync } from "node:child_process";
@@ -26,6 +27,7 @@ const INSTALL_DIR = IS_WIN
   ? path.join(process.env.LOCALAPPDATA || path.join(HOME, "AppData", "Local"), "mcp-deliberation")
   : path.join(HOME, ".local", "lib", "mcp-deliberation");
 const MCP_CONFIG = path.join(HOME, ".claude", ".mcp.json");
+const GEMINI_CONFIG = path.join(HOME, ".gemini", "settings.json");
 
 /** Normalize path to forward slashes for JSON config (Windows backslash → forward slash) */
 function toForwardSlash(p) {
@@ -38,6 +40,7 @@ const FILES_TO_COPY = [
   "browser-control-port.js",
   "degradation-state-machine.js",
   "model-router.js",
+  "doctor.js",
   "session-monitor.sh",
   "session-monitor-win.js",
   "package.json",
@@ -137,7 +140,34 @@ function install() {
     ? "   → 기존 등록 업데이트 완료"
     : "   → 새로 등록 완료");
 
-  // Step 5: Make session-monitor.sh executable
+  // Step 5: Register Gemini CLI MCP server
+  log("🔧 Gemini CLI MCP 서버 등록 시도...");
+  const geminiDir = path.join(HOME, ".gemini");
+  if (!fs.existsSync(geminiDir)) fs.mkdirSync(geminiDir, { recursive: true });
+
+  let geminiConfig = {};
+  if (fs.existsSync(GEMINI_CONFIG)) {
+    try {
+      geminiConfig = JSON.parse(fs.readFileSync(GEMINI_CONFIG, "utf-8"));
+    } catch {
+      geminiConfig = {};
+    }
+  }
+
+  if (!geminiConfig.mcpServers) geminiConfig.mcpServers = {};
+
+  const geminiAlreadyRegistered = !!geminiConfig.mcpServers.deliberation;
+  geminiConfig.mcpServers.deliberation = {
+    command: "node",
+    args: [toForwardSlash(path.join(INSTALL_DIR, "index.js"))],
+  };
+
+  fs.writeFileSync(GEMINI_CONFIG, JSON.stringify(geminiConfig, null, 2));
+  log(geminiAlreadyRegistered
+    ? "   → Gemini CLI 기존 등록 업데이트 완료"
+    : "   → Gemini CLI 새로 등록 완료");
+
+  // Step 6: Make session-monitor.sh executable
   const monitorScript = path.join(INSTALL_DIR, "session-monitor.sh");
   if (fs.existsSync(monitorScript)) {
     try {
@@ -154,7 +184,7 @@ function install() {
   // Done
   console.log("\n✅ 설치 완료!\n");
   console.log("  다음 단계:");
-  console.log("  1. Claude Code 세션을 재시작하세요");
+  console.log("  1. Claude Code 또는 Gemini CLI 세션을 재시작하세요");
   console.log("  2. \"토론 시작해\" 또는 deliberation_start(topic: \"...\") 호출");
   console.log("  3. 첫 사용 시 온보딩 위저드가 기본 설정을 안내합니다\n");
 }
@@ -175,18 +205,31 @@ Options:
 
 설치 경로: ${INSTALL_DIR}
 MCP 설정:  ${MCP_CONFIG}
+Gemini:    ${GEMINI_CONFIG}
 `);
 } else if (args.includes("--uninstall") || args.includes("uninstall")) {
   console.log("\n🗑️ Deliberation MCP Server 제거\n");
 
-  // Remove from MCP config
+  // Remove from Claude MCP config
   if (fs.existsSync(MCP_CONFIG)) {
     try {
       const mcpConfig = JSON.parse(fs.readFileSync(MCP_CONFIG, "utf-8"));
       if (mcpConfig.mcpServers?.deliberation) {
         delete mcpConfig.mcpServers.deliberation;
         fs.writeFileSync(MCP_CONFIG, JSON.stringify(mcpConfig, null, 2));
-        log("MCP 등록 해제 완료");
+        log("Claude Code MCP 등록 해제 완료");
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Remove from Gemini CLI config
+  if (fs.existsSync(GEMINI_CONFIG)) {
+    try {
+      const geminiConfig = JSON.parse(fs.readFileSync(GEMINI_CONFIG, "utf-8"));
+      if (geminiConfig.mcpServers?.deliberation) {
+        delete geminiConfig.mcpServers.deliberation;
+        fs.writeFileSync(GEMINI_CONFIG, JSON.stringify(geminiConfig, null, 2));
+        log("Gemini CLI MCP 등록 해제 완료");
       }
     } catch { /* ignore */ }
   }
@@ -197,7 +240,7 @@ MCP 설정:  ${MCP_CONFIG}
     log("설치 디렉토리 삭제 완료");
   }
 
-  console.log("\n✅ 제거 완료. Claude Code를 재시작하세요.\n");
+  console.log("\n✅ 제거 완료. Claude Code / Gemini CLI를 재시작하세요.\n");
 } else {
   install();
 }

package/model-router.js

@@ -0,0 +1,224 @@
+// model-router.js
+// Dynamic model selection based on deliberation prompt context
+
+const CATEGORY_KEYWORDS = {
+  reasoning: [
+    'analyze', 'analysis', 'debug', 'debugging', 'complex', 'logic', 'reasoning',
+    'problem', 'solve', 'evaluate', 'assess', 'critique', 'argument', 'inference',
+    'contradiction', 'flaw', 'why', 'explain', 'cause', 'effect', 'implication',
+    'consequence', 'tradeoff', 'compare', 'pros', 'cons', 'decision', 'strategy',
+    'architecture', 'design pattern', 'refactor', 'optimize', 'performance',
+  ],
+  coding: [
+    'code', 'implement', 'function', 'class', 'module', 'api', 'library',
+    'algorithm', 'data structure', 'typescript', 'javascript', 'python', 'rust',
+    'build', 'deploy', 'test', 'unit test', 'integration', 'bug', 'fix', 'error',
+    'syntax', 'runtime', 'compile', 'script', 'program', 'software', 'feature',
+    'endpoint', 'schema', 'database', 'query', 'sql', 'migration', 'lint',
+  ],
+  creative: [
+    'write', 'writing', 'design', 'brainstorm', 'idea', 'creative', 'story',
+    'narrative', 'style', 'tone', 'voice', 'draft', 'outline', 'concept',
+    'vision', 'imagine', 'suggest', 'propose', 'generate', 'name', 'brand',
+    'ui', 'ux', 'interface', 'experience', 'aesthetic', 'layout', 'visual',
+  ],
+  research: [
+    'research', 'find', 'search', 'fact', 'data', 'statistic', 'source',
+    'reference', 'study', 'survey', 'report', 'paper', 'documentation', 'docs',
+    'compare', 'benchmark', 'review', 'overview', 'summary', 'what is', 'who is',
+    'history', 'background', 'context', 'information', 'knowledge',
+  ],
+  simple: [
+    'yes', 'no', 'confirm', 'ok', 'okay', 'agree', 'disagree', 'correct',
+    'hello', 'hi', 'thanks', 'thank you', 'sure', 'got it', 'understood',
+    'clarify', 'quick', 'brief', 'simple', 'basic',
+  ],
+};
+
+const COMPLEXITY_KEYWORDS = {
+  high: [
+    'complex', 'complicated', 'difficult', 'challenging', 'sophisticated',
+    'advanced', 'deep', 'thorough', 'comprehensive', 'exhaustive', 'detailed',
+    'multi-step', 'multi-faceted', 'nuanced', 'ambiguous', 'architecture',
+    'system', 'scalable', 'distributed', 'concurrent', 'critical', 'production',
+  ],
+  low: [
+    'simple', 'basic', 'quick', 'brief', 'short', 'easy', 'trivial',
+    'straightforward', 'obvious', 'clear', 'confirm', 'yes', 'no', 'agree',
+    'ok', 'sure', 'hello', 'hi',
+  ],
+};
+
+const ROLE_KEYWORDS = {
+  critic: 'reasoning',
+  implementer: 'coding',
+  mediator: 'creative',
+  researcher: 'research',
+};
+
+/**
+ * Count keyword matches in text for a given keyword list.
+ */
+function countMatches(text, keywords) {
+  const lower = text.toLowerCase();
+  return keywords.reduce((count, kw) => {
+    return count + (lower.includes(kw.toLowerCase()) ? 1 : 0);
+  }, 0);
+}
+
+/**
+ * Analyze deliberation context to determine category and complexity.
+ * @param {string} topic - The deliberation topic
+ * @param {string} recentLog - Recent log text from deliberation
+ * @param {string} role - The speaker's role
+ * @returns {{ category: string, complexity: string }}
+ */
+export function analyzePromptContext(topic, recentLog, role) {
+  const text = `${topic} ${recentLog}`;
+
+  // Role-based category hint
+  let roleCategory = null;
+  if (role) {
+    const lowerRole = role.toLowerCase();
+    for (const [keyword, category] of Object.entries(ROLE_KEYWORDS)) {
+      if (lowerRole.includes(keyword)) {
+        roleCategory = category;
+        break;
+      }
+    }
+  }
+
+  // Keyword-based category scoring
+  const scores = {};
+  for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
+    scores[category] = countMatches(text, keywords);
+  }
+
+  // Find top category by keyword score
+  let topCategory = 'simple';
+  let topScore = 0;
+  for (const [category, score] of Object.entries(scores)) {
+    if (score > topScore) {
+      topScore = score;
+      topCategory = category;
+    }
+  }
+
+  // Role hint takes precedence if no strong keyword signal
+  const category = topScore >= 2 ? topCategory : (roleCategory || topCategory);
+
+  // Complexity detection
+  const highCount = countMatches(text, COMPLEXITY_KEYWORDS.high);
+  const lowCount = countMatches(text, COMPLEXITY_KEYWORDS.low);
+
+  let complexity;
+  if (highCount > lowCount && highCount >= 1) {
+    complexity = 'high';
+  } else if (lowCount > 0 && highCount === 0) {
+    complexity = 'low';
+  } else {
+    complexity = 'medium';
+  }
+
+  return { category, complexity };
+}
+
+/**
+ * Select the optimal model for a given provider based on category and complexity.
+ * @param {string} provider - The AI provider identifier
+ * @param {string} category - Prompt category
+ * @param {string} complexity - Prompt complexity
+ * @returns {{ model: string, reason: string }}
+ */
+export function selectModelForProvider(provider, category, complexity) {
+  const isHighReasoning = category === 'reasoning' || complexity === 'high';
+  const isSimple = complexity === 'low' || category === 'simple';
+  const isCoding = category === 'coding';
+
+  switch (provider) {
+    case 'chatgpt': {
+      if (isHighReasoning) return { model: 'o3', reason: 'High-complexity reasoning task' };
+      if (isCoding) return { model: 'o4-mini', reason: 'Coding/implementation task' };
+      if (isSimple) return { model: 'gpt-4o-mini', reason: 'Simple task, cost-efficient model' };
+      return { model: 'gpt-4o', reason: 'Creative or medium-complexity task' };
+    }
+
+    case 'claude': {
+      if (isHighReasoning) return { model: 'opus', reason: 'High-complexity reasoning task' };
+      if (isSimple) return { model: 'haiku', reason: 'Simple task, fast and cost-efficient' };
+      return { model: 'sonnet', reason: 'Coding or medium-complexity task' };
+    }
+
+    case 'gemini': {
+      if (isHighReasoning || complexity === 'high') return { model: '2.5 Pro', reason: 'High-complexity or reasoning task' };
+      if (isSimple) return { model: '2.0 Flash', reason: 'Simple task, fast response' };
+      return { model: '2.5 Flash', reason: 'Medium-complexity task' };
+    }
+
+    case 'deepseek': {
+      if (category === 'reasoning') return { model: 'DeepSeek-R1', reason: 'Reasoning-focused task' };
+      return { model: 'DeepSeek-V3', reason: 'General task' };
+    }
+
+    case 'grok': {
+      if (complexity === 'high' || isHighReasoning) return { model: 'grok-3', reason: 'High-complexity task' };
+      return { model: 'grok-3-mini', reason: 'Simple task' };
+    }
+
+    case 'mistral': {
+      if (complexity === 'high' || isHighReasoning) return { model: 'Mistral Large', reason: 'High-complexity task' };
+      return { model: 'Mistral Small', reason: 'Simple task' };
+    }
+
+    case 'poe': {
+      if (complexity === 'high' || isHighReasoning) return { model: 'Claude-3.5-Sonnet', reason: 'High-complexity task' };
+      if (isSimple) return { model: 'Claude-3-Haiku', reason: 'Simple task' };
+      return { model: 'GPT-4o', reason: 'Medium-complexity task' };
+    }
+
+    case 'qwen': {
+      if (complexity === 'high' || isHighReasoning) return { model: 'Qwen-Max', reason: 'High-complexity task' };
+      return { model: 'Qwen-Plus', reason: 'Simple task' };
+    }
+
+    case 'huggingchat': {
+      if (complexity === 'high' || isHighReasoning) return { model: 'Qwen/QwQ-32B', reason: 'High-complexity task' };
+      return { model: 'meta-llama/Llama-3.3-70B', reason: 'Simple task' };
+    }
+
+    case 'copilot': {
+      return { model: 'GPT-4o', reason: 'Copilot uses GPT-4o (no model selection)' };
+    }
+
+    case 'perplexity': {
+      return { model: 'default', reason: 'Perplexity uses default model (no model selection)' };
+    }
+
+    default: {
+      return { model: 'default', reason: `Unknown provider: ${provider}` };
+    }
+  }
+}
+
+/**
+ * High-level function: analyze state and return optimal model selection for a turn.
+ * @param {object} state - Deliberation state with topic, log, speaker_roles
+ * @param {string} speaker - The current speaker identifier
+ * @param {string} provider - The AI provider to use
+ * @returns {{ model: string, category: string, complexity: string, reason: string }}
+ */
+export function getModelSelectionForTurn(state, speaker, provider) {
+  const topic = state.topic || '';
+  const role = (state.speaker_roles && state.speaker_roles[speaker]) || '';
+
+  // Use recent log entries (last 5) for context analysis
+  const recentEntries = Array.isArray(state.log) ? state.log.slice(-5) : [];
+  const recentLog = recentEntries
+    .map(entry => (typeof entry === 'string' ? entry : JSON.stringify(entry)))
+    .join(' ');
+
+  const { category, complexity } = analyzePromptContext(topic, recentLog, role);
+  const { model, reason } = selectModelForProvider(provider, category, complexity);
+
+  return { model, category, complexity, reason };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmsdc-ai/aigentry-deliberation",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "MCP Deliberation Server — Multi-session AI deliberation with smart speaker ordering and persona roles",
   "type": "module",
   "license": "MIT",
@@ -21,14 +21,17 @@
     "aigentry-deliberation": "index.js",
     "mcp-deliberation": "index.js",
     "deliberation-observer": "observer.js",
-    "deliberation-install": "install.js"
+    "deliberation-install": "install.js",
+    "deliberation-doctor": "doctor.js"
   },
   "engines": {
     "node": ">=18"
   },
   "files": [
     "index.js",
+    "model-router.js",
     "install.js",
+    "doctor.js",
     "observer.js",
     "browser-control-port.js",
     "degradation-state-machine.js",