@dmsdc-ai/aigentry-devkit 0.1.3 → 0.1.5

package/install.ps1

@@ -116,17 +116,20 @@ Write-Header "5. MCP Registration"
 $mcpConfig = Join-Path $ClaudeDir ".mcp.json"
 New-Item -ItemType Directory -Path $ClaudeDir -Force | Out-Null
 
+$cfg = $null
 if (Test-Path $mcpConfig) {
   try {
-    $cfg = Get-Content $mcpConfig -Raw | ConvertFrom-Json
-  } catch {
-    $cfg = [pscustomobject]@{}
-  }
-} else {
+    $raw = Get-Content $mcpConfig -Raw
+    if ($raw) {
+      $cfg = $raw | ConvertFrom-Json
+    }
+  } catch {}
+}
+if (-not $cfg) {
   $cfg = [pscustomobject]@{}
 }
 
-if (-not $cfg.PSObject.Properties.Name.Contains("mcpServers")) {
+if (-not ($cfg.PSObject.Properties.Match("mcpServers"))) {
   $cfg | Add-Member -MemberType NoteProperty -Name mcpServers -Value ([pscustomobject]@{})
 }
 

package/install.sh

@@ -220,9 +220,65 @@ else
   warn "direnv not found. Skipping .envrc setup."
 fi
 
-# ── Codex MCP 등록 (가능하면) ──
-header "7. Codex Integration (optional)"
+# ── 참가자 CLI 선택 ──
+header "7. Participant CLI Selection"
+
+# Detect available CLIs
+AVAILABLE_CLIS=""
+for cli in claude codex gemini qwen chatgpt aider llm opencode cursor; do
+  if command -v "$cli" >/dev/null 2>&1; then
+    AVAILABLE_CLIS="$AVAILABLE_CLIS $cli"
+  fi
+done
+AVAILABLE_CLIS=$(echo "$AVAILABLE_CLIS" | xargs)  # trim
+
+if [ -z "$AVAILABLE_CLIS" ]; then
+  warn "No participant CLIs detected. Install claude, codex, gemini, or other AI CLIs."
+else
+  info "Detected CLIs: $AVAILABLE_CLIS"
+  echo ""
+
+  # Interactive selection (skip if --force flag or non-interactive)
+  DELIBERATION_CONFIG="$MCP_DEST/config.json"
+  if [ -t 0 ] && [ "${FORCE_INSTALL:-}" != "true" ]; then
+    echo -e "  ${BOLD}Select CLIs to enable for deliberation:${NC}"
+    echo ""
+
+    SELECTED_CLIS=""
+    for cli in $AVAILABLE_CLIS; do
+      printf "  Enable ${CYAN}%-12s${NC} for deliberation? [Y/n] " "$cli"
+      read -r answer </dev/tty
+      case "$answer" in
+        [nN]*) ;;
+        *) SELECTED_CLIS="$SELECTED_CLIS $cli" ;;
+      esac
+    done
+    SELECTED_CLIS=$(echo "$SELECTED_CLIS" | xargs)
+
+    if [ -z "$SELECTED_CLIS" ]; then
+      warn "No CLIs selected. All detected CLIs will be available by default."
+      SELECTED_CLIS="$AVAILABLE_CLIS"
+    fi
+  else
+    # Non-interactive: enable all detected
+    SELECTED_CLIS="$AVAILABLE_CLIS"
+  fi
 
+  info "Enabled CLIs: $SELECTED_CLIS"
+
+  # Save config
+  node -e "
+    const fs = require('fs');
+    const configPath = '$DELIBERATION_CONFIG';
+    let config = {};
+    try { config = JSON.parse(fs.readFileSync(configPath, 'utf-8')); } catch {}
+    config.enabled_clis = '${SELECTED_CLIS}'.split(/\s+/).filter(Boolean);
+    config.updated = new Date().toISOString();
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  " && info "Saved CLI config to $DELIBERATION_CONFIG" || warn "Failed to save CLI config"
+fi
+
+# Codex MCP registration (only CLI with native MCP support)
 if command -v codex >/dev/null 2>&1; then
   codex mcp add deliberation -- node "$MCP_DEST/index.js" 2>/dev/null && \
     info "Registered deliberation MCP in Codex" || \
@@ -233,14 +289,13 @@ if command -v codex >/dev/null 2>&1; then
   else
     warn "Codex MCP verification failed. Run manually: codex mcp add deliberation -- node $MCP_DEST/index.js"
   fi
-else
-  warn "Codex CLI not found. Skipping Codex integration."
 fi
 
 header "8. Cross-platform Notes"
-info "Codex is a deliberation participant CLI, not a separate MCP server."
+info "Supported participant CLIs: claude, codex, gemini, qwen, chatgpt, aider, llm, opencode, cursor"
+info "Manage enabled CLIs anytime: deliberation_cli_config MCP tool"
 info "Browser LLM tab detection: macOS automation + CDP scan (Linux/Windows need browser remote-debugging port)."
-info "If browser tab auto-scan is unavailable, use clipboard workflow: prepare_turn -> paste in browser -> submit_turn."
+info "CDP auto-detect upgrades browser speakers to browser_auto for hands-free operation."
 
 # ── 완료 ──
 header "Installation Complete!"
@@ -252,9 +307,10 @@ echo -e "    MCP Server: $MCP_DEST"
 echo -e "    Config:     $CLAUDE_DIR"
 echo ""
 echo -e "  ${BOLD}Next steps:${NC}"
