adhdev 0.1.21 → 0.1.23

package/dist/index.js

@@ -325,11 +325,61 @@ var init_config = __esm({
       userName: null,
       setupCompleted: false,
       setupDate: null,
-      configuredCLIs: []
+      configuredCLIs: [],
+      enabledIdes: []
     };
   }
 });
 
+// src/cli-detector.ts
+async function detectCLIs() {
+  const platform9 = os.platform();
+  const whichCmd = platform9 === "win32" ? "where" : "which";
+  const results = [];
+  for (const cli of KNOWN_CLIS) {
+    try {
+      const pathResult = (0, import_child_process3.execSync)(`${whichCmd} ${cli.command} 2>/dev/null`, {
+        encoding: "utf-8",
+        timeout: 5e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim().split("\n")[0];
+      if (!pathResult) throw new Error("Not found");
+      let version;
+      try {
+        const versionResult = (0, import_child_process3.execSync)(`${cli.command} --version 2>/dev/null`, {
+          encoding: "utf-8",
+          timeout: 5e3,
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        const match = versionResult.match(/(\d+\.\d+[\.\d]*)/);
+        version = match ? match[1] : versionResult.split("\n")[0].slice(0, 30);
+      } catch {
+      }
+      results.push({ ...cli, installed: true, version, path: pathResult });
+    } catch {
+      results.push({ ...cli, installed: false });
+    }
+  }
+  return results;
+}
+async function detectCLI(cliId) {
+  const all = await detectCLIs();
+  return all.find((c) => c.id === cliId && c.installed) || null;
+}
+var import_child_process3, os, KNOWN_CLIS;
+var init_cli_detector = __esm({
+  "src/cli-detector.ts"() {
+    "use strict";
+    import_child_process3 = require("child_process");
+    os = __toESM(require("os"));
+    KNOWN_CLIS = [
+      { id: "gemini-cli", displayName: "Gemini CLI", icon: "\u264A", command: "gemini" },
+      { id: "claude-code", displayName: "Claude Code", icon: "\u{1F916}", command: "claude" },
+      { id: "codex-cli", displayName: "Codex CLI", icon: "\u{1F9E0}", command: "codex" }
+    ];
+  }
+});
+
 // src/launch.ts
 async function findFreePort(ports) {
   for (const port2 of ports) {
@@ -377,38 +427,38 @@ async function isCdpActive(port) {
   });
 }
 async function killIdeProcess(ideId) {
-  const plat = os.platform();
+  const plat = os2.platform();
   const appName = MAC_APP_IDENTIFIERS[ideId];
   const winProcesses = WIN_PROCESS_NAMES[ideId];
   try {
     if (plat === "darwin" && appName) {
       try {
-        (0, import_child_process3.execSync)(`osascript -e 'tell application "${appName}" to quit' 2>/dev/null`, {
+        (0, import_child_process4.execSync)(`osascript -e 'tell application "${appName}" to quit' 2>/dev/null`, {
           timeout: 5e3
         });
       } catch {
         try {
-          (0, import_child_process3.execSync)(`pkill -f "${appName}" 2>/dev/null`);
+          (0, import_child_process4.execSync)(`pkill -f "${appName}" 2>/dev/null`);
         } catch {
         }
       }
     } else if (plat === "win32" && winProcesses) {
       for (const proc of winProcesses) {
         try {
-          (0, import_child_process3.execSync)(`taskkill /IM "${proc}" /F 2>nul`, { timeout: 5e3 });
+          (0, import_child_process4.execSync)(`taskkill /IM "${proc}" /F 2>nul`, { timeout: 5e3 });
         } catch {
         }
       }
       try {
         const exeName = winProcesses[0].replace(".exe", "");
-        (0, import_child_process3.execSync)(`powershell -Command "Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue | Stop-Process -Force"`, {
+        (0, import_child_process4.execSync)(`powershell -Command "Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue | Stop-Process -Force"`, {
           timeout: 1e4
         });
       } catch {
       }
     } else {
       try {
-        (0, import_child_process3.execSync)(`pkill -f "${ideId}" 2>/dev/null`);
+        (0, import_child_process4.execSync)(`pkill -f "${ideId}" 2>/dev/null`);
       } catch {
       }
     }
@@ -418,13 +468,13 @@ async function killIdeProcess(ideId) {
     }
     if (plat === "darwin" && appName) {
       try {
-        (0, import_child_process3.execSync)(`pkill -9 -f "${appName}" 2>/dev/null`);
+        (0, import_child_process4.execSync)(`pkill -9 -f "${appName}" 2>/dev/null`);
       } catch {
       }
     } else if (plat === "win32" && winProcesses) {
       for (const proc of winProcesses) {
         try {
-          (0, import_child_process3.execSync)(`taskkill /IM "${proc}" /F 2>nul`);
+          (0, import_child_process4.execSync)(`taskkill /IM "${proc}" /F 2>nul`);
         } catch {
         }
       }
@@ -436,26 +486,26 @@ async function killIdeProcess(ideId) {
   }
 }
 function isIdeRunning(ideId) {
-  const plat = os.platform();
+  const plat = os2.platform();
   try {
     if (plat === "darwin") {
       const appName = MAC_APP_IDENTIFIERS[ideId];
       if (!appName) return false;
-      const result = (0, import_child_process3.execSync)(`pgrep -f "${appName}" 2>/dev/null`, { encoding: "utf-8" });
+      const result = (0, import_child_process4.execSync)(`pgrep -f "${appName}" 2>/dev/null`, { encoding: "utf-8" });
       return result.trim().length > 0;
     } else if (plat === "win32") {
       const winProcesses = WIN_PROCESS_NAMES[ideId];
       if (!winProcesses) return false;
       for (const proc of winProcesses) {
         try {
-          const result = (0, import_child_process3.execSync)(`tasklist /FI "IMAGENAME eq ${proc}" /NH 2>nul`, { encoding: "utf-8" });
+          const result = (0, import_child_process4.execSync)(`tasklist /FI "IMAGENAME eq ${proc}" /NH 2>nul`, { encoding: "utf-8" });
           if (result.includes(proc)) return true;
         } catch {
         }
       }
       try {
         const exeName = winProcesses[0].replace(".exe", "");
-        const result = (0, import_child_process3.execSync)(
+        const result = (0, import_child_process4.execSync)(
           `powershell -Command "(Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue).Count"`,
           { encoding: "utf-8", timeout: 5e3 }
         );
@@ -464,7 +514,7 @@ function isIdeRunning(ideId) {
       }
       return false;
     } else {
-      const result = (0, import_child_process3.execSync)(`pgrep -f "${ideId}" 2>/dev/null`, { encoding: "utf-8" });
+      const result = (0, import_child_process4.execSync)(`pgrep -f "${ideId}" 2>/dev/null`, { encoding: "utf-8" });
       return result.trim().length > 0;
     }
   } catch {
@@ -472,12 +522,12 @@ function isIdeRunning(ideId) {
   }
 }
 function detectCurrentWorkspace(ideId) {
-  const plat = os.platform();
+  const plat = os2.platform();
   if (plat === "darwin") {
     try {
       const appName = MAC_APP_IDENTIFIERS[ideId];
       if (!appName) return void 0;
-      const result = (0, import_child_process3.execSync)(
+      const result = (0, import_child_process4.execSync)(
         `lsof -c "${appName}" 2>/dev/null | grep cwd | head -1 | awk '{print $NF}'`,
         { encoding: "utf-8", timeout: 3e3 }
       );
@@ -498,7 +548,7 @@ function detectCurrentWorkspace(ideId) {
       const appName = appNameMap[ideId];
       if (appName) {
         const storagePath = path.join(
-          process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"),
+          process.env.APPDATA || path.join(os2.homedir(), "AppData", "Roaming"),
           appName,
           "storage.json"
         );
@@ -520,7 +570,7 @@ function detectCurrentWorkspace(ideId) {
   return void 0;
 }
 async function launchWithCdp(options = {}) {
-  const platform9 = os.platform();
+  const platform9 = os2.platform();
   let targetIde;
   const ides = await detectIDEs();
   if (options.ideId) {
@@ -630,9 +680,9 @@ async function launchMacOS(ide, port, workspace, newWindow) {
   if (workspace) args.push(workspace);
   if (appName) {
     const openArgs = ["-a", appName, "--args", ...args];
-    (0, import_child_process3.spawn)("open", openArgs, { detached: true, stdio: "ignore" }).unref();
+    (0, import_child_process4.spawn)("open", openArgs, { detached: true, stdio: "ignore" }).unref();
   } else if (ide.cliCommand) {
-    (0, import_child_process3.spawn)(ide.cliCommand, args, { detached: true, stdio: "ignore" }).unref();
+    (0, import_child_process4.spawn)(ide.cliCommand, args, { detached: true, stdio: "ignore" }).unref();
   } else {
     throw new Error(`No app identifier or CLI for ${ide.displayName}`);
   }
@@ -658,15 +708,15 @@ async function launchLinux(ide, port, workspace, newWindow) {
   const args = ["--remote-debugging-port=" + port];
   if (newWindow) args.push("--new-window");
   if (workspace) args.push(workspace);
-  (0, import_child_process3.spawn)(cli, args, { detached: true, stdio: "ignore" }).unref();
+  (0, import_child_process4.spawn)(cli, args, { detached: true, stdio: "ignore" }).unref();
 }
-var import_child_process3, net, os, path, CDP_PORTS, MAC_APP_IDENTIFIERS, WIN_PROCESS_NAMES;
+var import_child_process4, net, os2, path, CDP_PORTS, MAC_APP_IDENTIFIERS, WIN_PROCESS_NAMES;
 var init_launch = __esm({
   "src/launch.ts"() {
     "use strict";
-    import_child_process3 = require("child_process");
+    import_child_process4 = require("child_process");
     net = __toESM(require("net"));
-    os = __toESM(require("os"));
+    os2 = __toESM(require("os"));
     path = __toESM(require("path"));
     init_detector();
     init_config();
@@ -821,6 +871,8 @@ var init_cli_bridge = __esm({
           const handlers = this.messageHandlers.get(message.type);
           if (handlers) {
             handlers.forEach((h) => h(message));
+          } else if (message.type !== "auth_ok") {
+            console.log(`[CliBridge] Unhandled message type: ${message.type}`);
           }
         } catch (error) {
           console.error("[CliBridge] Failed to parse message:", error);
@@ -881,21 +933,21 @@ function stripAnsi(str) {
   return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/\x1B\][^\x07]*\x07/g, "").replace(/\x1B\][^\x1B]*\x1B\\/g, "");
 }
 function findGeminiBinary() {
-  const isWin = os2.platform() === "win32";
+  const isWin = os3.platform() === "win32";
   const cmd = isWin ? "where gemini" : "which gemini";
   try {
-    const result = (0, import_child_process4.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const result = (0, import_child_process5.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
     return result.split("\n")[0].trim();
   } catch {
     return isWin ? "gemini.cmd" : "gemini";
   }
 }
-var os2, import_child_process4, pty, PROMPT_PATTERNS, STARTUP_DIALOG_PATTERNS, GeminiCliAdapter;
+var os3, import_child_process5, pty, PROMPT_PATTERNS, STARTUP_DIALOG_PATTERNS, GeminiCliAdapter;
 var init_gemini_cli = __esm({
   "src/cli-adapters/gemini-cli.ts"() {
     "use strict";
-    os2 = __toESM(require("os"));
-    import_child_process4 = require("child_process");
+    os3 = __toESM(require("os"));
+    import_child_process5 = require("child_process");
     try {
       pty = require("node-pty");
     } catch {
@@ -1147,21 +1199,21 @@ function stripAnsi2(str) {
   return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/\x1B\][^\x07]*\x07/g, "").replace(/\x1B\][^\x1B]*\x1B\\/g, "");
 }
 function findClaudeBinary() {
-  const isWin = os3.platform() === "win32";
+  const isWin = os4.platform() === "win32";
   const cmd = isWin ? "where claude" : "which claude";
   try {
-    const result = (0, import_child_process5.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const result = (0, import_child_process6.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
     return result.split("\n")[0].trim();
   } catch {
     return isWin ? "claude.cmd" : "claude";
   }
 }
-var os3, import_child_process5, pty2, ClaudeCliAdapter;
+var os4, import_child_process6, pty2, ClaudeCliAdapter;
 var init_claude_cli = __esm({
   "src/cli-adapters/claude-cli.ts"() {
     "use strict";
-    os3 = __toESM(require("os"));
-    import_child_process5 = require("child_process");
+    os4 = __toESM(require("os"));
+    import_child_process6 = require("child_process");
     try {
       pty2 = require("node-pty");
     } catch {
@@ -1359,21 +1411,21 @@ function stripAnsi3(str) {
   return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/\x1B\][^\x07]*\x07/g, "").replace(/\x1B\][^\x1B]*\x1B\\/g, "");
 }
 function findCodexBinary() {
-  const isWin = os4.platform() === "win32";
+  const isWin = os5.platform() === "win32";
   const cmd = isWin ? "where codex" : "which codex";
   try {
-    const result = (0, import_child_process6.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const result = (0, import_child_process7.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
     return result.split("\n")[0].trim();
   } catch {
     return isWin ? "codex.cmd" : "codex";
   }
 }
-var os4, import_child_process6, pty3, CodexCliAdapter;
+var os5, import_child_process7, pty3, CodexCliAdapter;
 var init_codex_cli = __esm({
   "src/cli-adapters/codex-cli.ts"() {
     "use strict";
-    os4 = __toESM(require("os"));
-    import_child_process6 = require("child_process");
+    os5 = __toESM(require("os"));
+    import_child_process7 = require("child_process");
     try {
       pty3 = require("node-pty");
     } catch {
@@ -1826,13 +1878,16 @@ var init_local_server = __esm({
       /**
        * 가장 최근 Extension 상태 데이터 (통합)
        */
-      getLatestExtensionData() {
+      getLatestExtensionData(enabledIdes) {
         let activeFile = null;
         const allWorkspaceFolders = [];
         let totalTerminals = 0;
         const allAgents = [];
         const connectedIdes = [];
         for (const ext of this.extensions.values()) {
+          if (enabledIdes && enabledIdes.length > 0 && !enabledIdes.includes(ext.ideType.toLowerCase())) {
+            continue;
+          }
           connectedIdes.push({ ideType: ext.ideType, instanceId: ext.instanceId });
           if (ext.lastStatus) {
             if (!activeFile && ext.lastStatus.activeFile) {
@@ -1855,55 +1910,6 @@ var init_local_server = __esm({
   }
 });
 
-// src/cli-detector.ts
-async function detectCLIs() {
-  const platform9 = os5.platform();
-  const whichCmd = platform9 === "win32" ? "where" : "which";
-  const results = [];
-  for (const cli of KNOWN_CLIS) {
-    try {
-      const pathResult = (0, import_child_process7.execSync)(`${whichCmd} ${cli.command} 2>/dev/null`, {
-        encoding: "utf-8",
-        timeout: 5e3,
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim().split("\n")[0];
-      if (!pathResult) throw new Error("Not found");
-      let version;
-      try {
-        const versionResult = (0, import_child_process7.execSync)(`${cli.command} --version 2>/dev/null`, {
-          encoding: "utf-8",
-          timeout: 5e3,
-          stdio: ["pipe", "pipe", "pipe"]
-        }).trim();
-        const match = versionResult.match(/(\d+\.\d+[\.\d]*)/);
-        version = match ? match[1] : versionResult.split("\n")[0].slice(0, 30);
-      } catch {
-      }
-      results.push({ ...cli, installed: true, version, path: pathResult });
-    } catch {
-      results.push({ ...cli, installed: false });
-    }
-  }
-  return results;
-}
-async function detectCLI(cliId) {
-  const all = await detectCLIs();
-  return all.find((c) => c.id === cliId && c.installed) || null;
-}
-var import_child_process7, os5, KNOWN_CLIS;
-var init_cli_detector = __esm({
-  "src/cli-detector.ts"() {
-    "use strict";
-    import_child_process7 = require("child_process");
-    os5 = __toESM(require("os"));
-    KNOWN_CLIS = [
-      { id: "gemini-cli", displayName: "Gemini CLI", icon: "\u264A", command: "gemini" },
-      { id: "claude-code", displayName: "Claude Code", icon: "\u{1F916}", command: "claude" },
-      { id: "codex-cli", displayName: "Codex CLI", icon: "\u{1F9E0}", command: "codex" }
-    ];
-  }
-});
-
 // src/daemon-cdp.ts
 var import_ws3, http, fs, KNOWN_AGENTS, DaemonCdpManager;
 var init_daemon_cdp = __esm({
@@ -1919,10 +1925,15 @@ var init_daemon_cdp = __esm({
     ];
     DaemonCdpManager = class {
       ws = null;
+      browserWs = null;
+      // browser-level WS for Target discovery
+      browserMsgId = 1e4;
+      browserPending = /* @__PURE__ */ new Map();
       msgId = 1;
       pending = /* @__PURE__ */ new Map();
       port;
       _connected = false;
+      _browserConnected = false;
       targetUrl = "";
       reconnectTimer = null;
       contexts = /* @__PURE__ */ new Set();
@@ -1931,8 +1942,10 @@ var init_daemon_cdp = __esm({
       MAX_FAILURES = 5;
       agentSessions = /* @__PURE__ */ new Map();
       logFn;
-      constructor(port = 9333, logFn) {
+      disableFallback;
+      constructor(port = 9333, logFn, disableFallback = false) {
         this.port = port;
+        this.disableFallback = disableFallback;
         this.logFn = logFn || ((msg) => {
           console.log(msg);
           try {
@@ -2011,6 +2024,7 @@ var init_daemon_cdp = __esm({
       async findTarget() {
         let target = await this.findTargetOnPort(this.port);
         if (target) return target;
+        if (this.disableFallback) return null;
         const fallbackPorts = [9222, 9333, 9335, 9337, 9339].filter((p) => p !== this.port);
         for (const port of fallbackPorts) {
           target = await this.findTargetOnPort(port);
@@ -2031,6 +2045,8 @@ var init_daemon_cdp = __esm({
               await this.sendInternal("Runtime.enable");
             } catch {
             }
+            this.connectBrowserWs().catch(() => {
+            });
             resolve3(true);
           });
           this.ws.on("message", (data) => {
@@ -2055,6 +2071,9 @@ var init_daemon_cdp = __esm({
           this.ws.on("close", () => {
             this.log("[CDP] WebSocket closed \u2014 scheduling reconnect");
             this._connected = false;
+            this._browserConnected = false;
+            this.browserWs?.close();
+            this.browserWs = null;
             this.connectPromise = null;
             this.scheduleReconnect();
           });
@@ -2065,12 +2084,98 @@ var init_daemon_cdp = __esm({
           });
         });
       }
+      /** Browser-level CDP 연결 — Target discovery에 필요 */
+      async connectBrowserWs() {
+        if (this._browserConnected && this.browserWs?.readyState === import_ws3.default.OPEN) return;
+        try {
+          const browserWsUrl = await this.getBrowserWsUrl();
+          if (!browserWsUrl) {
+            this.log("[CDP] No browser WS URL found");
+            return;
+          }
+          this.log(`[CDP] Connecting browser WS for target discovery...`);
+          await new Promise((resolve3, reject) => {
+            this.browserWs = new import_ws3.default(browserWsUrl);
+            this.browserWs.on("open", async () => {
+              this._browserConnected = true;
+              this.log("[CDP] \u2705 Browser WS connected \u2014 enabling target discovery");
+              try {
+                await this.sendBrowser("Target.setDiscoverTargets", { discover: true });
+              } catch (e) {
+                this.log(`[CDP] setDiscoverTargets failed: ${e.message}`);
+              }
+              resolve3();
+            });
+            this.browserWs.on("message", (data) => {
+              try {
+                const msg = JSON.parse(data.toString());
+                if (msg.id && this.browserPending.has(msg.id)) {
+                  const { resolve: resolve4, reject: reject2 } = this.browserPending.get(msg.id);
+                  this.browserPending.delete(msg.id);
+                  if (msg.error) reject2(new Error(msg.error.message));
+                  else resolve4(msg.result);
+                }
+              } catch {
+              }
+            });
+            this.browserWs.on("close", () => {
+              this._browserConnected = false;
+              this.browserWs = null;
+            });
+            this.browserWs.on("error", (err) => {
+              this.log(`[CDP] Browser WS error: ${err.message}`);
+              this._browserConnected = false;
+              reject(err);
+            });
+          });
+        } catch (e) {
+          this.log(`[CDP] Browser WS connect failed: ${e.message}`);
+        }
+      }
+      getBrowserWsUrl() {
+        return new Promise((resolve3) => {
+          const req = http.get(`http://127.0.0.1:${this.port}/json/version`, (res) => {
+            let data = "";
+            res.on("data", (chunk) => data += chunk.toString());
+            res.on("end", () => {
+              try {
+                const info = JSON.parse(data);
+                resolve3(info.webSocketDebuggerUrl || null);
+              } catch {
+                resolve3(null);
+              }
+            });
+          });
+          req.on("error", () => resolve3(null));
+          req.setTimeout(3e3, () => {
+            req.destroy();
+            resolve3(null);
+          });
+        });
+      }
+      sendBrowser(method, params = {}, timeoutMs = 15e3) {
+        return new Promise((resolve3, reject) => {
+          if (!this.browserWs || !this._browserConnected) return reject(new Error("Browser WS not connected"));
+          const id = this.browserMsgId++;
+          this.browserPending.set(id, { resolve: resolve3, reject });
+          this.browserWs.send(JSON.stringify({ id, method, params }));
+          setTimeout(() => {
+            if (this.browserPending.has(id)) {
+              this.browserPending.delete(id);
+              reject(new Error(`Browser CDP timeout: ${method}`));
+            }
+          }, timeoutMs);
+        });
+      }
       scheduleReconnect() {
         if (this.reconnectTimer) return;
         this.reconnectTimer = setTimeout(async () => {
           this.reconnectTimer = null;
           if (!this._connected) {
-            await this.connect();
+            const ok = await this.connect();
+            if (!ok && !this._connected) {
+              this.scheduleReconnect();
+            }
           }
         }, 5e3);
       }
@@ -2082,6 +2187,9 @@ var init_daemon_cdp = __esm({
         this.ws?.close();
         this.ws = null;
         this._connected = false;
+        this.browserWs?.close();
+        this.browserWs = null;
+        this._browserConnected = false;
         this.failureCount = 0;
       }
       get isConnected() {
@@ -2155,23 +2263,47 @@ var init_daemon_cdp = __esm({
       // ─── Agent Webview Multi-Session ─────────────────────────
       async discoverAgentWebviews() {
         if (!this.isConnected) return [];
+        if (!this._browserConnected) {
+          await this.connectBrowserWs().catch(() => {
+          });
+        }
         try {
-          const result = await this.sendInternal("Target.getTargets");
-          const allTargets = result?.targetInfos || [];
+          let allTargets = [];
+          if (this._browserConnected) {
+            const result = await this.sendBrowser("Target.getTargets");
+            allTargets = result?.targetInfos || [];
+          } else {
+            const result = await this.sendInternal("Target.getTargets");
+            allTargets = result?.targetInfos || [];
+          }
           const iframes = allTargets.filter((t) => t.type === "iframe");
-          this.log(`[CDP] discoverAgentWebviews: ${allTargets.length} total, ${iframes.length} iframes`);
+          const typeMap = /* @__PURE__ */ new Map();
+          for (const t of allTargets) {
+            typeMap.set(t.type, (typeMap.get(t.type) || 0) + 1);
+          }
+          const typeSummary = [...typeMap.entries()].map(([k, v]) => `${k}:${v}`).join(",");
+          this.log(`[CDP] discoverAgentWebviews: ${allTargets.length} total [${typeSummary}], ${iframes.length} iframes (browser=${this._browserConnected})`);
+          for (const t of allTargets) {
+            if (t.type !== "page" && t.type !== "worker" && t.type !== "service_worker") {
+              this.log(`[CDP]   target: type=${t.type} url=${(t.url || "").substring(0, 120)}`);
+            }
+            if ((t.url || "").includes("vscode-webview")) {
+              this.log(`[CDP]   webview: type=${t.type} url=${(t.url || "").substring(0, 150)}`);
+            }
+          }
           const agents = [];
           for (const target of allTargets) {
             if (target.type !== "iframe") continue;
-            const hasWebview = target.url?.includes("vscode-webview");
+            const url = target.url || "";
+            const hasWebview = url.includes("vscode-webview");
             if (!hasWebview) continue;
             for (const known of KNOWN_AGENTS) {
-              if (known.extensionIdPattern.test(target.url)) {
+              if (known.extensionIdPattern.test(url)) {
                 agents.push({
                   targetId: target.targetId,
                   extensionId: known.extensionId,
                   agentType: known.agentType,
-                  url: target.url
+                  url
                 });
                 this.log(`[CDP] Found agent: ${known.agentType} (${target.targetId})`);
                 break;
@@ -2190,7 +2322,8 @@ var init_daemon_cdp = __esm({
           if (t.agentType === target.agentType) return sid;
         }
         try {
-          const result = await this.sendInternal("Target.attachToTarget", {
+          const sendFn = this._browserConnected ? this.sendBrowser.bind(this) : this.sendInternal.bind(this);
+          const result = await sendFn("Target.attachToTarget", {
             targetId: target.targetId,
             flatten: true
           });
@@ -2206,12 +2339,15 @@ var init_daemon_cdp = __esm({
         }
       }
       async evaluateInSession(sessionId, expression, timeoutMs = 15e3) {
-        if (!this.isConnected || !this.ws || this.ws.readyState !== import_ws3.default.OPEN) {
+        const ws = this._browserConnected ? this.browserWs : this.ws;
+        const pendingMap = this._browserConnected ? this.browserPending : this.pending;
+        const getNextId = () => this._browserConnected ? this.browserMsgId++ : this.msgId++;
+        if (!ws || ws.readyState !== import_ws3.default.OPEN) {
           throw new Error("CDP not connected");
         }
         return new Promise((resolve3, reject) => {
-          const id = this.msgId++;
-          this.pending.set(id, {
+          const id = getNextId();
+          pendingMap.set(id, {
             resolve: (result) => {
               if (result?.result?.subtype === "error") {
                 reject(new Error(result.result.description));
@@ -2221,15 +2357,15 @@ var init_daemon_cdp = __esm({
             },
             reject
           });
-          this.ws.send(JSON.stringify({
+          ws.send(JSON.stringify({
             id,
             sessionId,
             method: "Runtime.evaluate",
             params: { expression, returnByValue: true, awaitPromise: true }
           }));
           setTimeout(() => {
-            if (this.pending.has(id)) {
-              this.pending.delete(id);
+            if (pendingMap.has(id)) {
+              pendingMap.delete(id);
               reject(new Error(`CDP agent timeout: ${sessionId.substring(0, 12)}...`));
             }
           }, timeoutMs);
@@ -2237,7 +2373,8 @@ var init_daemon_cdp = __esm({
       }
       async detachAgent(sessionId) {
         try {
-          await this.sendInternal("Target.detachFromTarget", { sessionId });
+          const sendFn = this._browserConnected ? this.sendBrowser.bind(this) : this.sendInternal.bind(this);
+          await sendFn("Target.detachFromTarget", { sessionId });
         } catch {
         }
         this.agentSessions.delete(sessionId);
@@ -2256,7 +2393,9 @@ var init_daemon_cdp = __esm({
         try {
           const result = await this.sendInternal("Page.captureScreenshot", {
             format: "jpeg",
-            quality: 60
+            quality: 25,
+            clip: void 0
+            // full viewport
           }, 1e4);
           if (result?.data) {
             return Buffer.from(result.data, "base64");
@@ -2577,12 +2716,22 @@ var init_daemon_p2p = __esm({
       fileRequestHandler = null;
       inputHandler = null;
       commandHandler = null;
+      _ssDebugDone = false;
       get screenshotActive() {
         for (const peer of this.peers.values()) {
           if (peer.screenshotActive && peer.state === "connected") return true;
         }
         return false;
       }
+      /** Get the ideType for the currently active screenshot request */
+      get screenshotIdeType() {
+        for (const peer of this.peers.values()) {
+          if (peer.screenshotActive && peer.state === "connected" && peer.screenshotIdeType) {
+            return peer.screenshotIdeType;
+          }
+        }
+        return void 0;
+      }
       constructor(bridge) {
         this.bridge = bridge;
         this.tryLoadNodeDatachannel();
@@ -2591,7 +2740,8 @@ var init_daemon_p2p = __esm({
       tryLoadNodeDatachannel() {
         try {
           this.nodeDatachannel = require_lib();
-          log(`node-datachannel loaded \u2705`);
+          const keys = Object.keys(this.nodeDatachannel).join(",");
+          log(`node-datachannel loaded \u2705 (keys: ${keys.substring(0, 100)})`);
           return;
         } catch (e) {
           log(`node-datachannel not found: ${e?.message}`);
@@ -2725,7 +2875,12 @@ var init_daemon_p2p = __esm({
         if (existing?.state === "connected") return;
         if (existing?.state === "connecting") this.disconnectPeer(pid);
         log(`initiateConnection() for peer ${pid}...`);
-        const { PeerConnection } = this.nodeDatachannel;
+        const mod = this.nodeDatachannel;
+        const PeerConnectionCtor = mod.PeerConnection || mod.default?.PeerConnection || mod.default || mod;
+        if (!PeerConnectionCtor || typeof PeerConnectionCtor !== "function") {
+          log(`PeerConnection constructor not found in node-datachannel module. Keys: ${Object.keys(mod).join(",")}`);
+          return;
+        }
         let iceServers = [
           "stun:stun.cloudflare.com:3478",
           "stun:stun.l.google.com:19302"
@@ -2738,7 +2893,7 @@ var init_daemon_p2p = __esm({
           }
         } catch {
         }
-        const pc = new PeerConnection(`ADHDev-Daemon-${pid.substring(0, 8)}`, {
+        const pc = new PeerConnectionCtor(`ADHDev-Daemon-${pid.substring(0, 8)}`, {
           iceServers
         });
         const entry = {
@@ -2781,11 +2936,17 @@ var init_daemon_p2p = __esm({
             }
           });
           const screenshotCh = pc.createDataChannel("screenshots");
-          entry.screenshotChannel = screenshotCh;
           screenshotCh.onOpen(() => {
             log(`Screenshots channel OPEN for peer ${pid}`);
-            entry.state = "connected";
-            this.notifyStateChange();
+            const peer = this.peers.get(pid);
+            if (peer) {
+              peer.screenshotChannel = screenshotCh;
+              peer.state = "connected";
+              this.notifyStateChange();
+              if (peer.screenshotActive) {
+                log(`Screenshots auto-starting for peer ${pid} (was waiting for channel open)`);
+              }
+            }
           });
           screenshotCh.onClosed(() => {
             log(`Screenshots channel CLOSED for peer ${pid}`);
@@ -2819,14 +2980,24 @@ var init_daemon_p2p = __esm({
         const text = typeof msg === "string" ? msg : msg.toString("utf-8");
         try {
           const parsed = JSON.parse(text);
+          log(`Files message from peer ${peerId}: type=${parsed.type}`);
           if (parsed.type === "screenshot_start") {
             const peer = this.peers.get(peerId);
-            if (peer) peer.screenshotActive = true;
+            if (peer) {
+              peer.screenshotActive = true;
+              peer.screenshotIdeType = parsed.ideType || void 0;
+              log(`screenshot_start: peer=${peerId}, ideType=${parsed.ideType || "any"}, channelOpen=${!!peer.screenshotChannel}, state=${peer.state}`);
+            } else {
+              log(`screenshot_start: peer ${peerId} NOT FOUND in peers map!`);
+            }
             return;
           }
           if (parsed.type === "screenshot_stop") {
             const peer = this.peers.get(peerId);
-            if (peer) peer.screenshotActive = false;
+            if (peer) {
+              peer.screenshotActive = false;
+              log(`screenshot_stop: peer=${peerId}`);
+            }
             return;
           }
           if (parsed.type === "input") {
@@ -2863,14 +3034,28 @@ var init_daemon_p2p = __esm({
       sendScreenshot(base64Data) {
         let sentAny = false;
         const buffer = Buffer.from(base64Data, "base64");
-        for (const peer of this.peers.values()) {
+        let debugOnce = !this._ssDebugDone;
+        const CHUNK_SIZE = 6e4;
+        for (const [pid, peer] of this.peers.entries()) {
+          if (debugOnce) {
+            log(`sendScreenshot peer=${pid}: state=${peer.state}, hasSsCh=${!!peer.screenshotChannel}, ssActive=${peer.screenshotActive}, chOpen=${peer.screenshotChannel?.isOpen?.() ?? "N/A"}, bufSize=${buffer.length}`);
+          }
           if (peer.state !== "connected" || !peer.screenshotChannel || !peer.screenshotActive) continue;
           try {
-            peer.screenshotChannel.sendMessageBinary(buffer);
+            if (!peer.screenshotChannel.isOpen()) continue;
+            const header = Buffer.alloc(4);
+            header.writeUInt32BE(buffer.length, 0);
+            peer.screenshotChannel.sendMessageBinary(header);
+            for (let offset = 0; offset < buffer.length; offset += CHUNK_SIZE) {
+              const chunk = buffer.subarray(offset, Math.min(offset + CHUNK_SIZE, buffer.length));
+              peer.screenshotChannel.sendMessageBinary(chunk);
+            }
             sentAny = true;
-          } catch {
+          } catch (e) {
+            if (debugOnce) log(`sendScreenshot ERROR for peer ${pid}: ${e?.message}`);
           }
         }
+        if (debugOnce) this._ssDebugDone = true;
         return sentAny;
       }
       // ─── 핸들러 등록 ────────────────────────────
@@ -2904,7 +3089,9 @@ var init_daemon_p2p = __esm({
           return;
         }
         try {
-          const result = await this.inputHandler({ action, params });
+          const peer = this.peers.get(peerId);
+          const ideType = peer?.screenshotIdeType;
+          const result = await this.inputHandler({ action, params, _targetInstance: ideType ? `${ideType}_` : void 0 });
           this.sendToPeer(peerId, { id, type: "response", success: true, result });
         } catch (e) {
           this.sendToPeer(peerId, { id, type: "response", success: false, error: e?.message });
@@ -3156,13 +3343,46 @@ var init_daemon_commands = __esm({
     DaemonCommandHandler = class {
       ctx;
       agentStream = null;
+      /** Get CDP manager for a specific ideType, or first connected one */
+      getCdp(ideType) {
+        const key = ideType || this._currentIdeType;
+        if (key) {
+          const m = this.ctx.cdpManagers.get(key.toLowerCase());
+          if (m?.isConnected) return m;
+        }
+        for (const m of this.ctx.cdpManagers.values()) {
+          if (m.isConnected) return m;
+        }
+        return null;
+      }
+      /** Current IDE type extracted from command args (per-request) */
+      _currentIdeType;
+      /** Extract ideType from _targetInstance (e.g. 'vscode_abc123' → 'vscode') */
+      extractIdeType(args) {
+        if (args?._targetInstance) {
+          const parts = args._targetInstance.split("_");
+          if (parts.length >= 2) return parts[0];
+        }
+        return void 0;
+      }
       constructor(ctx) {
         this.ctx = ctx;
       }
+      /** Get ScriptLoader for specific ideType, fallback to first available */
+      getScriptLoader(ideType) {
+        const key = ideType || this._currentIdeType;
+        if (key) {
+          const l = this.ctx.scriptLoaders.get(key.toLowerCase());
+          if (l) return l;
+        }
+        for (const l of this.ctx.scriptLoaders.values()) return l;
+        return void 0;
+      }
       setAgentStreamManager(manager) {
         this.agentStream = manager;
       }
       async handle(cmd, args) {
+        this._currentIdeType = this.extractIdeType(args);
         switch (cmd) {
           // ─── CDP 직접 처리 ───────────────────
           case "read_chat":
@@ -3205,8 +3425,13 @@ var init_daemon_commands = __esm({
             return this.handleFileListBrowse(args);
           // ─── vscode API → Extension 위임 ────
           case "vscode_command_exec":
-          case "execute_vscode_command":
-            return this.delegateToExtension(args?.command || cmd, args?.args);
+          case "execute_vscode_command": {
+            const resolvedCmd = args?.commandId || args?.command;
+            if (resolvedCmd === "adhdev.captureCdpScreenshot") {
+              return this.handleScreenshot(args);
+            }
+            return this.delegateToExtension(resolvedCmd || cmd, args?.args);
+          }
           case "get_open_editors":
             return this.delegateToExtension("adhdev.getOpenEditors", [args]);
           case "open_tab":
@@ -3249,59 +3474,97 @@ var init_daemon_commands = __esm({
       }
       // ─── CDP 기반 채팅 명령 ──────────────────────
       async handleReadChat(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
-        const script = this.ctx.scriptLoader?.get("read_chat");
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
+        const script = this.getScriptLoader()?.get("read_chat");
         if (!script) return { success: false, error: "read_chat script not loaded" };
         try {
-          const result = await this.ctx.cdp.evaluate(script, 5e4);
+          const result = await this.getCdp().evaluate(script, 5e4);
           return { success: true, ...result };
         } catch (e) {
           return { success: false, error: e.message };
         }
       }
       async handleSendChat(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
         const text = args?.text || args?.message;
         if (!text) return { success: false, error: "text required" };
-        const script = this.ctx.scriptLoader?.getWithParams("send_message", { MESSAGE: JSON.stringify(text) });
-        if (!script) return { success: false, error: "send_message script not loaded" };
-        try {
-          await this.ctx.cdp.evaluate(script, 3e4);
-          return { success: true, sent: true };
-        } catch (e) {
-          return { success: false, error: e.message };
+        const targetCdp = this.getCdp();
+        const targetLoader = this.getScriptLoader();
+        if (targetCdp?.isConnected && targetLoader) {
+          const script = targetLoader.getWithParams("send_message", { MESSAGE: JSON.stringify(text) });
+          if (script) {
+            console.log(`[send_chat] Targeting IDE: ${this._currentIdeType || "fallback-first"}`);
+            try {
+              await targetCdp.evaluate(script, 3e4);
+              return { success: true, sent: true };
+            } catch (e) {
+              console.log(`[send_chat] Failed on ${this._currentIdeType}: ${e.message}`);
+            }
+          }
+        }
+        console.log(`[send_chat] No specific target, trying all CDPs...`);
+        for (const [ideType, cdp] of this.ctx.cdpManagers) {
+          if (!cdp.isConnected) continue;
+          const loader = this.ctx.scriptLoaders.get(ideType);
+          if (!loader) continue;
+          const script = loader.getWithParams("send_message", { MESSAGE: JSON.stringify(text) });
+          if (!script) continue;
+          console.log(`[send_chat] Trying IDE: ${ideType}`);
+          try {
+            await cdp.evaluate(script, 3e4);
+            return { success: true, sent: true, targetIde: ideType };
+          } catch (e) {
+            console.log(`[send_chat] Failed on ${ideType}: ${e.message}`);
+          }
         }
+        return { success: false, error: "No CDP could send the message" };
       }
       async handleListChats(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
-        const script = this.ctx.scriptLoader?.get("list_chats");
-        if (!script) return { success: false, error: "list_chats script not loaded" };
+        const cdp = this.getCdp();
+        if (!cdp?.isConnected) {
+          console.log(`[list_chats] CDP not connected, ideType=${this._currentIdeType}`);
+          return { success: false, error: "CDP not connected" };
+        }
+        const script = this.getScriptLoader()?.get("list_chats");
+        if (!script) {
+          console.log(`[list_chats] script not loaded`);
+          return { success: false, error: "list_chats script not loaded" };
+        }
         try {
-          const result = await this.ctx.cdp.evaluate(script, 3e4);
-          return { success: true, chats: result };
+          console.log(`[list_chats] Evaluating on ideType=${this._currentIdeType}`);
+          const result = await cdp.evaluate(script, 3e4);
+          let parsed = result;
+          if (typeof result === "string") {
+            try {
+              parsed = JSON.parse(result);
+            } catch {
+            }
+          }
+          console.log(`[list_chats] Result type=${typeof parsed}, isArray=${Array.isArray(parsed)}, len=${Array.isArray(parsed) ? parsed.length : "N/A"}`);
+          return { success: true, chats: parsed };
         } catch (e) {
+          console.log(`[list_chats] Error: ${e.message}`);
           return { success: false, error: e.message };
         }
       }
       async handleNewChat(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
-        const script = this.ctx.scriptLoader?.get("new_session");
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
+        const script = this.getScriptLoader()?.get("new_session");
         if (!script) return { success: false, error: "new_session script not loaded" };
         try {
-          await this.ctx.cdp.evaluate(script, 15e3);
+          await this.getCdp().evaluate(script, 15e3);
           return { success: true };
         } catch (e) {
           return { success: false, error: e.message };
         }
       }
       async handleSwitchChat(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         const sessionId = args?.sessionId || args?.id || args?.chatId;
         if (!sessionId) return { success: false, error: "sessionId required" };
-        const script = this.ctx.scriptLoader?.getWithParams("switch_session", { SESSION_ID: sessionId });
+        const script = this.getScriptLoader()?.getWithParams("switch_session", { SESSION_ID: sessionId });
         if (!script) return { success: false, error: "switch_session script not loaded" };
         try {
-          await this.ctx.cdp.evaluate(script, 15e3);
+          await this.getCdp().evaluate(script, 15e3);
           return { success: true };
         } catch (e) {
           return { success: false, error: e.message };
@@ -3315,12 +3578,12 @@ var init_daemon_commands = __esm({
         return this.delegateToExtension("workbench.action.openSettings", [`cursor.model`]);
       }
       async handleResolveModal(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         const button = args?.button || args?.buttonText || "Accept";
-        const script = this.ctx.scriptLoader?.getWithParams("resolve_modal", { BUTTON_TEXT: button });
+        const script = this.getScriptLoader()?.getWithParams("resolve_modal", { BUTTON_TEXT: button });
         if (!script) {
           try {
-            await this.ctx.cdp.evaluate(`
+            await this.getCdp().evaluate(`
                     (() => {
                         const btns = [...document.querySelectorAll('button')];
                         const btn = btns.find(b => b.textContent?.trim() === ${JSON.stringify(button)});
@@ -3334,7 +3597,7 @@ var init_daemon_commands = __esm({
           }
         }
         try {
-          await this.ctx.cdp.evaluate(script, 1e4);
+          await this.getCdp().evaluate(script, 1e4);
           return { success: true };
         } catch (e) {
           return { success: false, error: e.message };
@@ -3342,22 +3605,23 @@ var init_daemon_commands = __esm({
       }
       // ─── CDP 직접 명령 ──────────────────────────
       async handleCdpEval(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         const expression = args?.expression || args?.script;
         if (!expression) return { success: false, error: "expression required" };
         try {
-          const result = await this.ctx.cdp.evaluate(expression, 5e4);
+          const result = await this.getCdp().evaluate(expression, 5e4);
           return { success: true, result };
         } catch (e) {
           return { success: false, error: e.message };
         }
       }
       async handleScreenshot(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         try {
-          const buf = await this.ctx.cdp.captureScreenshot();
+          const buf = await this.getCdp().captureScreenshot();
           if (buf) {
-            return { success: true, screenshot: buf.toString("base64"), format: "jpeg" };
+            const b64 = buf.toString("base64");
+            return { success: true, result: b64, base64: b64, screenshot: b64, format: "jpeg" };
           }
           return { success: false, error: "Screenshot failed" };
         } catch (e) {
@@ -3365,26 +3629,26 @@ var init_daemon_commands = __esm({
         }
       }
       async handleCdpCommand(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         const method = args?.method;
         const params = args?.params || {};
         if (!method) return { success: false, error: "method required" };
         try {
-          const result = await this.ctx.cdp.sendCdpCommand(method, params);
+          const result = await this.getCdp().sendCdpCommand(method, params);
           return { success: true, result };
         } catch (e) {
           return { success: false, error: e.message };
         }
       }
       async handleCdpBatch(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         const commands = args?.commands;
         const stopOnError = args?.stopOnError !== false;
         if (!commands?.length) return { success: false, error: "commands array required" };
         const results = [];
         for (const cmd of commands) {
           try {
-            const result = await this.ctx.cdp.sendCdpCommand(cmd.method, cmd.params || {});
+            const result = await this.getCdp().sendCdpCommand(cmd.method, cmd.params || {});
             results.push({ method: cmd.method, success: true, result });
           } catch (e) {
             results.push({ method: cmd.method, success: false, error: e.message });
@@ -3394,49 +3658,60 @@ var init_daemon_commands = __esm({
         return { success: true, results };
       }
       async handleCdpRemoteAction(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         const action = args?.action;
         const params = args?.params || args;
         try {
           switch (action) {
             case "input_key": {
               const { key, modifiers } = params;
-              await this.ctx.cdp.send("Input.dispatchKeyEvent", {
+              await this.getCdp().send("Input.dispatchKeyEvent", {
                 type: "keyDown",
                 key,
                 ...modifiers?.ctrl ? { modifiers: 2 } : {},
                 ...modifiers?.shift ? { modifiers: 8 } : {}
               });
-              await this.ctx.cdp.send("Input.dispatchKeyEvent", { type: "keyUp", key });
+              await this.getCdp().send("Input.dispatchKeyEvent", { type: "keyUp", key });
               return { success: true };
             }
             case "input_click": {
-              const { x, y, button: btn } = params;
-              await this.ctx.cdp.send("Input.dispatchMouseEvent", {
+              let { x, y, nx, ny, button: btn } = params;
+              if ((x === void 0 || y === void 0) && nx !== void 0 && ny !== void 0) {
+                const viewport = await this.getCdp().evaluate(
+                  "JSON.stringify({ w: window.innerWidth, h: window.innerHeight })"
+                );
+                const { w, h } = JSON.parse(viewport);
+                x = Math.round(nx * w);
+                y = Math.round(ny * h);
+              }
+              if (x === void 0 || y === void 0) {
+                return { success: false, error: "No coordinates provided (x,y or nx,ny required)" };
+              }
+              await this.getCdp().send("Input.dispatchMouseEvent", {
                 type: "mousePressed",
                 x,
                 y,
                 button: btn || "left",
                 clickCount: 1
               });
-              await this.ctx.cdp.send("Input.dispatchMouseEvent", {
+              await this.getCdp().send("Input.dispatchMouseEvent", {
                 type: "mouseReleased",
                 x,
                 y,
                 button: btn || "left",
                 clickCount: 1
               });
-              return { success: true };
+              return { success: true, x, y };
             }
             case "input_type": {
               const { text } = params;
               for (const char of text || "") {
-                await this.ctx.cdp.send("Input.dispatchKeyEvent", {
+                await this.getCdp().send("Input.dispatchKeyEvent", {
                   type: "keyDown",
                   text: char,
                   key: char
                 });
-                await this.ctx.cdp.send("Input.dispatchKeyEvent", { type: "keyUp", key: char });
+                await this.getCdp().send("Input.dispatchKeyEvent", { type: "keyUp", key: char });
               }
               return { success: true };
             }
@@ -3445,9 +3720,28 @@ var init_daemon_commands = __esm({
             case "page_eval":
               return this.handleCdpEval(params);
             case "dom_query": {
-              const html = await this.ctx.cdp.querySelector(params?.selector);
+              const html = await this.getCdp().querySelector(params?.selector);
               return { success: true, html };
             }
+            case "input_wheel": {
+              let { x, y, nx, ny, deltaX, deltaY } = params;
+              if ((x === void 0 || y === void 0) && nx !== void 0 && ny !== void 0) {
+                const viewport = await this.getCdp().evaluate(
+                  "JSON.stringify({ w: window.innerWidth, h: window.innerHeight })"
+                );
+                const { w, h } = JSON.parse(viewport);
+                x = Math.round(nx * w);
+                y = Math.round(ny * h);
+              }
+              await this.getCdp().send("Input.dispatchMouseEvent", {
+                type: "mouseWheel",
+                x: x || 0,
+                y: y || 0,
+                deltaX: deltaX || 0,
+                deltaY: deltaY || 0
+              });
+              return { success: true };
+            }
             default:
               return { success: false, error: `Unknown remote action: ${action}` };
           }
@@ -3456,8 +3750,8 @@ var init_daemon_commands = __esm({
         }
       }
       async handleDiscoverAgents(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
-        const agents = await this.ctx.cdp.discoverAgentWebviews();
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
+        const agents = await this.getCdp().discoverAgentWebviews();
         return { success: true, agents };
       }
       // ─── 파일 직접 처리 ─────────────────────────
@@ -3514,7 +3808,7 @@ var init_daemon_commands = __esm({
         if (!this.ctx.localServer || this.ctx.localServer.extensionCount === 0) {
           return { success: false, error: "No extension connected" };
         }
-        return this.ctx.localServer.executeVscodeCommand(command, args);
+        return this.ctx.localServer.executeVscodeCommand(command, args, this._currentIdeType);
       }
       // ─── 기타 ───────────────────────────────────
       async handleGetRecentWorkspaces(args) {
@@ -3533,66 +3827,67 @@ var init_daemon_commands = __esm({
         }
       }
       async handleRefreshScripts(args) {
-        if (!this.ctx.scriptLoader) return { success: false, error: "ScriptLoader not initialized" };
-        await this.ctx.scriptLoader.refresh();
+        const loader = this.getScriptLoader();
+        if (!loader) return { success: false, error: "ScriptLoader not initialized" };
+        await loader.refresh();
         return { success: true };
       }
       // ─── Agent Stream 명령 ───────────────────────
       async handleAgentStreamSwitch(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || null;
-        await this.agentStream.switchActiveAgent(this.ctx.cdp, agentType);
+        await this.agentStream.switchActiveAgent(this.getCdp(), agentType);
         return { success: true, activeAgent: agentType };
       }
       async handleAgentStreamRead(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
-        const streams = await this.agentStream.collectAgentStreams(this.ctx.cdp);
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
+        const streams = await this.agentStream.collectAgentStreams(this.getCdp());
         return { success: true, streams };
       }
       async handleAgentStreamSend(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || this.agentStream.activeAgentType;
         const text = args?.text || args?.message;
         if (!agentType || !text) return { success: false, error: "agentType and text required" };
-        const ok = await this.agentStream.sendToAgent(this.ctx.cdp, agentType, text);
+        const ok = await this.agentStream.sendToAgent(this.getCdp(), agentType, text);
         return { success: ok };
       }
       async handleAgentStreamResolve(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || this.agentStream.activeAgentType;
         const action = args?.action || "approve";
         if (!agentType) return { success: false, error: "agentType required" };
-        const ok = await this.agentStream.resolveAgentAction(this.ctx.cdp, agentType, action);
+        const ok = await this.agentStream.resolveAgentAction(this.getCdp(), agentType, action);
         return { success: ok };
       }
       async handleAgentStreamNew(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || this.agentStream.activeAgentType;
         if (!agentType) return { success: false, error: "agentType required" };
-        const ok = await this.agentStream.newAgentSession(this.ctx.cdp, agentType);
+        const ok = await this.agentStream.newAgentSession(this.getCdp(), agentType);
         return { success: ok };
       }
       async handleAgentStreamListChats(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || this.agentStream.activeAgentType;
         if (!agentType) return { success: false, error: "agentType required" };
-        const chats = await this.agentStream.listAgentChats(this.ctx.cdp, agentType);
+        const chats = await this.agentStream.listAgentChats(this.getCdp(), agentType);
         return { success: true, chats };
       }
       async handleAgentStreamSwitchSession(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || this.agentStream.activeAgentType;
         const sessionId = args?.sessionId || args?.id;
         if (!agentType || !sessionId) return { success: false, error: "agentType and sessionId required" };
-        const ok = await this.agentStream.switchAgentSession(this.ctx.cdp, agentType, sessionId);
+        const ok = await this.agentStream.switchAgentSession(this.getCdp(), agentType, sessionId);
         return { success: ok };
       }
       async handleAgentStreamFocus(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || this.agentStream.activeAgentType;
         if (!agentType) return { success: false, error: "agentType required" };
         await this.agentStream.ensureAgentPanelOpen(agentType);
-        const ok = await this.agentStream.focusAgentEditor(this.ctx.cdp, agentType);
+        const ok = await this.agentStream.focusAgentEditor(this.getCdp(), agentType);
         return { success: ok };
       }
     };
@@ -4192,23 +4487,29 @@ var init_adhdev_daemon = __esm({
     AdhdevDaemon = class {
       localServer = null;
       bridge = null;
-      adapter = null;
-      cdpManager = null;
+      adapters = /* @__PURE__ */ new Map();
+      cdpManagers = /* @__PURE__ */ new Map();
       cdpDiscoveryTimer = null;
       p2p = null;
-      scriptLoader = null;
+      scriptLoaders = /* @__PURE__ */ new Map();
       commandHandler = null;
       screenshotTimer = null;
       agentStreamManager = null;
       agentStreamTimer = null;
       running = false;
       statusTimer = null;
-      lastAgentStatus = "idle";
-      generatingStartedAt = 0;
+      lastAgentStatus = /* @__PURE__ */ new Map();
+      generatingStartedAt = /* @__PURE__ */ new Map();
+      getCliKey(cliType, dir) {
+        const hash = require("crypto").createHash("md5").update(require("path").resolve(dir)).digest("hex").slice(0, 8);
+        return `${cliType}_${hash}`;
+      }
       detectedIdes = [];
       localPort;
       ideType = "unknown";
-      _cachedAgentStreams = [];
+      _cachedAgentStreamsMap = /* @__PURE__ */ new Map();
+      _cachedActiveChatMap = /* @__PURE__ */ new Map();
+      _cdpChatBusy = false;
       constructor() {
         this.localPort = DEFAULT_DAEMON_PORT;
       }
@@ -4271,18 +4572,27 @@ var init_adhdev_daemon = __esm({
         }
         this.detectedIdes = await detectIDEs();
         await this.initCdp();
-        this.ideType = this.detectedIdes.find((ide) => ide.running)?.type || "cursor";
-        this.scriptLoader = new DaemonScriptLoader(
-          options.serverUrl || config.serverUrl,
-          this.ideType
-        );
-        this.scriptLoader.setToken(config.connectionToken);
-        await this.scriptLoader.start().catch((e) => {
-          console.log(import_chalk2.default.yellow(`  \u26A0 ScriptLoader start failed: ${e.message}`));
-        });
+        const serverUrl = options.serverUrl || config.serverUrl;
+        for (const ideType of this.cdpManagers.keys()) {
+          const loader = new DaemonScriptLoader(serverUrl, ideType);
+          loader.setToken(config.connectionToken);
+          await loader.start().catch((e) => {
+            console.log(import_chalk2.default.yellow(`  \u26A0 ScriptLoader start failed for ${ideType}: ${e.message}`));
+          });
+          this.scriptLoaders.set(ideType, loader);
+        }
+        if (this.scriptLoaders.size === 0) {
+          const fallbackType = this.detectedIdes.find((ide) => ide.installed)?.id || "cursor";
+          const loader = new DaemonScriptLoader(serverUrl, fallbackType);
+          loader.setToken(config.connectionToken);
+          await loader.start().catch((e) => {
+            console.log(import_chalk2.default.yellow(`  \u26A0 ScriptLoader start failed: ${e.message}`));
+          });
+          this.scriptLoaders.set(fallbackType, loader);
+        }
         this.commandHandler = new DaemonCommandHandler({
-          cdp: this.cdpManager,
-          scriptLoader: this.scriptLoader,
+          cdpManagers: this.cdpManagers,
+          scriptLoaders: this.scriptLoaders,
           localServer: this.localServer,
           ideType: this.ideType
         });
@@ -4293,26 +4603,11 @@ var init_adhdev_daemon = __esm({
         );
         this.agentStreamManager.setLocalServer(this.localServer);
         this.commandHandler.setAgentStreamManager(this.agentStreamManager);
-        if (this.cdpManager) {
-          this.agentStreamTimer = setInterval(async () => {
-            if (!this.cdpManager?.isConnected || !this.agentStreamManager) return;
-            try {
-              await this.agentStreamManager.syncAgentSessions(this.cdpManager);
-              this._cachedAgentStreams = await this.agentStreamManager.collectAgentStreams(this.cdpManager);
-            } catch {
-            }
-          }, 5e3);
-        }
+        this.startAgentStreamPolling();
         if (options.cliType) {
-          const cliInfo = await detectCLI(options.cliType);
-          if (cliInfo) {
-            this.adapter = this.createAdapter(options.cliType, workingDir);
-            await this.adapter.spawn();
-            this.adapter.setOnStatusChange(() => this.sendUnifiedStatusReport());
-            console.log(import_chalk2.default.green(`  \u{1F916} CLI Agent started: ${cliInfo.displayName} v${cliInfo.version || "unknown"}`));
-          } else {
-            console.log(import_chalk2.default.yellow(`  \u26A0 CLI ${options.cliType} not found \u2014 running without CLI agent`));
-          }
+          await this.startCliSession(options.cliType, workingDir).catch((e) => {
+            console.log(import_chalk2.default.yellow(`  \u26A0 Failed to start CLI ${options.cliType}: ${e.message}`));
+          });
         }
         const machineId = os8.hostname().replace(/[^a-zA-Z0-9]/g, "_");
         const machineHash = crypto2.createHash("md5").update(os8.hostname() + os8.homedir()).digest("hex").slice(0, 8);
@@ -4327,9 +4622,6 @@ var init_adhdev_daemon = __esm({
             instanceId
           }
         });
-        if (this.adapter && typeof this.adapter.setBridge === "function") {
-          this.adapter.setBridge(this.bridge);
-        }
         this.p2p = new DaemonP2PSender(this.bridge);
         if (this.p2p.isAvailable) {
           console.log(import_chalk2.default.green("  \u{1F517} P2P available (node-datachannel)"));
@@ -4353,12 +4645,26 @@ var init_adhdev_daemon = __esm({
               return { id: req.id, success: result.success, entries: result.files, error: result.error };
             }
           });
+          let ssDebugCount = 0;
           this.screenshotTimer = setInterval(async () => {
-            if (!this.p2p?.screenshotActive || !this.cdpManager?.isConnected) return;
+            const active = this.p2p?.screenshotActive;
+            const ssIdeType = this.p2p?.screenshotIdeType;
+            const cdp = ssIdeType ? this.getCdpFor(ssIdeType) : this.getAnyCdp();
+            if (!active || !cdp) return;
+            ssDebugCount++;
+            if (ssDebugCount <= 3 || ssDebugCount % 25 === 0) {
+              console.log(`[SS] Capturing screenshot... (tick ${ssDebugCount}, active=${active}, cdp=true)`);
+            }
             try {
-              const buf = await this.cdpManager.captureScreenshot();
-              if (buf) this.p2p.sendScreenshot(buf.toString("base64"));
-            } catch {
+              const buf = await cdp.captureScreenshot();
+              if (buf) {
+                const sent = this.p2p.sendScreenshot(buf.toString("base64"));
+                if (ssDebugCount <= 3) console.log(`[SS] Screenshot sent: ${buf.length} bytes, delivered=${sent}`);
+              } else {
+                if (ssDebugCount <= 5) console.log(`[SS] captureScreenshot returned null`);
+              }
+            } catch (e) {
+              if (ssDebugCount <= 5) console.log(`[SS] Screenshot error: ${e?.message}`);
             }
           }, 200);
         } else {
@@ -4391,9 +4697,10 @@ var init_adhdev_daemon = __esm({
         console.log(import_chalk2.default.bold("  \u{1F309} ADHDev Daemon"));
         console.log(`  ${import_chalk2.default.bold("Local:")}   ws://127.0.0.1:${this.localPort}/ipc`);
         console.log(`  ${import_chalk2.default.bold("Server:")}  ${serverUrl}`);
-        console.log(`  ${import_chalk2.default.bold("CDP:")}     ${this.cdpManager?.isConnected ? `\u2705 port ${this.cdpManager.getPort()}` : "\u274C not connected"}`);
+        const cdpStatus = this.cdpManagers.size > 0 ? `\u2705 ${[...this.cdpManagers.entries()].map(([k, m]) => `${k}:${m.getPort()}`).join(", ")}` : "\u274C not connected";
+        console.log(`  ${import_chalk2.default.bold("CDP:")}     ${cdpStatus}`);
         console.log(`  ${import_chalk2.default.bold("P2P:")}     ${this.p2p?.isAvailable ? "\u2705 available" : "\u274C unavailable"}`);
-        console.log(`  ${import_chalk2.default.bold("Scripts:")} ${this.scriptLoader ? `\u2705 ${this.ideType}` : "\u274C not loaded"}`);
+        console.log(`  ${import_chalk2.default.bold("Scripts:")} ${this.scriptLoaders.size > 0 ? `\u2705 ${[...this.scriptLoaders.keys()].join(", ")}` : "\u274C not loaded"}`);
         if (options.cliType) {
           console.log(`  ${import_chalk2.default.bold("CLI:")}     ${options.cliType}`);
           console.log(`  ${import_chalk2.default.bold("Dir:")}     ${options.workingDir || process.cwd()}`);
@@ -4405,19 +4712,6 @@ var init_adhdev_daemon = __esm({
       // ─── 서버 명령 핸들러 ───────────────────────────
       registerServerHandlers() {
         if (!this.bridge) return;
-        this.bridge.on("send_chat", (msg) => {
-          const text = msg.payload.message;
-          if (!text || !this.adapter) {
-            this.sendResult(msg, false, { error: "No message or CLI adapter" });
-            return;
-          }
-          console.log(import_chalk2.default.cyan(`  \u2190 Chat: "${text.slice(0, 60)}${text.length > 60 ? "..." : ""}"`));
-          this.adapter.sendMessage(text).then(() => {
-            this.sendResult(msg, true, { sent: true });
-          }).catch((e) => {
-            this.sendResult(msg, false, { error: e?.message || "Failed" });
-          });
-        });
         this.bridge.on("command", async (msg) => {
           const cmd = msg.payload.command;
           const args = msg.payload.args;
@@ -4455,7 +4749,38 @@ var init_adhdev_daemon = __esm({
           "file_list",
           "file_list_browse",
           "terminal_exec",
-          "refresh_scripts"
+          "refresh_scripts",
+          // CLI/daemon-local commands (launch, restart, detect)
+          "launch_ide",
+          "detect_ides",
+          "restart_session",
+          "exec_command",
+          "launch_cli",
+          "stop_cli",
+          // Extension-delegated commands (must be registered to receive WS messages)
+          "vscode_command_exec",
+          "execute_vscode_command",
+          "get_open_editors",
+          "open_tab",
+          "close_tab",
+          "open_folder",
+          "open_folder_picker",
+          "open_recent",
+          "get_commands",
+          "get_recent_workspaces",
+          "open_panel",
+          "open_file",
+          "create_terminal",
+          "close_terminal",
+          // Agent stream commands
+          "agent_stream_switch",
+          "agent_stream_read",
+          "agent_stream_send",
+          "agent_stream_resolve",
+          "agent_stream_new",
+          "agent_stream_list_chats",
+          "agent_stream_switch_session",
+          "agent_stream_focus"
         ];
         for (const cmdType of directCdpCommands) {
           this.bridge.on(cmdType, async (msg) => {
@@ -4467,21 +4792,33 @@ var init_adhdev_daemon = __esm({
         console.log(import_chalk2.default.magenta(`  \u2699 Command: ${cmd}`));
         try {
           switch (cmd) {
-            case "switch_cli": {
-              const newCli = args?.cli || "gemini-cli";
-              const newDir = args?.dir || this.adapter?.workingDir || process.cwd();
-              await this.switchCliSession(newCli, newDir);
-              this.sendResult(msg, true, { cli: newCli, dir: newDir });
+            case "launch_cli": {
+              const cliType = args?.cliType;
+              const dir = args?.dir || process.cwd();
+              if (!cliType) throw new Error("cliType required");
+              const key = this.getCliKey(cliType, dir);
+              if (!this.adapters.has(key)) {
+                await this.startCliSession(cliType, dir);
+              }
+              this.sendResult(msg, true, { cliType, dir, id: key });
               return;
             }
-            case "change_dir": {
-              if (!args?.dir) throw new Error("Directory path required");
-              if (this.adapter) await this.switchCliSession(this.adapter.cliType, args.dir);
-              this.sendResult(msg, true, { dir: args.dir });
+            case "stop_cli": {
+              const cliType = args?.cliType;
+              const dir = args?.dir || process.cwd();
+              if (!cliType) throw new Error("cliType required");
+              const key = this.getCliKey(cliType, dir);
+              await this.stopCliSession(key);
+              this.sendResult(msg, true, { cliType, dir });
               return;
             }
             case "restart_session": {
-              if (this.adapter) await this.switchCliSession(this.adapter.cliType, this.adapter.workingDir);
+              const cliType = args?.cliType || args?.agentType;
+              const dir = args?.dir || process.cwd();
+              if (!cliType) throw new Error("cliType required");
+              const key = this.getCliKey(cliType, dir);
+              await this.stopCliSession(key);
+              await this.startCliSession(cliType, dir);
               this.sendResult(msg, true, { restarted: true });
               return;
             }
@@ -4492,7 +4829,7 @@ var init_adhdev_daemon = __esm({
                 this.sendResult(msg, false, { error: `Blocked: "${cmdStr}"` });
                 return;
               }
-              const cwd = this.adapter?.workingDir || process.cwd();
+              const cwd = args?.dir || process.cwd();
               const { exec: exec2 } = require("child_process");
               exec2(cmdStr, { cwd, timeout: 6e4 }, (err, stdout, stderr) => {
                 if (!this.bridge) return;
@@ -4506,7 +4843,33 @@ var init_adhdev_daemon = __esm({
               return;
             }
             case "launch_ide": {
-              const result = await launchWithCdp(args);
+              const launchArgs = { ...args, ideId: args.ideId || args.ideType };
+              const ideKey = launchArgs.ideId;
+              console.log(`[launch_ide] target=${ideKey || "auto"}`);
+              const result = await launchWithCdp(launchArgs);
+              if (result.success && result.port && result.ideId && !this.cdpManagers.has(result.ideId)) {
+                console.log(import_chalk2.default.cyan(`[launch_ide] Connecting CDP for ${result.ideId} on port ${result.port}...`));
+                const manager = new DaemonCdpManager(result.port, (msg2) => {
+                  console.log(import_chalk2.default.gray(msg2));
+                }, true);
+                const connected = await manager.connect();
+                if (connected) {
+                  this.cdpManagers.set(result.ideId, manager);
+                  console.log(import_chalk2.default.green(`  \u{1F50D} CDP connected: ${result.ideId} (port ${result.port})`));
+                  console.log(import_chalk2.default.green(`  \u{1F4E1} CDP: ${this.cdpManagers.size} IDE(s) connected`));
+                  if (!this.scriptLoaders.has(result.ideId)) {
+                    const config = loadConfig();
+                    const serverUrl = config.serverUrl || "https://api.adhf.dev";
+                    const loader = new DaemonScriptLoader(serverUrl, result.ideId);
+                    loader.setToken(config.connectionToken || "");
+                    await loader.start().catch((e) => {
+                      console.log(import_chalk2.default.yellow(`  \u26A0 ScriptLoader start failed for ${result.ideId}: ${e?.message}`));
+                    });
+                    this.scriptLoaders.set(result.ideId, loader);
+                  }
+                }
+              }
+              this.startAgentStreamPolling();
               this.sendResult(msg, result.success, result);
               return;
             }
@@ -4551,48 +4914,111 @@ var init_adhdev_daemon = __esm({
           return new GeminiCliAdapter(workingDir);
         }
       }
-      async switchCliSession(cliType, workingDir) {
-        console.log(import_chalk2.default.yellow(`  \u26A1 Switching CLI to ${cliType} in ${workingDir}...`));
-        if (this.adapter) this.adapter.shutdown();
+      async startCliSession(cliType, workingDir) {
         const cliInfo = await detectCLI(cliType);
         if (!cliInfo) throw new Error(`${cliType} not found`);
-        this.adapter = this.createAdapter(cliType, workingDir);
-        await this.adapter.spawn();
-        if (this.bridge && typeof this.adapter.setBridge === "function") {
-          this.adapter.setBridge(this.bridge);
+        const key = this.getCliKey(cliType, workingDir);
+        if (this.adapters.has(key)) {
+          console.log(import_chalk2.default.yellow(`  \u26A1 CLI ${cliType} already running in ${workingDir}`));
+          return;
+        }
+        console.log(import_chalk2.default.yellow(`  \u26A1 Starting CLI ${cliType} in ${workingDir}...`));
+        const adapter = this.createAdapter(cliType, workingDir);
+        await adapter.spawn();
+        if (this.bridge && typeof adapter.setBridge === "function") {
+          adapter.setBridge(this.bridge);
+        }
+        adapter.setOnStatusChange(() => this.sendUnifiedStatusReport());
+        this.adapters.set(key, adapter);
+        this.lastAgentStatus.set(key, "idle");
+        console.log(import_chalk2.default.green(`  \u2713 CLI started: ${cliInfo.displayName} v${cliInfo.version || "unknown"} in ${workingDir}`));
+        this.sendUnifiedStatusReport();
+      }
+      async stopCliSession(key) {
+        const adapter = this.adapters.get(key);
+        if (adapter) {
+          adapter.shutdown();
+          this.adapters.delete(key);
+          this.lastAgentStatus.delete(key);
+          this.generatingStartedAt.delete(key);
+          console.log(import_chalk2.default.yellow(`  \u{1F6D1} CLI Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`));
+          this.sendUnifiedStatusReport();
         }
-        this.adapter.setOnStatusChange(() => this.sendUnifiedStatusReport());
-        console.log(import_chalk2.default.green(`  \u2713 CLI switched to ${cliType}`));
       }
       // ─── 통합 상태 보고 ─────────────────────────────
       startStatusReporting() {
         const scheduleNext = () => {
-          const isProcessing = this.adapter?.isProcessing();
+          const isProcessing = Array.from(this.adapters.values()).some((a) => a.isProcessing());
           const interval = isProcessing ? 2e3 : 15e3;
           this.statusTimer = setTimeout(() => {
-            this.sendUnifiedStatusReport();
+            this.sendUnifiedStatusReport().catch(() => {
+            });
             scheduleNext();
           }, interval);
         };
         scheduleNext();
       }
-      sendUnifiedStatusReport() {
+      async sendUnifiedStatusReport() {
         if (!this.bridge?.isConnected()) return;
+        if (this.cdpManagers.size > 0 && this.scriptLoaders.size > 0 && !this._cdpChatBusy) {
+          this._cdpChatBusy = true;
+          for (const [ideType, cdp] of this.cdpManagers) {
+            if (!cdp.isConnected) continue;
+            const loader = this.scriptLoaders.get(ideType);
+            if (!loader) continue;
+            const readChatScript = loader.get("read_chat");
+            if (!readChatScript) continue;
+            try {
+              const raw = await cdp.evaluate(readChatScript, 3e4);
+              if (raw && typeof raw === "object") {
+                let { activeModal } = raw;
+                if (activeModal) {
+                  const w = activeModal.width ?? Infinity;
+                  const h = activeModal.height ?? Infinity;
+                  if (w < 80 || h < 40) activeModal = void 0;
+                  else activeModal = {
+                    message: activeModal.message?.slice(0, 300) ?? "",
+                    buttons: (activeModal.buttons ?? []).filter((t) => t.length < 30)
+                  };
+                }
+                this._cachedActiveChatMap.set(ideType, { ...raw, activeModal });
+              }
+            } catch {
+            }
+          }
+          this._cdpChatBusy = false;
+        }
         const now = Date.now();
         const perExtData = this.localServer?.getPerExtensionData() || [];
-        const extSummary = this.localServer?.getLatestExtensionData() || {
+        const enabledIdesFilter = loadConfig().enabledIdes || [];
+        const filteredExtData = enabledIdesFilter.length > 0 ? perExtData.filter((ext) => enabledIdesFilter.includes(ext.ideType.toLowerCase())) : perExtData;
+        const extSummary = this.localServer?.getLatestExtensionData(enabledIdesFilter) || {
           activeFile: null,
           workspaceFolders: [],
           terminals: 0,
           aiAgents: [],
           connectedIdes: []
         };
-        const cdpAgentStreams = this._cachedAgentStreams || [];
-        const managedIdes = perExtData.map((ext) => {
-          const isMainCdpIde = ext.ideType.toLowerCase() === this.ideType.toLowerCase();
+        const managedIdes = filteredExtData.map((ext) => {
+          const ideKey = ext.ideType.toLowerCase();
+          const isMainCdpIde = this.cdpManagers.has(ideKey);
+          const cdpStreamsForIde = this._cachedAgentStreamsMap.get(ideKey) || [];
+          const extAgentsForIde = (ext.aiAgents || []).filter((a) => {
+            const existsInCdp = cdpStreamsForIde.some((s) => s.agentType === a.id);
+            const existsInExt = ext.agentStreams.some((s) => s.agentType === a.id);
+            return !existsInCdp && !existsInExt;
+          }).map((a) => ({
+            agentType: a.id,
+            agentName: a.name,
+            extensionId: a.id,
+            status: a.status === "active" || a.status === "installed" ? "connected" : "idle",
+            messages: [],
+            inputContent: ""
+          }));
           const ideAgentStreams = [
             ...ext.agentStreams,
-            ...isMainCdpIde ? cdpAgentStreams : []
+            ...isMainCdpIde ? cdpStreamsForIde : [],
+            ...extAgentsForIde
           ];
           return {
             ideType: ext.ideType,
@@ -4602,54 +5028,57 @@ var init_adhdev_daemon = __esm({
             activeFile: ext.activeFile,
             terminals: ext.terminals,
             aiAgents: ext.aiAgents,
-            activeChat: ext.activeChat,
+            activeChat: isMainCdpIde && this._cachedActiveChatMap.has(ideKey) ? this._cachedActiveChatMap.get(ideKey) : ext.activeChat,
             chats: ext.chats,
             agentStreams: ideAgentStreams,
-            cdpConnected: isMainCdpIde ? this.cdpManager?.isConnected || false : false
+            cdpConnected: isMainCdpIde ? this.cdpManagers.get(ext.ideType.toLowerCase())?.isConnected || false : false
           };
         });
         const managedClis = [];
-        if (this.adapter) {
-          const adapterStatus = this.adapter.getStatus();
+        for (const [key, adapter] of this.adapters.entries()) {
+          const adapterStatus = adapter.getStatus();
           const cliStatus = adapterStatus.status;
-          if (cliStatus !== this.lastAgentStatus) {
-            if (this.lastAgentStatus === "idle" && cliStatus === "generating") {
-              this.generatingStartedAt = now;
-              this.bridge.sendMessage("status_event", {
+          let lastStatus = this.lastAgentStatus.get(key) || "idle";
+          if (cliStatus !== lastStatus) {
+            if (lastStatus === "idle" && cliStatus === "generating") {
+              this.generatingStartedAt.set(key, now);
+              this.bridge?.sendMessage("status_event", {
                 event: "agent:generating_started",
-                chatTitle: `${this.adapter.cliName} Session`,
+                chatTitle: `${adapter.cliName} Session`,
                 timestamp: now
               });
-            } else if (this.lastAgentStatus === "generating" && cliStatus === "idle") {
-              const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1e3) : 0;
-              this.bridge.sendMessage("status_event", {
+            } else if (lastStatus === "generating" && cliStatus === "idle") {
+              const startedAt = this.generatingStartedAt.get(key);
+              const duration = startedAt ? Math.round((now - startedAt) / 1e3) : 0;
+              this.bridge?.sendMessage("status_event", {
                 event: "agent:generating_completed",
-                chatTitle: `${this.adapter.cliName} Session`,
+                chatTitle: `${adapter.cliName} Session`,
                 duration,
                 timestamp: now
               });
-              this.generatingStartedAt = 0;
+              this.generatingStartedAt.delete(key);
             }
-            this.lastAgentStatus = cliStatus;
+            this.lastAgentStatus.set(key, cliStatus);
           }
           const recentMessages = adapterStatus.messages.slice(-50);
           const cliMessages = recentMessages.map((m) => ({
             role: m.role,
             content: m.content.length > 2e3 ? m.content.slice(0, 2e3) + "\n... (truncated)" : m.content
           }));
-          const partial = this.adapter.getPartialResponse();
+          const partial = adapter.getPartialResponse();
           if (cliStatus === "generating" && partial) {
-            cliMessages.push({ role: "assistant", content: partial.slice(0, 2e3) + "..." });
+            cliMessages.push({ role: "assistant", content: partial.length > 2e3 ? partial.slice(0, 2e3) + "..." : partial + "..." });
           }
           managedClis.push({
-            cliType: this.adapter.cliType,
-            cliName: this.adapter.cliName,
-            workingDir: this.adapter.workingDir,
+            id: key,
+            cliType: adapter.cliType,
+            cliName: adapter.cliName,
             status: cliStatus,
+            workingDir: adapter.workingDir,
             activeChat: {
-              id: `cli-${this.adapter.cliType}`,
+              id: key,
               status: cliStatus,
-              title: `${this.adapter.cliName} Session`,
+              title: `${adapter.cliName} Session`,
               messages: cliMessages,
               inputContent: "",
               activeModal: adapterStatus.activeModal
@@ -4673,8 +5102,12 @@ var init_adhdev_daemon = __esm({
           // 관리 중인 IDE/CLI (계층 데이터)
           managedIdes,
           managedClis,
-          // IDE 감지 결과 (설치된 IDE 목록)
-          detectedIdes: this.detectedIdes,
+          // IDE 감지 결과 (설치된 IDE 목록) — 프론트엔드 호환 매핑 (id→type)
+          detectedIdes: this.detectedIdes.map((ide) => ({
+            ...ide,
+            type: ide.id
+            // 프론트엔드 MachineDetail.tsx는 'type' 필드 사용
+          })),
           // P2P 상태
           p2p: {
             available: this.p2p?.isAvailable || false,
@@ -4682,18 +5115,25 @@ var init_adhdev_daemon = __esm({
             peers: this.p2p?.connectedPeerCount || 0,
             screenshotActive: this.p2p?.screenshotActive || false
           },
-          cdpConnected: this.cdpManager?.isConnected || false,
-          scriptLoaderReady: !!this.scriptLoader,
+          cdpConnected: this.getAnyCdp() !== null,
+          scriptLoaderReady: this.scriptLoaders.size > 0,
           timestamp: now,
           // ─── Legacy compat (서버 기존 로직용, 점진적 제거 예정) ───
           activeFile: extSummary.activeFile,
-          workspaceFolders: extSummary.workspaceFolders.length > 0 ? extSummary.workspaceFolders : this.adapter ? [{ name: path4.basename(this.adapter.workingDir), path: this.adapter.workingDir }] : [],
+          workspaceFolders: extSummary.workspaceFolders.length > 0 ? extSummary.workspaceFolders : Array.from(this.adapters.values()).map((a) => ({ name: path4.basename(a.workingDir), path: a.workingDir })),
           terminals: extSummary.terminals,
+          // Legacy aiAgents: managedIdes에서 각 IDE의 aiAgents를 통합
           aiAgents: [
-            ...extSummary.aiAgents,
-            ...this.adapter ? [{ id: this.adapter.cliType, name: this.adapter.cliName, status: this.lastAgentStatus }] : []
+            ...managedIdes.flatMap((ide) => (ide.aiAgents || []).map((a) => ({
+              id: a.id,
+              name: a.name,
+              status: a.status,
+              ideType: ide.ideType
+            }))),
+            ...Array.from(this.adapters.entries()).map(([k, a]) => ({ id: a.cliType, name: a.cliName, status: this.lastAgentStatus.get(k) || "idle" }))
           ],
           activeChat: managedClis[0]?.activeChat || managedIdes[0]?.activeChat || null,
+          // Legacy agentStreams: managedIdes의 agentStreams를 통합 (이미 IDE별로 올바르게 구성됨)
           agentStreams: [
             ...managedClis.map((c) => ({
               agentType: c.cliType,
@@ -4703,7 +5143,7 @@ var init_adhdev_daemon = __esm({
               messages: c.activeChat?.messages || [],
               inputContent: ""
             })),
-            ...cdpAgentStreams
+            ...managedIdes.flatMap((ide) => ide.agentStreams || [])
           ],
           connectedExtensions: extSummary.connectedIdes,
           system: {
@@ -4735,18 +5175,22 @@ var init_adhdev_daemon = __esm({
         if (!this.running) return;
         this.running = false;
         console.log(import_chalk2.default.yellow("\n  Shutting down ADHDev Daemon..."));
-        this.adapter?.cancel();
+        for (const adapter of this.adapters.values()) adapter.shutdown();
+        this.adapters.clear();
         if (this.statusTimer) clearTimeout(this.statusTimer);
         if (this.cdpDiscoveryTimer) clearInterval(this.cdpDiscoveryTimer);
         if (this.screenshotTimer) clearInterval(this.screenshotTimer);
         if (this.agentStreamTimer) clearInterval(this.agentStreamTimer);
-        if (this.agentStreamManager && this.cdpManager) {
-          await this.agentStreamManager.dispose(this.cdpManager).catch(() => {
+        const anyCdpStop = this.getAnyCdp();
+        if (this.agentStreamManager && anyCdpStop) {
+          await this.agentStreamManager.dispose(anyCdpStop).catch(() => {
           });
         }
         this.p2p?.disconnect();
-        this.scriptLoader?.stop();
-        this.cdpManager?.disconnect();
+        for (const loader of this.scriptLoaders.values()) loader.stop();
+        this.scriptLoaders.clear();
+        for (const m of this.cdpManagers.values()) m.disconnect();
+        this.cdpManagers.clear();
         this.localServer?.stop();
         this.bridge?.disconnect();
         removeDaemonPid();
@@ -4754,6 +5198,33 @@ var init_adhdev_daemon = __esm({
         process.exit(0);
       }
       // ─── CDP 관리 ───────────────────────────────────
+      /** 첫 번째 연결된 CDP 매니저 반환 */
+      getAnyCdp() {
+        for (const m of this.cdpManagers.values()) {
+          if (m.isConnected) return m;
+        }
+        return null;
+      }
+      /** 특정 IDE의 CDP 매니저 반환 */
+      getCdpFor(ideType) {
+        return this.cdpManagers.get(ideType.toLowerCase()) || null;
+      }
+      /** Agent stream polling 시작 (idempotent — 이미 시작됐으면 무시) */
+      startAgentStreamPolling() {
+        if (this.agentStreamTimer) return;
+        this.agentStreamTimer = setInterval(async () => {
+          if (!this.agentStreamManager || this.cdpManagers.size === 0) return;
+          for (const [ideType, cdp] of this.cdpManagers) {
+            if (!cdp.isConnected) continue;
+            try {
+              await this.agentStreamManager.syncAgentSessions(cdp);
+              const streams = await this.agentStreamManager.collectAgentStreams(cdp);
+              this._cachedAgentStreamsMap.set(ideType, streams);
+            } catch {
+            }
+          }
+        }, 5e3);
+      }
       async initCdp() {
         const cdpPortMap = {
           cursor: 9333,
@@ -4763,7 +5234,7 @@ var init_adhdev_daemon = __esm({
         };
         const portsToTry = [];
         for (const ide of this.detectedIdes) {
-          const ideKey = ide.type || ide.name?.toLowerCase();
+          const ideKey = ide.id || ide.name?.toLowerCase();
           const port = cdpPortMap[ideKey];
           if (port) portsToTry.push({ port, ide: ideKey });
         }
@@ -4772,25 +5243,36 @@ var init_adhdev_daemon = __esm({
             portsToTry.push({ port, ide });
           }
         }
-        for (const { port, ide } of portsToTry) {
+        const enabledIdes = loadConfig().enabledIdes || [];
+        const filteredPorts = enabledIdes.length > 0 ? portsToTry.filter((p) => enabledIdes.includes(p.ide)) : portsToTry;
+        for (const { port, ide } of filteredPorts) {
           const manager = new DaemonCdpManager(port, (msg) => {
             console.log(import_chalk2.default.gray(msg));
-          });
+          }, true);
           const connected = await manager.connect();
           if (connected) {
-            this.cdpManager = manager;
-            this.ideType = ide;
-            console.log(import_chalk2.default.green(`  \u{1F50D} CDP connected: ${ide} (port ${port})`));
-            this.cdpDiscoveryTimer = setInterval(async () => {
-              if (this.cdpManager?.isConnected) {
-                await this.cdpManager.discoverAgentWebviews();
-              }
-            }, 3e4);
-            return;
+            const actualPort = manager.getPort();
+            const actualIde = Object.entries(cdpPortMap).find(([, p]) => p === actualPort)?.[0] || ide;
+            this.cdpManagers.set(actualIde, manager);
+            console.log(import_chalk2.default.green(`  \u{1F50D} CDP connected: ${actualIde} (port ${actualPort})`));
+            if (this.ideType === "unknown") {
+              this.ideType = actualIde;
+            }
           }
         }
-        console.log(import_chalk2.default.yellow(`  \u26A0 CDP not available \u2014 tried ports: ${portsToTry.map((p) => `${p.ide}:${p.port}`).join(", ")}`));
-        console.log(import_chalk2.default.yellow(`    IDE may need relaunch with --remote-debugging-port`));
+        if (this.cdpManagers.size > 0) {
+          console.log(import_chalk2.default.green(`  \u{1F4E1} CDP: ${this.cdpManagers.size} IDE(s) connected`));
+          this.cdpDiscoveryTimer = setInterval(async () => {
+            for (const m of this.cdpManagers.values()) {
+              if (m.isConnected) {
+                await m.discoverAgentWebviews();
+              }
+            }
+          }, 3e4);
+        } else {
+          console.log(import_chalk2.default.yellow(`  \u26A0 CDP not available \u2014 tried ports: ${portsToTry.map((p) => `${p.ide}:${p.port}`).join(", ")}`));
+          console.log(import_chalk2.default.yellow(`    IDE may need relaunch with --remote-debugging-port`));
+        }
       }
     };
   }
@@ -6170,6 +6652,7 @@ async function installCliOnly() {
 
 // src/index.ts
 init_detector();
+init_cli_detector();
 init_config();
 init_launch();
 var import_fs3 = require("fs");
@@ -6299,6 +6782,15 @@ program.command("status").description("Show current ADHDev setup status").action
       }
     }
   }
+  const clis = await detectCLIs();
+  const installedClis = clis.filter((c) => c.installed);
+  if (installedClis.length > 0) {
+    console.log(`  ${import_chalk4.default.bold("CLI Agents:")}`);
+    installedClis.forEach((cli) => {
+      const ver = cli.version ? import_chalk4.default.gray(` v${cli.version}`) : "";
+      console.log(`    ${import_chalk4.default.green("\u2713")} ${cli.icon} ${cli.displayName}${ver}`);
+    });
+  }
   console.log(`  ${import_chalk4.default.bold("Extensions:")}   ${config.installedExtensions.length} installed`);
   config.installedExtensions.forEach((ext) => {
     console.log(import_chalk4.default.gray(`                 \u2022 ${ext}`));
@@ -6326,6 +6818,17 @@ program.command("detect").description("Detect installed IDEs on your system").ac
       console.log(`  ${import_chalk4.default.gray("\u2717")} ${ide.icon} ${import_chalk4.default.gray(ide.displayName)} \u2014 not found`);
     }
   });
+  console.log(import_chalk4.default.bold("\n\u{1F50D} Detecting installed CLI Agents...\n"));
+  const clis = await detectCLIs();
+  clis.forEach((cli) => {
+    if (cli.installed) {
+      const version = cli.version ? import_chalk4.default.gray(` v${cli.version}`) : "";
+      console.log(`  ${import_chalk4.default.green("\u2713")} ${cli.icon} ${import_chalk4.default.bold(cli.displayName)}${version}`);
+      console.log(import_chalk4.default.gray(`     Path: ${cli.path}`));
+    } else {
+      console.log(`  ${import_chalk4.default.gray("\u2717")} ${cli.icon} ${import_chalk4.default.gray(cli.displayName)} \u2014 not found`);
+    }
+  });
   console.log();
 });
 program.command("reset").description("Reset ADHDev configuration").action(async () => {