@adhdev/daemon-core 0.8.27 → 0.8.29

package/dist/index.js

@@ -251,13 +251,13 @@ function getDaemonLogDir() {
   return LOG_DIR;
 }
 function getCurrentDaemonLogPath(date = /* @__PURE__ */ new Date()) {
-  return path4.join(LOG_DIR, `daemon-${date.toISOString().slice(0, 10)}.log`);
+  return path6.join(LOG_DIR, `daemon-${date.toISOString().slice(0, 10)}.log`);
 }
 function checkDateRotation() {
   const today = getDateStr();
   if (today !== currentDate) {
     currentDate = today;
-    currentLogFile = path4.join(LOG_DIR, `daemon-${currentDate}.log`);
+    currentLogFile = path6.join(LOG_DIR, `daemon-${currentDate}.log`);
     cleanOldLogs();
   }
 }
@@ -271,7 +271,7 @@ function cleanOldLogs() {
       const dateMatch = file.match(/daemon-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs2.unlinkSync(path4.join(LOG_DIR, file));
+          fs2.unlinkSync(path6.join(LOG_DIR, file));
         } catch {
         }
       }
@@ -388,17 +388,17 @@ function installGlobalInterceptor() {
   writeToFile(`Log file: ${currentLogFile}`);
   writeToFile(`Log level: ${currentLevel}`);
 }