-echo -e "    1. Restart Claude/Codex processes for MCP changes to take effect"
-echo -e "    2. Add other MCP servers to $MCP_CONFIG as needed"
-echo -e "    3. Configure your HUD in settings.json if not already done"
-echo -e "    4. For Linux/Windows browser scan, launch browser with --remote-debugging-port=9222"
+echo -e "    1. Restart CLI processes for MCP changes to take effect"
+echo -e "    2. Modify enabled CLIs anytime via deliberation_cli_config MCP tool"
+echo -e "    3. Add other MCP servers to $MCP_CONFIG as needed"
+echo -e "    4. Configure your HUD in settings.json if not already done"
+echo -e "    5. For Linux/Windows browser scan, launch browser with --remote-debugging-port=9222"
 echo ""
 echo -e "  ${CYAN}Enjoy your AI development environment!${NC}"

package/mcp-servers/deliberation/index.js

@@ -19,9 +19,8 @@
  *   deliberation_reset        세션 초기화 (session_id 선택적, 없으면 전체)
  *   deliberation_speaker_candidates      선택 가능한 스피커 후보(로컬 CLI + 브라우저 LLM 탭) 조회
  *   deliberation_browser_llm_tabs      브라우저 LLM 탭 목록 조회
- *   deliberation_clipboard_prepare_turn 브라우저 LLM용 턴 프롬프트를 클립보드로 복사
- *   deliberation_clipboard_submit_turn  클립보드 텍스트를 현재 턴 응답으로 제출
  *   deliberation_browser_auto_turn      브라우저 LLM에 자동으로 턴을 전송하고 응답을 수집 (CDP 기반)
+ *   deliberation_request_review         코드 리뷰 요청 (CLI 리뷰어 자동 호출, sync/async 모드)
  */
 
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -55,6 +54,22 @@ const DEFAULT_CLI_CANDIDATES = [
   "continue",
 ];
 const MAX_AUTO_DISCOVERED_SPEAKERS = 12;
