adhdev 0.1.35 → 0.1.37

package/dist/index.js

@@ -32,18 +32,473 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../core/dist/chunk-PP6RFM75.js
+function generateSecureToken(type) {
+  const prefix = TOKEN_PREFIX[type];
+  const randomBytes = new Uint8Array(32);
+  if (typeof globalThis.crypto?.getRandomValues !== "undefined") {
+    crypto.getRandomValues(randomBytes);
+  } else {
+    for (let i = 0; i < 32; i++) {
+      randomBytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let token = prefix;
+  for (const byte of randomBytes) {
+    token += chars[byte % chars.length];
+  }
+  return token;
+}
+var TOKEN_PREFIX, AuthClient, FileTokenStorage;
 var init_chunk_PP6RFM75 = __esm({
   "../core/dist/chunk-PP6RFM75.js"() {
     "use strict";
+    TOKEN_PREFIX = {
+      connection: "adc_",
+      apiKey: "adk_",
+      refresh: "adr_"
+    };
+    AuthClient = class {
+      options;
+      constructor(options) {
+        this.options = options;
+      }
+      /**
+       * OAuth PKCE 로그인 URL 생성
+       */
+      async getLoginUrl(provider) {
+        const codeVerifier = this.generateCodeVerifier();
+        const codeChallenge = await this.generateCodeChallenge(codeVerifier);
+        const state = this.generateRandomString(32);
+        const params = new URLSearchParams({
+          provider,
+          code_challenge: codeChallenge,
+          code_challenge_method: "S256",
+          state,
+          redirect_uri: `${this.options.serverUrl}/auth/callback`
+        });
+        return {
+          url: `${this.options.serverUrl}/auth/login?${params}`,
+          codeVerifier,
+          state
+        };
+      }
+      /**
+       * OAuth 콜백 처리 → 토큰 저장
+       */
+      async handleCallback(code, codeVerifier) {
+        const response = await fetch(`${this.options.serverUrl}/auth/token`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ code, code_verifier: codeVerifier })
+        });
+        if (!response.ok) {
+          throw new Error(`Auth failed: ${response.statusText}`);
+        }
+        const tokens = await response.json();
+        await this.options.storage.set("access_token", tokens.accessToken);
+        await this.options.storage.set("refresh_token", tokens.refreshToken);
+        return tokens;
+      }
+      /**
+       * Access Token 갱신
+       */
+      async refreshAccessToken() {
+        const refreshToken = await this.options.storage.get("refresh_token");
+        if (!refreshToken) return null;
+        try {
+          const response = await fetch(`${this.options.serverUrl}/auth/refresh`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ refresh_token: refreshToken })
+          });
+          if (!response.ok) {
+            await this.logout();
+            return null;
+          }
+          const { accessToken, refreshToken: newRefreshToken } = await response.json();
+          await this.options.storage.set("access_token", accessToken);
+          if (newRefreshToken) {
+            await this.options.storage.set("refresh_token", newRefreshToken);
+          }
+          return accessToken;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * 현재 유효한 Access Token 가져오기 (필요시 자동 갱신)
+       */
+      async getValidAccessToken() {
+        const token = await this.options.storage.get("access_token");
+        if (!token) return this.refreshAccessToken();
+        if (this.isTokenExpired(token)) {
+          return this.refreshAccessToken();
+        }
+        return token;
+      }
+      /**
+       * Connection Token 생성 (IDE 브리지용)
+       */
+      async createConnectionToken() {
+        const accessToken = await this.getValidAccessToken();
+        if (!accessToken) throw new Error("Not authenticated");
+        const response = await fetch(
+          `${this.options.serverUrl}/auth/connection-token`,
+          {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${accessToken}`,
+              "Content-Type": "application/json"
+            }
+          }
+        );
+        if (!response.ok) throw new Error("Failed to create connection token");
+        const { connectionToken } = await response.json();
+        await this.options.storage.set("connection_token", connectionToken);
+        return connectionToken;
+      }
+      /**
+       * API Key 생성
+       */
+      async createApiKey(name, scopes) {
+        const accessToken = await this.getValidAccessToken();
+        if (!accessToken) throw new Error("Not authenticated");
+        const response = await fetch(`${this.options.serverUrl}/api/v1/api-keys`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ name, scopes })
+        });
+        if (!response.ok) throw new Error("Failed to create API key");
+        return response.json();
+      }
+      /**
+       * 로그아웃
+       */
+      async logout() {
+        await this.options.storage.delete("access_token");
+        await this.options.storage.delete("refresh_token");
+        await this.options.storage.delete("connection_token");
+      }
+      /**
+       * 로그인 여부 확인
+       */
+      async isAuthenticated() {
+        const token = await this.getValidAccessToken();
+        return token !== null;
+      }
+      // ─── Crypto Helpers ───────────────────────────────────────
+      generateCodeVerifier() {
+        return this.generateRandomString(64);
+      }
+      async generateCodeChallenge(verifier) {
+        if (typeof globalThis.crypto?.subtle !== "undefined") {
+          const encoder = new TextEncoder();
+          const data = encoder.encode(verifier);
+          const hash2 = await crypto.subtle.digest("SHA-256", data);
+          return this.base64url(new Uint8Array(hash2));
+        }
+        const { createHash: createHash3 } = await import("crypto");
+        const hash = createHash3("sha256").update(verifier).digest();
+        return this.base64url(new Uint8Array(hash));
+      }
+      generateRandomString(length) {
+        const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+        let result = "";
+        const randomValues = new Uint8Array(length);
+        if (typeof globalThis.crypto?.getRandomValues !== "undefined") {
+          crypto.getRandomValues(randomValues);
+        } else {
+          for (let i = 0; i < length; i++) {
+            randomValues[i] = Math.floor(Math.random() * 256);
+          }
+        }
+        for (let i = 0; i < length; i++) {
+          result += chars[randomValues[i] % chars.length];
+        }
+        return result;
+      }
+      base64url(bytes) {
+        let binary = "";
+        for (const byte of bytes) {
+          binary += String.fromCharCode(byte);
+        }
+        if (typeof btoa !== "undefined") {
+          return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+        }
+        return Buffer.from(bytes).toString("base64url");
+      }
+      isTokenExpired(jwt) {
+        try {
+          const parts = jwt.split(".");
+          if (parts.length !== 3) return true;
+          const payload = JSON.parse(
+            typeof atob !== "undefined" ? atob(parts[1]) : Buffer.from(parts[1], "base64").toString()
+          );
+          if (!payload.exp) return false;
+          return Date.now() >= payload.exp * 1e3;
+        } catch {
+          return true;
+        }
+      }
+    };
+    FileTokenStorage = class {
+      configDir;
+      constructor(configDir) {
+        this.configDir = configDir;
+      }
+      async get(key) {
+        const { existsSync: existsSync7, readFileSync: readFileSync7 } = await import("fs");
+        const { join: join9 } = await import("path");
+        const filePath = join9(this.configDir, `${key}.secret`);
+        if (!existsSync7(filePath)) return null;
+        try {
+          return readFileSync7(filePath, "utf-8").trim();
+        } catch {
+          return null;
+        }
+      }
+      async set(key, value) {
+        const { mkdirSync: mkdirSync7, writeFileSync: writeFileSync5, chmodSync } = await import("fs");
+        const { join: join9 } = await import("path");
+        const { existsSync: existsSync7 } = await import("fs");
+        if (!existsSync7(this.configDir)) {
+          mkdirSync7(this.configDir, { recursive: true });
+        }
+        const filePath = join9(this.configDir, `${key}.secret`);
+        writeFileSync5(filePath, value, "utf-8");
+        try {
+          chmodSync(filePath, 384);
+        } catch {
+        }
+      }
+      async delete(key) {
+        const { unlinkSync: unlinkSync4, existsSync: existsSync7 } = await import("fs");
+        const { join: join9 } = await import("path");
+        const filePath = join9(this.configDir, `${key}.secret`);
+        if (existsSync7(filePath)) {
+          unlinkSync4(filePath);
+        }
+      }
+    };
   }
 });
 
 // ../core/dist/chunk-ZZGGFYGY.js
+function getCompatibilityManager(matrixUrl) {
+  if (!_instance) {
+    _instance = new CompatibilityManager(matrixUrl);
+  }
+  return _instance;
+}
+var DEFAULT_MATRIX, CompatibilityManager, _instance;
 var init_chunk_ZZGGFYGY = __esm({
   "../core/dist/chunk-ZZGGFYGY.js"() {
     "use strict";
+    DEFAULT_MATRIX = {
+      version: "2026-02-25-default",
+      ides: {
+        vscode: {
+          minVersion: "1.85.0",
+          testedVersions: ["1.85.0", "1.90.0", "1.95.0", "2.0.0", "2.5.0"]
+        },
+        cursor: {
+          minVersion: "0.40.0",
+          testedVersions: ["0.40.0", "0.42.0", "0.45.0"],
+          notes: "Forked VS Code, some command IDs may differ"
+        },
+        vscodium: {
+          minVersion: "1.85.0",
+          testedVersions: ["1.85.0", "1.90.0"]
+        },
+        windsurf: {
+          minVersion: "1.0.0",
+          testedVersions: ["1.0.0"]
+        }
+      },
+      agents: {
+        "roo-code": {
+          extensionId: "rooveterinaryinc.roo-cline",
+          versions: {
+            "*": {
+              send: "roo-cline.sendMessage",
+              approve: "roo-cline.approveAction",
+              reject: "roo-cline.rejectAction",
+              status: "roo-cline.getStatus",
+              open: "roo-cline.focus"
+            }
+          }
+        },
+        copilot: {
+          extensionId: "github.copilot",
+          versions: {
+            "*": {
+              send: "github.copilot.chat.sendMessage",
+              accept: "editor.action.inlineSuggest.commit",
+              reject: "editor.action.inlineSuggest.hide",
+              open: "github.copilot.chat.focus"
+            }
+          }
+        },
+        cline: {
+          extensionId: "saoudrizwan.claude-dev",
+          versions: {
+            "*": {
+              send: "cline.sendMessage",
+              approve: "cline.approveAction",
+              reject: "cline.rejectAction",
+              open: "cline.focus"
+            }
+          }
+        },
+        continue: {
+          extensionId: "continue.continue",
+          versions: {
+            "*": {
+              send: "continue.sendToChat",
+              open: "continue.focusChat"
+            }
+          }
+        }
+      }
+    };
+    CompatibilityManager = class {
+      matrix;
+      matrixUrl;
+      lastFetch = 0;
+      fetchIntervalMs = 36e5;
+      // 1시간마다 갱신
+      constructor(matrixUrl) {
+        this.matrix = { ...DEFAULT_MATRIX };
+        this.matrixUrl = matrixUrl || "https://api.adhdev.io/compatibility/matrix.json";
+      }
+      /**
+       * 원격에서 최신 호환성 매트릭스 가져오기
+       */
+      async fetchMatrix() {
+        const now = Date.now();
+        if (now - this.lastFetch < this.fetchIntervalMs) return;
+        try {
+          const response = await fetch(this.matrixUrl);
+          if (response.ok) {
+            const remote = await response.json();
+            this.matrix = remote;
+            this.lastFetch = now;
+            console.log(`[Compat] Matrix updated: ${remote.version}`);
+          }
+        } catch (error) {
+          console.warn("[Compat] Failed to fetch remote matrix, using local fallback");
+        }
+      }
+      /**
+       * 특정 IDE가 지원되는지 확인
+       */
+      isIDESupported(ideType, ideVersion) {
+        const entry = this.matrix.ides[ideType];
+        if (!entry) {
+          return {
+            supported: false,
+            tested: false,
+            warnings: [`IDE '${ideType}' is not in the compatibility matrix`]
+          };
+        }
+        const warnings = [];
+        const supported = this.compareVersions(ideVersion, entry.minVersion) >= 0;
+        const tested = entry.testedVersions.includes(ideVersion);
+        if (!tested && supported) {
+          warnings.push(
+            `IDE version ${ideVersion} has not been tested. Tested versions: ${entry.testedVersions.join(", ")}`
+          );
+        }
+        if (entry.knownIssues?.[ideVersion]) {
+          warnings.push(`Known issue for v${ideVersion}: ${entry.knownIssues[ideVersion]}`);
+        }
+        return { supported, tested, warnings };
+      }
+      /**
+       * AI 에이전트의 명령어 확인
+       * 버전에 맞는 정확한 VS Code 명령어 ID를 반환
+       */
+      getAgentCommand(agentType, action, agentVersion) {
+        const agent = this.matrix.agents[agentType];
+        if (!agent) {
+          return { command: null, unsupported: true };
+        }
+        let commands = null;
+        if (agentVersion) {
+          const majorMinor = agentVersion.split(".").slice(0, 2).join(".");
+          const major = agentVersion.split(".")[0] + ".x";
+          commands = agent.versions[agentVersion] || agent.versions[majorMinor] || agent.versions[major] || agent.versions["*"] || null;
+        } else {
+          commands = agent.versions["*"] || Object.values(agent.versions)[0] || null;
+        }
+        if (!commands) {
+          return { command: null, unsupported: true };
+        }
+        const command = commands[action];
+        if (!command) {
+          const availableActions = Object.keys(commands);
+          return {
+            command: null,
+            unsupported: true,
+            fallback: `Available actions for ${agentType}: ${availableActions.join(", ")}`
+          };
+        }
+        return { command, unsupported: false };
+      }
+      /**
+       * 현재 매트릭스 버전 정보
+       */
+      getMatrixVersion() {
+        return this.matrix.version;
+      }
+      /**
+       * 매트릭스를 수동으로 업데이트 (테스트/디버그용)
+       */
+      updateMatrix(matrix) {
+        this.matrix = matrix;
+      }
+      /**
+       * 지원되는 모든 에이전트 목록
+       */
+      getSupportedAgents() {
+        return Object.keys(this.matrix.agents);
+      }
+      /**
+       * 특정 에이전트의 지원 액션 목록
+       */
+      getAgentActions(agentType) {
+        const agent = this.matrix.agents[agentType];
+        if (!agent) return [];
+        const actions = /* @__PURE__ */ new Set();
+        for (const commands of Object.values(agent.versions)) {
+          for (const action of Object.keys(commands)) {
+            actions.add(action);
+          }
+        }
+        return Array.from(actions);
+      }
+      // ─── Private Helpers ──────────────────────────────────────
+      compareVersions(a, b) {
+        const pa = a.split(".").map(Number);
+        const pb = b.split(".").map(Number);
+        const len = Math.max(pa.length, pb.length);
+        for (let i = 0; i < len; i++) {
+          const va = pa[i] || 0;
+          const vb = pb[i] || 0;
+          if (va > vb) return 1;
+          if (va < vb) return -1;
+        }
+        return 0;
+      }
+    };
+    _instance = null;
   }
 });
 
@@ -87,18 +542,18 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs() {
-  const os10 = (0, import_os.platform)();
+  const os11 = (0, import_os.platform)();
   const results = [];
   for (const def of IDE_DEFINITIONS) {
     const cliPath = findCliCommand(def.cli);
-    const appPath = checkPathExists(def.paths[os10] || []);
+    const appPath = checkPathExists(def.paths[os11] || []);
     const installed = !!(cliPath || appPath);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os10 === "darwin") {
+    if (!resolvedCli && appPath && os11 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if ((0, import_fs.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os10 === "win32") {
+    if (!resolvedCli && appPath && os11 === "win32") {
       const { dirname: dirname4 } = await import("path");
       const appDir = dirname4(appPath);
       const candidates = [
@@ -130,6 +585,18 @@ async function detectIDEs() {
   }
   return results;
 }
+async function getInstalledIDEs() {
+  const all = await detectIDEs();
+  return all.filter((ide) => ide.installed);
+}
+async function isIdeInstalled(ideId) {
+  const all = await detectIDEs();
+  const ide = all.find((i) => i.id === ideId);
+  return ide?.installed ?? false;
+}
+function getIdeDefinitions() {
+  return IDE_DEFINITIONS;
+}
 var import_child_process, import_fs, import_os, IDE_DEFINITIONS;
 var init_chunk_BFUPGBW2 = __esm({
   "../core/dist/chunk-BFUPGBW2.js"() {
@@ -230,6 +697,20 @@ var init_chunk_BFUPGBW2 = __esm({
 });
 
 // ../core/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  AuthClient: () => AuthClient,
+  CompatibilityManager: () => CompatibilityManager,
+  DAEMON_WS_PATH: () => DAEMON_WS_PATH,
+  DEFAULT_DAEMON_PORT: () => DEFAULT_DAEMON_PORT,
+  FileTokenStorage: () => FileTokenStorage,
+  detectIDEs: () => detectIDEs,
+  generateSecureToken: () => generateSecureToken,
+  getCompatibilityManager: () => getCompatibilityManager,
+  getIdeDefinitions: () => getIdeDefinitions,
+  getInstalledIDEs: () => getInstalledIDEs,
+  isIdeInstalled: () => isIdeInstalled
+});
 var DEFAULT_DAEMON_PORT, DAEMON_WS_PATH;
 var init_dist = __esm({
   "../core/dist/index.js"() {
@@ -539,7 +1020,7 @@ function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs7 = require("fs");
+      const fs6 = require("fs");
       const appNameMap = {
         vscode: "Code",
         cursor: "Cursor",
@@ -554,8 +1035,8 @@ function detectCurrentWorkspace(ideId) {
           appName,
           "storage.json"
         );
-        if (fs7.existsSync(storagePath)) {
-          const data = JSON.parse(fs7.readFileSync(storagePath, "utf-8"));
+        if (fs6.existsSync(storagePath)) {
+          const data = JSON.parse(fs6.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -2024,17 +2505,16 @@ var init_local_server = __esm({
 });
 
 // src/daemon-cdp.ts
-var import_ws3, http, fs, KNOWN_AGENTS, DaemonCdpManager;
+var import_ws3, http, KNOWN_AGENTS, DaemonCdpManager;
 var init_daemon_cdp = __esm({
   "src/daemon-cdp.ts"() {
     "use strict";
     import_ws3 = __toESM(require("ws"));
     http = __toESM(require("http"));
-    fs = __toESM(require("fs"));
     KNOWN_AGENTS = [
-      { agentType: "cline", extensionId: "saoudrizwan.claude-dev", extensionIdPattern: /saoudrizwan\.claude-dev/ },
-      { agentType: "roo-code", extensionId: "rooveterinaryinc.roo-cline", extensionIdPattern: /rooveterinaryinc\.roo-cline/ },
-      { agentType: "continue", extensionId: "continue.continue", extensionIdPattern: /continue\.continue/ }
+      { agentType: "cline", extensionId: "saoudrizwan.claude-dev", extensionIdPattern: /saoudrizwan\.claude-dev/i },
+      { agentType: "roo-code", extensionId: "rooveterinaryinc.roo-cline", extensionIdPattern: /rooveterinaryinc\.roo-cline/i },
+      { agentType: "continue", extensionId: "continue.continue", extensionIdPattern: /continue\.continue/i }
     ];
     DaemonCdpManager = class {
       ws = null;
@@ -2061,10 +2541,6 @@ var init_daemon_cdp = __esm({
         this.disableFallback = disableFallback;
         this.logFn = logFn || ((msg) => {
           console.log(msg);
-          try {
-            fs.appendFileSync("/tmp/adhdev_daemon_cdp.log", msg + "\n");
-          } catch {
-          }
         });
       }
       setPort(port) {
@@ -2373,6 +2849,62 @@ var init_daemon_cdp = __esm({
             })()
         `);
       }
+      /**
+       * CDP 프로토콜로 텍스트 입력 후 Enter 전송
+       * Lexical 등 execCommand가 작동하지 않는 에디터에서 사용.
+       * 
+       * 1. selector로 에디터 찾아서 focus + click
+       * 2. Input.insertText로 텍스트 삽입
+       * 3. Input.dispatchKeyEvent로 Enter 전송
+       */
+      async typeAndSend(selector, text) {
+        if (!this.isConnected) return false;
+        const focusResult = await this.evaluate(`(() => {
+            const e = document.querySelector(${JSON.stringify(selector)});
+            if (!e) return null;
+            e.focus();
+            const r = e.getBoundingClientRect();
+            return JSON.stringify({ x: r.x + r.width / 2, y: r.y + r.height / 2 });
+        })()`);
+        if (!focusResult) {
+          this.log("[CDP] typeAndSend: selector not found");
+          return false;
+        }
+        const pos = JSON.parse(focusResult);
+        await this.sendInternal("Input.dispatchMouseEvent", {
+          type: "mousePressed",
+          x: Math.round(pos.x),
+          y: Math.round(pos.y),
+          button: "left",
+          clickCount: 1
+        });
+        await this.sendInternal("Input.dispatchMouseEvent", {
+          type: "mouseReleased",
+          x: Math.round(pos.x),
+          y: Math.round(pos.y),
+          button: "left",
+          clickCount: 1
+        });
+        await new Promise((r) => setTimeout(r, 150));
+        await this.sendInternal("Input.insertText", { text });
+        await new Promise((r) => setTimeout(r, 200));
+        await this.sendInternal("Input.dispatchKeyEvent", {
+          type: "rawKeyDown",
+          key: "Enter",
+          code: "Enter",
+          windowsVirtualKeyCode: 13,
+          nativeVirtualKeyCode: 13
+        });
+        await this.sendInternal("Input.dispatchKeyEvent", {
+          type: "keyUp",
+          key: "Enter",
+          code: "Enter",
+          windowsVirtualKeyCode: 13,
+          nativeVirtualKeyCode: 13
+        });
+        this.log(`[CDP] typeAndSend: sent "${text.substring(0, 50)}..."`);
+        return true;
+      }
       // ─── Agent Webview Multi-Session ─────────────────────────
       async discoverAgentWebviews() {
         if (!this.isConnected) return [];
@@ -2805,21 +3337,17 @@ var require_lib = __commonJS({
 });
 
 // src/daemon-p2p.ts
-var fs2, path2, os6, logFile, log, DaemonP2PSender;
+var fs, path2, os6, logFile, log, DaemonP2PSender;
 var init_daemon_p2p = __esm({
   "src/daemon-p2p.ts"() {
     "use strict";
-    fs2 = __toESM(require("fs"));
+    fs = __toESM(require("fs"));
     path2 = __toESM(require("path"));
     os6 = __toESM(require("os"));
     logFile = path2.join(os6.tmpdir(), "adhdev_daemon_p2p.log");
     log = (msg) => {
       const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [P2P] ${msg}`;
       console.log(line);
-      try {
-        fs2.appendFileSync(logFile, line + "\n");
-      } catch {
-      }
     };
     DaemonP2PSender = class {
       bridge;
@@ -2876,11 +3404,11 @@ var init_daemon_p2p = __esm({
           ];
           for (const candidate of candidates) {
             const prebuildPath = path2.join(candidate, "prebuilds", prebuildKey, "node_datachannel.node");
-            if (fs2.existsSync(prebuildPath)) {
+            if (fs.existsSync(prebuildPath)) {
               const targetDir = path2.join(candidate, "build", "Release");
               const targetPath = path2.join(targetDir, "node_datachannel.node");
-              fs2.mkdirSync(targetDir, { recursive: true });
-              fs2.copyFileSync(prebuildPath, targetPath);
+              fs.mkdirSync(targetDir, { recursive: true });
+              fs.copyFileSync(prebuildPath, targetPath);
               try {
                 delete require.cache[require.resolve("node-datachannel")];
               } catch {
@@ -2941,7 +3469,7 @@ var init_daemon_p2p = __esm({
           const configPath = path2.join(os6.homedir(), ".adhdev", "config.json");
           let token = "";
           try {
-            const config = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+            const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
             token = config.connectionToken || "";
           } catch {
           }
@@ -3354,17 +3882,12 @@ var init_daemon_p2p = __esm({
 
 // src/daemon-script-loader.ts
 function log2(msg) {
-  try {
-    fs3.appendFileSync(`${require("os").tmpdir()}/adhdev_daemon_scripts.log`, `${msg}
-`);
-  } catch {
-  }
+  console.log(msg);
 }
-var fs3, http2, https, DaemonScriptLoader;
+var http2, https, DaemonScriptLoader;
 var init_daemon_script_loader = __esm({
   "src/daemon-script-loader.ts"() {
     "use strict";
-    fs3 = __toESM(require("fs"));
     http2 = __toESM(require("http"));
     https = __toESM(require("https"));
     DaemonScriptLoader = class {
@@ -3374,9 +3897,13 @@ var init_daemon_script_loader = __esm({
       // name → code
       fallbacks = /* @__PURE__ */ new Map();
       // name → bundled fallback code
+      capabilityMap = /* @__PURE__ */ new Map();
+      // capability → { script, params }
       manifestVersion = "0";
       refreshTimer = null;
       token = "";
+      platform = "";
+      // darwin, win32, linux
       constructor(baseUrl, ideType) {
         this.baseUrl = baseUrl.replace(/\/$/, "");
         this.ideType = ideType;
@@ -3384,6 +3911,9 @@ var init_daemon_script_loader = __esm({
       setToken(token) {
         this.token = token;
       }
+      setPlatform(platform9) {
+        this.platform = platform9;
+      }
       registerFallback(name, code) {
         this.fallbacks.set(name, code);
       }
@@ -3400,6 +3930,46 @@ var init_daemon_script_loader = __esm({
       has(name) {
         return this.cache.has(name) || this.fallbacks.has(name);
       }
+      /** Resolve a logical capability to its IDE-specific script */
+      getCapability(capability) {
+        const entry = this.capabilityMap.get(capability);
+        if (entry?.script) {
+          return this.get(entry.script);
+        }
+        return this.get(capability);
+      }
+      /** Resolve capability with template params */
+      getCapabilityWithParams(capability, params) {
+        const entry = this.capabilityMap.get(capability);
+        if (entry?.script) {
+          return this.getWithParams(entry.script, params);
+        }
+        return this.getWithParams(capability, params);
+      }
+      /** Check if a capability is supported (implemented) */
+      hasCapability(capability) {
+        const entry = this.capabilityMap.get(capability);
+        if (!entry) return this.has(capability);
+        if (entry.status === "not_implemented" || entry.status === "not_needed") return false;
+        return !!entry.script && this.has(entry.script);
+      }
+      /** Get the capability map for status reporting */
+      getCapabilities() {
+        const result = {};
+        for (const [k, v] of this.capabilityMap) result[k] = v;
+        return result;
+      }
+      /** Manually set capability map (for testing or static config) */
+      setCapabilityMap(map) {
+        this.capabilityMap.clear();
+        for (const [cap, entry] of Object.entries(map)) {
+          if (entry && typeof entry === "object" && "script" in entry) {
+            this.capabilityMap.set(cap, entry);
+          } else if (entry && typeof entry === "object" && "status" in entry) {
+            this.capabilityMap.set(cap, entry);
+          }
+        }
+      }
       async start() {
         log2(`[DaemonScriptLoader] Starting: baseUrl=${this.baseUrl} ide=${this.ideType}`);
         await this.refresh();
@@ -3480,6 +4050,22 @@ var init_daemon_script_loader = __esm({
           log2(`[DaemonScriptLoader] Downloading ${scriptNames.length} scripts for ${this.ideType}/${version}`);
           const downloads = scriptNames.map((name) => this.downloadScript(version, name));
           await Promise.allSettled(downloads);
+          const capabilities = manifest.capabilities?.[this.ideType]?.[version];
+          if (capabilities && typeof capabilities === "object") {
+            this.capabilityMap.clear();
+            for (const [cap, entry] of Object.entries(capabilities)) {
+              if (entry && typeof entry === "object") {
+                const osFilter = entry.os;
+                if (osFilter && Array.isArray(osFilter) && this.platform && !osFilter.includes(this.platform)) {
+                  continue;
+                }
+                this.capabilityMap.set(cap, entry);
+              }
+            }
+            log2(`[DaemonScriptLoader] Loaded ${this.capabilityMap.size} capabilities for ${this.ideType}/${version}`);
+          } else {
+            this.buildDefaultCapabilityMap(scriptNames);
+          }
           log2(`[DaemonScriptLoader] Loaded ${this.cache.size} scripts`);
         } catch (e) {
           log2(`[DaemonScriptLoader] Refresh error: ${e?.message}`);
@@ -3503,28 +4089,47 @@ var init_daemon_script_loader = __esm({
           log2(`[DaemonScriptLoader] Download error ${name}: ${e?.message}`);
         }
       }
+      /** Build a default capability map from script names when no explicit map exists */
+      buildDefaultCapabilityMap(scriptNames) {
+        this.capabilityMap.clear();
+        for (const name of scriptNames) {
+          this.capabilityMap.set(name, { script: name });
+        }
+        if (scriptNames.includes("resolve_modal")) {
+          this.capabilityMap.set("resolve", { script: "resolve_modal", params: ["BUTTON_TEXT"] });
+        } else if (scriptNames.includes("resolve_action")) {
+          this.capabilityMap.set("resolve", { script: "resolve_action", params: ["ACTION"] });
+        }
+        log2(`[DaemonScriptLoader] Built default capability map: ${this.capabilityMap.size} entries`);
+      }
     };
   }
 });
 
 // src/daemon-commands.ts
-var fs4, path3, os7, DaemonCommandHandler;
+var fs2, path3, os7, DaemonCommandHandler;
 var init_daemon_commands = __esm({
   "src/daemon-commands.ts"() {
     "use strict";
-    fs4 = __toESM(require("fs"));
+    fs2 = __toESM(require("fs"));
     path3 = __toESM(require("path"));
     os7 = __toESM(require("os"));
     init_config();
     DaemonCommandHandler = class {
       ctx;
       agentStream = null;
-      /** Get CDP manager for a specific ideType, or first connected one */
+      /** Get CDP manager for a specific ideType.
+       *  When ideType is explicitly specified (via arg or _currentIdeType),
+       *  returns null if that IDE's CDP is unavailable — never falls back to another IDE.
+       *  Fallback to first connected manager only when no ideType is known at all.
+       */
       getCdp(ideType) {
         const key = ideType || this._currentIdeType;
         if (key) {
           const m = this.ctx.cdpManagers.get(key.toLowerCase());
           if (m?.isConnected) return m;
+          console.log(`[getCdp] \u26A0 Target IDE "${key}" CDP not available, refusing fallback`);
+          return null;
         }
         for (const m of this.ctx.cdpManagers.values()) {
           if (m.isConnected) return m;
@@ -3533,10 +4138,17 @@ var init_daemon_commands = __esm({
       }
       /** Current IDE type extracted from command args (per-request) */
       _currentIdeType;
-      /** Extract ideType from _targetInstance (e.g. 'vscode_abc123' → 'vscode') */
+      /** Extract ideType from _targetInstance
+       *  Handles both simple ('vscode_abc123') and composite ('doId:ide:vscode_abc123') formats.
+       */
       extractIdeType(args) {
         if (args?._targetInstance) {
-          const parts = args._targetInstance.split("_");
+          let raw = args._targetInstance;
+          const ideMatch = raw.match(/:ide:(.+)$/);
+          const cliMatch = raw.match(/:cli:(.+)$/);
+          if (ideMatch) raw = ideMatch[1];
+          else if (cliMatch) raw = cliMatch[1];
+          const parts = raw.split("_");
           if (parts.length >= 2) return parts[0];
         }
         return void 0;
@@ -3559,6 +4171,7 @@ var init_daemon_commands = __esm({
       }
       async handle(cmd, args) {
         this._currentIdeType = this.extractIdeType(args);
+        console.log(`[Cmd] ${cmd} \u2192 ideType=${this._currentIdeType || "none"} _targetInstance=${args?._targetInstance || "none"}`);
         switch (cmd) {
           // ─── CDP 직접 처리 ───────────────────
           case "read_chat":
@@ -3590,6 +4203,12 @@ var init_daemon_commands = __esm({
             return this.handleCdpRemoteAction(args);
           case "cdp_discover_agents":
             return this.handleDiscoverAgents(args);
+          case "cdp_dom_dump":
+            return this.handleCdpDomDump(args);
+          case "cdp_dom_query":
+            return this.handleCdpDomQuery(args);
+          case "cdp_dom_debug":
+            return this.handleCdpDomDebug(args);
           // ─── 파일 직접 처리 ──────────────────
           case "file_read":
             return this.handleFileRead(args);
@@ -3655,29 +4274,66 @@ var init_daemon_commands = __esm({
       }
       // ─── CDP 기반 채팅 명령 ──────────────────────
       async handleReadChat(args) {
-        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
+        const cdp2 = this.getCdp();
+        if (!cdp2?.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" };
+        if (script) {
+          try {
+            const result = await cdp2.evaluate(script, 5e4);
+            if (result && typeof result === "object" && result.messages?.length > 0) {
+              console.log(`[read_chat] Server script OK: ${result.messages?.length} msgs`);
+              return { success: true, ...result };
+            }
+            if (result && typeof result === "object") {
+              console.log(`[read_chat] Server script returned ${result.messages?.length || 0} msgs, trying inline`);
+            }
+          } catch (e) {
+            console.log(`[read_chat] Server script error: ${e.message}`);
+          }
+        }
         try {
-          const result = await this.getCdp().evaluate(script, 5e4);
-          return { success: true, ...result };
+          const inlineScript = `(() => {
+                const container = document.querySelector('.flex.flex-col.gap-2\\\\.5');
+                if (!container) return { messages: [], status: 'idle' };
+                const msgs = [];
+                for (const child of container.children) {
+                    if ((child.className || '').includes('mark-js-ignore')) continue;
+                    if (child.offsetHeight < 10) continue;
+                    const inner = child.children[0];
+                    if (!inner) continue;
+                    const isUser = inner.className?.includes('flex-row') || !!inner.querySelector('.justify-end');
+                    const role = isUser ? 'user' : 'assistant';
+                    const text = child.textContent?.trim() || '';
+                    if (text.length < 1) continue;
+                    msgs.push({ id: 'msg_' + msgs.length, role, content: text.substring(0, 6000), index: msgs.length });
+                }
+                return { messages: msgs, status: 'idle', id: 'cascade' };
+            })()`;
+          const result = await cdp2.evaluate(inlineScript, 1e4);
+          if (result && typeof result === "object") {
+            const msgs = result.messages || [];
+            console.log(`[read_chat] Inline fallback: ${msgs.length} msgs`);
+            return { success: true, ...result };
+          }
         } catch (e) {
-          return { success: false, error: e.message };
+          console.log(`[read_chat] Inline fallback error: ${e.message}`);
         }
+        return { success: true, messages: [], status: "idle" };
       }
       async handleSendChat(args) {
         const text = args?.text || args?.message;
         if (!text) return { success: false, error: "text required" };
+        const _log = (msg) => console.log(`[send_chat] ${msg}`);
         const targetAgent = args?.agentType || args?.cliType || this._currentIdeType;
         if (targetAgent) {
           for (const [key, adapter] of this.ctx.adapters.entries()) {
             if (adapter.cliType === targetAgent || key.startsWith(targetAgent)) {
-              console.log(`[send_chat] Routing to CLI adapter: ${adapter.cliType} (${key})`);
+              _log(`Routing to CLI adapter: ${adapter.cliType} (${key})`);
               try {
                 await adapter.sendMessage(text);
                 return { success: true, sent: true, targetAgent: adapter.cliType };
               } catch (e) {
-                console.log(`[send_chat] CLI adapter failed: ${e.message}`);
+                _log(`CLI adapter failed: ${e.message}`);
                 return { success: false, error: `CLI send failed: ${e.message}` };
               }
             }
@@ -3685,49 +4341,86 @@ var init_daemon_commands = __esm({
         }
         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}`);
+        if (targetCdp?.isConnected) {
+          _log(`Targeting IDE: ${this._currentIdeType || "fallback-first"}`);
+          const inputSelector = '[data-lexical-editor="true"]';
+          try {
+            const sent = await targetCdp.typeAndSend(inputSelector, text);
+            if (sent) {
+              _log(`typeAndSend success`);
+              return { success: true, sent: true, method: "typeAndSend" };
+            }
+          } catch (e) {
+            _log(`typeAndSend failed: ${e.message}`);
+          }
+          const ceSelector = '[contenteditable="true"][role="textbox"]';
+          try {
+            const sent = await targetCdp.typeAndSend(ceSelector, text);
+            if (sent) {
+              _log(`typeAndSend(ce) success`);
+              return { success: true, sent: true, method: "typeAndSend-ce" };
+            }
+          } catch (e) {
+            _log(`typeAndSend(ce) failed: ${e.message}`);
+          }
+          if (targetLoader) {
+            const script = targetLoader.getWithParams("send_message", { MESSAGE: JSON.stringify(text) });
+            if (script) {
+              try {
+                const result = await targetCdp.evaluate(script, 3e4);
+                _log(`script result: ${JSON.stringify(result)}`);
+                return { success: true, sent: true, method: "script" };
+              } catch (e) {
+                _log(`script failed on ${this._currentIdeType}: ${e.message}`);
+              }
             }
           }
+        } else {
+          _log(`No CDP (connected=${targetCdp?.isConnected}) for ${this._currentIdeType}`);
         }
-        console.log(`[send_chat] No specific target, trying all CDPs...`);
-        for (const [ideType, cdp] of this.ctx.cdpManagers) {
-          if (!cdp.isConnected) continue;
+        if (this._currentIdeType) {
+          _log(`Target IDE "${this._currentIdeType}" CDP not available \u2014 refusing cross-IDE fallback`);
+          return { success: false, error: `CDP for ${this._currentIdeType} not connected. Ensure the IDE is running with --remote-debugging-port.` };
+        }
+        _log(`No target IDE specified, trying all ${this.ctx.cdpManagers.size} CDPs...`);
+        for (const [ideType, cdp2] of this.ctx.cdpManagers) {
+          if (!cdp2.isConnected) continue;
+          try {
+            const sent = await cdp2.typeAndSend('[data-lexical-editor="true"]', text);
+            if (sent) {
+              _log(`fallback typeAndSend success on ${ideType}`);
+              return { success: true, sent: true, targetIde: ideType, method: "typeAndSend" };
+            }
+          } catch {
+          }
           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}`);
+          _log(`Trying script on ${ideType}`);
           try {
-            await cdp.evaluate(script, 3e4);
-            return { success: true, sent: true, targetIde: ideType };
+            const result = await cdp2.evaluate(script, 3e4);
+            _log(`Success on ${ideType}: ${JSON.stringify(result)}`);
+            return { success: true, sent: true, targetIde: ideType, method: "script" };
           } catch (e) {
-            console.log(`[send_chat] Failed on ${ideType}: ${e.message}`);
+            _log(`Failed on ${ideType}: ${e.message}`);
           }
         }
+        _log("All methods failed");
         return { success: false, error: "No CDP or CLI adapter could send the message" };
       }
       async handleListChats(args) {
-        const cdp = this.getCdp();
-        if (!cdp?.isConnected) {
+        const cdp2 = this.getCdp();
+        if (!cdp2?.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" };
-        }
+        const loader = this.getScriptLoader();
+        if (!loader) return { success: false, error: "Script loader not initialized" };
+        const script = loader.getCapability("list_chats");
+        if (!script) return { success: false, error: "list_chats script not available" };
         try {
-          console.log(`[list_chats] Evaluating on ideType=${this._currentIdeType}`);
-          const result = await cdp.evaluate(script, 3e4);
+          const result = await cdp2.evaluate(script, 3e4);
           let parsed = result;
           if (typeof result === "string") {
             try {
@@ -3735,10 +4428,13 @@ var init_daemon_commands = __esm({
             } 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 };
+          if (Array.isArray(parsed)) {
+            console.log(`[list_chats] OK: ${parsed.length} chats (ideType=${this._currentIdeType})`);
+            return { success: true, chats: parsed };
+          }
+          return { success: true, chats: [] };
         } catch (e) {
-          console.log(`[list_chats] Error: ${e.message}`);
+          console.log(`[list_chats] error: ${e.message}`);
           return { success: false, error: e.message };
         }
       }
@@ -3754,15 +4450,22 @@ var init_daemon_commands = __esm({
         }
       }
       async handleSwitchChat(args) {
-        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
+        const ideType = this._currentIdeType;
+        const cdp2 = this.getCdp(ideType);
+        if (!cdp2?.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.getScriptLoader()?.getWithParams("switch_session", { SESSION_ID: sessionId });
-        if (!script) return { success: false, error: "switch_session script not loaded" };
+        console.log(`[switch_chat] sessionId=${sessionId}, ideType=${ideType}`);
+        const loader = this.getScriptLoader();
+        if (!loader) return { success: false, error: "Script loader not initialized" };
+        const script = loader.getCapabilityWithParams("switch_session", { SESSION_ID: JSON.stringify(sessionId) });
+        if (!script) return { success: false, error: "switch_session script not available" };
         try {
-          await this.getCdp().evaluate(script, 15e3);
-          return { success: true };
+          const result = await cdp2.evaluate(script, 15e3);
+          console.log(`[switch_chat] result:`, result);
+          return { success: true, result };
         } catch (e) {
+          console.error(`[switch_chat] error:`, e.message);
           return { success: false, error: e.message };
         }
       }
@@ -3950,35 +4653,328 @@ var init_daemon_commands = __esm({
         const agents = await this.getCdp().discoverAgentWebviews();
         return { success: true, agents };
       }
-      // ─── 파일 직접 처리 ─────────────────────────
-      async handleFileRead(args) {
+      // ─── CDP DOM Analysis Tools ─────────────────
+      /**
+       * CDP DOM Dump — IDE의 DOM 트리를 가져옴
+       * 
+       * args:
+       *   selector?: string   — CSS 셀렉터로 특정 영역만 덤프 (default: 전체)
+       *   depth?: number      — 덤프 깊이 제한 (default: 10)
+       *   attrs?: boolean     — 속성 포함 여부 (default: true)
+       *   maxLength?: number  — 최대 문자 수 (default: 200000)
+       *   format?: 'html' | 'tree' | 'summary'  — 출력 형식 (default: 'html')
+       *   sessionId?: string  — agent webview 세션 ID (있으면 해당 webview DOM)
+       */
+      async handleCdpDomDump(args) {
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
+        const selector = args?.selector || "body";
+        const depth = args?.depth || 10;
+        const maxLength = args?.maxLength || 2e5;
+        const format = args?.format || "html";
+        const attrs = args?.attrs !== false;
+        const sessionId = args?.sessionId;
         try {
-          const filePath = this.resolveSafePath(args?.path);
-          const content = fs4.readFileSync(filePath, "utf-8");
-          return { success: true, content, path: filePath };
+          let expression;
+          if (format === "summary") {
+            expression = `(() => {
+                    const root = document.querySelector('${selector.replace(/'/g, "\\'")}');
+                    if (!root) return JSON.stringify({ error: 'Selector not found: ${selector}' });
+                    
+                    function summarize(el, depth, maxD) {
+                        if (depth > maxD) return { tag: '...', note: 'max depth' };
+                        const node = {
+                            tag: el.tagName?.toLowerCase(),
+                            id: el.id || undefined,
+                            class: el.className && typeof el.className === 'string' ? el.className.split(' ').filter(c => c).slice(0, 5).join(' ') : undefined,
+                            role: el.getAttribute?.('role') || undefined,
+                            'data-testid': el.getAttribute?.('data-testid') || undefined,
+                            childCount: el.children?.length || 0,
+                        };
+                        if (el.children?.length > 0 && depth < maxD) {
+                            node.children = Array.from(el.children).slice(0, 30).map(c => summarize(c, depth + 1, maxD));
+                        }
+                        return node;
+                    }
+                    return JSON.stringify(summarize(root, 0, ${depth}));
+                })()`;
+          } else if (format === "tree") {
+            expression = `(() => {
+                    const root = document.querySelector('${selector.replace(/'/g, "\\'")}');
+                    if (!root) return 'Selector not found: ${selector}';
+                    
+                    function tree(el, indent, depth, maxD) {
+                        if (depth > maxD) return indent + '...\\n';
+                        let line = indent + '<' + (el.tagName?.toLowerCase() || '?');
+                        if (el.id) line += ' #' + el.id;
+                        if (el.className && typeof el.className === 'string') {
+                            const cls = el.className.trim().split(' ').filter(c => c).slice(0, 3).join('.');
+                            if (cls) line += ' .' + cls;
+                        }
+                        const role = el.getAttribute?.('role');
+                        if (role) line += ' [role=' + role + ']';
+                        const testId = el.getAttribute?.('data-testid');
+                        if (testId) line += ' [data-testid=' + testId + ']';
+                        line += '> (' + (el.children?.length || 0) + ')\\n';
+                        
+                        let result = line;
+                        if (el.children?.length > 0 && depth < maxD) {
+                            for (let i = 0; i < Math.min(el.children.length, 30); i++) {
+                                result += tree(el.children[i], indent + '  ', depth + 1, maxD);
+                            }
+                            if (el.children.length > 30) result += indent + '  ... +' + (el.children.length - 30) + ' more\\n';
+                        }
+                        return result;
+                    }
+                    return tree(root, '', 0, ${depth});
+                })()`;
+          } else {
+            expression = `(() => {
+                    const root = document.querySelector('${selector.replace(/'/g, "\\'")}');
+                    if (!root) return 'Selector not found: ${selector}';
+                    let html = root.outerHTML;
+                    if (html.length > ${maxLength}) {
+                        html = html.slice(0, ${maxLength}) + '\\n<!-- TRUNCATED at ${maxLength} chars -->';
+                    }
+                    return html;
+                })()`;
+          }
+          let result;
+          if (sessionId) {
+            result = await this.getCdp().evaluateInSession(sessionId, expression);
+          } else {
+            result = await this.getCdp().evaluate(expression, 3e4);
+          }
+          if (format === "summary" && typeof result === "string") {
+            try {
+              result = JSON.parse(result);
+            } catch {
+            }
+          }
+          const size = typeof result === "string" ? result.length : JSON.stringify(result).length;
+          return { success: true, result, format, selector, size };
         } catch (e) {
           return { success: false, error: e.message };
         }
       }
-      async handleFileWrite(args) {
+      /**
+       * CDP DOM Query — CSS 셀렉터 테스트
+       * 셀렉터가 몇 개 요소에 매칭되는지, 어떤 요소인지 확인
+       * 
+       * args:
+       *   selector: string      — CSS 셀렉터
+       *   limit?: number        — 반환할 최대 요소 수 (default: 20)
+       *   content?: boolean     — 텍스트 내용 포함 여부 (default: true)
+       *   sessionId?: string    — agent webview 세션 ID
+       */
+      async handleCdpDomQuery(args) {
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
+        const selector = args?.selector;
+        if (!selector) return { success: false, error: "selector required" };
+        const limit = args?.limit || 20;
+        const content = args?.content !== false;
+        const sessionId = args?.sessionId;
+        const expression = `(() => {
+            try {
+                const els = document.querySelectorAll('${selector.replace(/'/g, "\\'")}');
+                const results = [];
+                for (let i = 0; i < Math.min(els.length, ${limit}); i++) {
+                    const el = els[i];
+                    const item = {
+                        index: i,
+                        tag: el.tagName?.toLowerCase(),
+                        id: el.id || null,
+                        class: el.className && typeof el.className === 'string' ? el.className.trim().slice(0, 200) : null,
+                        role: el.getAttribute?.('role') || null,
+                        'data-testid': el.getAttribute?.('data-testid') || null,
+                        rect: (() => { try { const r = el.getBoundingClientRect(); return { x: Math.round(r.x), y: Math.round(r.y), w: Math.round(r.width), h: Math.round(r.height) }; } catch { return null; } })(),
+                        visible: el.offsetParent !== null || el.offsetWidth > 0,
+                    };
+                    ${content ? `item.text = (el.textContent || '').trim().slice(0, 200);` : ""}
+                    ${content ? `item.value = el.value !== undefined ? String(el.value).slice(0, 200) : undefined;` : ""}
+                    results.push(item);
+                }
+                return JSON.stringify({ total: els.length, results });
+            } catch(e) {
+                return JSON.stringify({ error: e.message });
+            }
+        })()`;
         try {
-          const filePath = this.resolveSafePath(args?.path);
-          fs4.mkdirSync(path3.dirname(filePath), { recursive: true });
-          fs4.writeFileSync(filePath, args?.content || "", "utf-8");
-          return { success: true, path: filePath };
+          let raw;
+          if (sessionId) {
+            raw = await this.getCdp().evaluateInSession(sessionId, expression);
+          } else {
+            raw = await this.getCdp().evaluate(expression, 15e3);
+          }
+          const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+          return { success: true, ...parsed, selector };
         } catch (e) {
           return { success: false, error: e.message };
         }
       }
-      async handleFileList(args) {
-        try {
-          const dirPath = this.resolveSafePath(args?.path || ".");
-          const entries = fs4.readdirSync(dirPath, { withFileTypes: true });
-          const files = entries.map((e) => ({
-            name: e.name,
-            type: e.isDirectory() ? "directory" : "file",
-            size: e.isFile() ? fs4.statSync(path3.join(dirPath, e.name)).size : void 0
-          }));
+      /**
+       * CDP DOM Debug — IDE AI 패널 특화 분석
+       * 새 IDE 지원 시 필요한 핵심 정보를 한 번에 수집
+       * 
+       * args:
+       *   ideType?: string   — IDE 유형 힌트
+       *   sessionId?: string — agent webview 세션 ID 
+       */
+      async handleCdpDomDebug(args) {
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
+        const sessionId = args?.sessionId;
+        const expression = `(() => {
+            const result = {
+                url: location.href,
+                title: document.title,
+                viewport: { w: window.innerWidth, h: window.innerHeight },
+                
+                // \uC785\uB825 \uD544\uB4DC \uD6C4\uBCF4
+                inputs: [],
+                // textarea \uD6C4\uBCF4
+                textareas: [],
+                // contenteditable \uD6C4\uBCF4
+                editables: [],
+                // \uBC84\uD2BC (send, submit \uB4F1)
+                buttons: [],
+                // iframes (agent webviews)
+                iframes: [],
+                // role="textbox" \uD6C4\uBCF4
+                textboxes: [],
+            };
+
+            // \uC785\uB825 \uD544\uB4DC
+            document.querySelectorAll('input[type="text"], input:not([type])').forEach((el, i) => {
+                if (i >= 10) return;
+                result.inputs.push({
+                    tag: 'input',
+                    id: el.id || null,
+                    class: (el.className || '').toString().slice(0, 150),
+                    placeholder: el.getAttribute('placeholder') || null,
+                    name: el.name || null,
+                    value: el.value?.slice(0, 100) || null,
+                    visible: el.offsetParent !== null,
+                    rect: (() => { try { const r = el.getBoundingClientRect(); return { x: Math.round(r.x), y: Math.round(r.y), w: Math.round(r.width), h: Math.round(r.height) }; } catch { return null; } })(),
+                });
+            });
+
+            // textarea
+            document.querySelectorAll('textarea').forEach((el, i) => {
+                if (i >= 10) return;
+                result.textareas.push({
+                    id: el.id || null,
+                    class: (el.className || '').toString().slice(0, 150),
+                    placeholder: el.getAttribute('placeholder') || null,
+                    rows: el.rows,
+                    value: el.value?.slice(0, 100) || null,
+                    visible: el.offsetParent !== null,
+                    rect: (() => { try { const r = el.getBoundingClientRect(); return { x: Math.round(r.x), y: Math.round(r.y), w: Math.round(r.width), h: Math.round(r.height) }; } catch { return null; } })(),
+                });
+            });
+
+            // contenteditable
+            document.querySelectorAll('[contenteditable="true"]').forEach((el, i) => {
+                if (i >= 10) return;
+                result.editables.push({
+                    tag: el.tagName?.toLowerCase(),
+                    id: el.id || null,
+                    class: (el.className || '').toString().slice(0, 150),
+                    role: el.getAttribute('role') || null,
+                    text: (el.textContent || '').trim().slice(0, 100),
+                    visible: el.offsetParent !== null,
+                    rect: (() => { try { const r = el.getBoundingClientRect(); return { x: Math.round(r.x), y: Math.round(r.y), w: Math.round(r.width), h: Math.round(r.height) }; } catch { return null; } })(),
+                });
+            });
+
+            // role="textbox"
+            document.querySelectorAll('[role="textbox"]').forEach((el, i) => {
+                if (i >= 10) return;
+                result.textboxes.push({
+                    tag: el.tagName?.toLowerCase(),
+                    id: el.id || null,
+                    class: (el.className || '').toString().slice(0, 150),
+                    'aria-label': el.getAttribute('aria-label') || null,
+                    text: (el.textContent || '').trim().slice(0, 100),
+                    visible: el.offsetParent !== null,
+                    rect: (() => { try { const r = el.getBoundingClientRect(); return { x: Math.round(r.x), y: Math.round(r.y), w: Math.round(r.width), h: Math.round(r.height) }; } catch { return null; } })(),
+                });
+            });
+
+            // \uBC84\uD2BC (send, submit, accept, reject, approve \uB4F1)
+            const btnKeywords = /send|submit|accept|reject|approve|deny|cancel|confirm|run|execute|apply/i;
+            document.querySelectorAll('button, [role="button"], input[type="submit"]').forEach((el, i) => {
+                const text = (el.textContent || el.getAttribute('aria-label') || '').trim();
+                if (i < 30 && (text.length < 30 || btnKeywords.test(text))) {
+                    result.buttons.push({
+                        tag: el.tagName?.toLowerCase(),
+                        id: el.id || null,
+                        class: (el.className || '').toString().slice(0, 150),
+                        text: text.slice(0, 80),
+                        'aria-label': el.getAttribute('aria-label') || null,
+                        disabled: el.disabled || el.getAttribute('disabled') !== null,
+                        visible: el.offsetParent !== null,
+                        rect: (() => { try { const r = el.getBoundingClientRect(); return { x: Math.round(r.x), y: Math.round(r.y), w: Math.round(r.width), h: Math.round(r.height) }; } catch { return null; } })(),
+                    });
+                }
+            });
+
+            // iframes
+            document.querySelectorAll('iframe, webview').forEach((el, i) => {
+                if (i >= 20) return;
+                result.iframes.push({
+                    tag: el.tagName?.toLowerCase(),
+                    id: el.id || null,
+                    class: (el.className || '').toString().slice(0, 150),
+                    src: el.getAttribute('src')?.slice(0, 200) || null,
+                    title: el.getAttribute('title') || null,
+                    visible: el.offsetParent !== null,
+                    rect: (() => { try { const r = el.getBoundingClientRect(); return { x: Math.round(r.x), y: Math.round(r.y), w: Math.round(r.width), h: Math.round(r.height) }; } catch { return null; } })(),
+                });
+            });
+
+            return JSON.stringify(result);
+        })()`;
+        try {
+          let raw;
+          if (sessionId) {
+            raw = await this.getCdp().evaluateInSession(sessionId, expression);
+          } else {
+            raw = await this.getCdp().evaluate(expression, 3e4);
+          }
+          const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+          return { success: true, ...parsed };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
+      // ─── 파일 직접 처리 ─────────────────────────
+      async handleFileRead(args) {
+        try {
+          const filePath = this.resolveSafePath(args?.path);
+          const content = fs2.readFileSync(filePath, "utf-8");
+          return { success: true, content, path: filePath };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
+      async handleFileWrite(args) {
+        try {
+          const filePath = this.resolveSafePath(args?.path);
+          fs2.mkdirSync(path3.dirname(filePath), { recursive: true });
+          fs2.writeFileSync(filePath, args?.content || "", "utf-8");
+          return { success: true, path: filePath };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
+      async handleFileList(args) {
+        try {
+          const dirPath = this.resolveSafePath(args?.path || ".");
+          const entries = fs2.readdirSync(dirPath, { withFileTypes: true });
+          const files = entries.map((e) => ({
+            name: e.name,
+            type: e.isDirectory() ? "directory" : "file",
+            size: e.isFile() ? fs2.statSync(path3.join(dirPath, e.name)).size : void 0
+          }));
           return { success: true, files, path: dirPath };
         } catch (e) {
           return { success: false, error: e.message };
@@ -4015,7 +5011,7 @@ var init_daemon_commands = __esm({
           const candidates = ["Cursor", "Code", "VSCodium"];
           for (const app of candidates) {
             const stateFile = path3.join(storageDir, app, "User", "globalStorage", "state.vscdb");
-            if (fs4.existsSync(stateFile)) {
+            if (fs2.existsSync(stateFile)) {
               const result = await this.delegateToExtension("adhdev.getRecentWorkspaces", []);
               if (result.success && Array.isArray(result.result)) {
                 const merged = Array.from(/* @__PURE__ */ new Set([...cliRecent, ...result.result])).slice(0, 20);
@@ -4124,13 +5120,18 @@ var init_daemon_commands = __esm({
         return { success: false, error: `CLI adapter not found: ${cliType}` };
       }
       handlePtyResize(args) {
-        const { cliType, cols, rows } = args || {};
+        const { cliType, cols, rows, force } = args || {};
         if (!cols || !rows) return { success: false, error: "cols and rows required" };
         if (this.ctx.adapters) {
           const targetCli = cliType || "gemini-cli";
           for (const [, adapter] of this.ctx.adapters) {
             if (adapter.cliType === targetCli && typeof adapter.resize === "function") {
-              adapter.resize(cols, rows);
+              if (force) {
+                adapter.resize(cols - 1, rows);
+                setTimeout(() => adapter.resize(cols, rows), 50);
+              } else {
+                adapter.resize(cols, rows);
+              }
               return { success: true };
             }
           }
@@ -4435,13 +5436,13 @@ var init_manager = __esm({
           }
         }
       }
-      async switchActiveAgent(cdp, agentType) {
+      async switchActiveAgent(cdp2, agentType) {
         if (this._activeAgentType === agentType) return;
         if (this._activeAgentType) {
           const prev = this.managed.get(this._activeAgentType);
           if (prev) {
             try {
-              await cdp.detachAgent(prev.sessionId);
+              await cdp2.detachAgent(prev.sessionId);
             } catch {
             }
             this.managed.delete(this._activeAgentType);
@@ -4453,7 +5454,7 @@ var init_manager = __esm({
         this.logFn(`[AgentStream] Active agent: ${agentType || "none"}`);
       }
       /** Agent webview 발견 + 세션 연결 */
-      async syncAgentSessions(cdp) {
+      async syncAgentSessions(cdp2) {
         if (!this.enabled || !this._activeAgentType) return;
         const now = Date.now();
         if (this.managed.has(this._activeAgentType) && now - this.lastDiscoveryTime < this.discoveryIntervalMs) {
@@ -4461,12 +5462,12 @@ var init_manager = __esm({
         }
         this.lastDiscoveryTime = now;
         try {
-          const targets = await cdp.discoverAgentWebviews();
+          const targets = await cdp2.discoverAgentWebviews();
           const activeTarget = targets.find((t) => t.agentType === this._activeAgentType);
           if (activeTarget && !this.managed.has(this._activeAgentType)) {
             const adapter = this.allAdapters.find((a) => a.agentType === this._activeAgentType);
             if (adapter) {
-              const sessionId = await cdp.attachToAgent(activeTarget);
+              const sessionId = await cdp2.attachToAgent(activeTarget);
               if (sessionId) {
                 this.managed.set(this._activeAgentType, {
                   adapter,
@@ -4482,7 +5483,7 @@ var init_manager = __esm({
           }
           for (const [type, agent] of this.managed) {
             if (type !== this._activeAgentType) {
-              await cdp.detachAgent(agent.sessionId);
+              await cdp2.detachAgent(agent.sessionId);
               this.managed.delete(type);
             }
           }
@@ -4492,7 +5493,7 @@ var init_manager = __esm({
         }
       }
       /** 활성 에이전트 상태 수집 */
-      async collectAgentStreams(cdp) {
+      async collectAgentStreams(cdp2) {
         if (!this.enabled) return [];
         const results = [];
         if (this._activeAgentType && this.managed.has(this._activeAgentType)) {
@@ -4504,7 +5505,7 @@ var init_manager = __esm({
             results.push(agent.lastState);
           } else {
             try {
-              const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+              const evaluate = (expr, timeout) => cdp2.evaluateInSession(agent.sessionId, expr, timeout);
               const state = await agent.adapter.readChat(evaluate);
               agent.lastState = state;
               agent.lastError = null;
@@ -4526,7 +5527,7 @@ var init_manager = __esm({
               });
               if (errorMsg.includes("timeout") || errorMsg.includes("not connected") || errorMsg.includes("Session")) {
                 try {
-                  await cdp.detachAgent(agent.sessionId);
+                  await cdp2.detachAgent(agent.sessionId);
                 } catch {
                 }
                 this.managed.delete(type);
@@ -4537,12 +5538,12 @@ var init_manager = __esm({
         }
         return results;
       }
-      async sendToAgent(cdp, agentType, text, targetIdeType) {
+      async sendToAgent(cdp2, agentType, text, targetIdeType) {
         await this.ensureAgentPanelOpen(agentType, targetIdeType);
         const agent = this.managed.get(agentType);
         if (!agent) return false;
         try {
-          const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+          const evaluate = (expr, timeout) => cdp2.evaluateInSession(agent.sessionId, expr, timeout);
           await agent.adapter.sendMessage(evaluate, text);
           return true;
         } catch (e) {
@@ -4550,24 +5551,24 @@ var init_manager = __esm({
           return false;
         }
       }
-      async resolveAgentAction(cdp, agentType, action, targetIdeType) {
+      async resolveAgentAction(cdp2, agentType, action, targetIdeType) {
         await this.ensureAgentPanelOpen(agentType, targetIdeType);
         const agent = this.managed.get(agentType);
         if (!agent) return false;
         try {
-          const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+          const evaluate = (expr, timeout) => cdp2.evaluateInSession(agent.sessionId, expr, timeout);
           return await agent.adapter.resolveAction(evaluate, action);
         } catch (e) {
           this.logFn(`[AgentStream] resolveAction(${agentType}) error: ${e.message}`);
           return false;
         }
       }
-      async newAgentSession(cdp, agentType, targetIdeType) {
+      async newAgentSession(cdp2, agentType, targetIdeType) {
         await this.ensureAgentPanelOpen(agentType, targetIdeType);
         const agent = this.managed.get(agentType);
         if (!agent) return false;
         try {
-          const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+          const evaluate = (expr, timeout) => cdp2.evaluateInSession(agent.sessionId, expr, timeout);
           await agent.adapter.newSession(evaluate);
           return true;
         } catch (e) {
@@ -4575,33 +5576,45 @@ var init_manager = __esm({
           return false;
         }
       }
-      async listAgentChats(cdp, agentType) {
-        const agent = this.managed.get(agentType);
+      async listAgentChats(cdp2, agentType) {
+        let agent = this.managed.get(agentType);
+        if (!agent) {
+          this.logFn(`[AgentStream] listChats: ${agentType} not managed, trying on-demand activation`);
+          await this.switchActiveAgent(cdp2, agentType);
+          await this.syncAgentSessions(cdp2);
+          agent = this.managed.get(agentType);
+        }
         if (!agent || typeof agent.adapter.listChats !== "function") return [];
         try {
-          const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+          const evaluate = (expr, timeout) => cdp2.evaluateInSession(agent.sessionId, expr, timeout);
           return await agent.adapter.listChats(evaluate);
         } catch (e) {
           this.logFn(`[AgentStream] listChats(${agentType}) error: ${e.message}`);
           return [];
         }
       }
-      async switchAgentSession(cdp, agentType, sessionId) {
-        const agent = this.managed.get(agentType);
+      async switchAgentSession(cdp2, agentType, sessionId) {
+        let agent = this.managed.get(agentType);
+        if (!agent) {
+          this.logFn(`[AgentStream] switchSession: ${agentType} not managed, trying on-demand activation`);
+          await this.switchActiveAgent(cdp2, agentType);
+          await this.syncAgentSessions(cdp2);
+          agent = this.managed.get(agentType);
+        }
         if (!agent || typeof agent.adapter.switchSession !== "function") return false;
         try {
-          const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+          const evaluate = (expr, timeout) => cdp2.evaluateInSession(agent.sessionId, expr, timeout);
           return await agent.adapter.switchSession(evaluate, sessionId);
         } catch (e) {
           this.logFn(`[AgentStream] switchSession(${agentType}) error: ${e.message}`);
           return false;
         }
       }
-      async focusAgentEditor(cdp, agentType) {
+      async focusAgentEditor(cdp2, agentType) {
         const agent = this.managed.get(agentType);
         if (!agent || typeof agent.adapter.focusEditor !== "function") return false;
         try {
-          const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+          const evaluate = (expr, timeout) => cdp2.evaluateInSession(agent.sessionId, expr, timeout);
           await agent.adapter.focusEditor(evaluate);
           return true;
         } catch (e) {
@@ -4615,12 +5628,12 @@ var init_manager = __esm({
       getManagedAgent(agentType) {
         return this.managed.get(agentType);
       }
-      async dispose(cdp) {
+      async dispose(cdp2) {
         for (const loader of this.scriptLoaders.values()) loader.stop();
         this.scriptLoaders.clear();
         for (const [, agent] of this.managed) {
           try {
-            await cdp.detachAgent(agent.sessionId);
+            await cdp2.detachAgent(agent.sessionId);
           } catch {
           }
         }
@@ -4649,6 +5662,107 @@ var init_agent_stream = __esm({
   }
 });
 
+// src/daemon-logger.ts
+var daemon_logger_exports = {};
+__export(daemon_logger_exports, {
+  LOG_DIR_PATH: () => LOG_DIR_PATH,
+  LOG_PATH: () => LOG_PATH,
+  cdpLogFn: () => cdpLogFn,
+  daemonLog: () => daemonLog,
+  installGlobalInterceptor: () => installGlobalInterceptor
+});
+function rotateIfNeeded() {
+  try {
+    const stat = fs3.statSync(LOG_FILE);
+    if (stat.size > MAX_LOG_SIZE) {
+      const backup = LOG_FILE + ".old";
+      try {
+        fs3.unlinkSync(backup);
+      } catch {
+      }
+      fs3.renameSync(LOG_FILE, backup);
+    }
+  } catch {
+  }
+}
+function writeToFile(line) {
+  try {
+    fs3.appendFileSync(LOG_FILE, line + "\n");
+  } catch {
+  }
+}
+function daemonLog(category, msg) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${category}] ${msg}`;
+  origConsoleLog(line);
+  writeToFile(line);
+}
+function cdpLogFn(ideType) {
+  return (msg) => {
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [CDP:${ideType}] ${msg}`;
+    origConsoleLog(line);
+    writeToFile(line);
+  };
+}
+function installGlobalInterceptor() {
+  if (interceptorInstalled) return;
+  interceptorInstalled = true;
+  const stripAnsi4 = (str) => str.replace(/\x1B\[[0-9;]*m/g, "");
+  console.log = (...args) => {
+    origConsoleLog(...args);
+    try {
+      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+      const clean = stripAnsi4(msg);
+      const line = clean.startsWith("[20") ? clean : `[${(/* @__PURE__ */ new Date()).toISOString()}] ${clean}`;
+      writeToFile(line);
+    } catch {
+    }
+  };
+  console.error = (...args) => {
+    origConsoleError(...args);
+    try {
+      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+      const clean = stripAnsi4(msg);
+      writeToFile(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ERROR] ${clean}`);
+    } catch {
+    }
+  };
+  console.warn = (...args) => {
+    origConsoleWarn(...args);
+    try {
+      const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+      const clean = stripAnsi4(msg);
+      writeToFile(`[${(/* @__PURE__ */ new Date()).toISOString()}] [WARN] ${clean}`);
+    } catch {
+    }
+  };
+  writeToFile(`
+=== ADHDev Daemon started at ${(/* @__PURE__ */ new Date()).toISOString()} ===`);
+  writeToFile(`Log file: ${LOG_FILE}`);
+}
+var fs3, path4, os8, LOG_DIR, LOG_FILE, MAX_LOG_SIZE, origConsoleLog, origConsoleError, origConsoleWarn, interceptorInstalled, LOG_PATH, LOG_DIR_PATH;
+var init_daemon_logger = __esm({
+  "src/daemon-logger.ts"() {
+    "use strict";
+    fs3 = __toESM(require("fs"));
+    path4 = __toESM(require("path"));
+    os8 = __toESM(require("os"));
+    LOG_DIR = process.platform === "darwin" ? path4.join(os8.homedir(), "Library", "Logs", "adhdev") : path4.join(os8.homedir(), ".local", "share", "adhdev", "logs");
+    LOG_FILE = path4.join(LOG_DIR, "daemon.log");
+    MAX_LOG_SIZE = 10 * 1024 * 1024;
+    try {
+      fs3.mkdirSync(LOG_DIR, { recursive: true });
+    } catch {
+    }
+    rotateIfNeeded();
+    origConsoleLog = console.log.bind(console);
+    origConsoleError = console.error.bind(console);
+    origConsoleWarn = console.warn.bind(console);
+    interceptorInstalled = false;
+    LOG_PATH = LOG_FILE;
+    LOG_DIR_PATH = LOG_DIR;
+  }
+});
+
 // src/adhdev-daemon.ts
 var adhdev_daemon_exports = {};
 __export(adhdev_daemon_exports, {
@@ -4657,24 +5771,24 @@ __export(adhdev_daemon_exports, {
   stopDaemon: () => stopDaemon
 });
 function getDaemonPidFile() {
-  const dir = path4.join(os8.homedir(), ".adhdev");
-  if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
-  return path4.join(dir, "daemon.pid");
+  const dir = path5.join(os9.homedir(), ".adhdev");
+  if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
+  return path5.join(dir, "daemon.pid");
 }
 function writeDaemonPid(pid) {
-  fs5.writeFileSync(getDaemonPidFile(), String(pid), "utf-8");
+  fs4.writeFileSync(getDaemonPidFile(), String(pid), "utf-8");
 }
 function removeDaemonPid() {
   try {
-    fs5.unlinkSync(getDaemonPidFile());
+    fs4.unlinkSync(getDaemonPidFile());
   } catch {
   }
 }
 function isDaemonRunning() {
   const pidFile = getDaemonPidFile();
   try {
-    if (!fs5.existsSync(pidFile)) return false;
-    const pid = parseInt(fs5.readFileSync(pidFile, "utf-8").trim());
+    if (!fs4.existsSync(pidFile)) return false;
+    const pid = parseInt(fs4.readFileSync(pidFile, "utf-8").trim());
     process.kill(pid, 0);
     return true;
   } catch {
@@ -4685,8 +5799,8 @@ function isDaemonRunning() {
 function stopDaemon() {
   const pidFile = getDaemonPidFile();
   try {
-    if (!fs5.existsSync(pidFile)) return false;
-    const pid = parseInt(fs5.readFileSync(pidFile, "utf-8").trim());
+    if (!fs4.existsSync(pidFile)) return false;
+    const pid = parseInt(fs4.readFileSync(pidFile, "utf-8").trim());
     process.kill(pid, "SIGTERM");
     removeDaemonPid();
     return true;
@@ -4695,7 +5809,7 @@ function stopDaemon() {
     return false;
   }
 }
-var os8, fs5, path4, crypto2, import_chalk2, DANGEROUS_PATTERNS, AdhdevDaemon;
+var os9, fs4, path5, crypto2, import_chalk2, DANGEROUS_PATTERNS, AdhdevDaemon;
 var init_adhdev_daemon = __esm({
   "src/adhdev-daemon.ts"() {
     "use strict";
@@ -4714,9 +5828,9 @@ var init_adhdev_daemon = __esm({
     init_daemon_commands();
     init_agent_stream();
     init_dist();
-    os8 = __toESM(require("os"));
-    fs5 = __toESM(require("fs"));
-    path4 = __toESM(require("path"));
+    os9 = __toESM(require("os"));
+    fs4 = __toESM(require("fs"));
+    path5 = __toESM(require("path"));
     crypto2 = __toESM(require("crypto"));
     import_chalk2 = __toESM(require("chalk"));
     DANGEROUS_PATTERNS = [
@@ -4766,6 +5880,11 @@ var init_adhdev_daemon = __esm({
         this.localPort = DEFAULT_DAEMON_PORT;
       }
       async start(options = {}) {
+        try {
+          const { installGlobalInterceptor: installGlobalInterceptor2 } = (init_daemon_logger(), __toCommonJS(daemon_logger_exports));
+          installGlobalInterceptor2();
+        } catch {
+        }
         this.localPort = options.localPort || DEFAULT_DAEMON_PORT;
         const workingDir = options.workingDir || process.cwd();
         if (isDaemonRunning()) {
@@ -4839,6 +5958,7 @@ var init_adhdev_daemon = __esm({
         for (const ideType of this.cdpManagers.keys()) {
           const loader = new DaemonScriptLoader(serverUrl, ideType);
           loader.setToken(config.connectionToken);
+          loader.setPlatform(os9.platform());
           await loader.start().catch((e) => {
             console.log(import_chalk2.default.yellow(`  \u26A0 ScriptLoader start failed for ${ideType}: ${e.message}`));
           });
@@ -4848,6 +5968,7 @@ var init_adhdev_daemon = __esm({
           const fallbackType = this.detectedIdes.find((ide) => ide.installed)?.id || "cursor";
           const loader = new DaemonScriptLoader(serverUrl, fallbackType);
           loader.setToken(config.connectionToken);
+          loader.setPlatform(os9.platform());
           await loader.start().catch((e) => {
             console.log(import_chalk2.default.yellow(`  \u26A0 ScriptLoader start failed: ${e.message}`));
           });
@@ -4873,8 +5994,8 @@ var init_adhdev_daemon = __esm({
             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);
+        const machineId = os9.hostname().replace(/[^a-zA-Z0-9]/g, "_");
+        const machineHash = crypto2.createHash("md5").update(os9.hostname() + os9.homedir()).digest("hex").slice(0, 8);
         const instanceId = `daemon_${machineId}_${machineHash}`;
         this.bridge = new CliBridgeConnection({
           serverUrl: options.serverUrl || config.serverUrl,
@@ -4882,7 +6003,7 @@ var init_adhdev_daemon = __esm({
           cliInfo: {
             type: "adhdev-daemon",
             version: "0.2.0",
-            platform: os8.platform(),
+            platform: os9.platform(),
             instanceId
           }
         });
@@ -4894,8 +6015,7 @@ var init_adhdev_daemon = __esm({
             return this.commandHandler.handle("cdp_remote_action", event);
           });
           this.p2p.onCommand(async (cmdType, data, id) => {
-            if (!this.commandHandler) return { success: false, error: "No handler" };
-            return this.commandHandler.handle(cmdType, data);
+            return this.handleP2PCommand(cmdType, data);
           });
           this.p2p.onFileRequest(async (req) => {
             if (req.type === "read") {
@@ -4929,14 +6049,14 @@ var init_adhdev_daemon = __esm({
           this.screenshotTimer = setInterval(async () => {
             const active = this.p2p?.screenshotActive;
             const ssIdeType = this.p2p?.screenshotIdeType;
-            const cdp = ssIdeType ? this.getCdpFor(ssIdeType) : this.getAnyCdp();
-            if (!active || !cdp) return;
+            const cdp2 = ssIdeType ? this.getCdpFor(ssIdeType) : this.getAnyCdp();
+            if (!active || !cdp2) return;
             ssDebugCount++;
             if (ssDebugCount <= 3 || ssDebugCount % 25 === 0) {
               console.log(`[SS] Capturing screenshot... (tick ${ssDebugCount}, active=${active}, cdp=true)`);
             }
             try {
-              const buf = await cdp.captureScreenshot();
+              const buf = await cdp2.captureScreenshot();
               if (buf) {
                 const sent = this.p2p.sendScreenshot(buf.toString("base64"));
                 if (ssDebugCount <= 3) console.log(`[SS] Screenshot sent: ${buf.length} bytes, delivered=${sent}`);
@@ -5188,7 +6308,7 @@ var init_adhdev_daemon = __esm({
               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));
+                  console.log(`[CDP:${result.ideId}] ${msg2}`);
                 }, true);
                 const connected = await manager.connect();
                 if (connected) {
@@ -5200,6 +6320,7 @@ var init_adhdev_daemon = __esm({
                     const serverUrl = config.serverUrl || "https://api.adhf.dev";
                     const loader = new DaemonScriptLoader(serverUrl, result.ideId);
                     loader.setToken(config.connectionToken || "");
+                    loader.setPlatform(os9.platform());
                     await loader.start().catch((e) => {
                       console.log(import_chalk2.default.yellow(`  \u26A0 ScriptLoader start failed for ${result.ideId}: ${e?.message}`));
                     });
@@ -5234,6 +6355,13 @@ var init_adhdev_daemon = __esm({
           if (this.commandHandler) {
             const result = await this.commandHandler.handle(cmd, args);
             this.sendResult(msg, result.success, result);
+            const CHAT_COMMANDS = ["send_chat", "new_chat", "switch_chat", "set_mode", "change_model", "agent_stream_send"];
+            if (CHAT_COMMANDS.includes(cmd)) {
+              setTimeout(() => this.sendUnifiedStatusReport().catch(() => {
+              }), 1e3);
+              setTimeout(() => this.sendUnifiedStatusReport().catch(() => {
+              }), 3e3);
+            }
           } else {
             this.sendResult(msg, false, { error: `Command handler not initialized: ${cmd}` });
           }
@@ -5242,6 +6370,87 @@ var init_adhdev_daemon = __esm({
           this.sendResult(msg, false, { error: e.message });
         }
       }
+      /** P2P 명령 처리 — DaemonCommandHandler + daemon-level 명령 */
+      async handleP2PCommand(cmdType, data) {
+        try {
+          switch (cmdType) {
+            case "launch_ide": {
+              const ideKey = data.ideId || data.ideType || "";
+              const launchArgs = { ...data, ideId: ideKey };
+              console.log(`[launch_ide] (P2P) 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, (msg) => {
+                  console.log(`[CDP:${result.ideId}] ${msg}`);
+                }, 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})`));
+                  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 || "");
+                    loader.setPlatform(os9.platform());
+                    await loader.start().catch(() => {
+                    });
+                    this.scriptLoaders.set(result.ideId, loader);
+                  }
+                }
+              }
+              this.startAgentStreamPolling();
+              return { success: result.success, ...result };
+            }
+            case "detect_ides": {
+              this.detectedIdes = await detectIDEs();
+              return { success: true, ides: this.detectedIdes };
+            }
+            case "launch_cli": {
+              const cliType = data.cliType || "gemini-cli";
+              const dir = data.dir || process.cwd();
+              await this.startCliSession(cliType, dir);
+              return { success: true, started: true };
+            }
+            case "stop_cli": {
+              const cliType = data.cliType || "gemini-cli";
+              const dir = data.dir || "";
+              const key = `${cliType}:${dir}`;
+              const adapter = this.adapters.get(key);
+              if (adapter) {
+                try {
+                  adapter.destroy?.();
+                } catch {
+                }
+                this.adapters.delete(key);
+              }
+              return { success: true, stopped: true };
+            }
+            case "restart_session": {
+              const cliType = data.cliType || data.ideType || "gemini-cli";
+              const dir = data.dir || process.cwd();
+              for (const [key, adapter] of this.adapters) {
+                if (key.startsWith(cliType)) {
+                  try {
+                    adapter.destroy?.();
+                  } catch {
+                  }
+                  this.adapters.delete(key);
+                }
+              }
+              await this.startCliSession(cliType, dir);
+              return { success: true, restarted: true };
+            }
+          }
+          if (this.commandHandler) {
+            return this.commandHandler.handle(cmdType, data);
+          }
+          return { success: false, error: `Unknown command: ${cmdType}` };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
       // ─── CLI 세션 관리 ──────────────────────────────
       createAdapter(cliType, workingDir) {
         if (cliType === "claude-cli" || cliType === "claude-code") {
@@ -5253,7 +6462,7 @@ var init_adhdev_daemon = __esm({
         }
       }
       async startCliSession(cliType, workingDir) {
-        const resolvedDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os8.homedir()) : workingDir;
+        const resolvedDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os9.homedir()) : workingDir;
         const cliInfo = await detectCLI(cliType);
         if (!cliInfo) throw new Error(`${cliType} not found`);
         const key = this.getCliKey(cliType, resolvedDir);
@@ -5270,7 +6479,7 @@ var init_adhdev_daemon = __esm({
         adapter.setOnStatusChange(() => this.sendUnifiedStatusReport());
         if (typeof adapter.setOnPtyData === "function") {
           adapter.setOnPtyData((data) => {
-            const sentViaP2P = this.p2pSender?.broadcastPtyOutput(adapter.cliType, data);
+            const sentViaP2P = this.p2p?.broadcastPtyOutput(adapter.cliType, data);
             if (!sentViaP2P && this.bridge) {
               this.bridge.sendMessage("pty_output", {
                 cliType: adapter.cliType,
@@ -5302,7 +6511,7 @@ var init_adhdev_daemon = __esm({
             this.sendUnifiedStatusReport().catch(() => {
             });
             scheduleNext();
-          }, 15e3);
+          }, 5e3);
         };
         scheduleNext();
       }
@@ -5325,16 +6534,17 @@ var init_adhdev_daemon = __esm({
       async sendUnifiedStatusReport() {
         if (!this.bridge?.isConnected()) return;
         this.lastStatusSentAt = Date.now();
+        console.log(`[StatusReport] Starting... cdp=${this.cdpManagers.size} scripts=${this.scriptLoaders.size} busy=${this._cdpChatBusy}`);
         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;
+          for (const [ideType, cdp2] of this.cdpManagers) {
+            if (!cdp2.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);
+              const raw = await cdp2.evaluate(readChatScript, 3e4);
               if (raw && typeof raw === "object") {
                 let { activeModal } = raw;
                 if (activeModal) {
@@ -5346,9 +6556,54 @@ var init_adhdev_daemon = __esm({
                     buttons: (activeModal.buttons ?? []).filter((t) => t.length < 30)
                   };
                 }
-                this._cachedActiveChatMap.set(ideType, { ...raw, activeModal });
+                const msgCount = raw.messages?.length || 0;
+                console.log(`[StatusReport] ${ideType} read_chat: ${msgCount} msgs, status=${raw.status}, id=${raw.id?.substring(0, 15)}`);
+                if (msgCount > 0) {
+                  const prevChat = this._cachedActiveChatMap.get(ideType);
+                  const prevMsgs = prevChat?.messages || [];
+                  const prevByHash = /* @__PURE__ */ new Map();
+                  for (const pm of prevMsgs) {
+                    const h = `${pm.role}:${(pm.content || "").slice(0, 100)}`;
+                    if (pm.receivedAt) prevByHash.set(h, pm.receivedAt);
+                  }
+                  const now2 = Date.now();
+                  for (const msg of raw.messages) {
+                    const h = `${msg.role}:${(msg.content || "").slice(0, 100)}`;
+                    msg.receivedAt = prevByHash.get(h) || now2;
+                  }
+                  this._cachedActiveChatMap.set(ideType, { ...raw, activeModal });
+                } else {
+                  try {
+                    const inlineResult = await cdp2.evaluate(`(() => {
+                                    const container = document.querySelector('.flex.flex-col.gap-2\\\\.5');
+                                    if (!container) return { messages: [], status: 'idle', id: 'cascade' };
+                                    const msgs = [];
+                                    for (const child of container.children) {
+                                        if ((child.className || '').includes('mark-js-ignore')) continue;
+                                        if (child.offsetHeight < 10) continue;
+                                        const inner = child.children[0];
+                                        if (!inner) continue;
+                                        const isUser = inner.className?.includes('flex-row') || !!inner.querySelector('.justify-end');
+                                        const role = isUser ? 'user' : 'assistant';
+                                        const text = child.textContent?.trim() || '';
+                                        if (text.length < 1) continue;
+                                        msgs.push({ id: 'msg_' + msgs.length, role, content: text.substring(0, 6000), index: msgs.length });
+                                    }
+                                    return { messages: msgs, status: 'idle', id: 'cascade' };
+                                })()`, 1e4);
+                    console.log(`[StatusReport] ${ideType} inline fallback: ${inlineResult?.messages?.length || 0} msgs`);
+                    if (inlineResult?.messages?.length > 0) {
+                      this._cachedActiveChatMap.set(ideType, { ...inlineResult, activeModal });
+                    }
+                  } catch (e2) {
+                    console.log(`[StatusReport] ${ideType} inline error: ${e2.message}`);
+                  }
+                }
+              } else {
+                console.log(`[StatusReport] ${ideType} read_chat: null/non-object result`);
               }
-            } catch {
+            } catch (e1) {
+              console.log(`[StatusReport] ${ideType} read_chat error: ${e1.message}`);
             }
           }
           this._cdpChatBusy = false;
@@ -5399,6 +6654,29 @@ var init_adhdev_daemon = __esm({
             cdpConnected: isMainCdpIde ? this.cdpManagers.get(ext.ideType.toLowerCase())?.isConnected || false : false
           };
         });
+        const managedIdeTypes = new Set(managedIdes.map((ide) => ide.ideType.toLowerCase()));
+        for (const [ideType, cdp2] of this.cdpManagers) {
+          if (!cdp2.isConnected) continue;
+          if (managedIdeTypes.has(ideType)) continue;
+          if (enabledIdesFilter.length > 0 && !enabledIdesFilter.includes(ideType)) continue;
+          const cachedChat = this._cachedActiveChatMap.get(ideType);
+          const cdpStreams = this._cachedAgentStreamsMap.get(ideType) || [];
+          const machineHash = require("crypto").createHash("md5").update(os9.hostname() + ideType).digest("hex").slice(0, 8);
+          console.log(`[StatusReport] Adding CDP-only IDE: ${ideType} (no bridge ext, chat=${cachedChat?.messages?.length || 0} msgs)`);
+          managedIdes.push({
+            ideType,
+            ideVersion: "",
+            instanceId: `${ideType}_${machineHash}`,
+            workspaceFolders: [],
+            activeFile: null,
+            terminals: 0,
+            aiAgents: [],
+            activeChat: cachedChat || null,
+            chats: [],
+            agentStreams: cdpStreams,
+            cdpConnected: true
+          });
+        }
         const managedClis = [];
         for (const [key, adapter] of this.adapters.entries()) {
           const adapterStatus = adapter.getStatus();
@@ -5457,15 +6735,15 @@ var init_adhdev_daemon = __esm({
           // Machine 정보
           daemonMode: true,
           machine: {
-            hostname: os8.hostname(),
-            platform: os8.platform(),
-            release: os8.release(),
-            arch: os8.arch(),
-            cpus: os8.cpus().length,
-            totalMem: os8.totalmem(),
-            freeMem: os8.freemem(),
-            loadavg: os8.loadavg(),
-            uptime: os8.uptime()
+            hostname: os9.hostname(),
+            platform: os9.platform(),
+            release: os9.release(),
+            arch: os9.arch(),
+            cpus: os9.cpus().length,
+            totalMem: os9.totalmem(),
+            freeMem: os9.freemem(),
+            loadavg: os9.loadavg(),
+            uptime: os9.uptime()
           },
           // 관리 중인 IDE/CLI (계층 데이터)
           managedIdes,
@@ -5488,7 +6766,7 @@ var init_adhdev_daemon = __esm({
           timestamp: now,
           // ─── Legacy compat (서버 기존 로직용, 점진적 제거 예정) ───
           activeFile: extSummary.activeFile,
-          workspaceFolders: extSummary.workspaceFolders.length > 0 ? extSummary.workspaceFolders : Array.from(this.adapters.values()).map((a) => ({ name: path4.basename(a.workingDir), path: a.workingDir })),
+          workspaceFolders: extSummary.workspaceFolders.length > 0 ? extSummary.workspaceFolders : Array.from(this.adapters.values()).map((a) => ({ name: path5.basename(a.workingDir), path: a.workingDir })),
           terminals: extSummary.terminals,
           // Legacy aiAgents: managedIdes에서 각 IDE의 aiAgents를 통합
           aiAgents: [
@@ -5507,15 +6785,15 @@ var init_adhdev_daemon = __esm({
           ],
           connectedExtensions: extSummary.connectedIdes,
           system: {
-            platform: os8.platform(),
-            release: os8.release(),
-            arch: os8.arch(),
-            cpus: os8.cpus().length,
-            totalMem: os8.totalmem(),
-            freeMem: os8.freemem(),
-            loadavg: os8.loadavg(),
-            uptime: os8.uptime(),
-            hostname: os8.hostname()
+            platform: os9.platform(),
+            release: os9.release(),
+            arch: os9.arch(),
+            cpus: os9.cpus().length,
+            totalMem: os9.totalmem(),
+            freeMem: os9.freemem(),
+            loadavg: os9.loadavg(),
+            uptime: os9.uptime(),
+            hostname: os9.hostname()
           }
         };
         const { timestamp: _ts, system: _sys, ...hashTarget } = payload;
@@ -5530,7 +6808,7 @@ var init_adhdev_daemon = __esm({
         }
         const p2pConnected = (this.p2p?.connectedPeerCount || 0) > 0;
         this.statusReportCount = (this.statusReportCount || 0) + 1;
-        const forceFullSync = this.statusReportCount % 4 === 0;
+        const forceFullSync = this.statusReportCount % 12 === 0;
         if (p2pConnected && this.lastStatusSentFull && !forceFullSync) {
           this.bridge.sendMessage("status_heartbeat", {
             timestamp: now,
@@ -5611,17 +6889,41 @@ var init_adhdev_daemon = __esm({
         return this.cdpManagers.get(ideType.toLowerCase()) || null;
       }
       /** Agent stream polling 시작 (idempotent — 이미 시작됐으면 무시) */
+      _agentStreamCdpIdeType = null;
+      // agent가 연결된 IDE
       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 {
+          if (this._agentStreamCdpIdeType) {
+            const cdp2 = this.cdpManagers.get(this._agentStreamCdpIdeType);
+            if (cdp2?.isConnected) {
+              try {
+                await this.agentStreamManager.syncAgentSessions(cdp2);
+                const streams = await this.agentStreamManager.collectAgentStreams(cdp2);
+                this._cachedAgentStreamsMap.set(this._agentStreamCdpIdeType, streams);
+              } catch {
+              }
+              return;
+            }
+            this._agentStreamCdpIdeType = null;
+          }
+          if (!this.agentStreamManager.activeAgentType) {
+            for (const [ideType, cdp2] of this.cdpManagers) {
+              if (!cdp2.isConnected) continue;
+              try {
+                const discovered = await cdp2.discoverAgentWebviews();
+                if (discovered.length > 0) {
+                  this._agentStreamCdpIdeType = ideType;
+                  await this.agentStreamManager.switchActiveAgent(cdp2, discovered[0].agentType);
+                  console.log(`[AgentStream] Auto-activated: ${discovered[0].agentType} (${ideType})`);
+                  await this.agentStreamManager.syncAgentSessions(cdp2);
+                  const streams = await this.agentStreamManager.collectAgentStreams(cdp2);
+                  this._cachedAgentStreamsMap.set(ideType, streams);
+                  return;
+                }
+              } catch {
+              }
             }
           }
         }, 5e3);
@@ -5648,7 +6950,7 @@ var init_adhdev_daemon = __esm({
         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));
+            console.log(`[CDP:${ide}] ${msg}`);
           }, true);
           const connected = await manager.connect();
           if (connected) {
@@ -5691,27 +6993,27 @@ __export(cli_daemon_exports, {
   uninstallService: () => uninstallService
 });
 function getPidFile(workingDir, cliType) {
-  const absPath = path5.resolve(workingDir);
+  const absPath = path6.resolve(workingDir);
   const hash = crypto3.createHash("md5").update(absPath).digest("hex").slice(0, 8);
-  const dir = path5.join(os9.homedir(), ".adhdev");
-  if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
-  return path5.join(dir, `bridge-${cliType}-${hash}.pid`);
+  const dir = path6.join(os10.homedir(), ".adhdev");
+  if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+  return path6.join(dir, `bridge-${cliType}-${hash}.pid`);
 }
 function writePidFile(pid, workingDir, cliType) {
   const pidFile = getPidFile(workingDir, cliType);
-  fs6.writeFileSync(pidFile, String(pid), "utf-8");
+  fs5.writeFileSync(pidFile, String(pid), "utf-8");
 }
 function removePidFile(workingDir, cliType) {
   try {
-    fs6.unlinkSync(getPidFile(workingDir, cliType));
+    fs5.unlinkSync(getPidFile(workingDir, cliType));
   } catch {
   }
 }
 function isDaemonRunning2(workingDir = process.cwd(), cliType = "gemini-cli") {
   const pidFile = getPidFile(workingDir, cliType);
   try {
-    if (!fs6.existsSync(pidFile)) return false;
-    const pid = parseInt(fs6.readFileSync(pidFile, "utf-8").trim());
+    if (!fs5.existsSync(pidFile)) return false;
+    const pid = parseInt(fs5.readFileSync(pidFile, "utf-8").trim());
     process.kill(pid, 0);
     return true;
   } catch {
@@ -5722,8 +7024,8 @@ function isDaemonRunning2(workingDir = process.cwd(), cliType = "gemini-cli") {
 function stopDaemon2(workingDir = process.cwd(), cliType = "gemini-cli") {
   const pidFile = getPidFile(workingDir, cliType);
   try {
-    if (!fs6.existsSync(pidFile)) return false;
-    const pid = parseInt(fs6.readFileSync(pidFile, "utf-8").trim());
+    if (!fs5.existsSync(pidFile)) return false;
+    const pid = parseInt(fs5.readFileSync(pidFile, "utf-8").trim());
     process.kill(pid, "SIGTERM");
     removePidFile(workingDir, cliType);
     return true;
@@ -5733,40 +7035,40 @@ function stopDaemon2(workingDir = process.cwd(), cliType = "gemini-cli") {
   }
 }
 function getServiceLabel(workingDir, cliType) {
-  const absPath = path5.resolve(workingDir);
+  const absPath = path6.resolve(workingDir);
   const hash = crypto3.createHash("md5").update(absPath).digest("hex").slice(0, 8);
   return `dev.adhf.cli-bridge.${cliType}.${hash}`;
 }
 function getLogFile(workingDir, cliType, isErr = false) {
-  const absPath = path5.resolve(workingDir);
+  const absPath = path6.resolve(workingDir);
   const hash = crypto3.createHash("md5").update(absPath).digest("hex").slice(0, 8);
-  if (!fs6.existsSync(LOG_DIR)) fs6.mkdirSync(LOG_DIR, { recursive: true });
-  return path5.join(LOG_DIR, `bridge-${cliType}-${hash}${isErr ? ".err" : ""}.log`);
+  if (!fs5.existsSync(LOG_DIR2)) fs5.mkdirSync(LOG_DIR2, { recursive: true });
+  return path6.join(LOG_DIR2, `bridge-${cliType}-${hash}${isErr ? ".err" : ""}.log`);
 }
 function getServicePaths(label) {
-  const platform9 = os9.platform();
+  const platform9 = os10.platform();
   if (platform9 === "darwin") {
     return {
-      plist: path5.join(os9.homedir(), "Library", "LaunchAgents", `${label}.plist`)
+      plist: path6.join(os10.homedir(), "Library", "LaunchAgents", `${label}.plist`)
     };
   } else if (platform9 === "linux") {
     return {
-      systemd: path5.join(os9.homedir(), ".config", "systemd", "user", `${label}.service`)
+      systemd: path6.join(os10.homedir(), ".config", "systemd", "user", `${label}.service`)
     };
   } else if (platform9 === "win32") {
     return {
-      startup: path5.join(os9.homedir(), "AppData", "Roaming", "Microsoft", "Windows", "Start Menu", "Programs", "Startup", `${label}.vbs`)
+      startup: path6.join(os10.homedir(), "AppData", "Roaming", "Microsoft", "Windows", "Start Menu", "Programs", "Startup", `${label}.vbs`)
     };
   }
   return {};
 }
 function installService(options = {}) {
-  const platform9 = os9.platform();
+  const platform9 = os10.platform();
   const cliType = options.cliType || "gemini-cli";
-  const workingDir = options.workingDir || os9.homedir();
+  const workingDir = options.workingDir || os10.homedir();
   const adhdevBin = process.argv[1];
   const nodeBin = process.execPath;
-  if (!fs6.existsSync(LOG_DIR)) fs6.mkdirSync(LOG_DIR, { recursive: true });
+  if (!fs5.existsSync(LOG_DIR2)) fs5.mkdirSync(LOG_DIR2, { recursive: true });
   const label = getServiceLabel(workingDir, cliType);
   const logFile2 = getLogFile(workingDir, cliType);
   const errLogFile = getLogFile(workingDir, cliType, true);
@@ -5821,17 +7123,17 @@ function installMacService(nodeBin, adhdevBin, cliType, workingDir, label, logFi
         <key>PATH</key>
         <string>${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}</string>
         <key>HOME</key>
-        <string>${os9.homedir()}</string>
+        <string>${os10.homedir()}</string>
     </dict>
 </dict>
 </plist>`;
-  const agentsDir = path5.dirname(plistPath);
-  if (!fs6.existsSync(agentsDir)) fs6.mkdirSync(agentsDir, { recursive: true });
+  const agentsDir = path6.dirname(plistPath);
+  if (!fs5.existsSync(agentsDir)) fs5.mkdirSync(agentsDir, { recursive: true });
   try {
     execSync8(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "pipe" });
   } catch {
   }
-  fs6.writeFileSync(plistPath, plistContent, "utf-8");
+  fs5.writeFileSync(plistPath, plistContent, "utf-8");
   try {
     execSync8(`launchctl load "${plistPath}"`, { stdio: "pipe" });
   } catch (e) {
@@ -5857,14 +7159,14 @@ RestartSec=10
 StandardOutput=append:${logFile2}
 StandardError=append:${errLogFile}
 Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
-Environment=HOME=${os9.homedir()}
+Environment=HOME=${os10.homedir()}
 
 [Install]
 WantedBy=default.target
 `;
-  const serviceDir = path5.dirname(servicePath);
-  if (!fs6.existsSync(serviceDir)) fs6.mkdirSync(serviceDir, { recursive: true });
-  fs6.writeFileSync(servicePath, serviceContent, "utf-8");
+  const serviceDir = path6.dirname(servicePath);
+  if (!fs5.existsSync(serviceDir)) fs5.mkdirSync(serviceDir, { recursive: true });
+  fs5.writeFileSync(servicePath, serviceContent, "utf-8");
   try {
     execSync8("systemctl --user daemon-reload", { stdio: "pipe" });
     execSync8(`systemctl --user enable ${label}.service`, { stdio: "pipe" });
@@ -5881,9 +7183,9 @@ function installWindowsService(nodeBin, adhdevBin, cliType, workingDir, label) {
   const vbsContent = `Set WshShell = CreateObject("WScript.Shell")
 WshShell.Run """${nodeBin}"" ""${adhdevBin}"" bridge --foreground --cli ${cliType} --dir ""${workingDir}""", 0, False
 `;
-  const startupDir = path5.dirname(startupPath);
-  if (!fs6.existsSync(startupDir)) fs6.mkdirSync(startupDir, { recursive: true });
-  fs6.writeFileSync(startupPath, vbsContent, "utf-8");
+  const startupDir = path6.dirname(startupPath);
+  if (!fs5.existsSync(startupDir)) fs5.mkdirSync(startupDir, { recursive: true });
+  fs5.writeFileSync(startupPath, vbsContent, "utf-8");
   try {
     const { execSync: execSync8 } = require("child_process");
     execSync8(`wscript "${startupPath}"`, { stdio: "pipe" });
@@ -5892,9 +7194,9 @@ WshShell.Run """${nodeBin}"" ""${adhdevBin}"" bridge --foreground --cli ${cliTyp
   return true;
 }
 function uninstallService(options = {}) {
-  const platform9 = os9.platform();
+  const platform9 = os10.platform();
   const cliType = options.cliType || "gemini-cli";
-  const workingDir = options.workingDir || os9.homedir();
+  const workingDir = options.workingDir || os10.homedir();
   const label = getServiceLabel(workingDir, cliType);
   const paths = getServicePaths(label);
   const { execSync: execSync8 } = require("child_process");
@@ -5904,7 +7206,7 @@ function uninstallService(options = {}) {
     } catch {
     }
     try {
-      if (fs6.existsSync(paths.plist)) fs6.unlinkSync(paths.plist);
+      if (fs5.existsSync(paths.plist)) fs5.unlinkSync(paths.plist);
     } catch {
     }
   } else if (platform9 === "linux" && paths.systemd) {
@@ -5914,7 +7216,7 @@ function uninstallService(options = {}) {
     } catch {
     }
     try {
-      if (fs6.existsSync(paths.systemd)) fs6.unlinkSync(paths.systemd);
+      if (fs5.existsSync(paths.systemd)) fs5.unlinkSync(paths.systemd);
     } catch {
     }
     try {
@@ -5923,25 +7225,25 @@ function uninstallService(options = {}) {
     }
   } else if (platform9 === "win32" && paths.startup) {
     try {
-      if (fs6.existsSync(paths.startup)) fs6.unlinkSync(paths.startup);
+      if (fs5.existsSync(paths.startup)) fs5.unlinkSync(paths.startup);
     } catch {
     }
   }
   removePidFile(workingDir, cliType);
   return true;
 }
-function isServiceInstalled(workingDir = os9.homedir(), cliType = "gemini-cli") {
+function isServiceInstalled(workingDir = os10.homedir(), cliType = "gemini-cli") {
   const label = getServiceLabel(workingDir, cliType);
   const paths = getServicePaths(label);
-  if (paths.plist) return fs6.existsSync(paths.plist);
-  if (paths.systemd) return fs6.existsSync(paths.systemd);
-  if (paths.startup) return fs6.existsSync(paths.startup);
+  if (paths.plist) return fs5.existsSync(paths.plist);
+  if (paths.systemd) return fs5.existsSync(paths.systemd);
+  if (paths.startup) return fs5.existsSync(paths.startup);
   return false;
 }
-function getLogPath(workingDir = os9.homedir(), cliType = "gemini-cli") {
+function getLogPath(workingDir = os10.homedir(), cliType = "gemini-cli") {
   return getLogFile(workingDir, cliType);
 }
-var os9, fs6, path5, crypto3, import_chalk3, DANGEROUS_PATTERNS2, CliDaemon, LOG_DIR;
+var os10, fs5, path6, crypto3, import_chalk3, DANGEROUS_PATTERNS2, CliDaemon, LOG_DIR2;
 var init_cli_daemon = __esm({
   "src/cli-daemon.ts"() {
     "use strict";
@@ -5951,9 +7253,9 @@ var init_cli_daemon = __esm({
     init_codex_cli();
     init_cli_detector();
     init_config();
-    os9 = __toESM(require("os"));
-    fs6 = __toESM(require("fs"));
-    path5 = __toESM(require("path"));
+    os10 = __toESM(require("os"));
+    fs5 = __toESM(require("fs"));
+    path6 = __toESM(require("path"));
     crypto3 = __toESM(require("crypto"));
     import_chalk3 = __toESM(require("chalk"));
     init_detector();
@@ -6022,8 +7324,8 @@ var init_cli_daemon = __esm({
         this.adapter.setOnStatusChange(() => {
           this.sendStatusReport();
         });
-        const machineId = os9.hostname().replace(/[^a-zA-Z0-9]/g, "_");
-        const dirHash = crypto3.createHash("md5").update(path5.resolve(workingDir)).digest("hex").slice(0, 4);
+        const machineId = os10.hostname().replace(/[^a-zA-Z0-9]/g, "_");
+        const dirHash = crypto3.createHash("md5").update(path6.resolve(workingDir)).digest("hex").slice(0, 4);
         const instanceId = `${cliType}_${machineId}_${dirHash}`;
         this.bridge = new CliBridgeConnection({
           serverUrl: options.serverUrl || config.serverUrl,
@@ -6031,7 +7333,7 @@ var init_cli_daemon = __esm({
           cliInfo: {
             type: cliType,
             version: cliInfo.version || "unknown",
-            platform: os9.platform(),
+            platform: os10.platform(),
             instanceId
           }
         });
@@ -6102,11 +7404,11 @@ var init_cli_daemon = __esm({
               }
               case "list_files": {
                 const targetDir = args?.dir || this.adapter?.workingDir || process.cwd();
-                const entries = fs6.readdirSync(targetDir).map((f) => {
+                const entries = fs5.readdirSync(targetDir).map((f) => {
                   try {
                     return {
                       name: f,
-                      isDirectory: fs6.statSync(path5.join(targetDir, f)).isDirectory()
+                      isDirectory: fs5.statSync(path6.join(targetDir, f)).isDirectory()
                     };
                   } catch {
                     return null;
@@ -6218,14 +7520,14 @@ var init_cli_daemon = __esm({
           this.sendStatusReport();
         });
         if (this.bridge) {
-          const machineId = os9.hostname().replace(/[^a-zA-Z0-9]/g, "_");
-          const dirHash = crypto3.createHash("md5").update(path5.resolve(workingDir)).digest("hex").slice(0, 4);
+          const machineId = os10.hostname().replace(/[^a-zA-Z0-9]/g, "_");
+          const dirHash = crypto3.createHash("md5").update(path6.resolve(workingDir)).digest("hex").slice(0, 4);
           const config2 = this.bridge.options;
           config2.cliInfo = {
             ...config2.cliInfo,
             type: cliType,
             version: cliInfo.version || "unknown",
-            platform: os9.platform(),
+            platform: os10.platform(),
             instanceId: `${cliType}_${machineId}_${dirHash}`
           };
         }
@@ -6292,13 +7594,13 @@ var init_cli_daemon = __esm({
         const payload = {
           activeFile: null,
           workspaceFolders: [{
-            name: path5.basename(adapterStatus.workingDir),
+            name: path6.basename(adapterStatus.workingDir),
             path: adapterStatus.workingDir
           }],
           currentConfig: {
             cli: this.bridge?.getCliInfo()?.type || "unknown",
             dir: adapterStatus.workingDir,
-            homeDir: os9.homedir()
+            homeDir: os10.homedir()
           },
           terminals: 1,
           aiAgents: [{
@@ -6317,19 +7619,19 @@ var init_cli_daemon = __esm({
             currentConfig: {
               cli: this.bridge?.getCliInfo()?.type || "unknown",
               dir: adapterStatus.workingDir,
-              homeDir: os9.homedir()
+              homeDir: os10.homedir()
             }
           }],
           system: {
-            platform: os9.platform(),
-            release: os9.release(),
-            arch: os9.arch(),
-            cpus: os9.cpus().length,
-            totalMem: os9.totalmem(),
-            freeMem: os9.freemem(),
-            loadavg: os9.loadavg(),
-            uptime: os9.uptime(),
-            hostname: os9.hostname()
+            platform: os10.platform(),
+            release: os10.release(),
+            arch: os10.arch(),
+            cpus: os10.cpus().length,
+            totalMem: os10.totalmem(),
+            freeMem: os10.freemem(),
+            loadavg: os10.loadavg(),
+            uptime: os10.uptime(),
+            hostname: os10.hostname()
           },
           detectedIdes: this.detectedIdes,
           activeChat: {
@@ -6368,7 +7670,7 @@ var init_cli_daemon = __esm({
         process.exit(0);
       }
     };
-    LOG_DIR = path5.join(os9.homedir(), ".adhdev", "logs");
+    LOG_DIR2 = path6.join(os10.homedir(), ".adhdev", "logs");
   }
 });
 
@@ -6511,8 +7813,8 @@ async function installExtension(ide, extension) {
       const res = await fetch(extension.vsixUrl);
       if (res.ok) {
         const buffer = Buffer.from(await res.arrayBuffer());
-        const fs7 = await import("fs");
-        fs7.writeFileSync(vsixPath, buffer);
+        const fs6 = await import("fs");
+        fs6.writeFileSync(vsixPath, buffer);
         return new Promise((resolve3) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
           (0, import_child_process2.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
@@ -6925,18 +8227,18 @@ async function loginFlow() {
 async function injectTokenToIDE(ide, connectionToken) {
   if (!ide.cliCommand) return;
   try {
-    const os10 = await import("os");
-    const fs7 = await import("fs");
-    const path6 = await import("path");
-    const platform9 = os10.platform();
-    const home = os10.homedir();
+    const os11 = await import("os");
+    const fs6 = await import("fs");
+    const path7 = await import("path");
+    const platform9 = os11.platform();
+    const home = os11.homedir();
     const getSettingsPath = (appName2) => {
       if (platform9 === "darwin") {
-        return path6.join(home, "Library", "Application Support", appName2, "User", "settings.json");
+        return path7.join(home, "Library", "Application Support", appName2, "User", "settings.json");
       } else if (platform9 === "win32") {
-        return path6.join(process.env.APPDATA || path6.join(home, "AppData", "Roaming"), appName2, "User", "settings.json");
+        return path7.join(process.env.APPDATA || path7.join(home, "AppData", "Roaming"), appName2, "User", "settings.json");
       } else {
-        return path6.join(home, ".config", appName2, "User", "settings.json");
+        return path7.join(home, ".config", appName2, "User", "settings.json");
       }
     };
     const appNameMap = {
@@ -6951,18 +8253,18 @@ async function injectTokenToIDE(ide, connectionToken) {
     if (!appName) return;
     const settingsPath = getSettingsPath(appName);
     let settings = {};
-    if (fs7.existsSync(settingsPath)) {
+    if (fs6.existsSync(settingsPath)) {
       try {
-        settings = JSON.parse(fs7.readFileSync(settingsPath, "utf-8"));
+        settings = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
       } catch {
         settings = {};
       }
     } else {
-      fs7.mkdirSync(path6.dirname(settingsPath), { recursive: true });
+      fs6.mkdirSync(path7.dirname(settingsPath), { recursive: true });
     }
     settings["adhdev.connectionToken"] = connectionToken;
     settings["adhdev.autoConnect"] = true;
-    fs7.writeFileSync(settingsPath, JSON.stringify(settings, null, 4), "utf-8");
+    fs6.writeFileSync(settingsPath, JSON.stringify(settings, null, 4), "utf-8");
     console.log(import_chalk.default.green("  \u2713 Connection token saved to IDE settings"));
   } catch (e) {
     console.log(import_chalk.default.yellow(`  \u26A0 Could not inject token: ${e.message}`));
@@ -7284,6 +8586,322 @@ program.command("daemon:stop").description("Stop ADHDev Daemon").action(async ()
 `));
   }
 });
+async function sendDaemonCommand(cmd, args = {}, port = 19222) {
+  const WebSocket4 = (await import("ws")).default;
+  const { DAEMON_WS_PATH: DAEMON_WS_PATH2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  return new Promise((resolve3, reject) => {
+    const wsUrl = `ws://127.0.0.1:${port}${DAEMON_WS_PATH2 || "/daemon"}`;
+    const ws = new WebSocket4(wsUrl);
+    const timeout = setTimeout(() => {
+      ws.close();
+      reject(new Error("Timeout: no response from daemon after 15s"));
+    }, 15e3);
+    ws.on("open", () => {
+      ws.send(JSON.stringify({
+        type: "ext:register",
+        payload: {
+          ideType: "cli-debug",
+          ideVersion: "1.0.0",
+          extensionVersion: "1.0.0",
+          instanceId: `cli-debug-${Date.now()}`,
+          machineId: "cli"
+        }
+      }));
+      setTimeout(() => {
+        ws.send(JSON.stringify({
+          type: "ext:command",
+          payload: { command: cmd, args, messageId: `cli-${Date.now()}` }
+        }));
+      }, 200);
+    });
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "daemon:command_result" || msg.type === "command_result") {
+          clearTimeout(timeout);
+          ws.close();
+          resolve3(msg.payload?.result || msg.payload || msg);
+        }
+      } catch {
+      }
+    });
+    ws.on("error", (e) => {
+      clearTimeout(timeout);
+      reject(new Error(`Cannot connect to daemon at port ${port}: ${e.message}
+Is 'adhdev daemon' running?`));
+    });
+    ws.on("close", () => {
+      clearTimeout(timeout);
+    });
+  });
+}
+async function directCdpEval(expression, port = 9222) {
+  const http3 = await import("http");
+  const targets = await new Promise((resolve3, reject) => {
+    http3.get(`http://127.0.0.1:${port}/json`, (res) => {
+      let data = "";
+      res.on("data", (c) => data += c);
+      res.on("end", () => {
+        try {
+          resolve3(JSON.parse(data));
+        } catch {
+          reject(new Error("Invalid JSON"));
+        }
+      });
+    }).on("error", (e) => reject(new Error(`Cannot reach CDP at port ${port}: ${e.message}`)));
+  });
+  const isNonMain = (title) => !title || /extension-output|ADHDev CDP|Debug Console|Output\s*$|Launchpad/i.test(title);
+  const pages = targets.filter((t) => (t.type === "page" || t.type === "Page") && t.webSocketDebuggerUrl);
+  const mainPages = pages.filter((t) => !isNonMain(t.title || ""));
+  const target = (mainPages.length > 0 ? mainPages[0] : pages[0]) || targets[0];
+  if (!target?.webSocketDebuggerUrl) throw new Error("No CDP target found");
+  const WebSocket4 = (await import("ws")).default;
+  return new Promise((resolve3, reject) => {
+    const ws = new WebSocket4(target.webSocketDebuggerUrl);
+    const timeout = setTimeout(() => {
+      ws.close();
+      reject(new Error("CDP timeout"));
+    }, 15e3);
+    let id = 1;
+    ws.on("open", () => {
+      const stripped = expression.replace(/\/\*[\s\S]*?\*\//g, "").trimStart();
+      const isAsync = stripped.startsWith("(async");
+      ws.send(JSON.stringify({
+        id: id++,
+        method: "Runtime.evaluate",
+        params: { expression, returnByValue: true, awaitPromise: isAsync }
+      }));
+    });
+    ws.on("message", (data) => {
+      const msg = JSON.parse(data.toString());
+      if (msg.id) {
+        clearTimeout(timeout);
+        ws.close();
+        if (msg.result?.result?.value !== void 0) {
+          resolve3(msg.result.result.value);
+        } else if (msg.result?.exceptionDetails) {
+          reject(new Error(msg.result.exceptionDetails.text));
+        } else {
+          resolve3(msg.result);
+        }
+      }
+    });
+    ws.on("error", (e) => {
+      clearTimeout(timeout);
+      reject(new Error(`CDP connection failed: ${e.message}`));
+    });
+  });
+}
+var cdp = program.command("cdp").description("\u{1F50D} CDP debugging tools \u2014 analyze IDE DOM for script development");
+cdp.command("debug").description("Analyze IDE AI panel \u2014 find inputs, buttons, textareas, iframes").option("-p, --port <port>", "CDP port (direct mode)", "9222").option("-d, --daemon", "Use running daemon instead of direct CDP").option("--session <id>", "Agent webview session ID").option("-j, --json", "Output raw JSON").action(async (options) => {
+  try {
+    let result;
+    if (options.daemon) {
+      result = await sendDaemonCommand("cdp_dom_debug", { sessionId: options.session });
+    } else {
+      const expression = `(() => {
+                    const result = { url: location.href, title: document.title, viewport: { w: window.innerWidth, h: window.innerHeight }, inputs: [], textareas: [], editables: [], buttons: [], iframes: [], textboxes: [] };
+                    document.querySelectorAll('input[type="text"], input:not([type])').forEach((el, i) => { if (i >= 10) return; result.inputs.push({ id: el.id||null, class: (el.className||'').toString().slice(0,150), placeholder: el.getAttribute('placeholder')||null, visible: el.offsetParent!==null, rect: (() => { try { const r=el.getBoundingClientRect(); return {x:Math.round(r.x),y:Math.round(r.y),w:Math.round(r.width),h:Math.round(r.height)}; } catch{return null;} })() }); });
+                    document.querySelectorAll('textarea').forEach((el, i) => { if (i >= 10) return; result.textareas.push({ id: el.id||null, class: (el.className||'').toString().slice(0,150), placeholder: el.getAttribute('placeholder')||null, rows: el.rows, visible: el.offsetParent!==null }); });
+                    document.querySelectorAll('[contenteditable="true"]').forEach((el, i) => { if (i >= 10) return; result.editables.push({ tag: el.tagName?.toLowerCase(), id: el.id||null, class: (el.className||'').toString().slice(0,150), role: el.getAttribute('role')||null, text: (el.textContent||'').trim().slice(0,100), visible: el.offsetParent!==null }); });
+                    document.querySelectorAll('[role="textbox"]').forEach((el, i) => { if (i >= 10) return; result.textboxes.push({ tag: el.tagName?.toLowerCase(), id: el.id||null, class: (el.className||'').toString().slice(0,150), text: (el.textContent||'').trim().slice(0,100), visible: el.offsetParent!==null }); });
+                    const btnKw = /send|submit|accept|reject|approve|deny|cancel|confirm|run|execute|apply/i;
+                    document.querySelectorAll('button, [role="button"]').forEach((el, i) => { const text=(el.textContent||el.getAttribute('aria-label')||'').trim(); if(i<30&&(text.length<30||btnKw.test(text))) result.buttons.push({ tag: el.tagName?.toLowerCase(), text: text.slice(0,80), disabled: el.disabled||el.getAttribute('disabled')!==null, visible: el.offsetParent!==null }); });
+                    document.querySelectorAll('iframe, webview').forEach((el, i) => { if (i >= 20) return; result.iframes.push({ tag: el.tagName?.toLowerCase(), src: el.getAttribute('src')?.slice(0,200)||null, title: el.getAttribute('title')||null }); });
+                    return JSON.stringify(result);
+                })()`;
+      const raw = await directCdpEval(expression, parseInt(options.port));
+      result = typeof raw === "string" ? JSON.parse(raw) : raw;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(import_chalk4.default.bold("\n\u{1F50D} CDP DOM Debug\n"));
+    console.log(`  ${import_chalk4.default.bold("URL:")}      ${result.url || "N/A"}`);
+    console.log(`  ${import_chalk4.default.bold("Title:")}    ${result.title || "N/A"}`);
+    if (result.viewport) console.log(`  ${import_chalk4.default.bold("Viewport:")} ${result.viewport.w}\xD7${result.viewport.h}`);
+    const sections = [
+      { key: "inputs", label: "\u{1F4DD} Inputs", fields: ["id", "placeholder", "class"] },
+      { key: "textareas", label: "\u{1F4DD} Textareas", fields: ["id", "placeholder", "rows"] },
+      { key: "editables", label: "\u270F\uFE0F  ContentEditable", fields: ["tag", "role", "class", "text"] },
+      { key: "textboxes", label: '\u{1F4E6} role="textbox"', fields: ["tag", "class", "text"] },
+      { key: "buttons", label: "\u{1F518} Buttons", fields: ["text", "disabled"] },
+      { key: "iframes", label: "\u{1F5BC}  Iframes/Webviews", fields: ["tag", "src", "title"] }
+    ];
+    for (const { key, label, fields } of sections) {
+      const items = result[key] || [];
+      if (items.length === 0) continue;
+      console.log(`
+  ${import_chalk4.default.bold(label)} (${items.length})`);
+      for (const item of items) {
+        const vis = item.visible === false ? import_chalk4.default.red(" [hidden]") : "";
+        const parts = fields.map((f) => item[f] ? `${f}=${import_chalk4.default.cyan(String(item[f]).slice(0, 60))}` : null).filter(Boolean);
+        console.log(`    ${import_chalk4.default.gray("\u2022")} ${parts.join(" ")}${vis}`);
+      }
+    }
+    console.log();
+  } catch (e) {
+    console.error(import_chalk4.default.red(`
+\u2717 ${e.message}
+`));
+    process.exit(1);
+  }
+});
+cdp.command("dump [selector]").description("Dump DOM tree (default: body)").option("-p, --port <port>", "CDP port (direct mode)", "9222").option("-d, --daemon", "Use running daemon").option("-f, --format <fmt>", "Format: html, tree, summary", "tree").option("--depth <n>", "Max depth", "6").option("--session <id>", "Agent webview session ID").option("-o, --output <file>", "Save to file").action(async (selector, options) => {
+  try {
+    const sel = selector || "body";
+    const depth = parseInt(options.depth) || 6;
+    let result;
+    if (options.daemon) {
+      const resp = await sendDaemonCommand("cdp_dom_dump", {
+        selector: sel,
+        format: options.format,
+        depth,
+        sessionId: options.session
+      });
+      result = resp?.result || resp;
+    } else {
+      let expr;
+      if (options.format === "tree") {
+        expr = `(() => { const root = document.querySelector('${sel.replace(/'/g, "\\'")}'); if (!root) return 'Not found: ${sel}'; function tree(el, indent, d, maxD) { if (d > maxD) return indent + '...\\n'; let line = indent + '<' + (el.tagName?.toLowerCase()||'?'); if (el.id) line += ' #' + el.id; if (el.className && typeof el.className === 'string') { const cls = el.className.trim().split(' ').filter(c=>c).slice(0,3).join('.'); if(cls) line += ' .' + cls; } const role = el.getAttribute?.('role'); if(role) line += ' [role=' + role + ']'; line += '> (' + (el.children?.length||0) + ')\\n'; let r = line; if (el.children?.length > 0 && d < maxD) { for (let i = 0; i < Math.min(el.children.length, 30); i++) { r += tree(el.children[i], indent + '  ', d+1, maxD); } if (el.children.length > 30) r += indent + '  ... +' + (el.children.length-30) + ' more\\n'; } return r; } return tree(root, '', 0, ${depth}); })()`;
+      } else if (options.format === "summary") {
+        expr = `(() => { const root = document.querySelector('${sel.replace(/'/g, "\\'")}'); if (!root) return JSON.stringify({error:'Not found'}); function s(el, d, maxD) { if (d > maxD) return {tag:'...',note:'max depth'}; const n = {tag:el.tagName?.toLowerCase(),id:el.id||undefined,class:el.className&&typeof el.className==='string'?el.className.split(' ').filter(c=>c).slice(0,5).join(' '):undefined,role:el.getAttribute?.('role')||undefined,childCount:el.children?.length||0}; if (el.children?.length > 0 && d < maxD) { n.children = Array.from(el.children).slice(0,30).map(c=>s(c,d+1,maxD)); } return n; } return JSON.stringify(s(root,0,${depth})); })()`;
+      } else {
+        expr = `(() => { const root = document.querySelector('${sel.replace(/'/g, "\\'")}'); if (!root) return 'Not found: ${sel}'; let html = root.outerHTML; if (html.length > 200000) html = html.slice(0, 200000) + '\\n<!-- TRUNCATED -->'; return html; })()`;
+      }
+      result = await directCdpEval(expr, parseInt(options.port));
+      if (options.format === "summary" && typeof result === "string") {
+        try {
+          result = JSON.parse(result);
+        } catch {
+        }
+      }
+    }
+    const output = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+    if (options.output) {
+      const fs6 = await import("fs");
+      fs6.writeFileSync(options.output, output, "utf-8");
+      console.log(import_chalk4.default.green(`
+  \u2713 Saved to ${options.output} (${output.length} chars)
+`));
+    } else {
+      console.log(output);
+    }
+  } catch (e) {
+    console.error(import_chalk4.default.red(`
+\u2717 ${e.message}
+`));
+    process.exit(1);
+  }
+});
+cdp.command("query <selector>").description("Test a CSS selector \u2014 count matches, show elements").option("-p, --port <port>", "CDP port (direct mode)", "9222").option("-d, --daemon", "Use running daemon").option("-l, --limit <n>", "Max results", "10").option("--session <id>", "Agent webview session ID").option("-j, --json", "Output raw JSON").action(async (selector, options) => {
+  try {
+    const limit = parseInt(options.limit) || 10;
+    let result;
+    if (options.daemon) {
+      result = await sendDaemonCommand("cdp_dom_query", {
+        selector,
+        limit,
+        sessionId: options.session
+      });
+    } else {
+      const expr = `(() => { try { const els = document.querySelectorAll('${selector.replace(/'/g, "\\'")}'); const results = []; for (let i = 0; i < Math.min(els.length, ${limit}); i++) { const el = els[i]; results.push({ index: i, tag: el.tagName?.toLowerCase(), id: el.id||null, class: el.className&&typeof el.className==='string'?el.className.trim().slice(0,200):null, role: el.getAttribute?.('role')||null, text: (el.textContent||'').trim().slice(0,100), visible: el.offsetParent!==null||el.offsetWidth>0, rect: (()=>{try{const r=el.getBoundingClientRect();return{x:Math.round(r.x),y:Math.round(r.y),w:Math.round(r.width),h:Math.round(r.height)};}catch{return null;}})() }); } return JSON.stringify({ total: els.length, results }); } catch(e) { return JSON.stringify({ error: e.message }); } })()`;
+      const raw = await directCdpEval(expr, parseInt(options.port));
+      result = typeof raw === "string" ? JSON.parse(raw) : raw;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    const total = result.total || 0;
+    console.log(import_chalk4.default.bold(`
+\u{1F50D} Selector: ${import_chalk4.default.cyan(selector)}`));
+    console.log(`   Matches: ${total === 0 ? import_chalk4.default.red("0") : import_chalk4.default.green(total)}
+`);
+    for (const item of result.results || []) {
+      const vis = item.visible === false ? import_chalk4.default.red(" [hidden]") : import_chalk4.default.green(" [visible]");
+      const rect = item.rect ? import_chalk4.default.gray(` ${item.rect.x},${item.rect.y} ${item.rect.w}\xD7${item.rect.h}`) : "";
+      console.log(`  ${import_chalk4.default.yellow(`[${item.index}]`)} <${import_chalk4.default.bold(item.tag)}>${vis}${rect}`);
+      if (item.id) console.log(`       id: ${import_chalk4.default.cyan(item.id)}`);
+      if (item.class) console.log(`       class: ${import_chalk4.default.gray(item.class.slice(0, 80))}`);
+      if (item.text) console.log(`       text: "${import_chalk4.default.white(item.text.slice(0, 80))}"`);
+      if (item.role) console.log(`       role: ${import_chalk4.default.magenta(item.role)}`);
+    }
+    console.log();
+  } catch (e) {
+    console.error(import_chalk4.default.red(`
+\u2717 ${e.message}
+`));
+    process.exit(1);
+  }
+});
+cdp.command("eval <expression>").description("Execute JavaScript expression via CDP").option("-p, --port <port>", "CDP port", "9222").option("-d, --daemon", "Use running daemon").action(async (expression, options) => {
+  try {
+    let result;
+    if (options.daemon) {
+      const resp = await sendDaemonCommand("cdp_eval", { expression });
+      result = resp?.result !== void 0 ? resp.result : resp;
+    } else {
+      result = await directCdpEval(expression, parseInt(options.port));
+    }
+    const output = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+    console.log(output);
+  } catch (e) {
+    console.error(import_chalk4.default.red(`
+\u2717 ${e.message}
+`));
+    process.exit(1);
+  }
+});
+cdp.command("screenshot").description("Capture IDE screenshot").option("-p, --port <port>", "CDP port", "9222").option("-o, --output <file>", "Output file path", "/tmp/cdp_screenshot.jpg").action(async (options) => {
+  try {
+    const http3 = await import("http");
+    const targets = await new Promise((resolve3, reject) => {
+      http3.get(`http://127.0.0.1:${options.port}/json`, (res) => {
+        let data = "";
+        res.on("data", (c) => data += c);
+        res.on("end", () => {
+          try {
+            resolve3(JSON.parse(data));
+          } catch {
+            reject(new Error("Invalid JSON"));
+          }
+        });
+      }).on("error", (e) => reject(e));
+    });
+    const isNonMain = (title) => !title || /extension-output|ADHDev CDP|Debug Console|Output\s*$|Launchpad/i.test(title);
+    const pages = targets.filter((t) => (t.type === "page" || t.type === "Page") && t.webSocketDebuggerUrl);
+    const mainPages = pages.filter((t) => !isNonMain(t.title || ""));
+    const target = (mainPages.length > 0 ? mainPages[0] : pages[0]) || targets[0];
+    if (!target?.webSocketDebuggerUrl) throw new Error("No CDP target");
+    const WebSocket4 = (await import("ws")).default;
+    const ws = new WebSocket4(target.webSocketDebuggerUrl);
+    await new Promise((resolve3, reject) => {
+      ws.on("open", () => {
+        ws.send(JSON.stringify({ id: 1, method: "Page.captureScreenshot", params: { format: "jpeg", quality: 50 } }));
+      });
+      ws.on("message", async (data) => {
+        const msg = JSON.parse(data.toString());
+        if (msg.id === 1 && msg.result?.data) {
+          const fs6 = await import("fs");
+          fs6.writeFileSync(options.output, Buffer.from(msg.result.data, "base64"));
+          console.log(import_chalk4.default.green(`
+  \u2713 Screenshot saved to ${options.output}
+`));
+          ws.close();
+          resolve3();
+        }
+      });
+      ws.on("error", (e) => reject(e));
+    });
+  } catch (e) {
+    console.error(import_chalk4.default.red(`
+\u2717 ${e.message}
+`));
+    process.exit(1);
+  }
+});
 program.command("bridge").description('[Legacy] Start CLI bridge (use "adhdev daemon" instead)').option("--foreground", "Run in foreground mode").option("-d, --dir <path>", "Working directory for CLI sessions", process.cwd()).option("--cli <type>", "CLI type to use", "gemini-cli").option("--server <url>", "Override server URL for testing").action(async (options) => {
   console.log(import_chalk4.default.yellow('  \u26A0 "adhdev bridge" is deprecated. Use "adhdev daemon --cli <type>" instead.\n'));
   const { CliDaemon: CliDaemon2 } = await Promise.resolve().then(() => (init_cli_daemon(), cli_daemon_exports));
@@ -7348,8 +8966,8 @@ program.command("bridge:logs").description("[Legacy] Show CLI bridge service log
   const logPath = getLogPath2();
   const { execSync: execSync8, spawn: spawnProc } = await import("child_process");
   try {
-    const fs7 = await import("fs");
-    if (!fs7.existsSync(logPath)) {
+    const fs6 = await import("fs");
+    if (!fs6.existsSync(logPath)) {
       console.log(import_chalk4.default.gray("\n  No logs yet. Start the bridge first.\n"));
       return;
     }