-var fs2, path4, os4, LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH;
+var fs2, path6, os4, LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH;
 var init_logger = __esm({
   "src/logging/logger.ts"() {
     "use strict";
     fs2 = __toESM(require("fs"));
-    path4 = __toESM(require("path"));
+    path6 = __toESM(require("path"));
     os4 = __toESM(require("os"));
     LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
     LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
     currentLevel = "info";
-    LOG_DIR = process.platform === "win32" ? path4.join(process.env.LOCALAPPDATA || process.env.APPDATA || path4.join(os4.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path4.join(os4.homedir(), "Library", "Logs", "adhdev") : path4.join(os4.homedir(), ".local", "share", "adhdev", "logs");
+    LOG_DIR = process.platform === "win32" ? path6.join(process.env.LOCALAPPDATA || process.env.APPDATA || path6.join(os4.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path6.join(os4.homedir(), "Library", "Logs", "adhdev") : path6.join(os4.homedir(), ".local", "share", "adhdev", "logs");
     MAX_LOG_SIZE = 5 * 1024 * 1024;
     MAX_LOG_DAYS = 7;
     try {
@@ -406,16 +406,16 @@ var init_logger = __esm({
     } catch {
     }
     currentDate = getDateStr();
-    currentLogFile = path4.join(LOG_DIR, `daemon-${currentDate}.log`);
+    currentLogFile = path6.join(LOG_DIR, `daemon-${currentDate}.log`);
     cleanOldLogs();
     try {
-      const oldLog = path4.join(LOG_DIR, "daemon.log");
+      const oldLog = path6.join(LOG_DIR, "daemon.log");
       if (fs2.existsSync(oldLog)) {
         const stat = fs2.statSync(oldLog);
         const oldDate = stat.mtime.toISOString().slice(0, 10);
-        fs2.renameSync(oldLog, path4.join(LOG_DIR, `daemon-${oldDate}.log`));
+        fs2.renameSync(oldLog, path6.join(LOG_DIR, `daemon-${oldDate}.log`));
       }
-      const oldLogBackup = path4.join(LOG_DIR, "daemon.log.old");
+      const oldLogBackup = path6.join(LOG_DIR, "daemon.log.old");
       if (fs2.existsSync(oldLogBackup)) {
         fs2.unlinkSync(oldLogBackup);
       }
@@ -447,7 +447,7 @@ var init_logger = __esm({
       }
     };
     interceptorInstalled = false;
-    LOG_PATH = path4.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+    LOG_PATH = path6.join(LOG_DIR, `daemon-${getDateStr()}.log`);
   }
 });
 
@@ -872,16 +872,22 @@ function computeTerminalQueryTail(buffer) {
   return "";
 }
 function findBinary(name) {
+  const trimmed = String(name || "").trim();
+  if (!trimmed) return trimmed;
+  const expanded = trimmed.startsWith("~") ? path9.join(os8.homedir(), trimmed.slice(1)) : trimmed;
+  if (path9.isAbsolute(expanded) || expanded.includes("/") || expanded.includes("\\")) {
+    return path9.isAbsolute(expanded) ? expanded : path9.resolve(expanded);
+  }
   const isWin = os8.platform() === "win32";
   try {
-    const cmd = isWin ? `where ${name}` : `which ${name}`;
+    const cmd = isWin ? `where ${trimmed}` : `which ${trimmed}`;
     return (0, import_child_process4.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n")[0].trim();
   } catch {
-    return isWin ? `${name}.cmd` : name;
+    return isWin ? `${trimmed}.cmd` : trimmed;
   }
 }
 function isScriptBinary(binaryPath) {
-  if (!path7.isAbsolute(binaryPath)) return false;
+  if (!path9.isAbsolute(binaryPath)) return false;
   try {
     const fs15 = require("fs");
     const resolved = fs15.realpathSync(binaryPath);
@@ -897,7 +903,7 @@ function isScriptBinary(binaryPath) {
   }
 }
 function looksLikeMachOOrElf(filePath) {
-  if (!path7.isAbsolute(filePath)) return false;
+  if (!path9.isAbsolute(filePath)) return false;
   try {
     const fs15 = require("fs");
     const resolved = fs15.realpathSync(filePath);
@@ -1021,12 +1027,12 @@ function normalizeCliProviderForRuntime(raw) {
     }
   };
 }
-var os8, path7, import_child_process4, buildCliSpawnEnv, ProviderCliAdapter;
+var os8, path9, import_child_process4, buildCliSpawnEnv, ProviderCliAdapter;
 var init_provider_cli_adapter = __esm({
   "src/cli-adapters/provider-cli-adapter.ts"() {
     "use strict";
     os8 = __toESM(require("os"));
-    path7 = __toESM(require("path"));
+    path9 = __toESM(require("path"));
     import_child_process4 = require("child_process");
     init_logger();
     init_terminal_screen();
@@ -1381,16 +1387,17 @@ var init_provider_cli_adapter = __esm({
       async spawn() {
         if (this.ptyProcess) return;
         const { spawn: spawnConfig } = this.provider;
-        const binaryPath = findBinary(spawnConfig.command);
+        const configuredCommand = typeof this.runtimeSettings.executablePath === "string" && this.runtimeSettings.executablePath.trim() ? this.runtimeSettings.executablePath.trim() : spawnConfig.command;
+        const binaryPath = findBinary(configuredCommand);
         const isWin = os8.platform() === "win32";
         const allArgs = [...spawnConfig.args, ...this.extraArgs];
         LOG.info("CLI", `[${this.cliType}] Spawning in ${this.workingDir}`);
         this.resetTraceSession();
         let shellCmd;
         let shellArgs;
-        const useShellUnix = !isWin && (!!spawnConfig.shell || !path7.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
+        const useShellUnix = !isWin && (!!spawnConfig.shell || !path9.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
         const isCmdShim = isWin && /\.(cmd|bat)$/i.test(binaryPath);
-        const useShellWin = !!spawnConfig.shell || isCmdShim || !path7.isAbsolute(binaryPath) || isScriptBinary(binaryPath);
+        const useShellWin = !!spawnConfig.shell || isCmdShim || !path9.isAbsolute(binaryPath) || isScriptBinary(binaryPath);
         const useShell = isWin ? useShellWin : useShellUnix;
         if (useShell) {
           if (!spawnConfig.shell && !isWin) {
@@ -1635,6 +1642,9 @@ var init_provider_cli_adapter = __esm({
       looksLikeVisibleIdlePrompt(screenText) {
         const text = String(screenText || "");
         if (!text.trim()) return false;
+        if (this.cliType === "codex-cli" && /(^|\n)\s*[❯›>]\s+(?:Find and fix a bug in @filename|Improve documentation in @filename|Use \/skills|Write tests for @filename|Explain this codebase|Summarize recent commits|Implement \{feature\}|Run \/review on my current changes)(?:\n|$)/im.test(text)) {
+          return true;
+        }
         return /(^|\n)\s*[❯›>]\s*(?:\n|$)/m.test(text) || /⏎\s+send/i.test(text) || /\?\s*for\s*shortcuts/i.test(text) || /Type your message(?:\s+or\s+@path\/to\/file)?/i.test(text) || /workspace\s*\(\/directory\)/i.test(text) || /for\s*shortcuts/i.test(text);
       }
       findLastMatchingLineIndex(lines, predicate) {
@@ -1764,7 +1774,7 @@ var init_provider_cli_adapter = __esm({
               `[${this.cliType}] Waiting for interactive prompt: hasPrompt=${hasPrompt} stableMs=${stableMs} recentOutputMs=${recentlyOutput} status=${status} startup=${startupLikelyActive} screen=${JSON.stringify(this.summarizeTraceText(screenText, 220)).slice(0, 260)}`
             );
           }
-          await new Promise((resolve9) => setTimeout(resolve9, 50));
+          await new Promise((resolve12) => setTimeout(resolve12, 50));
         }
         const finalScreenText = this.terminalScreen.getText() || "";
         LOG.warn(
@@ -2275,7 +2285,7 @@ ${data.message || ""}`.trim();
           const deadline = Date.now() + 1e4;
           while (this.startupParseGate && Date.now() < deadline) {
             this.resolveStartupState("send_wait");
-            await new Promise((resolve9) => setTimeout(resolve9, 50));
+            await new Promise((resolve12) => setTimeout(resolve12, 50));
           }
         }
         await this.waitForInteractivePrompt();
@@ -2500,17 +2510,17 @@ ${data.message || ""}`.trim();
         }
       }
       waitForStopped(timeoutMs) {
-        return new Promise((resolve9) => {
+        return new Promise((resolve12) => {
           const startedAt = Date.now();
           const timer = setInterval(() => {
             if (!this.ptyProcess || this.currentStatus === "stopped") {
               clearInterval(timer);
-              resolve9(true);
+              resolve12(true);
               return;
             }
             if (Date.now() - startedAt >= timeoutMs) {
               clearInterval(timer);
-              resolve9(false);
+              resolve12(false);
             }
           }, 100);
         });
@@ -3209,6 +3219,7 @@ function resetState() {
 var import_child_process = require("child_process");
 var import_fs3 = require("fs");
 var import_os2 = require("os");
+var path4 = __toESM(require("path"));
 var BUILTIN_IDE_DEFINITIONS = [];
 var registeredIDEs = /* @__PURE__ */ new Map();
 function registerIDEDefinition(def) {
@@ -3225,9 +3236,16 @@ function getMergedDefinitions() {
   return [...merged.values()];
 }
 function findCliCommand(command) {
+  const trimmed = String(command || "").trim();
+  if (!trimmed) return null;
+  if (path4.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
+    const candidate = trimmed.startsWith("~") ? path4.join((0, import_os2.homedir)(), trimmed.slice(1)) : trimmed;
+    const resolved = path4.isAbsolute(candidate) ? candidate : path4.resolve(candidate);
+    return (0, import_fs3.existsSync)(resolved) ? resolved : null;
+  }
   try {
     const result = (0, import_child_process.execSync)(
-      (0, import_os2.platform)() === "win32" ? `where ${command}` : `which ${command}`,
+      (0, import_os2.platform)() === "win32" ? `where ${trimmed}` : `which ${trimmed}`,
       { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
     return result.split("\n")[0] || null;
@@ -3250,23 +3268,23 @@ function getIdeVersion(cliCommand) {
 function checkPathExists(paths) {
   const home = (0, import_os2.homedir)();
   for (const p of paths) {
-    if (p.includes("*")) {
+    const normalized = p.startsWith("~") ? path4.join(home, p.slice(1)) : p;
+    if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
-      const resolved = p.replace("*", username);
+      const resolved = normalized.replace("*", username);
       if ((0, import_fs3.existsSync)(resolved)) return resolved;
     } else {
-      if ((0, import_fs3.existsSync)(p)) return p;
+      if ((0, import_fs3.existsSync)(normalized)) return normalized;
     }
   }
   return null;
 }
-async function detectIDEs() {
+async function detectIDEs(providerLoader) {
   const os18 = (0, import_os2.platform)();
   const results = [];
   for (const def of getMergedDefinitions()) {
-    const cliPath = findCliCommand(def.cli);
-    const appPath = checkPathExists(def.paths[os18] || []);
-    const installed = !!(cliPath || appPath);
+    const cliPath = findCliCommand(providerLoader?.getIdeCliCommand(def.id, def.cli) || def.cli);
+    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os18] || []) || []);
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os18 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
@@ -3289,6 +3307,7 @@ async function detectIDEs() {
         }
       }
     }
+    const installed = os18 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
     const version = resolvedCli ? getIdeVersion(resolvedCli) : null;
     results.push({
       id: def.id,
@@ -3307,48 +3326,77 @@ async function detectIDEs() {
 // src/detection/cli-detector.ts
 var import_child_process2 = require("child_process");
 var os2 = __toESM(require("os"));
+var path5 = __toESM(require("path"));
+var import_fs4 = require("fs");
 function parseVersion(raw) {
   const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
   return match ? match[1] : raw.split("\n")[0].slice(0, 100);
 }
+function shellQuote(value) {
+  if (/^[a-zA-Z0-9_./:@%+=,-]+$/.test(value)) return value;
+  return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+function expandHome(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("~")) return trimmed;
+  return path5.join(os2.homedir(), trimmed.slice(1));
+}
+function isExplicitCommandPath(command) {
+  const trimmed = command.trim();
+  return path5.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
+}
+function resolveCommandPath(command) {
+  const trimmed = command.trim();
+  if (!trimmed) return null;
+  if (isExplicitCommandPath(trimmed)) {
+    const expanded = expandHome(trimmed);
+    const candidate = path5.isAbsolute(expanded) ? expanded : path5.resolve(expanded);
+    return (0, import_fs4.existsSync)(candidate) ? candidate : null;
+  }
+  return null;
+}
 function execAsync(cmd, timeoutMs = 5e3) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve12) => {
     const child = (0, import_child_process2.exec)(cmd, { encoding: "utf-8", timeout: timeoutMs }, (err, stdout) => {
       if (err || !stdout?.trim()) {
-        resolve9(null);
+        resolve12(null);
       } else {
-        resolve9(stdout.trim());
+        resolve12(stdout.trim());
       }
     });
-    child.on("error", () => resolve9(null));
+    child.on("error", () => resolve12(null));
   });
 }
-async function detectCLIs(providerLoader) {
+async function detectCLIs(providerLoader, options) {
   const platform9 = os2.platform();
   const whichCmd = platform9 === "win32" ? "where" : "which";
+  const includeVersion = options?.includeVersion !== false;
   const cliList = providerLoader ? providerLoader.getCliDetectionList() : [];
   const results = await Promise.all(
     cliList.map(async (cli) => {
       try {
-        const pathResult = await execAsync(`${whichCmd} ${cli.command}`);
+        const explicitPath = resolveCommandPath(cli.command);
+        const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(cli.command)}`);
         if (!pathResult) return { ...cli, installed: false };
-        const firstPath = pathResult.split("\n")[0];
+        const firstPath = explicitPath || pathResult.split("\n")[0];
         let version;
-        try {
+        if (includeVersion) {
           const versionCommands = [
-            cli.versionCommand,
-            `${cli.command} --version`,
-            `${cli.command} -V`,
-            `${cli.command} -v`
+            `"${firstPath}" --version`,
+            `"${firstPath}" -V`,
+            `"${firstPath}" -v`,
+            cli.versionCommand
           ].filter((v) => !!v);
-          for (const versionCommand of versionCommands) {
-            const versionResult = await execAsync(versionCommand, 3e3);
-            if (versionResult) {
-              version = parseVersion(versionResult);
-              break;
+          try {
+            for (const versionCommand of versionCommands) {
+              const versionResult = await execAsync(versionCommand, 3e3);
+              if (versionResult) {
+                version = parseVersion(versionResult);
+                break;
+              }
             }
+          } catch {
           }
-        } catch {
         }
         return { ...cli, installed: true, version, path: firstPath };
       } catch {
@@ -3358,7 +3406,7 @@ async function detectCLIs(providerLoader) {
   );
   return results;
 }
-async function detectCLI(cliId, providerLoader) {
+async function detectCLI(cliId, providerLoader, options) {
   const resolvedId = providerLoader ? providerLoader.resolveAlias(cliId) : cliId;
   if (providerLoader) {
     const cliList = providerLoader.getCliDetectionList();
@@ -3367,25 +3415,28 @@ async function detectCLI(cliId, providerLoader) {
       const platform9 = os2.platform();
       const whichCmd = platform9 === "win32" ? "where" : "which";
       try {
-        const pathResult = await execAsync(`${whichCmd} ${target.command}`);
+        const explicitPath = resolveCommandPath(target.command);
+        const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(target.command)}`);
         if (!pathResult) return null;
-        const firstPath = pathResult.split("\n")[0];
+        const firstPath = explicitPath || pathResult.split("\n")[0];
         let version;
-        try {
+        if (options?.includeVersion !== false) {
           const versionCommands = [
-            target.versionCommand,
-            `${target.command} --version`,
-            `${target.command} -V`,
-            `${target.command} -v`
+            `"${firstPath}" --version`,
+            `"${firstPath}" -V`,
+            `"${firstPath}" -v`,
+            target.versionCommand
           ].filter((v) => !!v);
-          for (const versionCommand of versionCommands) {
-            const versionResult = await execAsync(versionCommand, 3e3);
-            if (versionResult) {
-              version = parseVersion(versionResult);
-              break;
+          try {
+            for (const versionCommand of versionCommands) {
+              const versionResult = await execAsync(versionCommand, 3e3);
+              if (versionResult) {
+                version = parseVersion(versionResult);
+                break;
+              }
             }
+          } catch {
           }
-        } catch {
         }
         return { ...target, installed: true, version, path: firstPath };
       } catch {
@@ -3393,7 +3444,7 @@ async function detectCLI(cliId, providerLoader) {
       }
     }
   }
-  const all = await detectCLIs(providerLoader);
+  const all = await detectCLIs(providerLoader, options);
   return all.find((c) => c.id === resolvedId && c.installed) || null;
 }
 
@@ -3520,7 +3571,7 @@ var DaemonCdpManager = class {
   * Returns multiple entries if multiple IDE windows are open on same port
   */
   static listAllTargets(port) {
-    return new Promise((resolve9) => {
+    return new Promise((resolve12) => {
       const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk.toString());
@@ -3536,16 +3587,16 @@ var DaemonCdpManager = class {
               (t) => !isNonMain(t.title || "") && t.url?.includes("workbench.html") && !t.url?.includes("agent")
             );
             const fallbackPages = pages.filter((t) => !isNonMain(t.title || ""));
-            resolve9(mainPages.length > 0 ? mainPages : fallbackPages);
+            resolve12(mainPages.length > 0 ? mainPages : fallbackPages);
           } catch {
-            resolve9([]);
+            resolve12([]);
           }
         });
       });
-      req.on("error", () => resolve9([]));
+      req.on("error", () => resolve12([]));
       req.setTimeout(2e3, () => {
         req.destroy();
-        resolve9([]);
+        resolve12([]);
       });
     });
   }
@@ -3585,7 +3636,7 @@ var DaemonCdpManager = class {
     }
   }
   findTargetOnPort(port) {
-    return new Promise((resolve9) => {
+    return new Promise((resolve12) => {
       const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk.toString());
@@ -3596,7 +3647,7 @@ var DaemonCdpManager = class {
               (t) => (t.type === "page" || t.type === "browser" || t.type === "Page") && t.webSocketDebuggerUrl
             );
             if (pages.length === 0) {
-              resolve9(targets.find((t) => t.webSocketDebuggerUrl) || null);
+              resolve12(targets.find((t) => t.webSocketDebuggerUrl) || null);
               return;
             }
             const mainPages = pages.filter((t) => !this.isNonMainTitle(t.title || ""));
@@ -3606,24 +3657,24 @@ var DaemonCdpManager = class {
               const specific = list.find((t) => t.id === this._targetId);
               if (specific) {
                 this._pageTitle = specific.title || "";
-                resolve9(specific);
+                resolve12(specific);
               } else {
                 this.log(`[CDP] Target ${this._targetId} not found in page list`);
-                resolve9(null);
+                resolve12(null);
               }
               return;
             }
             this._pageTitle = list[0]?.title || "";
-            resolve9(list[0]);
+            resolve12(list[0]);
           } catch {
-            resolve9(null);
+            resolve12(null);
           }
         });
       });
-      req.on("error", () => resolve9(null));
+      req.on("error", () => resolve12(null));
       req.setTimeout(2e3, () => {
         req.destroy();
-        resolve9(null);
+        resolve12(null);
       });
     });
   }
@@ -3634,7 +3685,7 @@ var DaemonCdpManager = class {
     this.extensionProviders = providers;
   }
   connectToTarget(wsUrl) {
-    return new Promise((resolve9) => {
+    return new Promise((resolve12) => {
       this.ws = new import_ws.default(wsUrl);
       this.ws.on("open", async () => {
         this._connected = true;
@@ -3644,17 +3695,17 @@ var DaemonCdpManager = class {
         }
         this.connectBrowserWs().catch(() => {
         });
-        resolve9(true);
+        resolve12(true);
       });
       this.ws.on("message", (data) => {
         try {
           const msg = JSON.parse(data.toString());
           if (msg.id && this.pending.has(msg.id)) {
-            const { resolve: resolve10, reject } = this.pending.get(msg.id);
+            const { resolve: resolve13, reject } = this.pending.get(msg.id);
             this.pending.delete(msg.id);
             this.failureCount = 0;
             if (msg.error) reject(new Error(msg.error.message));
-            else resolve10(msg.result);
+            else resolve13(msg.result);
           } else if (msg.method === "Runtime.executionContextCreated") {
             this.contexts.add(msg.params.context.id);
           } else if (msg.method === "Runtime.executionContextDestroyed") {
@@ -3677,7 +3728,7 @@ var DaemonCdpManager = class {
       this.ws.on("error", (err) => {
         this.log(`[CDP] WebSocket error: ${err.message}`);
         this._connected = false;
-        resolve9(false);
+        resolve12(false);
       });
     });
   }
@@ -3691,7 +3742,7 @@ var DaemonCdpManager = class {
         return;
       }
       this.log(`[CDP] Connecting browser WS for target discovery...`);
-      await new Promise((resolve9, reject) => {
+      await new Promise((resolve12, reject) => {
         this.browserWs = new import_ws.default(browserWsUrl);
         this.browserWs.on("open", async () => {
           this._browserConnected = true;
@@ -3701,16 +3752,16 @@ var DaemonCdpManager = class {
           } catch (e) {
             this.log(`[CDP] setDiscoverTargets failed: ${e.message}`);
           }
-          resolve9();
+          resolve12();
         });
         this.browserWs.on("message", (data) => {
           try {
             const msg = JSON.parse(data.toString());
             if (msg.id && this.browserPending.has(msg.id)) {
-              const { resolve: resolve10, reject: reject2 } = this.browserPending.get(msg.id);
+              const { resolve: resolve13, reject: reject2 } = this.browserPending.get(msg.id);
               this.browserPending.delete(msg.id);
               if (msg.error) reject2(new Error(msg.error.message));
-              else resolve10(msg.result);
+              else resolve13(msg.result);
             }
           } catch {
           }
@@ -3730,31 +3781,31 @@ var DaemonCdpManager = class {
     }
   }
   getBrowserWsUrl() {
-    return new Promise((resolve9) => {
+    return new Promise((resolve12) => {
       const req = http.get(`http://127.0.0.1:${this.port}/json/version`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk.toString());
         res.on("end", () => {
           try {
             const info = JSON.parse(data);
-            resolve9(info.webSocketDebuggerUrl || null);
+            resolve12(info.webSocketDebuggerUrl || null);
           } catch {
-            resolve9(null);
+            resolve12(null);
           }
         });
       });
-      req.on("error", () => resolve9(null));
+      req.on("error", () => resolve12(null));
       req.setTimeout(3e3, () => {
         req.destroy();
-        resolve9(null);
+        resolve12(null);
       });
     });
   }
   sendBrowser(method, params = {}, timeoutMs = 15e3) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve12, reject) => {
       if (!this.browserWs || !this._browserConnected) return reject(new Error("Browser WS not connected"));
       const id = this.browserMsgId++;
-      this.browserPending.set(id, { resolve: resolve9, reject });
+      this.browserPending.set(id, { resolve: resolve12, reject });
       this.browserWs.send(JSON.stringify({ id, method, params }));
       setTimeout(() => {
         if (this.browserPending.has(id)) {
@@ -3794,11 +3845,11 @@ var DaemonCdpManager = class {
   }
   // ─── CDP Protocol ────────────────────────────────────────
   sendInternal(method, params = {}, timeoutMs = 15e3) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve12, reject) => {
       if (!this.ws || !this._connected) return reject(new Error("CDP not connected"));
       if (this.ws.readyState !== import_ws.default.OPEN) return reject(new Error("WebSocket not open"));
       const id = this.msgId++;
-      this.pending.set(id, { resolve: resolve9, reject });
+      this.pending.set(id, { resolve: resolve12, reject });
       this.ws.send(JSON.stringify({ id, method, params }));
       setTimeout(() => {
         if (this.pending.has(id)) {
@@ -4047,7 +4098,7 @@ var DaemonCdpManager = class {
     const browserWs = this.browserWs;
     let msgId = this.browserMsgId;
     const sendWs = (method, params = {}, sessionId) => {
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve12, reject) => {
         const mid = msgId++;
         this.browserMsgId = msgId;
         const handler = (raw) => {
@@ -4056,7 +4107,7 @@ var DaemonCdpManager = class {
             if (msg.id === mid) {
               browserWs.removeListener("message", handler);
               if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
-              else resolve9(msg.result);
+              else resolve12(msg.result);
             }
           } catch {
           }
@@ -4247,14 +4298,14 @@ var DaemonCdpManager = class {
     if (!ws || ws.readyState !== import_ws.default.OPEN) {
       throw new Error("CDP not connected");
     }
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve12, reject) => {
       const id = getNextId();
       pendingMap.set(id, {
         resolve: (result) => {
           if (result?.result?.subtype === "error") {
             reject(new Error(result.result.description));
           } else {
-            resolve9(result?.result?.value);
+            resolve12(result?.result?.value);
           }
         },
         reject
@@ -4286,10 +4337,10 @@ var DaemonCdpManager = class {
       throw new Error("CDP not connected");
     }
     const sendViaSession = (method, params = {}) => {
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve12, reject) => {
         const pendingMap = this._browserConnected ? this.browserPending : this.pending;
         const id = this._browserConnected ? this.browserMsgId++ : this.msgId++;
-        pendingMap.set(id, { resolve: resolve9, reject });
+        pendingMap.set(id, { resolve: resolve12, reject });
         ws.send(JSON.stringify({ id, sessionId, method, params }));
         setTimeout(() => {
           if (pendingMap.has(id)) {
@@ -4917,15 +4968,76 @@ function normalizeControlValue(value) {
 
 // src/config/chat-history.ts
 var fs3 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var path7 = __toESM(require("path"));
 var os5 = __toESM(require("os"));
-var HISTORY_DIR = path5.join(os5.homedir(), ".adhdev", "history");
+var HISTORY_DIR = path7.join(os5.homedir(), ".adhdev", "history");
 var RETAIN_DAYS = 30;
+var CODEX_STARTER_PROMPT_RE = /^(?:[›❯]\s*)?(?:Find and fix a bug in @filename|Improve documentation in @filename|Write tests for @filename|Explain this codebase|Summarize recent commits|Implement \{feature\}|Use \/skills(?: to list available skills)?|Run \/review on my current changes)$/i;
+function normalizeHistoryComparable(text) {
+  return String(text || "").replace(/\s+/g, " ").trim();
+}
+function cleanupHistoryContent(agentType, role, content) {
+  let value = String(content || "").replace(/\r\n/g, "\n").trim();
+  if (!value) return "";
+  if (agentType === "codex-cli" && role === "assistant") {
+    const filtered = value.split("\n").filter((line) => !CODEX_STARTER_PROMPT_RE.test(line.trim())).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    value = filtered;
+  }
+  return value;
+}
+function buildHistoryMessageHash(agentType, message) {
+  if (message.historyDedupKey) return message.historyDedupKey;
+  const cleaned = cleanupHistoryContent(agentType, message.role, message.content);
+  return `${message.kind || "standard"}:${message.role}:${message.receivedAt || 0}:${normalizeHistoryComparable(cleaned)}`;
+}
+function buildHistoryMessageSignature(agentType, message) {
+  const cleaned = cleanupHistoryContent(agentType, message.role, message.content);
+  return `${message.kind || "standard"}:${message.role}:${normalizeHistoryComparable(cleaned)}`;
+}
+function isAdjacentHistoryDuplicate(agentType, previous, next) {
+  if (!previous || !next) return false;
+  return buildHistoryMessageSignature(agentType, previous) === buildHistoryMessageSignature(agentType, next);
+}
+function collapseReplayAssistantTurns(agentType, messages) {
+  if (agentType !== "codex-cli") return messages;
+  const collapsed = [];
+  let sawAssistantSinceLastUser = false;
+  for (const message of messages) {
+    if (message.role === "user") {
+      sawAssistantSinceLastUser = false;
+      collapsed.push(message);
+      continue;
+    }
+    if (message.role === "assistant") {
+      if (sawAssistantSinceLastUser) continue;
+      sawAssistantSinceLastUser = true;
+      collapsed.push(message);
+      continue;
+    }
+    collapsed.push(message);
+  }
+  return collapsed;
+}
+function sanitizeHistoryMessage(agentType, message) {
+  if (!message || message.role !== "user" && message.role !== "assistant" && message.role !== "system") {
+    return null;
+  }
+  const content = cleanupHistoryContent(agentType, message.role, message.content);
+  if (!content) return null;
+  return {
+    ...message,
+    content
+  };
+}
 var ChatHistoryWriter = class {
   /** Last seen message count per agent (deduplication) */
   lastSeenCounts = /* @__PURE__ */ new Map();
   /** Last seen message hash per agent (deduplication) */
   lastSeenHashes = /* @__PURE__ */ new Map();
+  /** Last appended normalized message signature per agent/session */
+  lastSeenSignatures = /* @__PURE__ */ new Map();
+  /** Last appended normalized non-system turn signature per agent/session */
+  lastSeenTurnSignatures = /* @__PURE__ */ new Map();
   rotated = false;
   /**
   * Append new messages to history
@@ -4947,14 +5059,36 @@ var ChatHistoryWriter = class {
       }
       const newMessages = [];
       for (const msg of messages) {
-        const hash = msg.historyDedupKey || `${msg.kind || "standard"}:${msg.role}:${(msg.content || "").slice(0, 50)}`;
+        const role = msg.role;
+        if (role !== "user" && role !== "assistant" && role !== "system") continue;
+        const content = cleanupHistoryContent(agentType, role, msg.content || "");
+        if (!content) continue;
+        const receivedAt = msg.receivedAt || Date.now();
+        const hash = buildHistoryMessageHash(agentType, {
+          role,
+          content,
+          receivedAt,
+          kind: typeof msg.kind === "string" ? msg.kind : void 0,
+          historyDedupKey: msg.historyDedupKey
+        });
+        const signature = buildHistoryMessageSignature(agentType, {
+          role,
+          content,
+          kind: typeof msg.kind === "string" ? msg.kind : void 0
+        });
         if (seenHashes.has(hash)) continue;
+        if (this.lastSeenSignatures.get(dedupKey) === signature) continue;
+        if (role !== "system" && this.lastSeenTurnSignatures.get(dedupKey) === signature) continue;
         seenHashes.add(hash);
+        this.lastSeenSignatures.set(dedupKey, signature);
+        if (role !== "system") {
+          this.lastSeenTurnSignatures.set(dedupKey, signature);
+        }
         newMessages.push({
-          ts: new Date(msg.receivedAt || Date.now()).toISOString(),
-          receivedAt: msg.receivedAt || Date.now(),
-          role: msg.role,
-          content: msg.content || "",
+          ts: new Date(receivedAt).toISOString(),
+          receivedAt,
+          role,
+          content,
           kind: typeof msg.kind === "string" ? msg.kind : void 0,
           senderName: typeof msg.senderName === "string" ? msg.senderName : void 0,
           agent: agentType,
@@ -4964,16 +5098,18 @@ var ChatHistoryWriter = class {
         });
       }
       if (newMessages.length === 0) return;
-      const dir = path5.join(HISTORY_DIR, this.sanitize(agentType));
+      const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
       fs3.mkdirSync(dir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const filePrefix = effectiveHistoryKey ? `${this.sanitize(effectiveHistoryKey)}_` : "";
-      const filePath = path5.join(dir, `${filePrefix}${date}.jsonl`);
+      const filePath = path7.join(dir, `${filePrefix}${date}.jsonl`);
       const lines = newMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
       fs3.appendFileSync(filePath, lines, "utf-8");
       const prevCount = this.lastSeenCounts.get(dedupKey) || 0;
       if (messages.length < prevCount * 0.5 && prevCount > 3) {
         seenHashes.clear();
+        this.lastSeenSignatures.delete(dedupKey);
+        this.lastSeenTurnSignatures.delete(dedupKey);
         for (const msg of messages) {
           seenHashes.add(msg.historyDedupKey || `${msg.kind || "standard"}:${msg.role}:${(msg.content || "").slice(0, 50)}`);
         }
@@ -4987,6 +5123,54 @@ var ChatHistoryWriter = class {
     } catch {
     }
   }
+  seedSessionHistory(agentType, messages = [], historySessionId, instanceId) {
+    const effectiveHistoryKey = historySessionId || instanceId;
+    const dedupKey = effectiveHistoryKey ? `${agentType}:${effectiveHistoryKey}` : agentType;
+    const seenHashes = /* @__PURE__ */ new Set();
+    for (const raw of messages) {
+      const role = raw?.role;
+      if (role !== "user" && role !== "assistant" && role !== "system") continue;
+      const content = cleanupHistoryContent(agentType, role, raw?.content || "");
+      if (!content) continue;
+      seenHashes.add(buildHistoryMessageHash(agentType, {
+        role,
+        content,
+        receivedAt: raw?.receivedAt || 0,
+        kind: typeof raw?.kind === "string" ? raw.kind : void 0,
+        historyDedupKey: raw?.historyDedupKey
+      }));
+    }
+    this.lastSeenHashes.set(dedupKey, seenHashes);
+    this.lastSeenCounts.set(dedupKey, messages.length);
+    const lastMessage = [...messages].reverse().find((raw) => {
+      const role = raw?.role;
+      if (role !== "user" && role !== "assistant" && role !== "system") return false;
+      return !!cleanupHistoryContent(agentType, role, raw?.content || "");
+    });
+    const lastTurnMessage = [...messages].reverse().find((raw) => {
+      const role = raw?.role;
+      if (role !== "user" && role !== "assistant") return false;
+      return !!cleanupHistoryContent(agentType, role, raw?.content || "");
+    });
+    if (lastMessage) {
+      this.lastSeenSignatures.set(dedupKey, buildHistoryMessageSignature(agentType, {
+        role: lastMessage.role,
+        content: lastMessage.content,
+        kind: typeof lastMessage.kind === "string" ? lastMessage.kind : void 0
+      }));
+    } else {
+      this.lastSeenSignatures.delete(dedupKey);
+    }
+    if (lastTurnMessage) {
+      this.lastSeenTurnSignatures.set(dedupKey, buildHistoryMessageSignature(agentType, {
+        role: lastTurnMessage.role,
+        content: lastTurnMessage.content,
+        kind: typeof lastTurnMessage.kind === "string" ? lastTurnMessage.kind : void 0
+      }));
+    } else {
+      this.lastSeenTurnSignatures.delete(dedupKey);
+    }
+  }
   appendSystemMarker(agentType, content, options = {}) {
     this.appendNewMessages(
       agentType,
@@ -5017,19 +5201,29 @@ var ChatHistoryWriter = class {
         this.lastSeenHashes.set(toDedupKey, nextHashes);
         this.lastSeenHashes.delete(fromDedupKey);
       }
+      const fromSignature = this.lastSeenSignatures.get(fromDedupKey);
+      if (fromSignature) {
+        this.lastSeenSignatures.set(toDedupKey, fromSignature);
+        this.lastSeenSignatures.delete(fromDedupKey);
+      }
+      const fromTurnSignature = this.lastSeenTurnSignatures.get(fromDedupKey);
+      if (fromTurnSignature) {
+        this.lastSeenTurnSignatures.set(toDedupKey, fromTurnSignature);
+        this.lastSeenTurnSignatures.delete(fromDedupKey);
+      }
       const fromCount = this.lastSeenCounts.get(fromDedupKey);
       if (typeof fromCount === "number") {
         this.lastSeenCounts.set(toDedupKey, Math.max(fromCount, this.lastSeenCounts.get(toDedupKey) || 0));
         this.lastSeenCounts.delete(fromDedupKey);
       }
-      const dir = path5.join(HISTORY_DIR, this.sanitize(agentType));
+      const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
       if (!fs3.existsSync(dir)) return;
       const fromPrefix = `${this.sanitize(fromId)}_`;
       const toPrefix = `${this.sanitize(toId)}_`;
       const files = fs3.readdirSync(dir).filter((file) => file.startsWith(fromPrefix) && file.endsWith(".jsonl"));
       for (const file of files) {
-        const sourcePath = path5.join(dir, file);
-        const targetPath = path5.join(dir, `${toPrefix}${file.slice(fromPrefix.length)}`);
+        const sourcePath = path7.join(dir, file);
+        const targetPath = path7.join(dir, `${toPrefix}${file.slice(fromPrefix.length)}`);
         const sourceLines = fs3.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
         const rewritten = sourceLines.map((line) => {
           try {
@@ -5058,10 +5252,61 @@ var ChatHistoryWriter = class {
     } catch {
     }
   }
+  compactHistorySession(agentType, historySessionId) {
+    const sessionId = String(historySessionId || "").trim();
+    if (!sessionId) return;
+    try {
+      const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
+      if (!fs3.existsSync(dir)) return;
+      const prefix = `${this.sanitize(sessionId)}_`;
+      const files = fs3.readdirSync(dir).filter((file) => file.startsWith(prefix) && file.endsWith(".jsonl")).sort();
+      const seen = /* @__PURE__ */ new Set();
+      for (const file of files) {
+        const filePath = path7.join(dir, file);
+        const lines = fs3.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+        const next = [];
+        for (const line of lines) {
+          let parsed = null;
+          try {
+            parsed = JSON.parse(line);
+          } catch {
+            parsed = null;
+          }
+          if (!parsed || parsed.historySessionId !== sessionId) continue;
+          const sanitized = sanitizeHistoryMessage(agentType, parsed);
+          if (!sanitized) continue;
+          const hash = buildHistoryMessageHash(agentType, sanitized);
+          if (seen.has(hash)) continue;
+          seen.add(hash);
+          next.push(sanitized);
+        }
+        next.sort((a, b) => a.receivedAt - b.receivedAt);
+        const dedupedAdjacent = [];
+        let lastTurn = null;
+        for (const entry of next) {
+          const previous = dedupedAdjacent[dedupedAdjacent.length - 1];
+          if (isAdjacentHistoryDuplicate(agentType, previous, entry)) continue;
+          if (entry.role !== "system" && isAdjacentHistoryDuplicate(agentType, lastTurn, entry)) continue;
+          dedupedAdjacent.push(entry);
+          if (entry.role !== "system") lastTurn = entry;
+        }
+        const collapsed = collapseReplayAssistantTurns(agentType, dedupedAdjacent);
+        if (collapsed.length === 0) {
+          fs3.unlinkSync(filePath);
+          continue;
+        }
+        fs3.writeFileSync(filePath, `${collapsed.map((entry) => JSON.stringify(entry)).join("\n")}
+`, "utf-8");
+      }
+    } catch {
+    }
+  }
   /** Called when agent session is explicitly changed */
   onSessionChange(agentType) {
     this.lastSeenHashes.delete(agentType);
     this.lastSeenCounts.delete(agentType);
+    this.lastSeenSignatures.delete(agentType);
+    this.lastSeenTurnSignatures.delete(agentType);
   }
   /** Delete history files older than 30 days */
   async rotateOldFiles() {
@@ -5070,10 +5315,10 @@ var ChatHistoryWriter = class {
       const cutoff = Date.now() - RETAIN_DAYS * 24 * 60 * 60 * 1e3;
       const agentDirs = fs3.readdirSync(HISTORY_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
       for (const dir of agentDirs) {
-        const dirPath = path5.join(HISTORY_DIR, dir.name);
+        const dirPath = path7.join(HISTORY_DIR, dir.name);
         const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl") || f.endsWith(".terminal.log"));
         for (const file of files) {
-          const filePath = path5.join(dirPath, file);
+          const filePath = path7.join(dirPath, file);
           const stat = fs3.statSync(filePath);
           if (stat.mtimeMs < cutoff) {
             fs3.unlinkSync(filePath);
@@ -5091,7 +5336,7 @@ var ChatHistoryWriter = class {
 function readChatHistory(agentType, offset = 0, limit = 30, historySessionId) {
   try {
     const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const dir = path5.join(HISTORY_DIR, sanitized);
+    const dir = path7.join(HISTORY_DIR, sanitized);
     if (!fs3.existsSync(dir)) return { messages: [], hasMore: false };
     const sanitizedInstance = historySessionId?.replace(/[^a-zA-Z0-9_-]/g, "_");
     const files = fs3.readdirSync(dir).filter((f) => {
@@ -5102,23 +5347,37 @@ function readChatHistory(agentType, offset = 0, limit = 30, historySessionId) {
       return true;
     }).sort().reverse();
     const allMessages = [];
-    const needed = offset + limit + 1;
+    const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
-      if (allMessages.length >= needed) break;
-      const filePath = path5.join(dir, file);
+      const filePath = path7.join(dir, file);
       const content = fs3.readFileSync(filePath, "utf-8");
       const lines = content.trim().split("\n").filter(Boolean);
-      for (let i = lines.length - 1; i >= 0; i--) {
-        if (allMessages.length >= needed) break;
+      for (let i = 0; i < lines.length; i++) {
         try {
-          allMessages.push(JSON.parse(lines[i]));
+          const parsed = JSON.parse(lines[i]);
+          const sanitizedMessage = sanitizeHistoryMessage(agentType, parsed);
+          if (!sanitizedMessage) continue;
+          const hash = buildHistoryMessageHash(agentType, sanitizedMessage);
+          if (seen.has(hash)) continue;
+          seen.add(hash);
+          allMessages.push(sanitizedMessage);
         } catch {
         }
       }
     }
-    const sliced = allMessages.slice(offset, offset + limit);
-    const hasMore = allMessages.length > offset + limit;
-    sliced.reverse();
+    allMessages.sort((a, b) => a.receivedAt - b.receivedAt);
+    const chronological = [];
+    let lastTurn = null;
+    for (const message of allMessages) {
+      const previous = chronological[chronological.length - 1];
+      if (isAdjacentHistoryDuplicate(agentType, previous, message)) continue;
+      if (message.role !== "system" && isAdjacentHistoryDuplicate(agentType, lastTurn, message)) continue;
+      chronological.push(message);
+      if (message.role !== "system") lastTurn = message;
+    }
+    const collapsed = collapseReplayAssistantTurns(agentType, chronological);
+    const sliced = collapsed.slice(offset, offset + limit);
+    const hasMore = collapsed.length > offset + limit;
     return { messages: sliced, hasMore };
   } catch {
     return { messages: [], hasMore: false };
@@ -5127,7 +5386,7 @@ function readChatHistory(agentType, offset = 0, limit = 30, historySessionId) {
 function listSavedHistorySessions(agentType, options = {}) {
   try {
     const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const dir = path5.join(HISTORY_DIR, sanitized);
+    const dir = path7.join(HISTORY_DIR, sanitized);
     if (!fs3.existsSync(dir)) return { sessions: [], hasMore: false };
     const groupedFiles = /* @__PURE__ */ new Map();
     const filePattern = /^([A-Za-z0-9_-]+)_\d{4}-\d{2}-\d{2}\.jsonl$/;
@@ -5148,7 +5407,7 @@ function listSavedHistorySessions(agentType, options = {}) {
       let sessionTitle = "";
       let preview = "";
       for (const file of files.sort()) {
-        const filePath = path5.join(dir, file);
+        const filePath = path7.join(dir, file);
         const content = fs3.readFileSync(filePath, "utf-8");
         const lines = content.split("\n").filter(Boolean);
         for (const line of lines) {
@@ -6972,6 +7231,46 @@ function didProviderConfirmSend(result) {
   if (!parsed || typeof parsed !== "object") return false;
   return parsed.sent === true || parsed.success === true || parsed.ok === true || parsed.submitted === true || parsed.dispatched === true;
 }
+async function readExtensionChatState(h) {
+  try {
+    const evalResult = await h.evaluateProviderScript("readChat", void 0, 5e4);
+    if (!evalResult?.result) return null;
+    const parsed = parseMaybeJson(evalResult.result);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function getStateMessageCount(state) {
+  return Array.isArray(state?.messages) ? state.messages.length : 0;
+}
+function getStateLastSignature(state) {
+  const messages = Array.isArray(state?.messages) ? state.messages : [];
+  const last = messages[messages.length - 1];
+  if (!last) return "";
+  return `${last.role || ""}:${String(last.content || "").replace(/\s+/g, " ").trim()}`;
+}
+async function getStableExtensionBaseline(h) {
+  const first = await readExtensionChatState(h);
+  if (getStateMessageCount(first) > 0 || getStateLastSignature(first)) return first;
+  await new Promise((resolve12) => setTimeout(resolve12, 150));
+  const second = await readExtensionChatState(h);
+  return getStateMessageCount(second) >= getStateMessageCount(first) ? second : first;
+}
+async function verifyExtensionSendObserved(h, before) {
+  const beforeCount = getStateMessageCount(before);
+  const beforeSignature = getStateLastSignature(before);
+  for (let attempt = 0; attempt < 12; attempt += 1) {
+    await new Promise((resolve12) => setTimeout(resolve12, 250));
+    const state = await readExtensionChatState(h);
+    if (state?.status === "waiting_approval") return true;
+    const afterCount = getStateMessageCount(state);
+    const afterSignature = getStateLastSignature(state);
+    if (afterCount > beforeCount) return true;
+    if (afterSignature && afterSignature !== beforeSignature) return true;
+  }
+  return false;
+}
 async function handleChatHistory(h, args) {
   const { agentType, offset, limit } = args;
   const historySessionId = getHistorySessionId(h, args);
@@ -7152,12 +7451,17 @@ async function handleSendChat(h, args) {
   if (isExtensionTransport(transport)) {
     _log(`Extension: ${provider?.type || "unknown_extension"}`);
     try {
+      const beforeState = await getStableExtensionBaseline(h);
       const evalResult = await h.evaluateProviderScript("sendMessage", { message: text }, 3e4);
       if (evalResult?.result) {
         const parsed = parseMaybeJson(evalResult.result);
         if (didProviderConfirmSend(parsed)) {
-          _log(`Extension script sent OK`);
-          return _logSendSuccess("extension-script");
+          const observed = await verifyExtensionSendObserved(h, beforeState);
+          if (observed) {
+            _log(`Extension script sent OK`);
+            return _logSendSuccess("extension-script");
+          }
+          _log(`Extension script reported send but no chat-state change was observed`);
         }
         if (parsed?.needsTypeAndSend) {
           _log(`Extension needsTypeAndSend \u2192 AgentStreamManager`);
@@ -7323,6 +7627,14 @@ async function handleListChats(h, args) {
         } catch {
         }
       }
+      if (parsed?.sessions && Array.isArray(parsed.sessions)) {
+        LOG.info("Command", `[list_chats] OK: ${parsed.sessions.length} chats`);
+        return { success: true, chats: parsed.sessions };
+      }
+      if (parsed?.chats && Array.isArray(parsed.chats)) {
+        LOG.info("Command", `[list_chats] OK: ${parsed.chats.length} chats`);
+        return { success: true, chats: parsed.chats };
+      }
       if (Array.isArray(parsed)) {
         LOG.info("Command", `[list_chats] OK: ${parsed.length} chats`);
         return { success: true, chats: parsed };
@@ -7392,7 +7704,13 @@ async function handleSwitchChat(h, args) {
   } catch (e) {
     return { success: false, error: `webviewSwitchSession failed: ${e.message}` };
   }
-  const script = h.getProviderScript("switchSession", { SESSION_ID: JSON.stringify(sessionId) }) || h.getProviderScript("switch_session", { SESSION_ID: JSON.stringify(sessionId) });
+  const switchParams = {
+    sessionId,
+    title: sessionId,
+    id: sessionId,
+    SESSION_ID: JSON.stringify(sessionId)
+  };
+  const script = h.getProviderScript("switchSession", switchParams) || h.getProviderScript("switch_session", switchParams);
   if (!script) return { success: false, error: "switch_session script not available" };
   try {
     const raw = await cdp.evaluate(script, 15e3);
@@ -7471,8 +7789,8 @@ async function handleSetMode(h, args) {
     const adapter = getTargetedCliAdapter(h, args, provider?.type);
     if (adapter) {
       const acpInstance = adapter._acpInstance;
-      if (acpInstance && typeof acpInstance.onEvent === "function") {
-        acpInstance.onEvent("set_mode", { mode });
+      if (acpInstance && typeof acpInstance.setMode === "function") {
+        await acpInstance.setMode(mode);
         return { success: true, mode };
       }
     }
@@ -7529,9 +7847,9 @@ async function handleChangeModel(h, args) {
     LOG.info("Command", `[change_model] ACP adapter found: ${!!adapter}, type=${adapter?.cliType}, hasAcpInstance=${!!adapter?._acpInstance}`);
     if (adapter) {
       const acpInstance = adapter._acpInstance;
-      if (acpInstance && typeof acpInstance.onEvent === "function") {
-        acpInstance.onEvent("change_model", { model });
-        LOG.info("Command", `[change_model] Dispatched change_model event to ACP instance`);
+      if (acpInstance && typeof acpInstance.setConfigOption === "function") {
+        await acpInstance.setConfigOption("model", model);
+        LOG.info("Command", `[change_model] Updated ACP model to ${model}`);
         return { success: true, model };
       }
     }
@@ -7648,9 +7966,21 @@ async function handleResolveAction(h, args) {
     return { success: true, buttonIndex, button: buttons[buttonIndex] ?? button };
   }
   if (isExtensionTransport(transport) && h.agentStream && h.getCdp() && h.currentSession?.sessionId) {
-    const ok = await h.agentStream.resolveSessionAction(h.getCdp(), h.currentSession.sessionId, action);
+    const ok = await h.agentStream.resolveSessionAction(h.getCdp(), h.currentSession.sessionId, action, button);
     return { success: ok };
   }
+  if (transport === "acp") {
+    const adapter = getTargetedCliAdapter(h, args, provider?.type);
+    const acpInstance = adapter?._acpInstance;
+    if (!acpInstance) return { success: false, error: "ACP instance not found" };
+    try {
+      await acpInstance.resolvePermission(action === "approve" || action === "accept" || action === "always");
+      LOG.info("Command", `[resolveAction] ACP \u2192 ${action}`);
+      return { success: true, action };
+    } catch (e) {
+      return { success: false, error: e?.message || "ACP resolve action failed" };
+    }
+  }
   if (provider?.scripts?.webviewResolveAction || provider?.scripts?.webview_resolve_action) {
     const script = h.getProviderScript("webviewResolveAction", { action, button, buttonText: button }) || h.getProviderScript("webview_resolve_action", { action, button, buttonText: button });
     if (script) {
@@ -7729,7 +8059,7 @@ async function handleResolveAction(h, args) {
 
 // src/commands/cdp-commands.ts
 var fs4 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var path8 = __toESM(require("path"));
 var os6 = __toESM(require("os"));
 var KEY_TO_VK = {
   Backspace: 8,
@@ -7981,25 +8311,25 @@ function resolveSafePath(requestedPath) {
   const inputPath = rawPath || ".";
   const home = os6.homedir();
   if (inputPath.startsWith("~")) {
-    return path6.resolve(path6.join(home, inputPath.slice(1)));
+    return path8.resolve(path8.join(home, inputPath.slice(1)));
   }
   if (process.platform === "win32") {
     const normalized = normalizeWindowsRequestedPath(inputPath);
-    if (path6.win32.isAbsolute(normalized)) {
-      return path6.win32.normalize(normalized);
+    if (path8.win32.isAbsolute(normalized)) {
+      return path8.win32.normalize(normalized);
     }
-    return path6.win32.resolve(normalized);
+    return path8.win32.resolve(normalized);
   }
-  if (path6.isAbsolute(inputPath)) {
-    return path6.normalize(inputPath);
+  if (path8.isAbsolute(inputPath)) {
+    return path8.normalize(inputPath);
   }
-  return path6.resolve(inputPath);
+  return path8.resolve(inputPath);
 }
 function listDirectoryEntriesSafe(dirPath) {
   const entries = fs4.readdirSync(dirPath, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const entryPath = path6.join(dirPath, entry.name);
+    const entryPath = path8.join(dirPath, entry.name);
     try {
       if (entry.isDirectory()) {
         files.push({ name: entry.name, type: "directory" });
@@ -8038,7 +8368,7 @@ async function handleFileRead(h, args) {
 async function handleFileWrite(h, args) {
   try {
     const filePath = resolveSafePath(args?.path);
-    fs4.mkdirSync(path6.dirname(filePath), { recursive: true });
+    fs4.mkdirSync(path8.dirname(filePath), { recursive: true });
     fs4.writeFileSync(filePath, args?.content || "", "utf-8");
     return { success: true, path: filePath };
   } catch (e) {
@@ -8126,7 +8456,7 @@ function handleGetProviderSettings(h, args) {
   }
   return { success: true, settings: allSettings, values: allValues };
 }
-function handleSetProviderSetting(h, args) {
+async function handleSetProviderSetting(h, args) {
   const loader = h.ctx.providerLoader;
   const { providerType, key, value } = args || {};
   if (!providerType || !key || value === void 0) {
@@ -8139,6 +8469,7 @@ function handleSetProviderSetting(h, args) {
       const updated = h.ctx.instanceManager.updateInstanceSettings(providerType, allSettings);
       LOG.info("Command", `[set_provider_setting] ${providerType}.${key}=${JSON.stringify(value)} \u2192 ${updated} instance(s) updated`);
     }
+    await h.ctx.onProviderSettingChanged?.(providerType, key, value);
     return { success: true, providerType, key, value };
   }
   return { success: false, error: `Failed to set ${providerType}.${key} \u2014 invalid key, value, or not a public setting` };
@@ -8176,10 +8507,10 @@ function getCliScriptCommand(payload) {
   }
   const command = payload.command;
   if (!command || typeof command !== "object") return null;
-  if (command.type !== "send_message") return null;
+  if (command.type !== "send_message" && command.type !== "pty_write") return null;
   const text = typeof command.text === "string" ? command.text.trim() : typeof command.message === "string" ? command.message.trim() : "";
   if (!text) return null;
-  return { type: "send_message", text };
+  return { type: command.type, text };
 }
 function applyProviderPatch(h, args, payload) {
   if (!payload || typeof payload !== "object") return;
@@ -8220,6 +8551,8 @@ async function executeProviderScript(h, args, scriptName) {
       const cliCommand = getCliScriptCommand(parsed.payload);
       if (cliCommand?.type === "send_message" && cliCommand.text) {
         await adapter.sendMessage(cliCommand.text);
+      } else if (cliCommand?.type === "pty_write" && cliCommand.text && adapter.writeRaw) {
+        adapter.writeRaw(cliCommand.text + "\r");
       }
       applyProviderPatch(h, args, parsed.payload);
       return { success: true, ...parsed.payload && typeof parsed.payload === "object" ? parsed.payload : { result: parsed.payload } };
@@ -8898,7 +9231,7 @@ var DaemonCommandHandler = class {
     try {
       const http3 = await import("http");
       const postData = JSON.stringify(body);
-      const result = await new Promise((resolve9, reject) => {
+      const result = await new Promise((resolve12, reject) => {
         const req = http3.request({
           hostname: "127.0.0.1",
           port: 19280,
@@ -8910,9 +9243,9 @@ var DaemonCommandHandler = class {
           res.on("data", (chunk) => data += chunk);
           res.on("end", () => {
             try {
-              resolve9(JSON.parse(data));
+              resolve12(JSON.parse(data));
             } catch {
-              resolve9({ raw: data });
+              resolve12({ raw: data });
             }
           });
         });
@@ -8930,15 +9263,15 @@ var DaemonCommandHandler = class {
     if (!providerType) return { success: false, error: "providerType required" };
     try {
       const http3 = await import("http");
-      const result = await new Promise((resolve9, reject) => {
+      const result = await new Promise((resolve12, reject) => {
         http3.get(`http://127.0.0.1:19280/api/providers/${providerType}/${endpoint}`, (res) => {
           let data = "";
           res.on("data", (chunk) => data += chunk);
           res.on("end", () => {
             try {
-              resolve9(JSON.parse(data));
+              resolve12(JSON.parse(data));
             } catch {
-              resolve9({ raw: data });
+              resolve12({ raw: data });
             }
           });
         }).on("error", reject);
@@ -8952,7 +9285,7 @@ var DaemonCommandHandler = class {
     try {
       const http3 = await import("http");
       const postData = JSON.stringify(args || {});
-      const result = await new Promise((resolve9, reject) => {
+      const result = await new Promise((resolve12, reject) => {
         const req = http3.request({
           hostname: "127.0.0.1",
           port: 19280,
@@ -8964,9 +9297,9 @@ var DaemonCommandHandler = class {
           res.on("data", (chunk) => data += chunk);
           res.on("end", () => {
             try {
-              resolve9(JSON.parse(data));
+              resolve12(JSON.parse(data));
             } catch {
-              resolve9({ raw: data });
+              resolve12({ raw: data });
             }
           });
         });
@@ -8983,7 +9316,7 @@ var DaemonCommandHandler = class {
 
 // src/commands/cli-manager.ts
 var os10 = __toESM(require("os"));
-var path9 = __toESM(require("path"));
+var path11 = __toESM(require("path"));
 var crypto4 = __toESM(require("crypto"));
 var import_chalk = __toESM(require("chalk"));
 init_provider_cli_adapter();
@@ -8991,7 +9324,7 @@ init_config();
 
 // src/providers/cli-provider-instance.ts
 var os9 = __toESM(require("os"));
-var path8 = __toESM(require("path"));
+var path10 = __toESM(require("path"));
 var crypto3 = __toESM(require("crypto"));
 var fs5 = __toESM(require("fs"));
 var import_node_module = require("module");
@@ -9000,7 +9333,7 @@ init_logger();
 var CachedDatabaseSync = null;
 function getDatabaseSync() {
   if (CachedDatabaseSync) return CachedDatabaseSync;
-  const requireFn = typeof require === "function" ? require : (0, import_node_module.createRequire)(path8.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
+  const requireFn = typeof require === "function" ? require : (0, import_node_module.createRequire)(path10.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
   const sqliteModule = requireFn(`node:${"sqlite"}`);
   CachedDatabaseSync = sqliteModule.DatabaseSync;
   if (!CachedDatabaseSync) {
@@ -9040,6 +9373,7 @@ var CliProviderInstance = class {
   historyWriter;
   runtimeMessages = [];
   instanceId;
+  suppressIdleHistoryReplay = false;
   presentationMode;
   providerSessionId;
   launchMode;
@@ -9067,7 +9401,15 @@ var CliProviderInstance = class {
     await this.adapter.spawn();
     this.maybeAppendRuntimeRecoveryMessage(this.adapter.getRuntimeMetadata());
     if (this.providerSessionId) {
+      this.historyWriter.compactHistorySession(this.type, this.providerSessionId);
       const restoredHistory = readChatHistory(this.type, 0, 200, this.providerSessionId);
+      this.historyWriter.seedSessionHistory(
+        this.type,
+        restoredHistory.messages,
+        this.providerSessionId,
+        this.instanceId
+      );
+      this.suppressIdleHistoryReplay = restoredHistory.messages.length > 0;
       if (restoredHistory.messages.length > 0) {
         this.adapter.seedCommittedMessages(
           restoredHistory.messages.map((message) => ({
@@ -9111,7 +9453,7 @@ var CliProviderInstance = class {
       } else if (this.type === "codex-cli") {
         probedSessionId = this.probeSessionIdFromConfig({
           dbPath: "~/.codex/state_5.sqlite",
-          query: "select id from threads where cwd in ({dirs}) and created_at >= ? and archived = 0 order by created_at desc limit 1",
+          query: "select id from threads where cwd in ({dirs}) and updated_at >= ? and archived = 0 order by updated_at desc limit 1",
           timestampFormat: "unix_s"
         });
       } else if (this.type === "goose-cli") {
@@ -9171,6 +9513,7 @@ var CliProviderInstance = class {
     const mergedMessages = this.mergeConversationMessages(parsedMessages);
     const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
     if (parsedMessages.length > 0) {
+      const shouldSkipReplayPersist = this.suppressIdleHistoryReplay && adapterStatus.status === "idle" && parsedStatus?.status === "idle";
       let messagesToSave = parsedMessages;
       if (parsedStatus?.status === "generating" || parsedStatus?.status === "long_generating") {
         const lastIdx = messagesToSave.length - 1;
@@ -9178,7 +9521,7 @@ var CliProviderInstance = class {
           messagesToSave = messagesToSave.slice(0, lastIdx);
         }
       }
-      if (messagesToSave.length > 0) {
+      if (!shouldSkipReplayPersist && messagesToSave.length > 0) {
         this.historyWriter.appendNewMessages(
           this.type,
           messagesToSave,
@@ -9273,6 +9616,7 @@ var CliProviderInstance = class {
     if (newStatus !== this.lastStatus) {
       LOG.info("CLI", `[${this.type}] status: ${this.lastStatus} \u2192 ${newStatus}`);
       if (this.lastStatus === "idle" && newStatus === "generating") {
+        this.suppressIdleHistoryReplay = false;
         if (this.completedDebouncePending) {
           LOG.info("CLI", `[${this.type}] cancelled pending completed (resumed generating)`);
           if (this.completedDebounceTimer) {
@@ -9292,6 +9636,7 @@ var CliProviderInstance = class {
           this.generatingDebounceTimer = null;
         }, 1e3);
       } else if (newStatus === "waiting_approval") {
+        this.suppressIdleHistoryReplay = false;
         if (this.generatingDebouncePending) {
           if (this.generatingDebounceTimer) {
             clearTimeout(this.generatingDebounceTimer);
@@ -9829,8 +10174,9 @@ var AcpProviderInstance = class {
   async setConfigOption(category, value) {
     const opt = this.configOptions.find((c) => c.category === category);
     if (!opt) {
-      this.log.warn(`[${this.type}] No config option for category: ${category}`);
-      return;
+      const message = `[${this.type}] No config option for category: ${category}`;
+      this.log.warn(message);
+      throw new Error(message);
     }
     if (this.useStaticConfig) {
       opt.currentValue = value;
@@ -9842,8 +10188,9 @@ var AcpProviderInstance = class {
       return;
     }
     if (!this.connection || !this.sessionId) {
-      this.log.warn(`[${this.type}] Cannot set config: no active connection/session`);
-      return;
+      const message = `[${this.type}] Cannot set config: no active connection/session`;
+      this.log.warn(message);
+      throw new Error(message);
     }
     try {
       this.log.info(`[${this.type}] Sending session/set_config_option: configId=${opt.configId} value=${value} sessionId=${this.sessionId}`);
@@ -9857,7 +10204,9 @@ var AcpProviderInstance = class {
       if (result?.configOptions) this.parseConfigOptions(result.configOptions);
       this.log.info(`[${this.type}] Config ${category} set to: ${value} | response: ${JSON.stringify(result)?.slice(0, 300)}`);
     } catch (e) {
-      this.log.warn(`[${this.type}] set_config_option failed: ${e?.message}`);
+      const message = e?.message || "Unknown ACP config error";
+      this.log.warn(`[${this.type}] set_config_option failed: ${message}`);
+      throw new Error(message);
     }
   }
   async setMode(modeId) {
@@ -9873,8 +10222,9 @@ var AcpProviderInstance = class {
       return;
     }
     if (!this.connection || !this.sessionId) {
-      this.log.warn(`[${this.type}] Cannot set mode: no active connection/session`);
-      return;
+      const message = `[${this.type}] Cannot set mode: no active connection/session`;
+      this.log.warn(message);
+      throw new Error(message);
     }
     try {
       await this.connection.setSessionMode({
@@ -9884,7 +10234,9 @@ var AcpProviderInstance = class {
       this.currentMode = modeId;
       this.log.info(`[${this.type}] Mode set to: ${modeId}`);
     } catch (e) {
-      this.log.warn(`[${this.type}] set_mode failed: ${e?.message}`);
+      const message = e?.message || "Unknown ACP mode error";
+      this.log.warn(`[${this.type}] set_mode failed: ${message}`);
+      throw new Error(message);
     }
   }
   /** Static config: kill process and restart with new args */
@@ -9932,7 +10284,7 @@ var AcpProviderInstance = class {
     if (!spawnConfig) {
       throw new Error(`[ACP:${this.type}] No spawn config defined`);
     }
-    const command = spawnConfig.command;
+    const command = typeof this.settings.executablePath === "string" && this.settings.executablePath.trim() ? this.settings.executablePath.trim() : spawnConfig.command;
     let baseArgs = spawnConfig.args || [];
     if (this.provider.spawnArgBuilder && Object.keys(this.selectedConfig).length > 0) {
       baseArgs = this.provider.spawnArgBuilder(this.selectedConfig);
@@ -10048,13 +10400,13 @@ var AcpProviderInstance = class {
         }
         this.currentStatus = "waiting_approval";
         this.detectStatusTransition();
-        const approved = await new Promise((resolve9) => {
-          this.permissionResolvers.push(resolve9);
+        const approved = await new Promise((resolve12) => {
+          this.permissionResolvers.push(resolve12);
           setTimeout(() => {
-            const idx = this.permissionResolvers.indexOf(resolve9);
+            const idx = this.permissionResolvers.indexOf(resolve12);
             if (idx >= 0) {
               this.permissionResolvers.splice(idx, 1);
-              resolve9(false);
+              resolve12(false);
             }
           }, 3e5);
         });
@@ -10761,7 +11113,7 @@ var DaemonCliManager = class {
   async startSession(cliType, workingDir, cliArgs, initialModel, options) {
     const trimmed = (workingDir || "").trim();
     if (!trimmed) throw new Error("working directory required");
-    const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os10.homedir()) : path9.resolve(trimmed);
+    const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os10.homedir()) : path11.resolve(trimmed);
     const normalizedType = this.providerLoader.resolveAlias(cliType);
     const provider = this.providerLoader.getByAlias(cliType);
     const key = crypto4.randomUUID();
@@ -10848,10 +11200,10 @@ ${installInfo}`
     if (!cliInfo) {
       const installHint = provider?.install || "";
       const displayName = provider?.displayName || provider?.name || cliType;
-      const spawnCmd = provider?.spawn?.command || cliType;
+      const spawnCmd = this.providerLoader.getSpawnCommand(normalizedType, provider?.spawn?.command || cliType);
       throw new Error(
         `${displayName} is not installed.
-Command '${spawnCmd}' not found on PATH.
+Command '${spawnCmd}' is not available.
 ` + (installHint ? `
 ${installHint}
 ` : "") + `
@@ -10997,6 +11349,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     if (!instanceManager) return 0;
     const sessions = records || await this.deps.listHostedCliRuntimes?.() || [];
     let restored = 0;
+    const restoredBindings = /* @__PURE__ */ new Set();
     for (const record of sessions) {
       if (!record?.runtimeId || !record?.cliType || !record?.workspace) continue;
       if (this.adapters.has(record.runtimeId) || instanceManager.getInstance(record.runtimeId)) continue;
@@ -11010,6 +11363,18 @@ Run 'adhdev doctor' for detailed diagnostics.`
         record.cliArgs,
         record.providerSessionId
       );
+      const bindingKey = [
+        normalizedType,
+        record.workspace,
+        sessionBinding.providerSessionId || record.runtimeId
+      ].join("::");
+      if (restoredBindings.has(bindingKey)) {
+        LOG.info(
+          "CLI",
+          `\u21B7 Skipping duplicate hosted runtime restore: ${record.runtimeKey || record.runtimeId} (${normalizedType} @ ${record.workspace}) binding=${sessionBinding.providerSessionId || "runtime"}`
+        );
+        continue;
+      }
       try {
         await this.registerCliInstance(
           record.runtimeId,
@@ -11025,6 +11390,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             launchMode: "manual"
           }
         );
+        restoredBindings.add(bindingKey);
         restored += 1;
         LOG.info("CLI", `\u267B Restored hosted runtime: ${record.runtimeKey || record.runtimeId} (${record.displayName || record.workspace})`);
       } catch (error) {
@@ -11211,16 +11577,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
 var import_child_process6 = require("child_process");
 var net = __toESM(require("net"));
 var os12 = __toESM(require("os"));
-var path11 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 
 // src/providers/provider-loader.ts
 var fs6 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 var os11 = __toESM(require("os"));
 var chokidar = __toESM(require("chokidar"));
 init_logger();
 var ProviderLoader = class _ProviderLoader {
   providers = /* @__PURE__ */ new Map();
+  providerAvailability = /* @__PURE__ */ new Map();
   userDir;
   upstreamDir;
   disableUpstream;
@@ -11236,12 +11603,12 @@ var ProviderLoader = class _ProviderLoader {
   static META_FILE = ".meta.json";
   constructor(options) {
     this.logFn = options?.logFn || LOG.forComponent("Provider").asLogFn();
-    const defaultProvidersDir = path10.join(os11.homedir(), ".adhdev", "providers");
+    const defaultProvidersDir = path12.join(os11.homedir(), ".adhdev", "providers");
     if (options?.userDir) {
       this.userDir = options.userDir;
       this.log(`Config 'providerDir' applied: ${this.userDir}`);
     } else {
-      const localRepoPath = path10.resolve(__dirname, "../../../../../adhdev-providers");
+      const localRepoPath = path12.resolve(__dirname, "../../../../../adhdev-providers");
       if (fs6.existsSync(localRepoPath)) {
         this.userDir = localRepoPath;
         this.log(`Auto-detected local public repository: ${this.userDir} (Dev workspace speedup)`);
@@ -11250,7 +11617,7 @@ var ProviderLoader = class _ProviderLoader {
         this.log(`Using default user providers directory: ${this.userDir}`);
       }
     }
-    this.upstreamDir = path10.join(defaultProvidersDir, ".upstream");
+    this.upstreamDir = path12.join(defaultProvidersDir, ".upstream");
     this.disableUpstream = options?.disableUpstream ?? false;
   }
   log(msg) {
@@ -11280,7 +11647,7 @@ var ProviderLoader = class _ProviderLoader {
   * Canonical provider directory shape for a given root.
   */
   getProviderDir(root, category, type) {
-    return path10.join(root, category, type);
+    return path12.join(root, category, type);
   }
   /**
   * Canonical user override directory for a provider.
@@ -11307,7 +11674,7 @@ var ProviderLoader = class _ProviderLoader {
   resolveProviderFile(type, ...segments) {
     const dir = this.findProviderDirInternal(type);
     if (!dir) return null;
-    return path10.join(dir, ...segments);
+    return path12.join(dir, ...segments);
   }
   /**
   * Load all providers (3-tier priority)
@@ -11318,6 +11685,7 @@ var ProviderLoader = class _ProviderLoader {
   */
   loadAll() {
     this.providers.clear();
+    this.providerAvailability.clear();
     let upstreamCount = 0;
     if (!this.disableUpstream && fs6.existsSync(this.upstreamDir)) {
       upstreamCount = this.loadDir(this.upstreamDir);
@@ -11345,7 +11713,7 @@ var ProviderLoader = class _ProviderLoader {
     if (!fs6.existsSync(this.upstreamDir)) return false;
     try {
       return fs6.readdirSync(this.upstreamDir).some(
-        (d) => fs6.statSync(path10.join(this.upstreamDir, d)).isDirectory()
+        (d) => fs6.statSync(path12.join(this.upstreamDir, d)).isDirectory()
       );
     } catch {
       return false;
@@ -11388,11 +11756,12 @@ var ProviderLoader = class _ProviderLoader {
       if ((p.category === "cli" || p.category === "acp") && p.spawn?.command) {
         const verCmdConfig = p.versionCommand;
         const versionCommand = typeof verCmdConfig === "object" && verCmdConfig !== null ? verCmdConfig[process.platform] : verCmdConfig;
+        const command = this.getSpawnCommand(p.type, p.spawn.command);
         result.push({
           id: p.type,
           displayName: p.displayName || p.name,
           icon: p.icon || "\u{1F527}",
-          command: p.spawn.command,
+          command,
           category: p.category,
           ...typeof versionCommand === "string" && versionCommand.trim() ? { versionCommand: versionCommand.trim() } : {}
         });
@@ -11521,6 +11890,71 @@ var ProviderLoader = class _ProviderLoader {
   getAvailableIdeTypes() {
     return [...this.providers.values()].filter((p) => p.category === "ide" && p.cdpPorts).map((p) => p.type);
   }
+  getSpawnCommand(type, fallback) {
+    const override = this.getOptionalStringSetting(type, "executablePath");
+    if (override) return override;
+    return fallback || this.providers.get(type)?.spawn?.command || type;
+  }
+  getIdeCliCommand(type, fallback) {
+    const override = this.getOptionalStringSetting(type, "cliPathOverride");
+    if (override) return override;
+    return fallback || this.providers.get(type)?.cli || null;
+  }
+  getIdePathCandidates(type, fallback) {
+    const override = this.getOptionalStringSetting(type, "appPathOverride");
+    if (override) return [override];
+    if (fallback && fallback.length > 0) return fallback;
+    const osPaths = this.providers.get(type)?.paths?.[process.platform];
+    return Array.isArray(osPaths) ? [...osPaths] : [];
+  }
+  setProviderAvailability(type, state) {
+    this.providerAvailability.set(type, {
+      installed: !!state.installed,
+      detectedPath: state.detectedPath ?? null
+    });
+  }
+  setCliDetectionResults(results, replace = true) {
+    if (replace) {
+      for (const provider of this.providers.values()) {
+        if (provider.category === "cli" || provider.category === "acp") {
+          this.providerAvailability.set(provider.type, { installed: false, detectedPath: null });
+        }
+      }
+    }
+    for (const result of results) {
+      this.setProviderAvailability(result.id, {
+        installed: !!result.installed,
+        detectedPath: result.path || null
+      });
+    }
+  }
+  setIdeDetectionResults(results, replace = true) {
+    if (replace) {
+      for (const provider of this.providers.values()) {
+        if (provider.category === "ide") {
+          this.providerAvailability.set(provider.type, { installed: false, detectedPath: null });
+        }
+      }
+    }
+    for (const result of results) {
+      this.setProviderAvailability(result.id, {
+        installed: !!result.installed,
+        detectedPath: result.cliCommand || result.path || null
+      });
+    }
+  }
+  getAvailableProviderInfos() {
+    return this.getAll().map((provider) => {
+      const availability = this.providerAvailability.get(provider.type);
+      return {
+        ...provider,
+        ...availability ? {
+          installed: availability.installed,
+          detectedPath: availability.detectedPath
+        } : {}
+      };
+    });
+  }
   /**
   * Register IDE providers to core/detector registry
   * → Enables detectIDEs() to detect provider.js-based IDEs
@@ -11595,8 +12029,8 @@ var ProviderLoader = class _ProviderLoader {
               resolved._resolvedScriptDir = entry.scriptDir;
               resolved._resolvedScriptsSource = `compatibility:${entry.ideVersion}`;
               if (providerDir) {
-                const fullDir = path10.join(providerDir, entry.scriptDir);
-                resolved._resolvedScriptsPath = fs6.existsSync(path10.join(fullDir, "scripts.js")) ? path10.join(fullDir, "scripts.js") : fullDir;
+                const fullDir = path12.join(providerDir, entry.scriptDir);
+                resolved._resolvedScriptsPath = fs6.existsSync(path12.join(fullDir, "scripts.js")) ? path12.join(fullDir, "scripts.js") : fullDir;
               }
               matched = true;
             }
@@ -11611,8 +12045,8 @@ var ProviderLoader = class _ProviderLoader {
             resolved._resolvedScriptDir = base.defaultScriptDir;
             resolved._resolvedScriptsSource = "defaultScriptDir:version_miss";
             if (providerDir) {
-              const fullDir = path10.join(providerDir, base.defaultScriptDir);
-              resolved._resolvedScriptsPath = fs6.existsSync(path10.join(fullDir, "scripts.js")) ? path10.join(fullDir, "scripts.js") : fullDir;
+              const fullDir = path12.join(providerDir, base.defaultScriptDir);
+              resolved._resolvedScriptsPath = fs6.existsSync(path12.join(fullDir, "scripts.js")) ? path12.join(fullDir, "scripts.js") : fullDir;
             }
           }
           resolved._versionWarning = `Version ${currentVersion} not in compatibility matrix. Using default scripts.`;
@@ -11629,8 +12063,8 @@ var ProviderLoader = class _ProviderLoader {
               resolved._resolvedScriptDir = dirOverride;
               resolved._resolvedScriptsSource = `versions:${range}`;
               if (providerDir) {
-                const fullDir = path10.join(providerDir, dirOverride);
-                resolved._resolvedScriptsPath = fs6.existsSync(path10.join(fullDir, "scripts.js")) ? path10.join(fullDir, "scripts.js") : fullDir;
+                const fullDir = path12.join(providerDir, dirOverride);
+                resolved._resolvedScriptsPath = fs6.existsSync(path12.join(fullDir, "scripts.js")) ? path12.join(fullDir, "scripts.js") : fullDir;
               }
             }
           } else if (override.scripts) {
@@ -11646,8 +12080,8 @@ var ProviderLoader = class _ProviderLoader {
         resolved._resolvedScriptDir = base.defaultScriptDir;
         resolved._resolvedScriptsSource = "defaultScriptDir:no_version";
         if (providerDir) {
-          const fullDir = path10.join(providerDir, base.defaultScriptDir);
-          resolved._resolvedScriptsPath = fs6.existsSync(path10.join(fullDir, "scripts.js")) ? path10.join(fullDir, "scripts.js") : fullDir;
+          const fullDir = path12.join(providerDir, base.defaultScriptDir);
+          resolved._resolvedScriptsPath = fs6.existsSync(path12.join(fullDir, "scripts.js")) ? path12.join(fullDir, "scripts.js") : fullDir;
         }
       }
     }
@@ -11672,14 +12106,14 @@ var ProviderLoader = class _ProviderLoader {
       this.log(`  [loadScriptsFromDir] ${type}: providerDir not found`);
       return null;
     }
-    const dir = path10.join(providerDir, scriptDir);
+    const dir = path12.join(providerDir, scriptDir);
     if (!fs6.existsSync(dir)) {
       this.log(`  [loadScriptsFromDir] ${type}: dir not found: ${dir}`);
       return null;
     }
     const cached = this.scriptsCache.get(dir);
     if (cached) return cached;
-    const scriptsJs = path10.join(dir, "scripts.js");
+    const scriptsJs = path12.join(dir, "scripts.js");
     if (fs6.existsSync(scriptsJs)) {
       try {
         delete require.cache[require.resolve(scriptsJs)];
@@ -11721,7 +12155,7 @@ var ProviderLoader = class _ProviderLoader {
             return;
           }
           if (filePath.endsWith(".js") || filePath.endsWith(".json")) {
-            this.log(`File changed: ${path10.basename(filePath)}, reloading...`);
+            this.log(`File changed: ${path12.basename(filePath)}, reloading...`);
             this.reload();
           }
         };
@@ -11776,7 +12210,7 @@ var ProviderLoader = class _ProviderLoader {
     }
     const https = require("https");
     const { execSync: execSync7 } = require("child_process");
-    const metaPath = path10.join(this.upstreamDir, _ProviderLoader.META_FILE);
+    const metaPath = path12.join(this.upstreamDir, _ProviderLoader.META_FILE);
     let prevEtag = "";
     let prevTimestamp = 0;
     try {
@@ -11793,7 +12227,7 @@ var ProviderLoader = class _ProviderLoader {
       return { updated: false };
     }
     try {
-      const etag = await new Promise((resolve9, reject) => {
+      const etag = await new Promise((resolve12, reject) => {
         const options = {
           method: "HEAD",
           hostname: "github.com",
@@ -11811,7 +12245,7 @@ var ProviderLoader = class _ProviderLoader {
               headers: { "User-Agent": "adhdev-launcher" },
               timeout: 1e4
             }, (res2) => {
-              resolve9(res2.headers.etag || res2.headers["last-modified"] || "");
+              resolve12(res2.headers.etag || res2.headers["last-modified"] || "");
             });
             req2.on("error", reject);
             req2.on("timeout", () => {
@@ -11820,7 +12254,7 @@ var ProviderLoader = class _ProviderLoader {
             });
             req2.end();
           } else {
-            resolve9(res.headers.etag || res.headers["last-modified"] || "");
+            resolve12(res.headers.etag || res.headers["last-modified"] || "");
           }
         });
         req.on("error", reject);
@@ -11836,17 +12270,17 @@ var ProviderLoader = class _ProviderLoader {
         return { updated: false };
       }
       this.log("Downloading latest providers from GitHub...");
-      const tmpTar = path10.join(os11.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
-      const tmpExtract = path10.join(os11.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
+      const tmpTar = path12.join(os11.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
+      const tmpExtract = path12.join(os11.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
       await this.downloadFile(_ProviderLoader.GITHUB_TARBALL_URL, tmpTar);
       fs6.mkdirSync(tmpExtract, { recursive: true });
       execSync7(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
       const extracted = fs6.readdirSync(tmpExtract);
       const rootDir = extracted.find(
-        (d) => fs6.statSync(path10.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
+        (d) => fs6.statSync(path12.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
       );
       if (!rootDir) throw new Error("Unexpected tarball structure");
-      const sourceDir = path10.join(tmpExtract, rootDir);
+      const sourceDir = path12.join(tmpExtract, rootDir);
       const backupDir = this.upstreamDir + ".bak";
       if (fs6.existsSync(this.upstreamDir)) {
         if (fs6.existsSync(backupDir)) fs6.rmSync(backupDir, { recursive: true, force: true });
@@ -11884,7 +12318,7 @@ var ProviderLoader = class _ProviderLoader {
   downloadFile(url, destPath) {
     const https = require("https");
     const http3 = require("http");
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve12, reject) => {
       const doRequest = (reqUrl, redirectCount = 0) => {
         if (redirectCount > 5) {
           reject(new Error("Too many redirects"));
@@ -11904,7 +12338,7 @@ var ProviderLoader = class _ProviderLoader {
           res.pipe(ws);
           ws.on("finish", () => {
             ws.close();
-            resolve9();
+            resolve12();
           });
           ws.on("error", reject);
         });
@@ -11921,8 +12355,8 @@ var ProviderLoader = class _ProviderLoader {
   copyDirRecursive(src, dest) {
     fs6.mkdirSync(dest, { recursive: true });
     for (const entry of fs6.readdirSync(src, { withFileTypes: true })) {
-      const srcPath = path10.join(src, entry.name);
-      const destPath = path10.join(dest, entry.name);
+      const srcPath = path12.join(src, entry.name);
+      const destPath = path12.join(dest, entry.name);
       if (entry.isDirectory()) {
         this.copyDirRecursive(srcPath, destPath);
       } else {
@@ -11933,7 +12367,7 @@ var ProviderLoader = class _ProviderLoader {
   /** .meta.json save */
   writeMeta(metaPath, etag, timestamp) {
     try {
-      fs6.mkdirSync(path10.dirname(metaPath), { recursive: true });
+      fs6.mkdirSync(path12.dirname(metaPath), { recursive: true });
       fs6.writeFileSync(metaPath, JSON.stringify({
         etag,
         timestamp,
@@ -11950,7 +12384,7 @@ var ProviderLoader = class _ProviderLoader {
     const scan = (d) => {
       try {
         for (const entry of fs6.readdirSync(d, { withFileTypes: true })) {
-          if (entry.isDirectory()) scan(path10.join(d, entry.name));
+          if (entry.isDirectory()) scan(path12.join(d, entry.name));
           else if (entry.name === "provider.json") count++;
         }
       } catch {
@@ -11964,9 +12398,8 @@ var ProviderLoader = class _ProviderLoader {
   * Get public settings schema for a provider (for dashboard UI rendering)
   */
   getPublicSettings(type) {
-    const provider = this.providers.get(type);
-    if (!provider?.settings) return [];
-    return Object.entries(provider.settings).filter(([, def]) => def.public === true).map(([key, def]) => ({ key, ...def }));
+    const settings = this.getSettingsSchema(type);
+    return Object.entries(settings).filter(([, def]) => def.public === true).map(([key, def]) => ({ key, ...def }));
   }
   /**
   * Get public settings schema for all providers
@@ -11983,8 +12416,7 @@ var ProviderLoader = class _ProviderLoader {
   * Resolved setting value for a provider (default + user override)
   */
   getSettingValue(type, key) {
-    const provider = this.providers.get(type);
-    const schemaDef = provider?.settings?.[key];
+    const schemaDef = this.getSettingsSchema(type)[key];
     const defaultVal = schemaDef ? schemaDef.default : void 0;
     try {
       const { loadConfig: loadConfig2 } = (init_config(), __toCommonJS(config_exports));
@@ -11999,10 +12431,9 @@ var ProviderLoader = class _ProviderLoader {
   * All resolved settings for a provider (default + user override)
   */
   getSettings(type) {
-    const provider = this.providers.get(type);
-    if (!provider?.settings) return {};
+    const settings = this.getSettingsSchema(type);
     const result = {};
-    for (const [key, def] of Object.entries(provider.settings)) {
+    for (const [key] of Object.entries(settings)) {
       result[key] = this.getSettingValue(type, key);
     }
     return result;
@@ -12011,11 +12442,11 @@ var ProviderLoader = class _ProviderLoader {
   * Save provider setting value (writes to config.json)
   */
   setSetting(type, key, value) {
-    const provider = this.providers.get(type);
-    const schemaDef = provider?.settings?.[key];
+    const schemaDef = this.getSettingsSchema(type)[key];
     if (!schemaDef) return false;
     if (!schemaDef.public) return false;
     if (schemaDef.type === "boolean" && typeof value !== "boolean") return false;
+    if (schemaDef.type === "string" && typeof value !== "string") return false;
     if (schemaDef.type === "number") {
       if (typeof value !== "number") return false;
       if (schemaDef.min !== void 0 && value < schemaDef.min) return false;
@@ -12036,6 +12467,53 @@ var ProviderLoader = class _ProviderLoader {
       return false;
     }
   }
+  getOptionalStringSetting(type, key) {
+    const value = this.getSettingValue(type, key);
+    if (typeof value !== "string") return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+  }
+  getSettingsSchema(type) {
+    const provider = this.providers.get(type);
+    if (!provider) return {};
+    return {
+      ...this.getSyntheticSettings(type, provider),
+      ...provider.settings || {}
+    };
+  }
+  getSyntheticSettings(type, provider) {
+    const result = {};
+    if ((provider.category === "cli" || provider.category === "acp") && provider.spawn?.command && !provider.settings?.executablePath) {
+      result.executablePath = {
+        type: "string",
+        default: "",
+        public: true,
+        label: "Executable path",
+        description: "Optional absolute path for this provider binary. Leave blank to use the default PATH lookup."
+      };
+    }
+    if (provider.category === "ide") {
+      if (provider.cli && !provider.settings?.cliPathOverride) {
+        result.cliPathOverride = {
+          type: "string",
+          default: "",
+          public: true,
+          label: "CLI path override",
+          description: "Optional absolute path for the IDE CLI launcher. Leave blank to use the detected default."
+        };
+      }
+      if (provider.paths && !provider.settings?.appPathOverride) {
+        result.appPathOverride = {
+          type: "string",
+          default: "",
+          public: true,
+          label: "App path override",
+          description: "Optional absolute path for the IDE app bundle or executable. Leave blank to use the default install locations."
+        };
+      }
+    }
+    return result;
+  }
   // ─── Private ───────────────────────────────────
   /**
    * Find the on-disk directory for a provider by type.
@@ -12049,17 +12527,17 @@ var ProviderLoader = class _ProviderLoader {
     for (const root of searchRoots) {
       if (!fs6.existsSync(root)) continue;
       const candidate = this.getProviderDir(root, cat, type);
-      if (fs6.existsSync(path10.join(candidate, "provider.json"))) return candidate;
-      const catDir = path10.join(root, cat);
+      if (fs6.existsSync(path12.join(candidate, "provider.json"))) return candidate;
+      const catDir = path12.join(root, cat);
       if (fs6.existsSync(catDir)) {
         try {
           for (const entry of fs6.readdirSync(catDir, { withFileTypes: true })) {
             if (!entry.isDirectory()) continue;
-            const jsonPath = path10.join(catDir, entry.name, "provider.json");
+            const jsonPath = path12.join(catDir, entry.name, "provider.json");
             if (fs6.existsSync(jsonPath)) {
               try {
                 const data = JSON.parse(fs6.readFileSync(jsonPath, "utf-8"));
-                if (data.type === type) return path10.join(catDir, entry.name);
+                if (data.type === type) return path12.join(catDir, entry.name);
               } catch {
               }
             }
@@ -12076,7 +12554,7 @@ var ProviderLoader = class _ProviderLoader {
    * (template substitution is NOT applied here — scripts.js handles that)
    */
   buildScriptWrappersFromDir(dir) {
-    const scriptsJs = path10.join(dir, "scripts.js");
+    const scriptsJs = path12.join(dir, "scripts.js");
     if (fs6.existsSync(scriptsJs)) {
       try {
         delete require.cache[require.resolve(scriptsJs)];
@@ -12090,7 +12568,7 @@ var ProviderLoader = class _ProviderLoader {
       for (const file of fs6.readdirSync(dir)) {
         if (!file.endsWith(".js")) continue;
         const scriptName = toCamel(file.replace(".js", ""));
-        const filePath = path10.join(dir, file);
+        const filePath = path12.join(dir, file);
         result[scriptName] = (...args) => {
           try {
             let content = fs6.readFileSync(filePath, "utf-8");
@@ -12150,7 +12628,7 @@ var ProviderLoader = class _ProviderLoader {
       }
       const hasJson = entries.some((e) => e.name === "provider.json");
       if (hasJson) {
-        const jsonPath = path10.join(d, "provider.json");
+        const jsonPath = path12.join(d, "provider.json");
         try {
           const raw = fs6.readFileSync(jsonPath, "utf-8");
           const mod = JSON.parse(raw);
@@ -12163,7 +12641,7 @@ var ProviderLoader = class _ProviderLoader {
               delete mod.extensionIdPattern_flags;
             }
             const hasCompatibility = Array.isArray(mod.compatibility);
-            const scriptsPath = path10.join(d, "scripts.js");
+            const scriptsPath = path12.join(d, "scripts.js");
             if (!hasCompatibility && fs6.existsSync(scriptsPath)) {
               try {
                 delete require.cache[require.resolve(scriptsPath)];
@@ -12189,7 +12667,7 @@ var ProviderLoader = class _ProviderLoader {
           if (!entry.isDirectory()) continue;
           if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
           if (excludeDirs && d === dir && excludeDirs.includes(entry.name)) continue;
-          scan(path10.join(d, entry.name));
+          scan(path12.join(d, entry.name));
         }
       }
     };
@@ -12285,17 +12763,17 @@ async function findFreePort(ports) {
   throw new Error("No free port found");
 }
 function checkPortFree(port) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve12) => {
     const server = net.createServer();
     server.unref();
-    server.on("error", () => resolve9(false));
+    server.on("error", () => resolve12(false));
     server.listen(port, "127.0.0.1", () => {
-      server.close(() => resolve9(true));
+      server.close(() => resolve12(true));
     });
   });
 }
 async function isCdpActive(port) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve12) => {
     const req = require("http").get(`http://127.0.0.1:${port}/json/version`, {
       timeout: 2e3
     }, (res) => {
@@ -12304,16 +12782,16 @@ async function isCdpActive(port) {
       res.on("end", () => {
         try {
           const info = JSON.parse(data);
-          resolve9(!!info["WebKit-Version"] || !!info["Browser"]);
+          resolve12(!!info["WebKit-Version"] || !!info["Browser"]);
         } catch {
-          resolve9(false);
+          resolve12(false);
         }
       });
     });
-    req.on("error", () => resolve9(false));
+    req.on("error", () => resolve12(false));
     req.on("timeout", () => {
       req.destroy();
-      resolve9(false);
+      resolve12(false);
     });
   });
 }
@@ -12447,8 +12925,8 @@ function detectCurrentWorkspace(ideId) {
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
-        const storagePath = path11.join(
-          process.env.APPDATA || path11.join(os12.homedir(), "AppData", "Roaming"),
+        const storagePath = path13.join(
+          process.env.APPDATA || path13.join(os12.homedir(), "AppData", "Roaming"),
           appName,
           "storage.json"
         );
@@ -12472,7 +12950,7 @@ function detectCurrentWorkspace(ideId) {
 async function launchWithCdp(options = {}) {
   const platform9 = os12.platform();
   let targetIde;
-  const ides = await detectIDEs();
+  const ides = await detectIDEs(getProviderLoader());
   if (options.ideId) {
     targetIde = ides.find((i) => i.id === options.ideId && i.installed);
     if (!targetIde) {
@@ -12626,9 +13104,9 @@ init_logger();
 
 // src/logging/command-log.ts
 var fs7 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 var os13 = __toESM(require("os"));
-var LOG_DIR2 = process.platform === "win32" ? path12.join(process.env.LOCALAPPDATA || process.env.APPDATA || path12.join(os13.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path12.join(os13.homedir(), "Library", "Logs", "adhdev") : path12.join(os13.homedir(), ".local", "share", "adhdev", "logs");
+var LOG_DIR2 = process.platform === "win32" ? path14.join(process.env.LOCALAPPDATA || process.env.APPDATA || path14.join(os13.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path14.join(os13.homedir(), "Library", "Logs", "adhdev") : path14.join(os13.homedir(), ".local", "share", "adhdev", "logs");
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var MAX_DAYS = 7;
 try {
@@ -12666,13 +13144,13 @@ function getDateStr2() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
 var currentDate2 = getDateStr2();
-var currentFile = path12.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+var currentFile = path14.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
 var writeCount2 = 0;
 function checkRotation() {
   const today = getDateStr2();
   if (today !== currentDate2) {
     currentDate2 = today;
-    currentFile = path12.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+    currentFile = path14.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
     cleanOldFiles();
   }
 }
@@ -12686,7 +13164,7 @@ function cleanOldFiles() {
       const dateMatch = file.match(/commands-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs7.unlinkSync(path12.join(LOG_DIR2, file));
+          fs7.unlinkSync(path14.join(LOG_DIR2, file));
         } catch {
         }
       }
@@ -12778,12 +13256,15 @@ function buildDetectedIdeInfos(detectedIdes, cdpManagers) {
   }));
 }
 function buildAvailableProviders(providerLoader) {
-  return providerLoader.getAll().map((provider) => ({
+  const providers = providerLoader.getAvailableProviderInfos?.() || providerLoader.getAll();
+  return providers.map((provider) => ({
     type: provider.type,
     name: provider.displayName || provider.type,
     displayName: provider.displayName || provider.type,
     icon: provider.icon || "\u{1F4BB}",
-    category: provider.category
+    category: provider.category,
+    ...provider.installed !== void 0 ? { installed: provider.installed } : {},
+    ...provider.detectedPath !== void 0 ? { detectedPath: provider.detectedPath } : {}
   }));
 }
 function parseMessageTime(value) {
@@ -12911,13 +13392,13 @@ var import_child_process7 = require("child_process");
 var import_child_process8 = require("child_process");
 var fs8 = __toESM(require("fs"));
 var os15 = __toESM(require("os"));
-var path13 = __toESM(require("path"));
+var path15 = __toESM(require("path"));
 var UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
 function getUpgradeLogPath() {
   const home = os15.homedir();
-  const dir = path13.join(home, ".adhdev");
+  const dir = path15.join(home, ".adhdev");
   fs8.mkdirSync(dir, { recursive: true });
-  return path13.join(dir, "daemon-upgrade.log");
+  return path15.join(dir, "daemon-upgrade.log");
 }
 function appendUpgradeLog(message) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
@@ -12950,14 +13431,14 @@ async function waitForPidExit(pid, timeoutMs) {
   while (Date.now() - start < timeoutMs) {
     try {
       process.kill(pid, 0);
-      await new Promise((resolve9) => setTimeout(resolve9, 250));
+      await new Promise((resolve12) => setTimeout(resolve12, 250));
     } catch {
       return;
     }
   }
 }
 function stopSessionHostProcesses(appName) {
-  const pidFile = path13.join(os15.homedir(), ".adhdev", `${appName}-session-host.pid`);
+  const pidFile = path15.join(os15.homedir(), ".adhdev", `${appName}-session-host.pid`);
   try {
     if (fs8.existsSync(pidFile)) {
       const pid = Number.parseInt(fs8.readFileSync(pidFile, "utf8").trim(), 10);
@@ -12986,7 +13467,7 @@ function stopSessionHostProcesses(appName) {
   }
 }
 function removeDaemonPidFile() {
-  const pidFile = path13.join(os15.homedir(), ".adhdev", "daemon.pid");
+  const pidFile = path15.join(os15.homedir(), ".adhdev", "daemon.pid");
   try {
     fs8.unlinkSync(pidFile);
   } catch {
@@ -12997,7 +13478,7 @@ function cleanupStaleGlobalInstallDirs(pkgName) {
   const npmRoot = (0, import_child_process7.execFileSync)(getNpmExecutable(), ["root", "-g"], { encoding: "utf8", ...npmExecOpts }).trim();
   if (!npmRoot) return;
   const npmPrefix = (0, import_child_process7.execFileSync)(getNpmExecutable(), ["prefix", "-g"], { encoding: "utf8", ...npmExecOpts }).trim();
-  const binDir = process.platform === "win32" ? npmPrefix : path13.join(npmPrefix, "bin");
+  const binDir = process.platform === "win32" ? npmPrefix : path15.join(npmPrefix, "bin");
   const packageBaseName = pkgName.startsWith("@") ? pkgName.split("/")[1] : pkgName;
   const binNames = /* @__PURE__ */ new Set([packageBaseName]);
   if (pkgName === "@adhdev/daemon-standalone") {
@@ -13005,25 +13486,25 @@ function cleanupStaleGlobalInstallDirs(pkgName) {
   }
   if (pkgName.startsWith("@")) {
     const [scope, name] = pkgName.split("/");
-    const scopeDir = path13.join(npmRoot, scope);
+    const scopeDir = path15.join(npmRoot, scope);
     if (!fs8.existsSync(scopeDir)) return;
     for (const entry of fs8.readdirSync(scopeDir)) {
       if (!entry.startsWith(`.${name}-`)) continue;
-      fs8.rmSync(path13.join(scopeDir, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale scoped staging dir: ${path13.join(scopeDir, entry)}`);
+      fs8.rmSync(path15.join(scopeDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale scoped staging dir: ${path15.join(scopeDir, entry)}`);
     }
   } else {
     for (const entry of fs8.readdirSync(npmRoot)) {
       if (!entry.startsWith(`.${pkgName}-`)) continue;
-      fs8.rmSync(path13.join(npmRoot, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale staging dir: ${path13.join(npmRoot, entry)}`);
+      fs8.rmSync(path15.join(npmRoot, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale staging dir: ${path15.join(npmRoot, entry)}`);
     }
   }
   if (fs8.existsSync(binDir)) {
     for (const entry of fs8.readdirSync(binDir)) {
       if (![...binNames].some((name) => entry.startsWith(`.${name}-`))) continue;
-      fs8.rmSync(path13.join(binDir, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale bin staging entry: ${path13.join(binDir, entry)}`);
+      fs8.rmSync(path15.join(binDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale bin staging entry: ${path15.join(binDir, entry)}`);
     }
   }
 }
@@ -13065,7 +13546,7 @@ async function runDaemonUpgradeHelper(payload) {
     appendUpgradeLog(installOutput.trim());
   }
   if (process.platform === "win32") {
-    await new Promise((resolve9) => setTimeout(resolve9, 500));
+    await new Promise((resolve12) => setTimeout(resolve12, 500));
     cleanupStaleGlobalInstallDirs(payload.packageName);
     appendUpgradeLog("Post-install staging cleanup complete");
   }
@@ -13261,6 +13742,15 @@ var DaemonCommandRouter = class {
         const record = await this.deps.sessionHostControl.forceDetachClient(sessionId, clientId);
         return { success: true, record };
       }
+      case "session_host_prune_duplicate_sessions": {
+        if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+        const result = await this.deps.sessionHostControl.pruneDuplicateSessions({
+          providerType: typeof args?.providerType === "string" ? args.providerType : void 0,
+          workspace: typeof args?.workspace === "string" ? args.workspace : void 0,
+          dryRun: args?.dryRun === true
+        });
+        return { success: true, result };
+      }
       case "session_host_acquire_write": {
         if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
         const sessionId = typeof args?.sessionId === "string" ? args.sessionId : "";
@@ -13343,6 +13833,12 @@ var DaemonCommandRouter = class {
         if (!ideType) throw new Error("ideType required");
         const killProcess = args?.killProcess !== false;
         await this.stopIde(ideType, killProcess);
+        try {
+          const results = await detectIDEs(this.deps.providerLoader);
+          this.deps.detectedIdes.value = results;
+          this.deps.providerLoader.setIdeDetectionResults(results, true);
+        } catch {
+        }
         return { success: true, ideType, stopped: true, processKilled: killProcess };
       }
       // ─── IDE restart ───
@@ -13385,6 +13881,12 @@ var DaemonCommandRouter = class {
           }
         }
         this.deps.onIdeConnected?.();
+        try {
+          const results = await detectIDEs(this.deps.providerLoader);
+          this.deps.detectedIdes.value = results;
+          this.deps.providerLoader.setIdeDetectionResults(results, true);
+        } catch {
+        }
         if (result.success && resolvedWorkspace) {
           try {
             const next = appendRecentActivity(loadState(), {
@@ -13412,8 +13914,9 @@ var DaemonCommandRouter = class {
       }
       // ─── Detect IDEs ───
       case "detect_ides": {
-        const results = await detectIDEs();
+        const results = await detectIDEs(this.deps.providerLoader);
         this.deps.detectedIdes.value = results;
+        this.deps.providerLoader.setIdeDetectionResults(results, true);
         return { success: true, detectedInfo: results };
       }
       // ─── Set User Name ───
@@ -13833,6 +14336,51 @@ var ProviderStreamAdapter = class {
   isTransportError(reason) {
     return /Session with given id not found/i.test(reason) || /CDP not connected/i.test(reason) || /Target closed/i.test(reason) || /WebSocket not open/i.test(reason) || /not connected/i.test(reason) || /execution context/i.test(reason) || /Cannot find context with specified id/i.test(reason);
   }
+  titlesMatch(actual, expected) {
+    const lhs = actual.trim().toLowerCase();
+    const rhs = expected.trim().toLowerCase();
+    if (!lhs || !rhs) return false;
+    return lhs === rhs || lhs.includes(rhs) || rhs.includes(lhs);
+  }
+  messageCount(state) {
+    return Array.isArray(state?.messages) ? state.messages.length : 0;
+  }
+  lastMessageSignature(state) {
+    const messages = Array.isArray(state?.messages) ? state.messages : [];
+    const last = messages[messages.length - 1];
+    if (!last) return "";
+    return `${last.role || ""}:${String(last.content || "").replace(/\s+/g, " ").trim()}`;
+  }
+  async verifySendOutcome(evaluate, before) {
+    const beforeCount = this.messageCount(before);
+    const beforeSignature = this.lastMessageSignature(before);
+    for (let attempt = 0; attempt < 12; attempt += 1) {
+      await new Promise((resolve12) => setTimeout(resolve12, 250));
+      let state;
+      try {
+        state = await this.readChat(evaluate);
+      } catch {
+        continue;
+      }
+      if (state.status === "waiting_approval") {
+        return true;
+      }
+      const afterCount = this.messageCount(state);
+      const afterSignature = this.lastMessageSignature(state);
+      if (afterCount > beforeCount) return true;
+      if (afterSignature && afterSignature !== beforeSignature) return true;
+    }
+    return false;
+  }
+  async readStableBaselineState(evaluate) {
+    const first = await this.readChat(evaluate);
+    if (this.messageCount(first) > 0 || this.lastMessageSignature(first)) {
+      return first;
+    }
+    await new Promise((resolve12) => setTimeout(resolve12, 150));
+    const second = await this.readChat(evaluate);
+    return this.messageCount(second) >= this.messageCount(first) ? second : first;
+  }
   async readChat(evaluate) {
     const script = this.callScript("readChat");
     if (!script) return this.errorState("readChat script not available");
@@ -13858,6 +14406,9 @@ var ProviderStreamAdapter = class {
         mode: data.mode,
         activeModal: data.activeModal
       };
+      if (typeof data.title === "string" && data.title.trim()) {
+        state.title = data.title.trim();
+      }
       const controlValues = extractProviderControlValues(this.provider.controls, data);
       if (controlValues) state.controlValues = controlValues;
       const effects = normalizeProviderEffects(data);
@@ -13881,6 +14432,12 @@ var ProviderStreamAdapter = class {
     }
   }
   async sendMessage(evaluate, text) {
+    let beforeState = null;
+    try {
+      beforeState = await this.readStableBaselineState(evaluate);
+    } catch {
+      beforeState = null;
+    }
     const params = { message: text };
     const script = this.callScript("sendMessage", params) || this.callScript("sendMessage", text);
     if (!script) throw new Error(`[${this.agentName}] sendMessage script not available`);
@@ -13898,7 +14455,9 @@ var ProviderStreamAdapter = class {
     }
     if (parsed && typeof parsed === "object") {
       if (parsed.sent === true || parsed.success === true || parsed.ok === true || parsed.submitted === true || parsed.dispatched === true) {
-        return;
+        const verified = await this.verifySendOutcome(evaluate, beforeState);
+        if (verified) return;
+        throw new Error(`[${this.agentName}] sendMessage was not observed in chat state`);
       }
       if (typeof parsed.error === "string" && parsed.error.trim()) {
         throw new Error(`[${this.agentName}] sendMessage failed: ${parsed.error}`);
@@ -13909,7 +14468,15 @@ var ProviderStreamAdapter = class {
   async resolveAction(evaluate, action, button) {
     const script = this.callScript("resolveAction", { action, button });
     if (!script) return false;
-    return await evaluate(script) === true;
+    const result = await evaluate(script);
+    const parsed = this.parseMaybeJson(result);
+    if (parsed === true) return true;
+    if (typeof parsed === "string") {
+      const normalized = parsed.trim().toLowerCase();
+      return normalized === "ok" || normalized === "success" || normalized === "true" || normalized === "resolved" || normalized === "approved" || normalized === "rejected";
+    }
+    if (!parsed || typeof parsed !== "object") return false;
+    return parsed.resolved === true || parsed.success === true || parsed.ok === true || parsed.found === true;
   }
   async newSession(evaluate) {
     const script = this.callScript("newSession");
@@ -13927,7 +14494,10 @@ var ProviderStreamAdapter = class {
       const raw = await evaluate(script, 1e4);
       const data = typeof raw === "string" ? JSON.parse(raw) : raw;
       if (data?.error) return [];
-      return Array.isArray(data) ? data : [];
+      if (Array.isArray(data)) return data;
+      if (Array.isArray(data?.sessions)) return data.sessions;
+      if (Array.isArray(data?.chats)) return data.chats;
+      return [];
     } catch {
       return [];
     }
@@ -13935,7 +14505,24 @@ var ProviderStreamAdapter = class {
   async switchSession(evaluate, sessionId) {
     const script = this.callScript("switchSession", sessionId);
     if (!script) return false;
-    return await evaluate(script, 1e4) === true;
+    const raw = await evaluate(script, 1e4);
+    const data = this.parseMaybeJson(raw);
+    if (data === true) return true;
+    if (typeof data === "string") {
+      const normalized = data.trim().toLowerCase();
+      return normalized === "true" || normalized === "ok" || normalized === "switched" || normalized === "success";
+    }
+    if (data && typeof data === "object") {
+      if (data.switched === true || data.success === true || data.ok === true) return true;
+      if (typeof data.error === "string" && data.error.trim()) return false;
+    }
+    for (let attempt = 0; attempt < 6; attempt += 1) {
+      await new Promise((resolve12) => setTimeout(resolve12, 250));
+      const state = await this.readChat(evaluate);
+      const title = typeof state.title === "string" ? state.title : "";
+      if (this.titlesMatch(title, sessionId)) return true;
+    }
+    return false;
   }
   async focusEditor(evaluate) {
     const script = this.callScript("focusEditor");
@@ -14141,7 +14728,7 @@ var DaemonAgentStreamManager = class {
       return false;
     }
   }
-  async resolveSessionAction(cdp, sessionId, action) {
+  async resolveSessionAction(cdp, sessionId, action, button) {
     await this.ensureSessionPanelOpen(sessionId);
     const target = this.getSessionTarget(sessionId);
     if (!target?.parentSessionId) return false;
@@ -14151,7 +14738,7 @@ var DaemonAgentStreamManager = class {
     if (!agent) return false;
     try {
       const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
-      return await agent.adapter.resolveAction(evaluate, action);
+      return await agent.adapter.resolveAction(evaluate, action, button);
     } catch (e) {
       this.logFn(`[AgentStream] resolveAction(${sessionId}) error: ${e.message}`);
       return false;
@@ -14625,11 +15212,11 @@ var ProviderInstanceManager = class {
 
 // src/providers/version-archive.ts
 var fs10 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var path16 = __toESM(require("path"));
 var os16 = __toESM(require("os"));
 var import_child_process9 = require("child_process");
 var import_os3 = require("os");
-var ARCHIVE_PATH = path14.join(os16.homedir(), ".adhdev", "version-history.json");
+var ARCHIVE_PATH = path16.join(os16.homedir(), ".adhdev", "version-history.json");
 var MAX_ENTRIES_PER_PROVIDER = 20;
 var VersionArchive = class {
   history = {};
@@ -14676,7 +15263,7 @@ var VersionArchive = class {
   }
   save() {
     try {
-      fs10.mkdirSync(path14.dirname(ARCHIVE_PATH), { recursive: true });
+      fs10.mkdirSync(path16.dirname(ARCHIVE_PATH), { recursive: true });
       fs10.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
     } catch {
     }
@@ -14717,7 +15304,7 @@ function checkPathExists2(paths) {
   for (const p of paths) {
     if (p.includes("*")) {
       const home = os16.homedir();
-      const resolved = p.replace(/\*/g, home.split(path14.sep).pop() || "");
+      const resolved = p.replace(/\*/g, home.split(path16.sep).pop() || "");
       if (fs10.existsSync(resolved)) return resolved;
     } else {
       if (fs10.existsSync(p)) return p;
@@ -14727,7 +15314,7 @@ function checkPathExists2(paths) {
 }
 function getMacAppVersion(appPath) {
   if ((0, import_os3.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
-  const plistPath = path14.join(appPath, "Contents", "Info.plist");
+  const plistPath = path16.join(appPath, "Contents", "Info.plist");
   if (!fs10.existsSync(plistPath)) return null;
   const raw = runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
@@ -14754,7 +15341,7 @@ async function detectAllVersions(loader, archive) {
       const cliBin = provider.cli ? findBinary2(provider.cli) : null;
       let resolvedBin = cliBin;
       if (!resolvedBin && appPath && currentOs === "darwin") {
-        const bundled = path14.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
+        const bundled = path16.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
         if (provider.cli && fs10.existsSync(bundled)) resolvedBin = bundled;
       }
       info.installed = !!(appPath || resolvedBin);
@@ -14795,7 +15382,7 @@ async function detectAllVersions(loader, archive) {
 // src/daemon/dev-server.ts
 var http2 = __toESM(require("http"));
 var fs14 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var path20 = __toESM(require("path"));
 
 // src/daemon/scaffold-template.ts
 function generateFiles(type, name, category, opts = {}) {
@@ -15131,7 +15718,7 @@ init_logger();
 
 // src/daemon/dev-cdp-handlers.ts
 var fs11 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
 init_logger();
 async function handleCdpEvaluate(ctx, req, res) {
   const body = await ctx.readBody(req);
@@ -15310,17 +15897,17 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   let scriptsPath = "";
-  const directScripts = path15.join(dir, "scripts.js");
+  const directScripts = path17.join(dir, "scripts.js");
   if (fs11.existsSync(directScripts)) {
     scriptsPath = directScripts;
   } else {
-    const scriptsDir = path15.join(dir, "scripts");
+    const scriptsDir = path17.join(dir, "scripts");
     if (fs11.existsSync(scriptsDir)) {
       const versions = fs11.readdirSync(scriptsDir).filter((d) => {
-        return fs11.statSync(path15.join(scriptsDir, d)).isDirectory();
+        return fs11.statSync(path17.join(scriptsDir, d)).isDirectory();
       }).sort().reverse();
       for (const ver of versions) {
-        const p = path15.join(scriptsDir, ver, "scripts.js");
+        const p = path17.join(scriptsDir, ver, "scripts.js");
         if (fs11.existsSync(p)) {
           scriptsPath = p;
           break;
@@ -16139,7 +16726,7 @@ async function handleDomContext(ctx, type, req, res) {
 
 // src/daemon/dev-cli-debug.ts
 var fs12 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var path18 = __toESM(require("path"));
 function slugifyFixtureName(value) {
   const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return normalized || `fixture-${Date.now()}`;
@@ -16149,11 +16736,11 @@ function getCliFixtureDir(ctx, type) {
   if (!providerDir) {
     throw new Error(`Provider directory not found for '${type}'`);
   }
-  return path16.join(providerDir, "fixtures");
+  return path18.join(providerDir, "fixtures");
 }
 function readCliFixture(ctx, type, name) {
   const fixtureDir = getCliFixtureDir(ctx, type);
-  const filePath = path16.join(fixtureDir, `${name}.json`);
+  const filePath = path18.join(fixtureDir, `${name}.json`);
   if (!fs12.existsSync(filePath)) {
     throw new Error(`Fixture not found: ${filePath}`);
   }
@@ -16313,7 +16900,7 @@ function getCliTargetBundle(ctx, type, instanceId) {
   return { target, instance, adapter };
 }
 function sleep(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 async function waitForCliReady(ctx, type, instanceId, timeoutMs) {
   const startedAt = Date.now();
@@ -16912,7 +17499,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       },
       notes: typeof body?.notes === "string" ? body.notes : void 0
     };
-    const filePath = path16.join(fixtureDir, `${name}.json`);
+    const filePath = path18.join(fixtureDir, `${name}.json`);
     fs12.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
     ctx.json(res, 200, {
       saved: true,
@@ -16936,7 +17523,7 @@ async function handleCliFixtureList(ctx, type, _req, res) {
       return;
     }
     const fixtures = fs12.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
-      const fullPath = path16.join(fixtureDir, file);
+      const fullPath = path18.join(fixtureDir, file);
       try {
         const raw = JSON.parse(fs12.readFileSync(fullPath, "utf-8"));
         return {
@@ -17072,7 +17659,7 @@ async function handleCliRaw(ctx, req, res) {
 
 // src/daemon/dev-auto-implement.ts
 var fs13 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var path19 = __toESM(require("path"));
 var os17 = __toESM(require("os"));
 function getAutoImplPid(ctx) {
   const proc = ctx.autoImplProcess;
@@ -17112,22 +17699,22 @@ function getLatestScriptVersionDir(scriptsDir) {
   if (!fs13.existsSync(scriptsDir)) return null;
   const versions = fs13.readdirSync(scriptsDir).filter((d) => {
     try {
-      return fs13.statSync(path17.join(scriptsDir, d)).isDirectory();
+      return fs13.statSync(path19.join(scriptsDir, d)).isDirectory();
     } catch {
       return false;
     }
   }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
   if (versions.length === 0) return null;
-  return path17.join(scriptsDir, versions[0]);
+  return path19.join(scriptsDir, versions[0]);
 }
 function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
-  const canonicalUserDir = path17.resolve(ctx.providerLoader.getUserProviderDir(category, type));
-  const desiredDir = requestedDir ? path17.resolve(requestedDir) : canonicalUserDir;
-  const upstreamRoot = path17.resolve(ctx.providerLoader.getUpstreamDir());
-  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path17.sep}`)) {
+  const canonicalUserDir = path19.resolve(ctx.providerLoader.getUserProviderDir(category, type));
+  const desiredDir = requestedDir ? path19.resolve(requestedDir) : canonicalUserDir;
+  const upstreamRoot = path19.resolve(ctx.providerLoader.getUpstreamDir());
+  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path19.sep}`)) {
     return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
   }
-  if (path17.basename(desiredDir) !== type) {
+  if (path19.basename(desiredDir) !== type) {
     return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
   }
   const sourceDir = ctx.findProviderDir(type);
@@ -17135,11 +17722,11 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
     return { dir: null, reason: `Provider source directory not found for '${type}'` };
   }
   if (!fs13.existsSync(desiredDir)) {
-    fs13.mkdirSync(path17.dirname(desiredDir), { recursive: true });
+    fs13.mkdirSync(path19.dirname(desiredDir), { recursive: true });
     fs13.cpSync(sourceDir, desiredDir, { recursive: true });
     ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
   }
-  const providerJson = path17.join(desiredDir, "provider.json");
+  const providerJson = path19.join(desiredDir, "provider.json");
   if (!fs13.existsSync(providerJson)) {
     return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
   }
@@ -17162,13 +17749,13 @@ function loadAutoImplReferenceScripts(ctx, referenceType) {
   const refDir = ctx.findProviderDir(referenceType);
   if (!refDir || !fs13.existsSync(refDir)) return {};
   const referenceScripts = {};
-  const scriptsDir = path17.join(refDir, "scripts");
+  const scriptsDir = path19.join(refDir, "scripts");
   const latestDir = getLatestScriptVersionDir(scriptsDir);
   if (!latestDir) return referenceScripts;
   for (const file of fs13.readdirSync(latestDir)) {
     if (!file.endsWith(".js")) continue;
     try {
-      referenceScripts[file] = fs13.readFileSync(path17.join(latestDir, file), "utf-8");
+      referenceScripts[file] = fs13.readFileSync(path19.join(latestDir, file), "utf-8");
     } catch {
     }
   }
@@ -17276,9 +17863,9 @@ async function handleAutoImplement(ctx, type, req, res) {
     });
     const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
     const prompt = buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
-    const tmpDir = path17.join(os17.tmpdir(), "adhdev-autoimpl");
+    const tmpDir = path19.join(os17.tmpdir(), "adhdev-autoimpl");
     if (!fs13.existsSync(tmpDir)) fs13.mkdirSync(tmpDir, { recursive: true });
-    const promptFile = path17.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
+    const promptFile = path19.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
     fs13.writeFileSync(promptFile, prompt, "utf-8");
     ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
     const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
@@ -17705,7 +18292,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     setMode: "set_mode.js"
   };
   const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-  const scriptsDir = path17.join(providerDir, "scripts");
+  const scriptsDir = path19.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -17716,7 +18303,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     for (const file of fs13.readdirSync(latestScriptsDir)) {
       if (file.endsWith(".js") && targetFileNames.has(file)) {
         try {
-          const content = fs13.readFileSync(path17.join(latestScriptsDir, file), "utf-8");
+          const content = fs13.readFileSync(path19.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -17733,7 +18320,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs13.readFileSync(path17.join(latestScriptsDir, file), "utf-8");
+          const content = fs13.readFileSync(path19.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -17774,10 +18361,10 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
       lines.push("");
     }
   }
-  const docsDir = path17.join(providerDir, "../../docs");
+  const docsDir = path19.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path17.join(docsDir, name);
+      const p = path19.join(docsDir, name);
       if (fs13.existsSync(p)) return fs13.readFileSync(p, "utf-8");
     } catch {
     }
@@ -18012,7 +18599,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     parseApproval: "parse_approval.js"
   };
   const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-  const scriptsDir = path17.join(providerDir, "scripts");
+  const scriptsDir = path19.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -18024,7 +18611,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       if (!file.endsWith(".js")) continue;
       if (!targetFileNames.has(file)) continue;
       try {
-        const content = fs13.readFileSync(path17.join(latestScriptsDir, file), "utf-8");
+        const content = fs13.readFileSync(path19.join(latestScriptsDir, file), "utf-8");
         lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -18040,7 +18627,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs13.readFileSync(path17.join(latestScriptsDir, file), "utf-8");
+          const content = fs13.readFileSync(path19.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -18073,10 +18660,10 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       lines.push("");
     }
   }
-  const docsDir = path17.join(providerDir, "../../docs");
+  const docsDir = path19.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path17.join(docsDir, name);
+      const p = path19.join(docsDir, name);
       if (fs13.existsSync(p)) return fs13.readFileSync(p, "utf-8");
     } catch {
     }
@@ -18487,8 +19074,8 @@ var DevServer = class _DevServer {
   }
   getEndpointList() {
     return this.routes.map((r) => {
-      const path19 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-      return `${r.method.padEnd(5)} ${path19}`;
+      const path21 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+      return `${r.method.padEnd(5)} ${path21}`;
     });
   }
   async start(port = DEV_SERVER_PORT) {
@@ -18519,15 +19106,15 @@ var DevServer = class _DevServer {
         this.json(res, 500, { error: e.message });
       }
     });
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve12, reject) => {
       this.server.listen(port, "127.0.0.1", () => {
         this.log(`Dev server listening on http://127.0.0.1:${port}`);
-        resolve9();
+        resolve12();
       });
       this.server.on("error", (e) => {
         if (e.code === "EADDRINUSE") {
           this.log(`Port ${port} in use, skipping dev server`);
-          resolve9();
+          resolve12();
         } else {
           reject(e);
         }
@@ -18610,20 +19197,20 @@ var DevServer = class _DevServer {
       child.stderr?.on("data", (d) => {
         stderr += d.toString().slice(0, 2e3);
       });
-      await new Promise((resolve9) => {
+      await new Promise((resolve12) => {
         const timer = setTimeout(() => {
           child.kill();
-          resolve9();
+          resolve12();
         }, 3e3);
         child.on("exit", () => {
           clearTimeout(timer);
-          resolve9();
+          resolve12();
         });
         child.stdout?.once("data", () => {
           setTimeout(() => {
             child.kill();
             clearTimeout(timer);
-            resolve9();
+            resolve12();
           }, 500);
         });
       });
@@ -18770,12 +19357,12 @@ var DevServer = class _DevServer {
   // ─── DevConsole SPA ───
   getConsoleDistDir() {
     const candidates = [
-      path18.resolve(__dirname, "../../web-devconsole/dist"),
-      path18.resolve(__dirname, "../../../web-devconsole/dist"),
-      path18.join(process.cwd(), "packages/web-devconsole/dist")
+      path20.resolve(__dirname, "../../web-devconsole/dist"),
+      path20.resolve(__dirname, "../../../web-devconsole/dist"),
+      path20.join(process.cwd(), "packages/web-devconsole/dist")
     ];
     for (const dir of candidates) {
-      if (fs14.existsSync(path18.join(dir, "index.html"))) return dir;
+      if (fs14.existsSync(path20.join(dir, "index.html"))) return dir;
     }
     return null;
   }
@@ -18785,7 +19372,7 @@ var DevServer = class _DevServer {
       this.json(res, 500, { error: "DevConsole not found. Run: npm run build -w packages/web-devconsole" });
       return;
     }
-    const htmlPath = path18.join(distDir, "index.html");
+    const htmlPath = path20.join(distDir, "index.html");
     try {
       const html = fs14.readFileSync(htmlPath, "utf-8");
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
@@ -18810,15 +19397,15 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: "Not found" });
       return;
     }
-    const safePath = path18.normalize(pathname).replace(/^\.\.\//, "");
-    const filePath = path18.join(distDir, safePath);
+    const safePath = path20.normalize(pathname).replace(/^\.\.\//, "");
+    const filePath = path20.join(distDir, safePath);
     if (!filePath.startsWith(distDir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
     try {
       const content = fs14.readFileSync(filePath);
-      const ext = path18.extname(filePath);
+      const ext = path20.extname(filePath);
       const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
       res.end(content);
@@ -18931,9 +19518,9 @@ var DevServer = class _DevServer {
           const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
           if (entry.isDirectory()) {
             files.push({ path: rel, size: 0, type: "dir" });
-            scan(path18.join(d, entry.name), rel);
+            scan(path20.join(d, entry.name), rel);
           } else {
-            const stat = fs14.statSync(path18.join(d, entry.name));
+            const stat = fs14.statSync(path20.join(d, entry.name));
             files.push({ path: rel, size: stat.size, type: "file" });
           }
         }
@@ -18956,7 +19543,7 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path18.resolve(dir, path18.normalize(filePath));
+    const fullPath = path20.resolve(dir, path20.normalize(filePath));
     if (!fullPath.startsWith(dir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
@@ -18981,14 +19568,14 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path18.resolve(dir, path18.normalize(filePath));
+    const fullPath = path20.resolve(dir, path20.normalize(filePath));
     if (!fullPath.startsWith(dir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
     try {
       if (fs14.existsSync(fullPath)) fs14.copyFileSync(fullPath, fullPath + ".bak");
-      fs14.mkdirSync(path18.dirname(fullPath), { recursive: true });
+      fs14.mkdirSync(path20.dirname(fullPath), { recursive: true });
       fs14.writeFileSync(fullPath, content, "utf-8");
       this.log(`File saved: ${fullPath} (${content.length} chars)`);
       this.providerLoader.reload();
@@ -19005,7 +19592,7 @@ var DevServer = class _DevServer {
       return;
     }
     for (const name of ["scripts.js", "provider.json"]) {
-      const p = path18.join(dir, name);
+      const p = path20.join(dir, name);
       if (fs14.existsSync(p)) {
         const source = fs14.readFileSync(p, "utf-8");
         this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
@@ -19026,8 +19613,8 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const target = fs14.existsSync(path18.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
-    const targetPath = path18.join(dir, target);
+    const target = fs14.existsSync(path20.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+    const targetPath = path20.join(dir, target);
     try {
       if (fs14.existsSync(targetPath)) fs14.copyFileSync(targetPath, targetPath + ".bak");
       fs14.writeFileSync(targetPath, source, "utf-8");
@@ -19132,14 +19719,14 @@ var DevServer = class _DevServer {
       child.stderr?.on("data", (d) => {
         stderr += d.toString();
       });
-      await new Promise((resolve9) => {
+      await new Promise((resolve12) => {
         const timer = setTimeout(() => {
           child.kill();
-          resolve9();
+          resolve12();
         }, timeout);
         child.on("exit", () => {
           clearTimeout(timer);
-          resolve9();
+          resolve12();
         });
       });
       const elapsed = Date.now() - start;
@@ -19187,7 +19774,7 @@ var DevServer = class _DevServer {
     }
     let targetDir;
     targetDir = this.providerLoader.getUserProviderDir(category, type);
-    const jsonPath = path18.join(targetDir, "provider.json");
+    const jsonPath = path20.join(targetDir, "provider.json");
     if (fs14.existsSync(jsonPath)) {
       this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
       return;
@@ -19199,8 +19786,8 @@ var DevServer = class _DevServer {
       const createdFiles = ["provider.json"];
       if (result.files) {
         for (const [relPath, content] of Object.entries(result.files)) {
-          const fullPath = path18.join(targetDir, relPath);
-          fs14.mkdirSync(path18.dirname(fullPath), { recursive: true });
+          const fullPath = path20.join(targetDir, relPath);
+          fs14.mkdirSync(path20.dirname(fullPath), { recursive: true });
           fs14.writeFileSync(fullPath, content, "utf-8");
           createdFiles.push(relPath);
         }
@@ -19253,22 +19840,22 @@ var DevServer = class _DevServer {
     if (!fs14.existsSync(scriptsDir)) return null;
     const versions = fs14.readdirSync(scriptsDir).filter((d) => {
       try {
-        return fs14.statSync(path18.join(scriptsDir, d)).isDirectory();
+        return fs14.statSync(path20.join(scriptsDir, d)).isDirectory();
       } catch {
         return false;
       }
     }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
     if (versions.length === 0) return null;
-    return path18.join(scriptsDir, versions[0]);
+    return path20.join(scriptsDir, versions[0]);
   }
   resolveAutoImplWritableProviderDir(category, type, requestedDir) {
-    const canonicalUserDir = path18.resolve(this.providerLoader.getUserProviderDir(category, type));
-    const desiredDir = requestedDir ? path18.resolve(requestedDir) : canonicalUserDir;
-    const upstreamRoot = path18.resolve(this.providerLoader.getUpstreamDir());
-    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path18.sep}`)) {
+    const canonicalUserDir = path20.resolve(this.providerLoader.getUserProviderDir(category, type));
+    const desiredDir = requestedDir ? path20.resolve(requestedDir) : canonicalUserDir;
+    const upstreamRoot = path20.resolve(this.providerLoader.getUpstreamDir());
+    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path20.sep}`)) {
       return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
     }
-    if (path18.basename(desiredDir) !== type) {
+    if (path20.basename(desiredDir) !== type) {
       return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
     }
     const sourceDir = this.findProviderDir(type);
@@ -19276,11 +19863,11 @@ var DevServer = class _DevServer {
       return { dir: null, reason: `Provider source directory not found for '${type}'` };
     }
     if (!fs14.existsSync(desiredDir)) {
-      fs14.mkdirSync(path18.dirname(desiredDir), { recursive: true });
+      fs14.mkdirSync(path20.dirname(desiredDir), { recursive: true });
       fs14.cpSync(sourceDir, desiredDir, { recursive: true });
       this.log(`Auto-implement writable copy created: ${desiredDir}`);
     }
-    const providerJson = path18.join(desiredDir, "provider.json");
+    const providerJson = path20.join(desiredDir, "provider.json");
     if (!fs14.existsSync(providerJson)) {
       return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
     }
@@ -19328,7 +19915,7 @@ var DevServer = class _DevServer {
       setMode: "set_mode.js"
     };
     const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-    const scriptsDir = path18.join(providerDir, "scripts");
+    const scriptsDir = path20.join(providerDir, "scripts");
     const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
     if (latestScriptsDir) {
       lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -19339,7 +19926,7 @@ var DevServer = class _DevServer {
       for (const file of fs14.readdirSync(latestScriptsDir)) {
         if (file.endsWith(".js") && targetFileNames.has(file)) {
           try {
-            const content = fs14.readFileSync(path18.join(latestScriptsDir, file), "utf-8");
+            const content = fs14.readFileSync(path20.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -19356,7 +19943,7 @@ var DevServer = class _DevServer {
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs14.readFileSync(path18.join(latestScriptsDir, file), "utf-8");
+            const content = fs14.readFileSync(path20.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -19397,10 +19984,10 @@ var DevServer = class _DevServer {
         lines.push("");
       }
     }
-    const docsDir = path18.join(providerDir, "../../docs");
+    const docsDir = path20.join(providerDir, "../../docs");
     const loadGuide = (name) => {
       try {
-        const p = path18.join(docsDir, name);
+        const p = path20.join(docsDir, name);
         if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
       } catch {
       }
@@ -19574,7 +20161,7 @@ var DevServer = class _DevServer {
       parseApproval: "parse_approval.js"
     };
     const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-    const scriptsDir = path18.join(providerDir, "scripts");
+    const scriptsDir = path20.join(providerDir, "scripts");
     const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
     if (latestScriptsDir) {
       lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -19586,7 +20173,7 @@ var DevServer = class _DevServer {
         if (!file.endsWith(".js")) continue;
         if (!targetFileNames.has(file)) continue;
         try {
-          const content = fs14.readFileSync(path18.join(latestScriptsDir, file), "utf-8");
+          const content = fs14.readFileSync(path20.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -19602,7 +20189,7 @@ var DevServer = class _DevServer {
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs14.readFileSync(path18.join(latestScriptsDir, file), "utf-8");
+            const content = fs14.readFileSync(path20.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -19635,10 +20222,10 @@ var DevServer = class _DevServer {
         lines.push("");
       }
     }
-    const docsDir = path18.join(providerDir, "../../docs");
+    const docsDir = path20.join(providerDir, "../../docs");
     const loadGuide = (name) => {
       try {
-        const p = path18.join(docsDir, name);
+        const p = path20.join(docsDir, name);
         if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
       } catch {
       }
@@ -19814,14 +20401,14 @@ data: ${JSON.stringify(msg.data)}
     res.end(JSON.stringify(data, null, 2));
   }
   async readBody(req) {
-    return new Promise((resolve9) => {
+    return new Promise((resolve12) => {
       let body = "";
       req.on("data", (chunk) => body += chunk);
       req.on("end", () => {
         try {
-          resolve9(JSON.parse(body));
+          resolve12(JSON.parse(body));
         } catch {
-          resolve9({});
+          resolve12({});
         }
       });
     });
@@ -20289,7 +20876,7 @@ async function waitForReady(endpoint, timeoutMs = STARTUP_TIMEOUT_MS) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (await canConnect(endpoint)) return;
-    await new Promise((resolve9) => setTimeout(resolve9, STARTUP_POLL_MS));
+    await new Promise((resolve12) => setTimeout(resolve12, STARTUP_POLL_MS));
   }
   throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
 }
@@ -20445,10 +21032,10 @@ async function installExtension(ide, extension) {
         const buffer = Buffer.from(await res.arrayBuffer());
         const fs15 = await import("fs");
         fs15.writeFileSync(vsixPath, buffer);
-        return new Promise((resolve9) => {
+        return new Promise((resolve12) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
           (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
-            resolve9({
+            resolve12({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
               success: !error,
@@ -20461,11 +21048,11 @@ async function installExtension(ide, extension) {
     } catch (e) {
     }
   }
-  return new Promise((resolve9) => {
+  return new Promise((resolve12) => {
     const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
     (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
       if (error) {
-        resolve9({
+        resolve12({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: false,
@@ -20473,7 +21060,7 @@ async function installExtension(ide, extension) {
           error: stderr || error.message
         });
       } else {
-        resolve9({
+        resolve12({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: true,
@@ -20609,13 +21196,32 @@ async function initDaemonComponents(config) {
   const detectedIdesRef = { value: [] };
   let agentStreamManager = null;
   let poller = null;
+  const refreshProviderAvailability = async (providerType) => {
+    const targetProvider = providerType ? providerLoader.getMeta(providerLoader.resolveAlias(providerType)) : null;
+    const targetCategory = targetProvider?.category;
+    if (!providerType || targetCategory === "cli" || targetCategory === "acp") {
+      if (providerType && targetProvider) {
+        const detected = await detectCLI(targetProvider.type, providerLoader, { includeVersion: false });
+        providerLoader.setProviderAvailability(targetProvider.type, {
+          installed: !!detected,
+          detectedPath: detected?.path || null
+        });
+      } else {
+        providerLoader.setCliDetectionResults(await detectCLIs(providerLoader, { includeVersion: false }), true);
+      }
+    }
+    if (!providerType || targetCategory === "ide") {
+      detectedIdesRef.value = await detectIDEs(providerLoader);
+      providerLoader.setIdeDetectionResults(detectedIdesRef.value, true);
+    }
+  };
   const cliManager = new DaemonCliManager({
     ...config.cliManagerDeps,
     getInstanceManager: () => instanceManager,
     getSessionRegistry: () => sessionRegistry
   }, providerLoader);
   LOG.info("Init", "Detecting IDEs...");
-  detectedIdesRef.value = await detectIDEs();
+  await refreshProviderAvailability();
   const installed = detectedIdesRef.value.filter((i) => i.installed);
   LOG.info("Init", `Found ${installed.length} IDE(s): ${installed.map((i) => i.id).join(", ") || "none"}`);
   const cdpSetupContext = {
@@ -20655,7 +21261,11 @@ async function initDaemonComponents(config) {
     adapters: cliManager.adapters,
     providerLoader,
     instanceManager,
-    sessionRegistry
+    sessionRegistry,
+    onProviderSettingChanged: async (providerType) => {
+      await refreshProviderAvailability(providerType);
+      config.onStatusChange?.();
+    }
   });
   agentStreamManager = new DaemonAgentStreamManager(
     LOG.forComponent("AgentStream").asLogFn(),