+
+function loadDeliberationConfig() {
+  const configPath = path.join(HOME, ".local", "lib", "mcp-deliberation", "config.json");
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function saveDeliberationConfig(config) {
+  const configPath = path.join(HOME, ".local", "lib", "mcp-deliberation", "config.json");
+  config.updated = new Date().toISOString();
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
 const DEFAULT_BROWSER_APPS = ["Google Chrome", "Brave Browser", "Arc", "Microsoft Edge", "Safari"];
 const DEFAULT_LLM_DOMAINS = [
   "chatgpt.com",
@@ -241,6 +256,13 @@ function resolveCliCandidates() {
     .split(/[,\s]+/)
     .map(v => v.trim())
     .filter(Boolean);
+
+  // If config has enabled_clis, use that as the primary filter
+  const config = loadDeliberationConfig();
+  if (Array.isArray(config.enabled_clis) && config.enabled_clis.length > 0) {
+    return dedupeSpeakers([...fromEnv, ...config.enabled_clis]);
+  }
+
   return dedupeSpeakers([...fromEnv, ...DEFAULT_CLI_CANDIDATES]);
 }
 
@@ -578,6 +600,59 @@ async function collectBrowserLlmTabsViaCdp() {
   };
 }
 
+async function ensureCdpAvailable() {
+  const endpoints = resolveCdpEndpoints();
+
+  // First attempt: try existing CDP endpoints
+  for (const endpoint of endpoints) {
+    try {
+      const payload = await fetchJson(endpoint, 1500);
+      if (Array.isArray(payload)) {
+        return { available: true, endpoint };
+      }
+    } catch { /* not reachable */ }
+  }
+
+  // If none respond and platform is macOS, try auto-launching Chrome with CDP
+  if (process.platform === "darwin") {
+    try {
+      execFileSync("open", ["-a", "Google Chrome", "--args", "--remote-debugging-port=9222"], {
+        timeout: 5000,
+        stdio: "ignore",
+      });
+    } catch {
+      return {
+        available: false,
+        reason: "Chrome 자동 실행에 실패했습니다. Chrome을 수동으로 --remote-debugging-port=9222 옵션과 함께 실행해주세요.",
+      };
+    }
+
+    // Wait for Chrome to initialize CDP
+    sleepMs(2000);
+
+    // Retry CDP connection after launch
+    for (const endpoint of endpoints) {
+      try {
+        const payload = await fetchJson(endpoint, 2000);
+        if (Array.isArray(payload)) {
+          return { available: true, endpoint, launched: true };
+        }
+      } catch { /* still not reachable */ }
+    }
+
+    return {
+      available: false,
+      reason: "Chrome을 실행했지만 CDP에 연결할 수 없습니다. Chrome을 완전히 종료한 후 다시 시도해주세요. (이미 실행 중인 Chrome이 CDP 없이 시작된 경우 재시작 필요)",
+    };
+  }
+
+  // Non-macOS: cannot auto-launch
+  return {
+    available: false,
+    reason: "Chrome CDP를 활성화할 수 없습니다. Chrome을 --remote-debugging-port=9222 옵션과 함께 실행해주세요.",
+  };
+}
+
 function collectBrowserLlmTabsViaAppleScript() {
   if (process.platform !== "darwin") {
     return { tabs: [], note: "AppleScript 탭 스캔은 macOS에서만 지원됩니다." };
@@ -588,56 +663,67 @@ function collectBrowserLlmTabsViaAppleScript() {
   const domainList = `{${escapedDomains.map(d => `"${d}"`).join(", ")}}`;
   const appList = `{${escapedApps.map(a => `"${a}"`).join(", ")}}`;
 
-  const script = [
-    `set llmDomains to ${domainList}`,
-    `set browserApps to ${appList}`,
-    "set outText to \"\"",
-    // Pre-check running apps via System Events (no locate dialog)
-    "tell application \"System Events\"",
-    "set runningApps to name of every application process",
-    "end tell",
-    "repeat with appName in browserApps",
-    "if runningApps contains (appName as string) then",
-    "try",
-    "tell application (appName as string)",
-    "if (appName as string) is \"Safari\" then",
-    "repeat with w in windows",
-    "try",
-    "repeat with t in tabs of w",
-    "set u to URL of t as string",
-    "set matched to false",
-    "repeat with d in llmDomains",
-    "if u contains (d as string) then set matched to true",
-    "end repeat",
-    "if matched then set outText to outText & (appName as string) & tab & (name of t as string) & tab & u & linefeed",
-    "end repeat",
-    "end try",
-    "end repeat",
-    "else",
-    "repeat with w in windows",
-    "try",
-    "repeat with t in tabs of w",
-    "set u to URL of t as string",
-    "set matched to false",
-    "repeat with d in llmDomains",
-    "if u contains (d as string) then set matched to true",
-    "end repeat",
-    "if matched then set outText to outText & (appName as string) & tab & (title of t as string) & tab & u & linefeed",
-    "end repeat",
-    "end try",
-    "end repeat",
-    "end if",
-    "end tell",
-    "on error errMsg",
-    "set outText to outText & (appName as string) & tab & \"ERROR\" & tab & errMsg & linefeed",
-    "end try",
-    "end if",
-    "end repeat",
-    "return outText",
-  ];
+  // NOTE: Use stdin pipe (`osascript -`) instead of multiple `-e` flags
+  // because osascript's `-e` mode silently breaks with nested try/on error blocks.
+  // Also wrap dynamic `tell application` with `using terms from` so that
+  // Chrome-specific properties like `tabs` resolve via the scripting dictionary.
+  // Use ASCII character 9 for tab delimiter because `using terms from`
+  // shadows the built-in `tab` constant, turning it into the literal string "tab".
+  const scriptText = `set llmDomains to ${domainList}
+set browserApps to ${appList}
+set outText to ""
+set tabChar to ASCII character 9
+tell application "System Events"
+set runningApps to name of every application process
+end tell
+repeat with appName in browserApps
+if runningApps contains (appName as string) then
+try
+if (appName as string) is "Safari" then
+using terms from application "Safari"
+tell application (appName as string)
+repeat with w in windows
+try
+repeat with t in tabs of w
+set u to URL of t as string
+set matched to false
+repeat with d in llmDomains
+if u contains (d as string) then set matched to true
+end repeat
+if matched then set outText to outText & (appName as string) & tabChar & (name of t as string) & tabChar & u & linefeed
+end repeat
+end try
+end repeat
+end tell
+end using terms from
+else
+using terms from application "Google Chrome"
+tell application (appName as string)
+repeat with w in windows
+try
+repeat with t in tabs of w
+set u to URL of t as string
+set matched to false
+repeat with d in llmDomains
+if u contains (d as string) then set matched to true
+end repeat
+if matched then set outText to outText & (appName as string) & tabChar & (title of t as string) & tabChar & u & linefeed
+end repeat
+end try
+end repeat
+end tell
+end using terms from
+end if
+on error errMsg
+set outText to outText & (appName as string) & tabChar & "ERROR" & tabChar & errMsg & linefeed
+end try
+end if
+end repeat
+return outText`;
 
   try {
-    const raw = execFileSync("osascript", script.flatMap(line => ["-e", line]), {
+    const raw = execFileSync("osascript", ["-"], {
+      input: scriptText,
       encoding: "utf-8",
       timeout: 8000,
       maxBuffer: 2 * 1024 * 1024,
@@ -745,8 +831,14 @@ async function collectSpeakerCandidates({ include_cli = true, include_browser =
 
   let browserNote = null;
   if (include_browser) {
+    // Ensure CDP is available before probing browser tabs
+    const cdpStatus = await ensureCdpAvailable();
+    if (cdpStatus.launched) {
+      browserNote = "Chrome CDP 자동 실행됨 (--remote-debugging-port=9222)";
+    }
+
     const { tabs, note } = await collectBrowserLlmTabs();
-    browserNote = note || null;
+    browserNote = browserNote ? `${browserNote} | ${note || ""}`.replace(/ \| $/, "") : (note || null);
     const providerCounts = new Map();
     for (const tab of tabs) {
       const provider = inferLlmProvider(tab.url);
@@ -924,7 +1016,7 @@ function formatTransportGuidance(transport, state, speaker) {
     case "cli_respond":
       return `CLI speaker입니다. \`deliberation_respond(session_id: "${sid}", speaker: "${speaker}", content: "...")\`로 직접 응답하세요.`;
     case "clipboard":
-      return `브라우저 LLM speaker입니다. 다음 순서로 진행하세요:\n1. \`deliberation_clipboard_prepare_turn(session_id: "${sid}")\` → 클립보드에 프롬프트 복사\n2. 브라우저 LLM에 붙여넣고 응답 생성\n3. 응답을 복사한 뒤 \`deliberation_clipboard_submit_turn(session_id: "${sid}", speaker: "${speaker}")\` 호출`;
+      return `브라우저 LLM speaker입니다. CDP 자동 연결 시도 중... Chrome이 이미 CDP 없이 실행 중이면 재시작이 필요할 수 있습니다.`;
     case "browser_auto":
       return `자동 브라우저 speaker입니다. \`deliberation_browser_auto_turn(session_id: "${sid}")\`으로 자동 진행됩니다. CDP를 통해 브라우저 LLM에 직접 입력하고 응답을 읽습니다.`;
     case "manual":
@@ -1803,6 +1895,23 @@ server.tool(
       created: new Date().toISOString(),
       updated: new Date().toISOString(),
     };
+
+    // Ensure CDP is ready if any speaker requires browser transport
+    const hasBrowserSpeaker = state.participant_profiles.some(
+      p => p.type === "browser" || p.type === "browser_auto"
+    );
+    if (hasBrowserSpeaker) {
+      const cdpReady = await ensureCdpAvailable();
+      if (!cdpReady.available) {
+        return {
+          content: [{
+            type: "text",
+            text: `❌ 브라우저 LLM speaker가 포함되어 있지만 CDP에 연결할 수 없습니다.\n\n${cdpReady.reason}\n\nCDP 연결 후 다시 deliberation_start를 호출하세요.`,
+          }],
+        };
+      }
+    }
+
     withSessionLock(sessionId, () => {
       saveSession(state);
     });
@@ -1945,88 +2054,6 @@ server.tool(
   }
 );
 
-server.tool(
-  "deliberation_clipboard_prepare_turn",
-  "현재 턴 요청 프롬프트를 생성해 클립보드에 복사합니다. 브라우저 LLM에 붙여넣어 사용하세요.",
-  {
-    session_id: z.string().optional().describe("세션 ID (여러 세션 진행 중이면 필수)"),
-    speaker: z.string().trim().min(1).max(64).optional().describe("대상 speaker (미지정 시 현재 차례)"),
-    prompt: z.string().optional().describe("브라우저 LLM에 추가로 전달할 지시"),
-    include_history_entries: z.number().int().min(0).max(12).default(4).describe("프롬프트에 포함할 최근 로그 개수"),
-  },
-  async ({ session_id, speaker, prompt, include_history_entries }) => {
-    const resolved = resolveSessionId(session_id);
-    if (!resolved) {
-      return { content: [{ type: "text", text: "활성 deliberation이 없습니다." }] };
-    }
-    if (resolved === "MULTIPLE") {
-      return { content: [{ type: "text", text: multipleSessionsError() }] };
-    }
-
-    const state = loadSession(resolved);
-    if (!state || state.status !== "active") {
-      return { content: [{ type: "text", text: `세션 "${resolved}"이 활성 상태가 아닙니다.` }] };
-    }
-
-    const targetSpeaker = normalizeSpeaker(speaker) || normalizeSpeaker(state.current_speaker) || state.speakers[0];
-    if (targetSpeaker !== state.current_speaker) {
-      return {
-        content: [{
-          type: "text",
-          text: `[${state.id}] 지금은 **${state.current_speaker}** 차례입니다. prepare 대상 speaker는 현재 차례와 같아야 합니다.`,
-        }],
-      };
-    }
-
-    const payload = buildClipboardTurnPrompt(state, targetSpeaker, prompt, include_history_entries);
-    try {
-      writeClipboardText(payload);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "unknown error";
-      return { content: [{ type: "text", text: `클립보드 복사 실패: ${message}` }] };
-    }
-
-    return {
-      content: [{
-        type: "text",
-        text: `✅ [${state.id}] 턴 프롬프트를 클립보드에 복사했습니다.\n\n**대상 speaker:** ${targetSpeaker}\n**라운드:** ${state.current_round}/${state.max_rounds}\n\n다음 단계:\n1. 브라우저 LLM에 붙여넣고 응답 생성\n2. 응답 본문을 복사\n3. deliberation_clipboard_submit_turn(session_id: "${state.id}", speaker: "${targetSpeaker}") 호출\n\n${PRODUCT_DISCLAIMER}`,
-      }],
-    };
-  }
-);
-
-server.tool(
-  "deliberation_clipboard_submit_turn",
-  "클립보드 텍스트(또는 content)를 현재 턴 응답으로 제출합니다.",
-  {
-    session_id: z.string().optional().describe("세션 ID (여러 세션 진행 중이면 필수)"),
-    speaker: z.string().trim().min(1).max(64).describe("응답자 이름"),
-    content: z.string().optional().describe("응답 내용 (미지정 시 클립보드 텍스트 사용)"),
-    trim_content: z.boolean().default(false).describe("응답 앞뒤 공백 제거 여부"),
-    turn_id: z.string().optional().describe("턴 검증 ID"),
-  },
-  safeToolHandler("deliberation_clipboard_submit_turn", async ({ session_id, speaker, content, trim_content, turn_id }) => {
-    let body = content;
-    if (typeof body !== "string") {
-      try {
-        body = readClipboardText();
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "unknown error";
-        return { content: [{ type: "text", text: `클립보드 읽기 실패: ${message}` }] };
-      }
-    }
-
-    if (trim_content) {
-      body = body.trim();
-    }
-    if (!body || body.trim().length === 0) {
-      return { content: [{ type: "text", text: "제출할 응답이 비어 있습니다. 클립보드 또는 content를 확인하세요." }] };
-    }
-
-    return submitDeliberationTurn({ session_id, speaker, content: body, turn_id, channel_used: "clipboard" });
-  })
-);
-
 server.tool(
   "deliberation_route_turn",
   "현재 턴의 speaker에 맞는 transport를 자동 결정하고 안내합니다. CLI speaker는 자동 응답 경로, 브라우저 speaker는 클립보드 경로로 라우팅합니다.",
@@ -2057,18 +2084,6 @@ server.tool(
 
     let extra = "";
 
-    if (transport === "clipboard" && auto_prepare_clipboard) {
-      // 자동으로 클립보드 prepare 실행
-      const payload = buildClipboardTurnPrompt(state, speaker, prompt, include_history_entries);
-      try {
-        writeClipboardText(payload);
-        extra = `\n\n✅ 클립보드에 턴 프롬프트가 자동 복사되었습니다.`;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "unknown error";
-        extra = `\n\n⚠️ 클립보드 자동 복사 실패: ${message}\n수동으로 deliberation_clipboard_prepare_turn을 호출하세요.`;
-      }
-    }
-
     if (transport === "browser_auto") {
       // Auto-execute browser_auto_turn
       try {
@@ -2109,15 +2124,8 @@ server.tool(
           throw new Error(waitResult.error?.message || "no response received");
         }
       } catch (autoErr) {
-        // Fallback to clipboard
         const errMsg = autoErr instanceof Error ? autoErr.message : String(autoErr);
-        const payload = buildClipboardTurnPrompt(state, speaker, prompt, include_history_entries);
-        try {
-          writeClipboardText(payload);
-          extra = `\n\n⚠️ 자동 실행 실패 (${errMsg}). 클립보드 모드로 폴백했습니다.\n✅ 클립보드에 턴 프롬프트가 복사되었습니다.`;
-        } catch (clipErr) {
-          extra = `\n\n⚠️ 자동 실행 실패 (${errMsg}). 클립보드 복사도 실패했습니다.\n수동으로 deliberation_clipboard_prepare_turn을 호출하세요.`;
-        }
+        extra = `\n\n⚠️ 자동 실행 실패 (${errMsg}). Chrome을 --remote-debugging-port=9222로 재시작하세요.`;
       }
     }
 
@@ -2195,7 +2203,7 @@ server.tool(
     // Step 4: Wait for response
     const waitResult = await port.waitTurnResult(resolved, turnId, timeout_sec);
     if (!waitResult.ok) {
-      return { content: [{ type: "text", text: `⏱️ 브라우저 LLM 응답 대기 타임아웃 (${timeout_sec}초)\n\n**에러:** ${waitResult.error.message}\n\nclipboard fallback으로 수동 진행하세요:\n1. \`deliberation_clipboard_prepare_turn(session_id: "${resolved}")\`\n2. 브라우저에 붙여넣기\n3. \`deliberation_clipboard_submit_turn(session_id: "${resolved}")\`\n\n${PRODUCT_DISCLAIMER}` }] };
+      return { content: [{ type: "text", text: `⏱️ 브라우저 LLM 응답 대기 타임아웃 (${timeout_sec}초)\n\n**에러:** ${waitResult.error.message}\n\n자동 실행이 타임아웃되었습니다. Chrome이 --remote-debugging-port=9222로 실행 중인지 확인하세요.\n\n${PRODUCT_DISCLAIMER}` }] };
     }
 
     // Step 5: Submit the response
@@ -2436,6 +2444,333 @@ server.tool(
   })
 );
 
+server.tool(
+  "deliberation_cli_config",
+  "딜리버레이션 참가자 CLI 설정을 조회하거나 변경합니다. enabled_clis를 지정하면 저장합니다.",
+  {
+    enabled_clis: z.array(z.string()).optional().describe("활성화할 CLI 목록 (예: [\"claude\", \"codex\", \"gemini\"]). 미지정 시 현재 설정 조회"),
+  },
+  safeToolHandler("deliberation_cli_config", async ({ enabled_clis }) => {
+    const config = loadDeliberationConfig();
+
+    if (!enabled_clis) {
+      // Read mode: show current config + detected CLIs
+      const detected = discoverLocalCliSpeakers();
+      const configured = Array.isArray(config.enabled_clis) ? config.enabled_clis : [];
+      const mode = configured.length > 0 ? "config" : "auto-detect";
+
+      return {
+        content: [{
+          type: "text",
+          text: `## Deliberation CLI 설정\n\n**모드:** ${mode}\n**설정된 CLI:** ${configured.length > 0 ? configured.join(", ") : "(없음 — 전체 자동 감지)"}\n**현재 감지된 CLI:** ${detected.join(", ") || "(없음)"}\n**지원 CLI 전체:** ${DEFAULT_CLI_CANDIDATES.join(", ")}\n\n변경하려면:\n\`deliberation_cli_config(enabled_clis: ["claude", "codex"])\`\n\n전체 자동 감지로 되돌리려면:\n\`deliberation_cli_config(enabled_clis: [])\``,
+        }],
+      };
+    }
+
+    // Write mode: save new config
+    if (enabled_clis.length === 0) {
+      // Empty array = reset to auto-detect all
+      delete config.enabled_clis;
+      saveDeliberationConfig(config);
+      return {
+        content: [{
+          type: "text",
+          text: `✅ CLI 설정 초기화 완료. 전체 자동 감지 모드로 전환되었습니다.\n감지 대상: ${DEFAULT_CLI_CANDIDATES.join(", ")}`,
+        }],
+      };
+    }
+
+    // Validate CLIs
+    const valid = [];
+    const invalid = [];
+    for (const cli of enabled_clis) {
+      const normalized = cli.trim().toLowerCase();
+      if (normalized) valid.push(normalized);
+    }
+
+    config.enabled_clis = valid;
+    saveDeliberationConfig(config);
+
+    // Check which are actually installed
+    const installed = valid.filter(cli => {
+      try {
+        execFileSync(process.platform === "win32" ? "where" : "which", [cli], { stdio: "ignore" });
+        return true;
+      } catch { return false; }
+    });
+    const notInstalled = valid.filter(cli => !installed.includes(cli));
+
+    let result = `✅ CLI 설정 저장 완료!\n\n**활성화된 CLI:** ${valid.join(", ")}`;
+    if (installed.length > 0) result += `\n**설치 확인됨:** ${installed.join(", ")}`;
+    if (notInstalled.length > 0) result += `\n**⚠️ 미설치:** ${notInstalled.join(", ")} (PATH에서 찾을 수 없음)`;
+
+    return { content: [{ type: "text", text: result }] };
+  })
+);
+
+// ── Request Review (auto-review) ───────────────────────────────
+
+function invokeCliReviewer(command, prompt, timeoutMs) {
+  const args = ["-p", prompt, "--no-input"];
+  try {
+    const result = execFileSync(command, args, {
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 5 * 1024 * 1024,
+      windowsHide: true,
+    });
+    return { ok: true, response: result.trim() };
+  } catch (error) {
+    if (error && error.killed) {
+      return { ok: false, error: "timeout" };
+    }
+    const msg = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: msg };
+  }
+}
+
+function buildReviewPrompt(context, question, priorReviews) {
+  let prompt = `You are a code reviewer. Provide a concise, structured review.\n\n`;
+  prompt += `## Context\n${context}\n\n`;
+  prompt += `## Review Question\n${question}\n\n`;
+  if (priorReviews.length > 0) {
+    prompt += `## Prior Reviews\n`;
+    for (const r of priorReviews) {
+      prompt += `### ${r.reviewer}\n${r.response}\n\n`;
+    }
+  }
+  prompt += `Respond with your review. Be specific about issues, risks, and suggestions.`;
+  return prompt;
+}
+
+function synthesizeReviews(context, question, reviews) {
+  if (reviews.length === 0) return "(No reviews completed)";
+
+  let synthesis = `## Review Synthesis\n\n`;
+  synthesis += `**Question:** ${question}\n`;
+  synthesis += `**Reviews:** ${reviews.length}\n\n`;
+
+  synthesis += `### Individual Reviews\n\n`;
+  for (const r of reviews) {
+    synthesis += `#### ${r.reviewer}\n${r.response}\n\n`;
+  }
+
+  if (reviews.length > 1) {
+    synthesis += `### Summary\n`;
+    synthesis += `${reviews.length} reviewer(s) provided feedback on: ${question}\n`;
+    synthesis += `Reviewers: ${reviews.map(r => r.reviewer).join(", ")}\n`;
+  }
+
+  return synthesis;
+}
+
+server.tool(
+  "deliberation_request_review",
+  "코드 리뷰를 요청합니다. 여러 CLI 리뷰어에게 동시에 리뷰를 요청하고 결과를 종합합니다.",
+  {
+    context: z.string().describe("리뷰할 변경사항 설명 (코드, diff, 설계 등)"),
+    question: z.string().describe("리뷰 질문 (예: 'Is this error handling sufficient?')"),
+    reviewers: z.array(z.string().trim().min(1).max(64)).min(1).describe("리뷰어 CLI 목록 (예: [\"claude\", \"codex\"])"),
+    mode: z.enum(["sync", "async"]).default("sync").describe("sync: 결과 대기 후 반환, async: session_id 즉시 반환"),
+    deadline_ms: z.number().int().min(5000).max(600000).default(60000).describe("전체 타임아웃 (밀리초, 기본 60초)"),
+    min_reviews: z.number().int().min(1).default(1).describe("최소 필요 리뷰 수 (기본 1)"),
+    on_timeout: z.enum(["partial", "fail"]).default("partial").describe("타임아웃 시 동작: partial=부분 결과 반환, fail=에러"),
+  },
+  safeToolHandler("deliberation_request_review", async ({ context, question, reviewers, mode, deadline_ms, min_reviews, on_timeout }) => {
+    // Validate reviewers exist in PATH
+    const validReviewers = [];
+    const invalidReviewers = [];
+    for (const r of reviewers) {
+      const normalized = normalizeSpeaker(r);
+      if (!normalized) continue;
+      if (commandExistsInPath(normalized)) {
+        validReviewers.push(normalized);
+      } else {
+        invalidReviewers.push(normalized);
+      }
+    }
+
+    if (validReviewers.length === 0) {
+      return {
+        content: [{
+          type: "text",
+          text: `❌ 유효한 리뷰어가 없습니다. PATH에서 찾을 수 없는 CLI: ${invalidReviewers.join(", ")}\n\n사용 가능한 CLI를 확인하려면 deliberation_speaker_candidates를 호출하세요.`,
+        }],
+      };
+    }
+
+    // Create mini-session
+    const sessionId = generateSessionId("review");
+    const callerSpeaker = detectCallerSpeaker() || "requester";
+    const now = new Date().toISOString();
+
+    const state = {
+      id: sessionId,
+      project: getProjectSlug(),
+      topic: question.slice(0, 80),
+      type: "auto_review",
+      status: "active",
+      max_rounds: 1,
+      current_round: 1,
+      current_speaker: validReviewers[0],
+      speakers: validReviewers,
+      participant_profiles: validReviewers.map(r => ({ speaker: r, type: "cli", command: r })),
+      log: [],
+      synthesis: null,
+      requester: callerSpeaker,
+      review_context: context,
+      review_question: question,
+      review_mode: mode,
+      review_deadline_ms: deadline_ms,
+      review_min_reviews: min_reviews,
+      review_on_timeout: on_timeout,
+      pending_turn_id: generateTurnId(),
+      monitor_terminal_window_ids: [],
+      created: now,
+      updated: now,
+    };
+
+    withSessionLock(sessionId, () => {
+      ensureDirs();
+      saveSession(state);
+    });
+
+    // Async mode: return immediately
+    if (mode === "async") {
+      const warn = invalidReviewers.length > 0
+        ? `\n⚠️ PATH에서 찾을 수 없는 리뷰어 (제외됨): ${invalidReviewers.join(", ")}`
+        : "";
+      return {
+        content: [{
+          type: "text",
+          text: `✅ 비동기 리뷰 세션 생성됨\n\n**Session ID:** ${sessionId}\n**리뷰어:** ${validReviewers.join(", ")}\n**모드:** async${warn}\n\n진행 상태는 \`deliberation_status(session_id: "${sessionId}")\`로 확인하세요.`,
+        }],
+      };
+    }
+
+    // Sync mode: invoke each reviewer sequentially with deadline enforcement
+    const globalStart = Date.now();
+    const softBudgetPerReviewer = Math.floor(deadline_ms / validReviewers.length);
+    const completedReviews = [];
+    const timedOutReviewers = [];
+    const failedReviewers = [];
+
+    for (const reviewer of validReviewers) {
+      const elapsed = Date.now() - globalStart;
+      const remaining = deadline_ms - elapsed;
+
+      // Global deadline check
+      if (remaining <= 1000) {
+        timedOutReviewers.push(reviewer);
+        continue;
+      }
+
+      // Per-reviewer timeout: min of soft budget and remaining global time
+      const reviewerTimeout = Math.min(softBudgetPerReviewer, remaining);
+
+      const prompt = buildReviewPrompt(context, question, completedReviews);
+      const result = invokeCliReviewer(reviewer, prompt, reviewerTimeout);
+
+      if (result.ok) {
+        const entry = { reviewer, response: result.response };
+        completedReviews.push(entry);
+
+        // Add to session log
+        withSessionLock(sessionId, () => {
+          const latest = loadSession(sessionId);
+          if (!latest) return;
+          latest.log.push({
+            round: 1,
+            speaker: reviewer,
+            content: result.response,
+            timestamp: new Date().toISOString(),
+            turn_id: generateTurnId(),
+            channel_used: "cli_auto_review",
+            fallback_reason: null,
+          });
+          latest.updated = new Date().toISOString();
+          saveSession(latest);
+        });
+      } else if (result.error === "timeout") {
+        timedOutReviewers.push(reviewer);
+      } else {
+        failedReviewers.push({ reviewer, error: result.error });
+      }
+    }
+
+    // Check min_reviews threshold
+    if (completedReviews.length < min_reviews) {
+      if (on_timeout === "fail") {
+        // Mark session as failed
+        withSessionLock(sessionId, () => {
+          const latest = loadSession(sessionId);
+          if (!latest) return;
+          latest.status = "completed";
+          latest.synthesis = `Review failed: only ${completedReviews.length}/${min_reviews} required reviews completed.`;
+          saveSession(latest);
+          archiveState(latest);
+          cleanupSyncMarkdown(latest);
+        });
+
+        return {
+          content: [{
+            type: "text",
+            text: `❌ 리뷰 실패: 최소 ${min_reviews}개 리뷰 필요, ${completedReviews.length}개만 완료\n\n**Session:** ${sessionId}\n**완료:** ${completedReviews.map(r => r.reviewer).join(", ") || "(없음)"}\n**타임아웃:** ${timedOutReviewers.join(", ") || "(없음)"}\n**실패:** ${failedReviewers.map(r => `${r.reviewer}: ${r.error}`).join(", ") || "(없음)"}`,
+          }],
+        };
+      }
+      // on_timeout === "partial": fall through to return partial results
+    }
+
+    // Synthesize
+    const synthesis = synthesizeReviews(context, question, completedReviews);
+
+    // Complete session
+    let archivePath = null;
+    withSessionLock(sessionId, () => {
+      const latest = loadSession(sessionId);
+      if (!latest) return;
+      latest.status = "completed";
+      latest.synthesis = synthesis;
+      latest.current_speaker = "none";
+      saveSession(latest);
+      archivePath = archiveState(latest);
+      cleanupSyncMarkdown(latest);
+    });
+
+    const totalMs = Date.now() - globalStart;
+    const coverage = `${completedReviews.length}/${validReviewers.length}`;
+    const warn = invalidReviewers.length > 0
+      ? `\n**제외된 리뷰어 (미설치):** ${invalidReviewers.join(", ")}`
+      : "";
+    const timeoutInfo = timedOutReviewers.length > 0
+      ? `\n**타임아웃 리뷰어:** ${timedOutReviewers.join(", ")}`
+      : "";
+    const failInfo = failedReviewers.length > 0
+      ? `\n**실패 리뷰어:** ${failedReviewers.map(r => `${r.reviewer}: ${r.error}`).join(", ")}`
+      : "";
+
+    const resultPayload = {
+      synthesis,
+      completed_reviewers: completedReviews.map(r => r.reviewer),
+      timed_out_reviewers: timedOutReviewers,
+      failed_reviewers: failedReviewers.map(r => r.reviewer),
+      coverage,
+      mode: "sync",
+      session_id: sessionId,
+      elapsed_ms: totalMs,
+    };
+
+    return {
+      content: [{
+        type: "text",
+        text: `## Review 완료\n\n**Session:** ${sessionId}\n**Coverage:** ${coverage}\n**소요 시간:** ${totalMs}ms\n**완료 리뷰어:** ${completedReviews.map(r => r.reviewer).join(", ") || "(없음)"}${timeoutInfo}${failInfo}${warn}\n\n${synthesis}\n\n---\n\n\`\`\`json\n${JSON.stringify(resultPayload, null, 2)}\n\`\`\``,
+      }],
+    };
+  })
+);
+
 // ── Start ──────────────────────────────────────────────────────
 
 const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmsdc-ai/aigentry-devkit",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Cross-platform installer and tooling bundle for aigentry-devkit",
   "license": "MIT",
   "repository": {

package/skills/deliberation/SKILL.md

@@ -29,9 +29,7 @@ Claude/Codex를 포함해 MCP를 지원하는 임의 CLI들이 구조화된 토
 | `deliberation_status` | 토론 상태 조회 | 선택적* |
 | `deliberation_context` | 프로젝트 컨텍스트 로드 | 불필요 |
 | `deliberation_browser_llm_tabs` | 브라우저 LLM 탭 목록 (웹 기반 LLM 참여용) | 불필요 |
-| `deliberation_clipboard_prepare_turn` | 클립보드 기반 턴 준비 (프롬프트 생성) | 선택적* |
-| `deliberation_clipboard_submit_turn` | 클립보드 기반 턴 제출 (응답 붙여넣기) | 선택적* |
-| `deliberation_route_turn` | 현재 차례 speaker의 transport(CLI/clipboard/manual)를 자동 라우팅 | 선택적* |
+| `deliberation_route_turn` | 현재 차례 speaker의 transport(CLI/browser_auto/manual)를 자동 라우팅 | 선택적* |
 | `deliberation_respond` | 현재 차례의 응답 제출 | 선택적* |
 | `deliberation_history` | 전체 토론 기록 조회 | 선택적* |
 | `deliberation_synthesize` | 합성 보고서 생성 및 토론 완료 | 선택적* |
@@ -52,21 +50,38 @@ Claude/Codex를 포함해 MCP를 지원하는 임의 CLI들이 구조화된 토
 - "deliberation", "deliberate", "토론", "debate"
 - "deliberation 시작", "토론 시작", "토론해", "토론하자"
 - "deliberation_start", "deliberation_respond", "deliberation_route_turn"
-- "speaker candidates", "브라우저 LLM", "clipboard submit"
+- "speaker candidates", "브라우저 LLM"
+- "크롬", "브라우저", "웹 LLM", "chrome", "browser LLM"
 - "{주제} 토론", "{주제} deliberation"
 
 ## 워크플로우
 
 ### A. 사용자 선택형 진행 (권장)
 1. `deliberation_speaker_candidates` → 참가 가능한 CLI/브라우저 speaker 확인
-2. (선택) `deliberation_browser_llm_tabs` → 웹 LLM 탭 점검
-3. `deliberation_start` (speakers 명시) → session_id 획득
-4. `deliberation_route_turn` → 현재 차례 speaker transport 확인 + turn_id 확보
-5. 라우팅 결과에 따라 제출:
-- CLI speaker: `deliberation_respond(session_id, speaker, content, turn_id)`
-- Browser speaker: `deliberation_clipboard_prepare_turn` → 응답 복사 → `deliberation_clipboard_submit_turn(session_id, speaker, turn_id)`
-6. 반복 후 `deliberation_synthesize(session_id)` → 합성 완료
-7. 구현이 필요하면 `deliberation-executor` 스킬로 handoff
+2. **AskUserQuestion으로 참가자 선택** — 감지된 CLI/브라우저 speaker 목록을 `multiSelect: true`로 제시하여 사용자가 원하는 참가자만 체크. 예:
+   ```
+   AskUserQuestion({
+     questions: [{
+       question: "토론에 참여할 speaker를 선택하세요",
+       header: "참가자",
+       multiSelect: true,
+       options: [
+         { label: "claude", description: "CLI (자동 응답)" },
+         { label: "codex", description: "CLI (자동 응답)" },
+         { label: "gemini", description: "CLI (자동 응답)" },
+         { label: "web-chatgpt-1", description: "⚡자동 (CDP 자동 연결)" },
+         { label: "web-claude-1", description: "⚡자동 (CDP 자동 연결)" },
+         { label: "web-gemini-1", description: "⚡자동 (CDP 자동 연결)" }
+       ]
+     }]
+   })
+   ```
+3. `deliberation_start` (선택된 speakers 전달) → session_id 획득
+4. `deliberation_route_turn` → 현재 차례 speaker transport 자동 결정
+   - CLI speaker → 자동 응답
+   - browser_auto → CDP로 자동 전송/수집
+5. 반복 후 `deliberation_synthesize(session_id)` → 합성 완료
+6. 구현이 필요하면 `deliberation-executor` 스킬로 handoff
    예: "session_id {id} 합의안 구현해줘"
 
 ### B. 병렬 세션 운영
@@ -100,6 +115,13 @@ bash deliberation-monitor.sh <session_id>
 bash deliberation-monitor.sh --tmux
 ```
 
+### E. 브라우저 LLM 자동 연결 (CDP Auto-Activation)
+- 브라우저 LLM speaker가 선택되면 CDP(Chrome DevTools Protocol)가 자동으로 활성화됩니다.
+- macOS에서는 Chrome이 실행되지 않은 경우 `--remote-debugging-port=9222`로 자동 실행을 시도합니다.
+- **Chrome이 이미 CDP 없이 실행 중인 경우**: Chrome을 완전히 종료한 후 다시 시도해야 합니다. (최초 1회만 필요)
+- CDP 연결 성공 시 모든 브라우저 speaker는 ⚡자동 모드로 동작합니다.
+- Windows/Linux에서는 사용자가 직접 Chrome을 `--remote-debugging-port=9222`로 실행해야 합니다.
+
 ## 역할 규칙
 
 ### 역할 예시 A: 비판적 분석가
@@ -130,6 +152,6 @@ bash deliberation-monitor.sh --tmux
 1. 여러 deliberation을 동시에 병렬 진행 가능
 2. session_id는 `deliberation_start` 응답에서 확인
 3. 토론 결과는 Obsidian vault에 자동 아카이브 (프로젝트 폴더 존재 시)
-4. `deliberation-{session_id}.md`가 프로젝트 루트에 실시간 동기화됨
+4. 실시간 sync 파일은 state 디렉토리에 저장되며 완료 시 자동 삭제됨 (프로젝트 루트 오염 없음)
 5. `Transport closed` 발생 시 현재 CLI 세션 재시작 후 재시도 (stdio 연결은 세션 바인딩)
 6. 멀티 세션 운영 중 `pkill -f mcp-deliberation` 사용 금지 (다른 세션 연결까지 끊길 수 있음)