adhdev 0.8.8 → 0.8.10

package/dist/index.js

@@ -569,18 +569,18 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs() {
-  const os21 = (0, import_os2.platform)();
+  const os22 = (0, import_os2.platform)();
   const results = [];
   for (const def of getMergedDefinitions()) {
     const cliPath = findCliCommand(def.cli);
-    const appPath = checkPathExists(def.paths[os21] || []);
+    const appPath = checkPathExists(def.paths[os22] || []);
     const installed = !!(cliPath || appPath);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os21 === "darwin") {
+    if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if ((0, import_fs2.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os21 === "win32") {
+    if (!resolvedCli && appPath && os22 === "win32") {
       const { dirname: dirname9 } = await import("path");
       const appDir = dirname9(appPath);
       const candidates = [
@@ -738,9 +738,22 @@ var init_host_memory = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/logging/logger.ts
+function setLogLevel(level) {
+  currentLevel = level;
+  daemonLog("Logger", `Log level set to: ${level}`, "info");
+}
+function getLogLevel() {
+  return currentLevel;
+}
 function getDateStr() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
+function getDaemonLogDir() {
+  return LOG_DIR;
+}
+function getCurrentDaemonLogPath(date5 = /* @__PURE__ */ new Date()) {
+  return path4.join(LOG_DIR, `daemon-${date5.toISOString().slice(0, 10)}.log`);
+}
 function checkDateRotation() {
   const today = getDateStr();
   if (today !== currentDate) {
@@ -3272,6 +3285,17 @@ async function setupIdeInstance(ctx, opts) {
   }
   return ideInstance;
 }
+async function connectCdpManager(port, ideType, logFn, providerLoader, targetId) {
+  const provider = providerLoader.getMeta(ideType);
+  const manager = new DaemonCdpManager(
+    port,
+    logFn,
+    targetId,
+    provider?.targetFilter
+  );
+  const connected = await manager.connect();
+  return connected ? manager : null;
+}
 async function probeCdpPort(port, timeoutMs = 1e3) {
   try {
     const probe = await fetch(`http://localhost:${port}/json/version`, {
@@ -3291,12 +3315,154 @@ var init_setup = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/cdp/scanner.ts
+var DaemonCdpScanner;
 var init_scanner = __esm({
   "../../oss/packages/daemon-core/src/cdp/scanner.ts"() {
     "use strict";
     init_manager();
     init_setup();
     init_logger();
+    DaemonCdpScanner = class {
+      ctx;
+      opts;
+      scanTimer = null;
+      discoveryTimer = null;
+      constructor(opts) {
+        this.ctx = opts.ctx;
+        this.opts = opts;
+      }
+      /**
+       * Initial CDP discovery — connect to all available IDEs.
+       * Supports both single-window and multi-window modes.
+       */
+      async initialScan(enabledIdes) {
+        const portMap = this.ctx.providerLoader.getCdpPortMap();
+        const portsToTry = [];
+        for (const [ide, ports] of Object.entries(portMap)) {
+          portsToTry.push({ port: ports[0], ide });
+        }
+        const filtered = enabledIdes?.length ? portsToTry.filter((p) => enabledIdes.includes(p.ide)) : portsToTry;
+        for (const { port, ide } of filtered) {
+          if (this.opts.multiWindow) {
+            await this.connectMultiWindow(port, ide);
+          } else {
+            await this.connectSingleWindow(port, ide);
+          }
+        }
+      }
+      /**
+       * Start periodic scanning for newly launched IDEs.
+       */
+      startPeriodicScan() {
+        if (this.scanTimer) return;
+        const interval = this.opts.scanIntervalMs || 3e4;
+        this.scanTimer = setInterval(async () => {
+          const portMap = this.ctx.providerLoader.getCdpPortMap();
+          for (const [ide, ports] of Object.entries(portMap)) {
+            const primaryPort = ports[0];
+            const alreadyConnected = [...this.ctx.cdpManagers.entries()].some(
+              ([key, m]) => m.isConnected && (key === ide || key.startsWith(ide + "_"))
+            );
+            if (alreadyConnected) continue;
+            if (this.opts.multiWindow) {
+              await this.connectMultiWindow(primaryPort, ide);
+            } else {
+              await this.connectSingleWindow(primaryPort, ide);
+            }
+          }
+        }, interval);
+      }
+      /**
+       * Start periodic agent webview discovery on all connected CDPs.
+       */
+      startWebviewDiscovery(intervalMs = 3e4) {
+        if (this.discoveryTimer) return;
+        this.discoveryTimer = setInterval(async () => {
+          for (const m of this.ctx.cdpManagers.values()) {
+            if (m.isConnected) {
+              await m.discoverAgentWebviews();
+            }
+          }
+        }, intervalMs);
+      }
+      /**
+       * Stop all timers.
+       */
+      stop() {
+        if (this.scanTimer) {
+          clearInterval(this.scanTimer);
+          this.scanTimer = null;
+        }
+        if (this.discoveryTimer) {
+          clearInterval(this.discoveryTimer);
+          this.discoveryTimer = null;
+        }
+      }
+      // ── Internal ────────────────────────────
+      getLogFn(ideType) {
+        if (this.opts.logFn) return this.opts.logFn(ideType);
+        return (msg) => LOG.info(`CDP:${ideType}`, msg);
+      }
+      /**
+       * Single-window connection (standalone mode).
+       * One CDP manager per IDE, first working port wins.
+       */
+      async connectSingleWindow(port, ide) {
+        if (this.ctx.cdpManagers.has(ide)) return;
+        const available = await probeCdpPort(port);
+        if (!available) return;
+        const manager = await connectCdpManager(
+          port,
+          ide,
+          this.getLogFn(ide),
+          this.ctx.providerLoader
+        );
+        if (!manager) return;
+        registerExtensionProviders(this.ctx.providerLoader, manager, ide);
+        this.ctx.cdpManagers.set(ide, manager);
+        LOG.info("IDE", `Attached: ${ide} (port ${port})`);
+        await setupIdeInstance(this.ctx, { ideType: ide, manager });
+        this.opts.onConnected?.(ide, ide, manager);
+      }
+      /**
+       * Multi-window connection.
+       * Multiple CDP managers per IDE — one per workbench page.
+       */
+      async connectMultiWindow(port, ide) {
+        const allTargets = await DaemonCdpManager.listAllTargets(port);
+        if (allTargets.length === 0) {
+          await this.connectSingleWindow(port, ide);
+          return;
+        }
+        for (let i = 0; i < allTargets.length; i++) {
+          const target = allTargets[i];
+          let managerKey;
+          if (allTargets.length === 1) {
+            managerKey = ide;
+          } else {
+            const workspaceName = (target.title || "").split(" \u2014 ")[0].trim() || `window_${i}`;
+            managerKey = `${ide}_${workspaceName}`;
+          }
+          if (this.ctx.cdpManagers.has(managerKey)) continue;
+          const manager = await connectCdpManager(
+            port,
+            ide,
+            this.getLogFn(managerKey),
+            this.ctx.providerLoader,
+            target.id
+          );
+          if (!manager) continue;
+          this.ctx.cdpManagers.set(managerKey, manager);
+          LOG.info("IDE", `Attached window: ${managerKey} (port ${port}, page "${target.title}")`);
+          await setupIdeInstance(this.ctx, {
+            ideType: ide,
+            manager,
+            managerKey
+          });
+          this.opts.onConnected?.(ide, managerKey, manager);
+        }
+      }
+    };
   }
 });
 
@@ -3540,6 +3706,12 @@ function normalizeManagedStatus(status, opts) {
   if (normalized === "disconnected") return "disconnected";
   return "idle";
 }
+function isManagedStatusWorking(status) {
+  return normalizeManagedStatus(status) === "generating";
+}
+function isManagedStatusWaiting(status, opts) {
+  return normalizeManagedStatus(status, opts) === "waiting_approval";
+}
 function normalizeActiveChatData(activeChat) {
   if (!activeChat) return activeChat;
   return {
@@ -3587,6 +3759,14 @@ function findCdpManager(cdpManagers, key) {
   }
   return null;
 }
+function hasCdpManager(cdpManagers, key) {
+  if (cdpManagers.has(key)) return true;
+  const prefix = key + "_";
+  for (const k of cdpManagers.keys()) {
+    if (k.startsWith(prefix)) return true;
+  }
+  return false;
+}
 function isCdpConnected(cdpManagers, key) {
   const m = findCdpManager(cdpManagers, key);
   return m?.isConnected ?? false;
@@ -6155,12 +6335,12 @@ function findBinary(name) {
 function isScriptBinary(binaryPath) {
   if (!path7.isAbsolute(binaryPath)) return false;
   try {
-    const fs17 = require("fs");
-    const resolved = fs17.realpathSync(binaryPath);
+    const fs18 = require("fs");
+    const resolved = fs18.realpathSync(binaryPath);
     const head = Buffer.alloc(8);
-    const fd = fs17.openSync(resolved, "r");
-    fs17.readSync(fd, head, 0, 8, 0);
-    fs17.closeSync(fd);
+    const fd = fs18.openSync(resolved, "r");
+    fs18.readSync(fd, head, 0, 8, 0);
+    fs18.closeSync(fd);
     let i = 0;
     if (head[0] === 239 && head[1] === 187 && head[2] === 191) i = 3;
     return head[i] === 35 && head[i + 1] === 33;
@@ -6171,12 +6351,12 @@ function isScriptBinary(binaryPath) {
 function looksLikeMachOOrElf(filePath) {
   if (!path7.isAbsolute(filePath)) return false;
   try {
-    const fs17 = require("fs");
-    const resolved = fs17.realpathSync(filePath);
+    const fs18 = require("fs");
+    const resolved = fs18.realpathSync(filePath);
     const buf = Buffer.alloc(8);
-    const fd = fs17.openSync(resolved, "r");
-    fs17.readSync(fd, buf, 0, 8, 0);
-    fs17.closeSync(fd);
+    const fd = fs18.openSync(resolved, "r");
+    fs18.readSync(fd, buf, 0, 8, 0);
+    fs18.closeSync(fd);
     let i = 0;
     if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
     const b = buf.subarray(i);
@@ -6273,14 +6453,14 @@ var init_provider_cli_adapter = __esm({
       pty2 = require("node-pty");
       if (os8.platform() !== "win32") {
         try {
-          const fs17 = require("fs");
+          const fs18 = require("fs");
           const ptyDir = path7.resolve(path7.dirname(require.resolve("node-pty")), "..");
           const platformArch = `${os8.platform()}-${os8.arch()}`;
           const helper = path7.join(ptyDir, "prebuilds", platformArch, "spawn-helper");
-          if (fs17.existsSync(helper)) {
-            const stat4 = fs17.statSync(helper);
+          if (fs18.existsSync(helper)) {
+            const stat4 = fs18.statSync(helper);
             if (!(stat4.mode & 73)) {
-              fs17.chmodSync(helper, stat4.mode | 493);
+              fs18.chmodSync(helper, stat4.mode | 493);
               LOG.info("CLI", "[node-pty] Fixed spawn-helper permissions");
             }
           }
@@ -8399,10 +8579,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path21) {
-  if (!path21)
+function getElementAtPath(obj, path23) {
+  if (!path23)
     return obj;
-  return path21.reduce((acc, key) => acc?.[key], obj);
+  return path23.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8714,11 +8894,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path21, issues) {
+function prefixIssues(path23, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path21);
+    iss.path.unshift(path23);
     return iss;
   });
 }
@@ -8961,7 +9141,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path21 = []) => {
+  const processError = (error49, path23 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -8971,7 +9151,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path21, ...issue2.path];
+        const fullpath = [...path23, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -9003,8 +9183,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path21 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path21) {
+  const path23 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path23) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21768,13 +21948,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path21 = ref.slice(1).split("/").filter(Boolean);
-  if (path21.length === 0) {
+  const path23 = ref.slice(1).split("/").filter(Boolean);
+  if (path23.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path21[0] === defsKey) {
-    const key = path21[1];
+  if (path23[0] === defsKey) {
+    const key = path23[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -25634,8 +25814,8 @@ var init_cli_manager = __esm({
           const spawnCmd = provider.spawn?.command;
           if (spawnCmd) {
             try {
-              const { execSync: execSync6 } = require("child_process");
-              execSync6(`which ${spawnCmd}`, { stdio: "ignore" });
+              const { execSync: execSync7 } = require("child_process");
+              execSync7(`which ${spawnCmd}`, { stdio: "ignore" });
             } catch {
               const installInfo = provider.install || `Install: check ${provider.displayName || provider.name} documentation`;
               throw new Error(
@@ -26162,7 +26342,7 @@ var init_readdirp = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
         if (wantBigintFsStats) {
-          this._stat = (path21) => statMethod(path21, { bigint: true });
+          this._stat = (path23) => statMethod(path23, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -26187,8 +26367,8 @@ var init_readdirp = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path21, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path21));
+              const { path: path23, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -26228,20 +26408,20 @@ var init_readdirp = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path21, depth) {
+      async _exploreDir(path23, depth) {
         let files;
         try {
-          files = await (0, import_promises.readdir)(path21, this._rdOptions);
+          files = await (0, import_promises.readdir)(path23, this._rdOptions);
         } catch (error48) {
           this._onError(error48);
         }
-        return { files, depth, path: path21 };
+        return { files, depth, path: path23 };
       }
-      async _formatEntry(dirent, path21) {
+      async _formatEntry(dirent, path23) {
         let entry;
         const basename7 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path21, basename7));
+          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path23, basename7));
           entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename7 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
@@ -26298,16 +26478,16 @@ var init_readdirp = __esm({
 });
 
 // ../../oss/packages/daemon-core/node_modules/chokidar/handler.js
-function createFsWatchInstance(path21, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path23, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path21);
-    emitRaw(rawEvent, evPath, { watchedPath: path21 });
-    if (evPath && path21 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path21, evPath), KEY_LISTENERS, sp.join(path21, evPath));
+    listener(path23);
+    emitRaw(rawEvent, evPath, { watchedPath: path23 });
+    if (evPath && path23 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path23, evPath), KEY_LISTENERS, sp.join(path23, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path21, {
+    return (0, import_node_fs.watch)(path23, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error48) {
@@ -26656,12 +26836,12 @@ var init_handler2 = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path21, fullPath, options, handlers) => {
+    setFsWatchListener = (path23, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path21, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path23, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -26672,7 +26852,7 @@ var init_handler2 = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path21,
+          path23,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -26687,7 +26867,7 @@ var init_handler2 = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error48.code === "EPERM") {
             try {
-              const fd = await (0, import_promises2.open)(path21, "r");
+              const fd = await (0, import_promises2.open)(path23, "r");
               await fd.close();
               broadcastErr(error48);
             } catch (err) {
@@ -26718,7 +26898,7 @@ var init_handler2 = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path21, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path23, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -26740,7 +26920,7 @@ var init_handler2 = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path21, curr));
+              foreach(cont.listeners, (listener2) => listener2(path23, curr));
             }
           })
         };
@@ -26770,13 +26950,13 @@ var init_handler2 = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path21, listener) {
+      _watchWithNodeFs(path23, listener) {
         const opts = this.fsw.options;
-        const directory = sp.dirname(path21);
-        const basename7 = sp.basename(path21);
+        const directory = sp.dirname(path23);
+        const basename7 = sp.basename(path23);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename7);
-        const absolutePath = sp.resolve(path21);
+        const absolutePath = sp.resolve(path23);
         const options = {
           persistent: opts.persistent
         };
@@ -26786,12 +26966,12 @@ var init_handler2 = __esm({
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
           options.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path21, absolutePath, options, {
+          closer = setFsWatchFileListener(path23, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path21, absolutePath, options, {
+          closer = setFsWatchListener(path23, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -26813,7 +26993,7 @@ var init_handler2 = __esm({
         let prevStats = stats;
         if (parent.has(basename7))
           return;
-        const listener = async (path21, newStats) => {
+        const listener = async (path23, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -26827,11 +27007,11 @@ var init_handler2 = __esm({
                 this.fsw._emit(EV.CHANGE, file2, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path21);
+                this.fsw._closeFile(path23);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file2, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path21, closer2);
+                  this.fsw._addPathCloser(path23, closer2);
               } else {
                 prevStats = newStats2;
               }
@@ -26863,7 +27043,7 @@ var init_handler2 = __esm({
        * @param item basename of this item
        * @returns true if no more processing is needed for this entry.
        */
-      async _handleSymlink(entry, directory, path21, item) {
+      async _handleSymlink(entry, directory, path23, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -26873,7 +27053,7 @@ var init_handler2 = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await (0, import_promises2.realpath)(path21);
+            linkPath = await (0, import_promises2.realpath)(path23);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -26883,12 +27063,12 @@ var init_handler2 = __esm({
           if (dir.has(item)) {
             if (this.fsw._symlinkPaths.get(full) !== linkPath) {
               this.fsw._symlinkPaths.set(full, linkPath);
-              this.fsw._emit(EV.CHANGE, path21, entry.stats);
+              this.fsw._emit(EV.CHANGE, path23, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path21, entry.stats);
+            this.fsw._emit(EV.ADD, path23, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -26918,9 +27098,9 @@ var init_handler2 = __esm({
             return;
           }
           const item = entry.path;
-          let path21 = sp.join(directory, item);
+          let path23 = sp.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path21, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -26929,8 +27109,8 @@ var init_handler2 = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path21 = sp.join(dir, sp.relative(dir, path21));
-            this._addToNodeFs(path21, initialAdd, wh, depth + 1);
+            path23 = sp.join(dir, sp.relative(dir, path23));
+            this._addToNodeFs(path23, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve13, reject) => {
@@ -26999,13 +27179,13 @@ var init_handler2 = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path21, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path21) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path23) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path21);
+        const wh = this.fsw._getWatchHelpers(path23);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -27021,8 +27201,8 @@ var init_handler2 = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sp.resolve(path21);
-            const targetPath = follow ? await (0, import_promises2.realpath)(path21) : path21;
+            const absPath = sp.resolve(path23);
+            const targetPath = follow ? await (0, import_promises2.realpath)(path23) : path23;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -27032,29 +27212,29 @@ var init_handler2 = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await (0, import_promises2.realpath)(path21) : path21;
+            const targetPath = follow ? await (0, import_promises2.realpath)(path23) : path23;
             if (this.fsw.closed)
               return;
             const parent = sp.dirname(wh.watchPath);
             this.fsw._getWatchedDir(parent).add(wh.watchPath);
             this.fsw._emit(EV.ADD, wh.watchPath, stats);
-            closer = await this._handleDir(parent, stats, initialAdd, depth, path21, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path23, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sp.resolve(path21), targetPath);
+              this.fsw._symlinkPaths.set(sp.resolve(path23), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path21, closer);
+            this.fsw._addPathCloser(path23, closer);
           return false;
         } catch (error48) {
           if (this.fsw._handleError(error48)) {
             ready();
-            return path21;
+            return path23;
           }
         }
       }
@@ -27089,24 +27269,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path21) {
-  if (typeof path21 !== "string")
+function normalizePath(path23) {
+  if (typeof path23 !== "string")
     throw new Error("string expected");
-  path21 = sp2.normalize(path21);
-  path21 = path21.replace(/\\/g, "/");
+  path23 = sp2.normalize(path23);
+  path23 = path23.replace(/\\/g, "/");
   let prepend = false;
-  if (path21.startsWith("//"))
+  if (path23.startsWith("//"))
     prepend = true;
-  path21 = path21.replace(DOUBLE_SLASH_RE, "/");
+  path23 = path23.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path21 = "/" + path21;
-  return path21;
+    path23 = "/" + path23;
+  return path23;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path21 = normalizePath(testString);
+  const path23 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path21, stats)) {
+    if (pattern(path23, stats)) {
       return true;
     }
   }
@@ -27169,19 +27349,19 @@ var init_chokidar = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path21) => toUnix(sp2.normalize(toUnix(path21)));
-    normalizeIgnored = (cwd = "") => (path21) => {
-      if (typeof path21 === "string") {
-        return normalizePathToUnix(sp2.isAbsolute(path21) ? path21 : sp2.join(cwd, path21));
+    normalizePathToUnix = (path23) => toUnix(sp2.normalize(toUnix(path23)));
+    normalizeIgnored = (cwd = "") => (path23) => {
+      if (typeof path23 === "string") {
+        return normalizePathToUnix(sp2.isAbsolute(path23) ? path23 : sp2.join(cwd, path23));
       } else {
-        return path21;
+        return path23;
       }
     };
-    getAbsolutePath = (path21, cwd) => {
-      if (sp2.isAbsolute(path21)) {
-        return path21;
+    getAbsolutePath = (path23, cwd) => {
+      if (sp2.isAbsolute(path23)) {
+        return path23;
       }
-      return sp2.join(cwd, path21);
+      return sp2.join(cwd, path23);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -27246,10 +27426,10 @@ var init_chokidar = __esm({
       dirParts;
       followSymlinks;
       statMethod;
-      constructor(path21, follow, fsw) {
+      constructor(path23, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path21;
-        this.path = path21 = path21.replace(REPLACER_RE, "");
+        const watchPath = path23;
+        this.path = path23 = path23.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sp2.resolve(watchPath);
         this.dirParts = [];
@@ -27389,20 +27569,20 @@ var init_chokidar = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path21) => {
-            const absPath = getAbsolutePath(path21, cwd);
+          paths = paths.map((path23) => {
+            const absPath = getAbsolutePath(path23, cwd);
             return absPath;
           });
         }
-        paths.forEach((path21) => {
-          this._removeIgnoredPath(path21);
+        paths.forEach((path23) => {
+          this._removeIgnoredPath(path23);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path21) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path21, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path23) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path23, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -27424,17 +27604,17 @@ var init_chokidar = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path21) => {
-          if (!sp2.isAbsolute(path21) && !this._closers.has(path21)) {
+        paths.forEach((path23) => {
+          if (!sp2.isAbsolute(path23) && !this._closers.has(path23)) {
             if (cwd)
-              path21 = sp2.join(cwd, path21);
-            path21 = sp2.resolve(path21);
+              path23 = sp2.join(cwd, path23);
+            path23 = sp2.resolve(path23);
           }
-          this._closePath(path21);
-          this._addIgnoredPath(path21);
-          if (this._watched.has(path21)) {
+          this._closePath(path23);
+          this._addIgnoredPath(path23);
+          if (this._watched.has(path23)) {
             this._addIgnoredPath({
-              path: path21,
+              path: path23,
               recursive: true
             });
           }
@@ -27498,38 +27678,38 @@ var init_chokidar = __esm({
        * @param stats arguments to be passed with event
        * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
        */
-      async _emit(event, path21, stats) {
+      async _emit(event, path23, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path21 = sp2.normalize(path21);
+          path23 = sp2.normalize(path23);
         if (opts.cwd)
-          path21 = sp2.relative(opts.cwd, path21);
-        const args = [path21];
+          path23 = sp2.relative(opts.cwd, path23);
+        const args = [path23];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path21))) {
+        if (awf && (pw = this._pendingWrites.get(path23))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path21, [event, ...args]);
+            this._pendingUnlinks.set(path23, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path23) => {
+              this._pendingUnlinks.forEach((entry, path24) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path23);
+                this._pendingUnlinks.delete(path24);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path21)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path21);
+            this._pendingUnlinks.delete(path23);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -27547,16 +27727,16 @@ var init_chokidar = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path21, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path21, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 50);
           if (isThrottled)
             return this;
         }
         if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-          const fullPath = opts.cwd ? sp2.join(opts.cwd, path21) : path21;
+          const fullPath = opts.cwd ? sp2.join(opts.cwd, path23) : path23;
           let stats2;
           try {
             stats2 = await (0, import_promises3.stat)(fullPath);
@@ -27587,23 +27767,23 @@ var init_chokidar = __esm({
        * @param timeout duration of time to suppress duplicate actions
        * @returns tracking object or false if action should be suppressed
        */
-      _throttle(actionType, path21, timeout) {
+      _throttle(actionType, path23, timeout) {
         if (!this._throttled.has(actionType)) {
           this._throttled.set(actionType, /* @__PURE__ */ new Map());
         }
         const action = this._throttled.get(actionType);
         if (!action)
           throw new Error("invalid throttle");
-        const actionPath = action.get(path21);
+        const actionPath = action.get(path23);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path21);
+          const item = action.get(path23);
           const count = item ? item.count : 0;
-          action.delete(path21);
+          action.delete(path23);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -27611,7 +27791,7 @@ var init_chokidar = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path21, thr);
+        action.set(path23, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -27625,44 +27805,44 @@ var init_chokidar = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path21, threshold, event, awfEmit) {
+      _awaitWriteFinish(path23, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path21;
-        if (this.options.cwd && !sp2.isAbsolute(path21)) {
-          fullPath = sp2.join(this.options.cwd, path21);
+        let fullPath = path23;
+        if (this.options.cwd && !sp2.isAbsolute(path23)) {
+          fullPath = sp2.join(this.options.cwd, path23);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-            if (err || !writes.has(path21)) {
+            if (err || !writes.has(path23)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path21).lastChange = now2;
+              writes.get(path23).lastChange = now2;
             }
-            const pw = writes.get(path21);
+            const pw = writes.get(path23);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path21);
+              writes.delete(path23);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path21)) {
-          writes.set(path21, {
+        if (!writes.has(path23)) {
+          writes.set(path23, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path21);
+              writes.delete(path23);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -27673,8 +27853,8 @@ var init_chokidar = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path21, stats) {
-        if (this.options.atomic && DOT_RE.test(path21))
+      _isIgnored(path23, stats) {
+        if (this.options.atomic && DOT_RE.test(path23))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -27684,17 +27864,17 @@ var init_chokidar = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path21, stats);
+        return this._userIgnored(path23, stats);
       }
-      _isntIgnored(path21, stat4) {
-        return !this._isIgnored(path21, stat4);
+      _isntIgnored(path23, stat4) {
+        return !this._isIgnored(path23, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path21) {
-        return new WatchHelper(path21, this.options.followSymlinks, this);
+      _getWatchHelpers(path23) {
+        return new WatchHelper(path23, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -27726,63 +27906,63 @@ var init_chokidar = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path21 = sp2.join(directory, item);
-        const fullPath = sp2.resolve(path21);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path21) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path21, 100))
+        const path23 = sp2.join(directory, item);
+        const fullPath = sp2.resolve(path23);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path23) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path23, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path21);
+        const wp = this._getWatchedDir(path23);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path21, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path23, nested));
         const parent = this._getWatchedDir(directory);
         const wasTracked = parent.has(item);
         parent.remove(item);
         if (this._symlinkPaths.has(fullPath)) {
           this._symlinkPaths.delete(fullPath);
         }
-        let relPath = path21;
+        let relPath = path23;
         if (this.options.cwd)
-          relPath = sp2.relative(this.options.cwd, path21);
+          relPath = sp2.relative(this.options.cwd, path23);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path21);
+        this._watched.delete(path23);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path21))
-          this._emit(eventName, path21);
-        this._closePath(path21);
+        if (wasTracked && !this._isIgnored(path23))
+          this._emit(eventName, path23);
+        this._closePath(path23);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path21) {
-        this._closeFile(path21);
-        const dir = sp2.dirname(path21);
-        this._getWatchedDir(dir).remove(sp2.basename(path21));
+      _closePath(path23) {
+        this._closeFile(path23);
+        const dir = sp2.dirname(path23);
+        this._getWatchedDir(dir).remove(sp2.basename(path23));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path21) {
-        const closers = this._closers.get(path21);
+      _closeFile(path23) {
+        const closers = this._closers.get(path23);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path21);
+        this._closers.delete(path23);
       }
-      _addPathCloser(path21, closer) {
+      _addPathCloser(path23, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path21);
+        let list = this._closers.get(path23);
         if (!list) {
           list = [];
-          this._closers.set(path21, list);
+          this._closers.set(path23, list);
         }
         list.push(closer);
       }
@@ -28374,7 +28554,7 @@ var init_provider_loader = __esm({
           return { updated: false };
         }
         const https = require("https");
-        const { execSync: execSync6 } = require("child_process");
+        const { execSync: execSync7 } = require("child_process");
         const metaPath = path10.join(this.upstreamDir, _ProviderLoader.META_FILE);
         let prevEtag = "";
         let prevTimestamp = 0;
@@ -28439,7 +28619,7 @@ var init_provider_loader = __esm({
           const tmpExtract = path10.join(os11.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
           await this.downloadFile(_ProviderLoader.GITHUB_TARBALL_URL, tmpTar);
           fs6.mkdirSync(tmpExtract, { recursive: true });
-          execSync6(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
+          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")
@@ -29012,7 +29192,7 @@ function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs17 = require("fs");
+      const fs18 = require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
@@ -29021,8 +29201,8 @@ function detectCurrentWorkspace(ideId) {
           appName,
           "storage.json"
         );
-        if (fs17.existsSync(storagePath)) {
-          const data = JSON.parse(fs17.readFileSync(storagePath, "utf-8"));
+        if (fs18.existsSync(storagePath)) {
+          const data = JSON.parse(fs18.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -29180,6 +29360,9 @@ async function launchLinux(ide, port, workspace, newWindow) {
   if (workspace) args.push(workspace);
   (0, import_child_process6.spawn)(cli, args, { detached: true, stdio: "ignore" }).unref();
 }
+function getAvailableIdeIds() {
+  return getProviderLoader().getAvailableIdeTypes();
+}
 var import_child_process6, net, os12, path11, _providerLoader;
 var init_launch = __esm({
   "../../oss/packages/daemon-core/src/launch.ts"() {
@@ -29274,6 +29457,31 @@ function logCommand(entry) {
   } catch {
   }
 }
+function getRecentCommands(count = 50) {
+  try {
+    if (!fs7.existsSync(currentFile)) return [];
+    const content = fs7.readFileSync(currentFile, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    return lines.slice(-count).map((line) => {
+      try {
+        const parsed = JSON.parse(line);
+        return {
+          ts: parsed.ts,
+          cmd: parsed.cmd,
+          source: parsed.src,
+          args: parsed.args,
+          success: parsed.ok,
+          error: parsed.err,
+          durationMs: parsed.ms
+        };
+      } catch {
+        return { ts: "", cmd: "parse_error", source: "unknown" };
+      }
+    });
+  } catch {
+    return [];
+  }
+}
 var fs7, path12, os13, LOG_DIR2, MAX_FILE_SIZE, MAX_DAYS, SENSITIVE_KEYS, currentDate2, currentFile, writeCount2, SKIP_COMMANDS;
 var init_command_log = __esm({
   "../../oss/packages/daemon-core/src/logging/command-log.ts"() {
@@ -29463,9 +29671,119 @@ var init_snapshot = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/commands/upgrade-helper.ts
+function getUpgradeLogPath() {
+  const home = os15.homedir();
+  const dir = path13.join(home, ".adhdev");
+  fs8.mkdirSync(dir, { recursive: true });
+  return path13.join(dir, "daemon-upgrade.log");
+}
+function appendUpgradeLog(message) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
+`;
+  try {
+    fs8.appendFileSync(getUpgradeLogPath(), line, "utf8");
+  } catch {
+  }
+}
+function getNpmExecutable() {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function killPid(pid) {
+  try {
+    if (process.platform === "win32") {
+      (0, import_child_process7.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+    } else {
+      process.kill(pid, "SIGTERM");
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForPidExit(pid, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      process.kill(pid, 0);
+      await new Promise((resolve13) => setTimeout(resolve13, 250));
+    } catch {
+      return;
+    }
+  }
+}
+function stopSessionHostProcesses(appName) {
+  const pidFile = path13.join(os15.homedir(), ".adhdev", `${appName}-session-host.pid`);
+  try {
+    if (fs8.existsSync(pidFile)) {
+      const pid = Number.parseInt(fs8.readFileSync(pidFile, "utf8").trim(), 10);
+      if (Number.isFinite(pid)) {
+        killPid(pid);
+      }
+    }
+  } catch {
+  } finally {
+    try {
+      fs8.unlinkSync(pidFile);
+    } catch {
+    }
+  }
+  if (process.platform !== "win32") {
+    try {
+      const raw = (0, import_child_process7.execFileSync)("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
+      for (const line of raw.split("\n")) {
+        const pid = Number.parseInt(line.trim(), 10);
+        if (Number.isFinite(pid)) {
+          killPid(pid);
+        }
+      }
+    } catch {
+    }
+  }
+}
+function removeDaemonPidFile() {
+  const pidFile = path13.join(os15.homedir(), ".adhdev", "daemon.pid");
+  try {
+    fs8.unlinkSync(pidFile);
+  } catch {
+  }
+}
+function cleanupStaleGlobalInstallDirs(pkgName) {
+  const npmRoot = (0, import_child_process7.execFileSync)(getNpmExecutable(), ["root", "-g"], { encoding: "utf8" }).trim();
+  if (!npmRoot) return;
+  const npmPrefix = (0, import_child_process7.execFileSync)(getNpmExecutable(), ["prefix", "-g"], { encoding: "utf8" }).trim();
+  const binDir = process.platform === "win32" ? npmPrefix : path13.join(npmPrefix, "bin");
+  const packageBaseName = pkgName.startsWith("@") ? pkgName.split("/")[1] : pkgName;
+  const binNames = /* @__PURE__ */ new Set([packageBaseName]);
+  if (pkgName === "@adhdev/daemon-standalone") {
+    binNames.add("adhdev-standalone");
+  }
+  if (pkgName.startsWith("@")) {
+    const [scope, name] = pkgName.split("/");
+    const scopeDir = path13.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)}`);
+    }
+  } 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)}`);
+    }
+  }
+  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)}`);
+    }
+  }
+}
 function spawnDetachedDaemonUpgradeHelper(payload) {
   const env = { ...process.env, [UPGRADE_HELPER_ENV]: JSON.stringify(payload) };
-  const child = (0, import_child_process7.spawn)(process.execPath, process.argv.slice(1), {
+  const child = (0, import_child_process8.spawn)(process.execPath, process.argv.slice(1), {
     detached: true,
     stdio: "ignore",
     windowsHide: true,
@@ -29474,17 +29792,75 @@ function spawnDetachedDaemonUpgradeHelper(payload) {
   });
   child.unref();
 }
-var import_child_process7, UPGRADE_HELPER_ENV;
+async function runDaemonUpgradeHelper(payload) {
+  const restartArgv = Array.isArray(payload.restartArgv) ? payload.restartArgv : [];
+  const sessionHostAppName = payload.sessionHostAppName || process.env.ADHDEV_SESSION_HOST_NAME || "adhdev";
+  appendUpgradeLog(`Upgrade helper started for ${payload.packageName}@${payload.targetVersion}`);
+  if (Number.isFinite(payload.parentPid) && payload.parentPid > 0) {
+    appendUpgradeLog(`Waiting for parent pid ${payload.parentPid} to exit`);
+    await waitForPidExit(payload.parentPid, 15e3);
+  }
+  stopSessionHostProcesses(sessionHostAppName);
+  removeDaemonPidFile();
+  cleanupStaleGlobalInstallDirs(payload.packageName);
+  const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
+  appendUpgradeLog(`Installing ${spec}`);
+  const installOutput = (0, import_child_process7.execFileSync)(
+    getNpmExecutable(),
+    ["install", "-g", spec, "--force"],
+    {
+      encoding: "utf8",
+      stdio: "pipe",
+      maxBuffer: 20 * 1024 * 1024
+    }
+  );
+  if (installOutput.trim()) {
+    appendUpgradeLog(installOutput.trim());
+  }
+  if (restartArgv.length > 0) {
+    const env = { ...process.env };
+    delete env[UPGRADE_HELPER_ENV];
+    appendUpgradeLog(`Restarting daemon with args: ${restartArgv.join(" ")}`);
+    const child = (0, import_child_process8.spawn)(process.execPath, restartArgv, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      cwd: payload.cwd || process.cwd(),
+      env
+    });
+    child.unref();
+  } else {
+    appendUpgradeLog("No restart argv provided; upgrade completed without restart");
+  }
+}
+async function maybeRunDaemonUpgradeHelperFromEnv() {
+  const raw = process.env[UPGRADE_HELPER_ENV];
+  if (!raw) return false;
+  delete process.env[UPGRADE_HELPER_ENV];
+  try {
+    const payload = JSON.parse(raw);
+    await runDaemonUpgradeHelper(payload);
+    process.exit(0);
+  } catch (error48) {
+    appendUpgradeLog(`Upgrade helper failed: ${error48?.stack || error48?.message || String(error48)}`);
+    process.exit(1);
+  }
+}
+var import_child_process7, import_child_process8, fs8, os15, path13, UPGRADE_HELPER_ENV;
 var init_upgrade_helper = __esm({
   "../../oss/packages/daemon-core/src/commands/upgrade-helper.ts"() {
     "use strict";
     import_child_process7 = require("child_process");
+    import_child_process8 = require("child_process");
+    fs8 = __toESM(require("fs"));
+    os15 = __toESM(require("os"));
+    path13 = __toESM(require("path"));
     UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
   }
 });
 
 // ../../oss/packages/daemon-core/src/commands/router.ts
-var fs8, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
+var fs9, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
 var init_router = __esm({
   "../../oss/packages/daemon-core/src/commands/router.ts"() {
     "use strict";
@@ -29504,7 +29880,7 @@ var init_router = __esm({
     init_builders();
     init_snapshot();
     init_upgrade_helper();
-    fs8 = __toESM(require("fs"));
+    fs9 = __toESM(require("fs"));
     CHAT_COMMANDS = [
       "send_chat",
       "new_chat",
@@ -29575,8 +29951,8 @@ var init_router = __esm({
               if (logs.length > 0) {
                 return { success: true, logs, totalBuffered: logs.length };
               }
-              if (fs8.existsSync(LOG_PATH)) {
-                const content = fs8.readFileSync(LOG_PATH, "utf-8");
+              if (fs9.existsSync(LOG_PATH)) {
+                const content = fs9.readFileSync(LOG_PATH, "utf-8");
                 const allLines = content.split("\n");
                 const recent = allLines.slice(-count).join("\n");
                 return { success: true, logs: recent, totalLines: allLines.length };
@@ -29759,14 +30135,14 @@ var init_router = __esm({
           case "daemon_upgrade": {
             LOG.info("Upgrade", "Remote upgrade requested from dashboard");
             try {
-              const { execSync: execSync6 } = await import("child_process");
+              const { execSync: execSync7 } = await import("child_process");
               const isStandalone = this.deps.packageName === "@adhdev/daemon-standalone" || process.argv[1]?.includes("daemon-standalone");
               const pkgName = isStandalone ? "@adhdev/daemon-standalone" : "adhdev";
-              const latest = execSync6(`npm view ${pkgName} version`, { encoding: "utf-8", timeout: 1e4 }).trim();
+              const latest = execSync7(`npm view ${pkgName} version`, { encoding: "utf-8", timeout: 1e4 }).trim();
               LOG.info("Upgrade", `Latest ${pkgName}: v${latest}`);
               let currentInstalled = null;
               try {
-                const currentJson = execSync6(`npm ls -g ${pkgName} --depth=0 --json`, {
+                const currentJson = execSync7(`npm ls -g ${pkgName} --depth=0 --json`, {
                   encoding: "utf-8",
                   timeout: 1e4,
                   stdio: ["pipe", "pipe", "pipe"]
@@ -30095,11 +30471,12 @@ var init_reporter = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/ipc-protocol.ts
-var DEFAULT_DAEMON_PORT;
+var DEFAULT_DAEMON_PORT, DAEMON_WS_PATH;
 var init_ipc_protocol = __esm({
   "../../oss/packages/daemon-core/src/ipc-protocol.ts"() {
     "use strict";
     DEFAULT_DAEMON_PORT = 19222;
+    DAEMON_WS_PATH = "/ipc";
   }
 });
 
@@ -30968,7 +31345,7 @@ var init_provider_instance_manager = __esm({
 // ../../oss/packages/daemon-core/src/providers/version-archive.ts
 function runCommand(cmd, timeout = 1e4) {
   try {
-    return (0, import_child_process8.execSync)(cmd, {
+    return (0, import_child_process9.execSync)(cmd, {
       encoding: "utf-8",
       timeout,
       stdio: ["pipe", "pipe", "pipe"]
@@ -31000,19 +31377,19 @@ function getVersion(binary, versionCommand) {
 function checkPathExists2(paths) {
   for (const p of paths) {
     if (p.includes("*")) {
-      const home = os15.homedir();
-      const resolved = p.replace(/\*/g, home.split(path13.sep).pop() || "");
-      if (fs9.existsSync(resolved)) return resolved;
+      const home = os16.homedir();
+      const resolved = p.replace(/\*/g, home.split(path14.sep).pop() || "");
+      if (fs10.existsSync(resolved)) return resolved;
     } else {
-      if (fs9.existsSync(p)) return p;
+      if (fs10.existsSync(p)) return p;
     }
   }
   return null;
 }
 function getMacAppVersion(appPath) {
   if ((0, import_os3.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
-  const plistPath = path13.join(appPath, "Contents", "Info.plist");
-  if (!fs9.existsSync(plistPath)) return null;
+  const plistPath = path14.join(appPath, "Contents", "Info.plist");
+  if (!fs10.existsSync(plistPath)) return null;
   const raw = runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
 }
@@ -31038,8 +31415,8 @@ async function detectAllVersions(loader, archive) {
       const cliBin = provider.cli ? findBinary2(provider.cli) : null;
       let resolvedBin = cliBin;
       if (!resolvedBin && appPath && currentOs === "darwin") {
-        const bundled = path13.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-        if (provider.cli && fs9.existsSync(bundled)) resolvedBin = bundled;
+        const bundled = path14.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
+        if (provider.cli && fs10.existsSync(bundled)) resolvedBin = bundled;
       }
       info.installed = !!(appPath || resolvedBin);
       info.path = appPath || null;
@@ -31075,16 +31452,16 @@ async function detectAllVersions(loader, archive) {
   }
   return results;
 }
-var fs9, path13, os15, import_child_process8, import_os3, ARCHIVE_PATH, MAX_ENTRIES_PER_PROVIDER, VersionArchive;
+var fs10, path14, os16, import_child_process9, import_os3, ARCHIVE_PATH, MAX_ENTRIES_PER_PROVIDER, VersionArchive;
 var init_version_archive = __esm({
   "../../oss/packages/daemon-core/src/providers/version-archive.ts"() {
     "use strict";
-    fs9 = __toESM(require("fs"));
-    path13 = __toESM(require("path"));
-    os15 = __toESM(require("os"));
-    import_child_process8 = require("child_process");
+    fs10 = __toESM(require("fs"));
+    path14 = __toESM(require("path"));
+    os16 = __toESM(require("os"));
+    import_child_process9 = require("child_process");
     import_os3 = require("os");
-    ARCHIVE_PATH = path13.join(os15.homedir(), ".adhdev", "version-history.json");
+    ARCHIVE_PATH = path14.join(os16.homedir(), ".adhdev", "version-history.json");
     MAX_ENTRIES_PER_PROVIDER = 20;
     VersionArchive = class {
       history = {};
@@ -31093,8 +31470,8 @@ var init_version_archive = __esm({
       }
       load() {
         try {
-          if (fs9.existsSync(ARCHIVE_PATH)) {
-            this.history = JSON.parse(fs9.readFileSync(ARCHIVE_PATH, "utf-8"));
+          if (fs10.existsSync(ARCHIVE_PATH)) {
+            this.history = JSON.parse(fs10.readFileSync(ARCHIVE_PATH, "utf-8"));
           }
         } catch {
           this.history = {};
@@ -31131,8 +31508,8 @@ var init_version_archive = __esm({
       }
       save() {
         try {
-          fs9.mkdirSync(path13.dirname(ARCHIVE_PATH), { recursive: true });
-          fs9.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
+          fs10.mkdirSync(path14.dirname(ARCHIVE_PATH), { recursive: true });
+          fs10.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
         } catch {
         }
       }
@@ -31652,18 +32029,18 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   let scriptsPath = "";
-  const directScripts = path14.join(dir, "scripts.js");
-  if (fs10.existsSync(directScripts)) {
+  const directScripts = path15.join(dir, "scripts.js");
+  if (fs11.existsSync(directScripts)) {
     scriptsPath = directScripts;
   } else {
-    const scriptsDir = path14.join(dir, "scripts");
-    if (fs10.existsSync(scriptsDir)) {
-      const versions = fs10.readdirSync(scriptsDir).filter((d) => {
-        return fs10.statSync(path14.join(scriptsDir, d)).isDirectory();
+    const scriptsDir = path15.join(dir, "scripts");
+    if (fs11.existsSync(scriptsDir)) {
+      const versions = fs11.readdirSync(scriptsDir).filter((d) => {
+        return fs11.statSync(path15.join(scriptsDir, d)).isDirectory();
       }).sort().reverse();
       for (const ver of versions) {
-        const p = path14.join(scriptsDir, ver, "scripts.js");
-        if (fs10.existsSync(p)) {
+        const p = path15.join(scriptsDir, ver, "scripts.js");
+        if (fs11.existsSync(p)) {
           scriptsPath = p;
           break;
         }
@@ -31675,7 +32052,7 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   try {
-    const source = fs10.readFileSync(scriptsPath, "utf-8");
+    const source = fs11.readFileSync(scriptsPath, "utf-8");
     const hints = {};
     const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
     let match;
@@ -32478,12 +32855,12 @@ async function handleDomContext(ctx, type, req, res) {
     ctx.json(res, 500, { error: `DOM context collection failed: ${e.message}` });
   }
 }
-var fs10, path14;
+var fs11, path15;
 var init_dev_cdp_handlers = __esm({
   "../../oss/packages/daemon-core/src/daemon/dev-cdp-handlers.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs"));
-    path14 = __toESM(require("path"));
+    fs11 = __toESM(require("fs"));
+    path15 = __toESM(require("path"));
     init_logger();
   }
 });
@@ -32498,15 +32875,15 @@ function getCliFixtureDir(ctx, type) {
   if (!providerDir) {
     throw new Error(`Provider directory not found for '${type}'`);
   }
-  return path15.join(providerDir, "fixtures");
+  return path16.join(providerDir, "fixtures");
 }
 function readCliFixture(ctx, type, name) {
   const fixtureDir = getCliFixtureDir(ctx, type);
-  const filePath = path15.join(fixtureDir, `${name}.json`);
-  if (!fs11.existsSync(filePath)) {
+  const filePath = path16.join(fixtureDir, `${name}.json`);
+  if (!fs12.existsSync(filePath)) {
     throw new Error(`Fixture not found: ${filePath}`);
   }
-  return JSON.parse(fs11.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs12.readFileSync(filePath, "utf-8"));
 }
 function getExerciseTranscriptText(result) {
   const parts = [];
@@ -33205,7 +33582,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       return;
     }
     const fixtureDir = getCliFixtureDir(ctx, type);
-    fs11.mkdirSync(fixtureDir, { recursive: true });
+    fs12.mkdirSync(fixtureDir, { recursive: true });
     const name = slugifyFixtureName(String(body?.name || `${type}-${Date.now()}`));
     const result = await runCliExerciseInternal(ctx, { ...request, type });
     const fixture = {
@@ -33232,8 +33609,8 @@ async function handleCliFixtureCapture(ctx, req, res) {
       },
       notes: typeof body?.notes === "string" ? body.notes : void 0
     };
-    const filePath = path15.join(fixtureDir, `${name}.json`);
-    fs11.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+    const filePath = path16.join(fixtureDir, `${name}.json`);
+    fs12.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
     ctx.json(res, 200, {
       saved: true,
       name,
@@ -33251,14 +33628,14 @@ async function handleCliFixtureCapture(ctx, req, res) {
 async function handleCliFixtureList(ctx, type, _req, res) {
   try {
     const fixtureDir = getCliFixtureDir(ctx, type);
-    if (!fs11.existsSync(fixtureDir)) {
+    if (!fs12.existsSync(fixtureDir)) {
       ctx.json(res, 200, { fixtures: [], count: 0 });
       return;
     }
-    const fixtures = fs11.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
-      const fullPath = path15.join(fixtureDir, file2);
+    const fixtures = fs12.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
+      const fullPath = path16.join(fixtureDir, file2);
       try {
-        const raw = JSON.parse(fs11.readFileSync(fullPath, "utf-8"));
+        const raw = JSON.parse(fs12.readFileSync(fullPath, "utf-8"));
         return {
           name: raw.name || file2.replace(/\.json$/i, ""),
           path: fullPath,
@@ -33389,12 +33766,12 @@ async function handleCliRaw(ctx, req, res) {
     ctx.json(res, 500, { error: `Raw send failed: ${e.message}` });
   }
 }
-var fs11, path15;
+var fs12, path16;
 var init_dev_cli_debug = __esm({
   "../../oss/packages/daemon-core/src/daemon/dev-cli-debug.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs"));
-    path15 = __toESM(require("path"));
+    fs12 = __toESM(require("fs"));
+    path16 = __toESM(require("path"));
   }
 });
 
@@ -33434,45 +33811,45 @@ function resolveAutoImplReference(ctx, category, requestedReference, targetType)
   return fallback?.type || null;
 }
 function getLatestScriptVersionDir(scriptsDir) {
-  if (!fs12.existsSync(scriptsDir)) return null;
-  const versions = fs12.readdirSync(scriptsDir).filter((d) => {
+  if (!fs13.existsSync(scriptsDir)) return null;
+  const versions = fs13.readdirSync(scriptsDir).filter((d) => {
     try {
-      return fs12.statSync(path16.join(scriptsDir, d)).isDirectory();
+      return fs13.statSync(path17.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 path16.join(scriptsDir, versions[0]);
+  return path17.join(scriptsDir, versions[0]);
 }
 function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
-  const canonicalUserDir = path16.resolve(ctx.providerLoader.getUserProviderDir(category, type));
-  const desiredDir = requestedDir ? path16.resolve(requestedDir) : canonicalUserDir;
-  const upstreamRoot = path16.resolve(ctx.providerLoader.getUpstreamDir());
-  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path16.sep}`)) {
+  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}`)) {
     return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
   }
-  if (path16.basename(desiredDir) !== type) {
+  if (path17.basename(desiredDir) !== type) {
     return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
   }
   const sourceDir = ctx.findProviderDir(type);
   if (!sourceDir) {
     return { dir: null, reason: `Provider source directory not found for '${type}'` };
   }
-  if (!fs12.existsSync(desiredDir)) {
-    fs12.mkdirSync(path16.dirname(desiredDir), { recursive: true });
-    fs12.cpSync(sourceDir, desiredDir, { recursive: true });
+  if (!fs13.existsSync(desiredDir)) {
+    fs13.mkdirSync(path17.dirname(desiredDir), { recursive: true });
+    fs13.cpSync(sourceDir, desiredDir, { recursive: true });
     ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
   }
-  const providerJson = path16.join(desiredDir, "provider.json");
-  if (!fs12.existsSync(providerJson)) {
+  const providerJson = path17.join(desiredDir, "provider.json");
+  if (!fs13.existsSync(providerJson)) {
     return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
   }
   try {
-    const providerData = JSON.parse(fs12.readFileSync(providerJson, "utf-8"));
+    const providerData = JSON.parse(fs13.readFileSync(providerJson, "utf-8"));
     if (providerData.disableUpstream !== true) {
       providerData.disableUpstream = true;
-      fs12.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
+      fs13.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
     }
   } catch (error48) {
     return {
@@ -33485,15 +33862,15 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
 function loadAutoImplReferenceScripts(ctx, referenceType) {
   if (!referenceType) return {};
   const refDir = ctx.findProviderDir(referenceType);
-  if (!refDir || !fs12.existsSync(refDir)) return {};
+  if (!refDir || !fs13.existsSync(refDir)) return {};
   const referenceScripts = {};
-  const scriptsDir = path16.join(refDir, "scripts");
+  const scriptsDir = path17.join(refDir, "scripts");
   const latestDir = getLatestScriptVersionDir(scriptsDir);
   if (!latestDir) return referenceScripts;
-  for (const file2 of fs12.readdirSync(latestDir)) {
+  for (const file2 of fs13.readdirSync(latestDir)) {
     if (!file2.endsWith(".js")) continue;
     try {
-      referenceScripts[file2] = fs12.readFileSync(path16.join(latestDir, file2), "utf-8");
+      referenceScripts[file2] = fs13.readFileSync(path17.join(latestDir, file2), "utf-8");
     } catch {
     }
   }
@@ -33601,16 +33978,16 @@ 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 = path16.join(os16.tmpdir(), "adhdev-autoimpl");
-    if (!fs12.existsSync(tmpDir)) fs12.mkdirSync(tmpDir, { recursive: true });
-    const promptFile = path16.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
-    fs12.writeFileSync(promptFile, prompt, "utf-8");
+    const tmpDir = path17.join(os17.tmpdir(), "adhdev-autoimpl");
+    if (!fs13.existsSync(tmpDir)) fs13.mkdirSync(tmpDir, { recursive: true });
+    const promptFile = path17.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);
     const spawn5 = agentProvider?.spawn;
     if (!spawn5?.command) {
       try {
-        fs12.unlinkSync(promptFile);
+        fs13.unlinkSync(promptFile);
       } catch {
       }
       ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -33712,7 +34089,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs12.unlinkSync(promptFile);
+          fs13.unlinkSync(promptFile);
         } catch {
         }
         ctx.log(`Auto-implement (ACP) ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -33755,7 +34132,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     const interactiveFlags = ["--yolo", "--interactive", "-i"];
     const baseArgs = [...spawn5.args || []].filter((a) => !interactiveFlags.includes(a));
     let shellCmd;
-    const isWin = os16.platform() === "win32";
+    const isWin = os17.platform() === "win32";
     const escapeArg = (a) => isWin ? `"${a.replace(/"/g, '""')}"` : `'${a.replace(/'/g, "'\\''")}'`;
     if (command === "claude") {
       const args = [...baseArgs, "--dangerously-skip-permissions"];
@@ -33799,7 +34176,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     try {
       const pty3 = require("node-pty");
       ctx.log(`Auto-implement spawn (PTY): ${shellCmd}`);
-      const isWin2 = os16.platform() === "win32";
+      const isWin2 = os17.platform() === "win32";
       child = pty3.spawn(isWin2 ? "cmd.exe" : process.env.SHELL || "/bin/zsh", [isWin2 ? "/c" : "-c", shellCmd], {
         name: "xterm-256color",
         cols: 120,
@@ -33947,7 +34324,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         }
       });
       try {
-        fs12.unlinkSync(promptFile);
+        fs13.unlinkSync(promptFile);
       } catch {
       }
       ctx.log(`Auto-implement ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -34030,7 +34407,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 = path16.join(providerDir, "scripts");
+  const scriptsDir = path17.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -34038,10 +34415,10 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
     lines.push("");
-    for (const file2 of fs12.readdirSync(latestScriptsDir)) {
+    for (const file2 of fs13.readdirSync(latestScriptsDir)) {
       if (file2.endsWith(".js") && targetFileNames.has(file2)) {
         try {
-          const content = fs12.readFileSync(path16.join(latestScriptsDir, file2), "utf-8");
+          const content = fs13.readFileSync(path17.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -34051,14 +34428,14 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
         }
       }
     }
-    const refFiles = fs12.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs13.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file2 of refFiles) {
         try {
-          const content = fs12.readFileSync(path16.join(latestScriptsDir, file2), "utf-8");
+          const content = fs13.readFileSync(path17.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -34099,11 +34476,11 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
       lines.push("");
     }
   }
-  const docsDir = path16.join(providerDir, "../../docs");
+  const docsDir = path17.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path16.join(docsDir, name);
-      if (fs12.existsSync(p)) return fs12.readFileSync(p, "utf-8");
+      const p = path17.join(docsDir, name);
+      if (fs13.existsSync(p)) return fs13.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -34337,7 +34714,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 = path16.join(providerDir, "scripts");
+  const scriptsDir = path17.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -34345,11 +34722,11 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
     lines.push("");
-    for (const file2 of fs12.readdirSync(latestScriptsDir)) {
+    for (const file2 of fs13.readdirSync(latestScriptsDir)) {
       if (!file2.endsWith(".js")) continue;
       if (!targetFileNames.has(file2)) continue;
       try {
-        const content = fs12.readFileSync(path16.join(latestScriptsDir, file2), "utf-8");
+        const content = fs13.readFileSync(path17.join(latestScriptsDir, file2), "utf-8");
         lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -34358,14 +34735,14 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       } catch {
       }
     }
-    const refFiles = fs12.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs13.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file2 of refFiles) {
         try {
-          const content = fs12.readFileSync(path16.join(latestScriptsDir, file2), "utf-8");
+          const content = fs13.readFileSync(path17.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -34398,11 +34775,11 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       lines.push("");
     }
   }
-  const docsDir = path16.join(providerDir, "../../docs");
+  const docsDir = path17.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path16.join(docsDir, name);
-      if (fs12.existsSync(p)) return fs12.readFileSync(p, "utf-8");
+      const p = path17.join(docsDir, name);
+      if (fs13.existsSync(p)) return fs13.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -34706,26 +35083,26 @@ data: ${JSON.stringify(msg.data)}
     }
   }
 }
-var fs12, path16, os16;
+var fs13, path17, os17;
 var init_dev_auto_implement = __esm({
   "../../oss/packages/daemon-core/src/daemon/dev-auto-implement.ts"() {
     "use strict";
-    fs12 = __toESM(require("fs"));
-    path16 = __toESM(require("path"));
-    os16 = __toESM(require("os"));
+    fs13 = __toESM(require("fs"));
+    path17 = __toESM(require("path"));
+    os17 = __toESM(require("os"));
     init_dev_server();
     init_dev_cli_debug();
   }
 });
 
 // ../../oss/packages/daemon-core/src/daemon/dev-server.ts
-var http2, fs13, path17, DEV_SERVER_PORT, DevServer;
+var http2, fs14, path18, DEV_SERVER_PORT, DevServer;
 var init_dev_server = __esm({
   "../../oss/packages/daemon-core/src/daemon/dev-server.ts"() {
     "use strict";
     http2 = __toESM(require("http"));
-    fs13 = __toESM(require("fs"));
-    path17 = __toESM(require("path"));
+    fs14 = __toESM(require("fs"));
+    path18 = __toESM(require("path"));
     init_scaffold_template();
     init_version_archive();
     init_logger();
@@ -34829,8 +35206,8 @@ var init_dev_server = __esm({
       }
       getEndpointList() {
         return this.routes.map((r) => {
-          const path21 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-          return `${r.method.padEnd(5)} ${path21}`;
+          const path23 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+          return `${r.method.padEnd(5)} ${path23}`;
         });
       }
       async start(port = DEV_SERVER_PORT) {
@@ -35112,12 +35489,12 @@ var init_dev_server = __esm({
       // ─── DevConsole SPA ───
       getConsoleDistDir() {
         const candidates = [
-          path17.resolve(__dirname, "../../web-devconsole/dist"),
-          path17.resolve(__dirname, "../../../web-devconsole/dist"),
-          path17.join(process.cwd(), "packages/web-devconsole/dist")
+          path18.resolve(__dirname, "../../web-devconsole/dist"),
+          path18.resolve(__dirname, "../../../web-devconsole/dist"),
+          path18.join(process.cwd(), "packages/web-devconsole/dist")
         ];
         for (const dir of candidates) {
-          if (fs13.existsSync(path17.join(dir, "index.html"))) return dir;
+          if (fs14.existsSync(path18.join(dir, "index.html"))) return dir;
         }
         return null;
       }
@@ -35127,9 +35504,9 @@ var init_dev_server = __esm({
           this.json(res, 500, { error: "DevConsole not found. Run: npm run build -w packages/web-devconsole" });
           return;
         }
-        const htmlPath = path17.join(distDir, "index.html");
+        const htmlPath = path18.join(distDir, "index.html");
         try {
-          const html = fs13.readFileSync(htmlPath, "utf-8");
+          const html = fs14.readFileSync(htmlPath, "utf-8");
           res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
           res.end(html);
         } catch (e) {
@@ -35152,15 +35529,15 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: "Not found" });
           return;
         }
-        const safePath = path17.normalize(pathname).replace(/^\.\.\//, "");
-        const filePath = path17.join(distDir, safePath);
+        const safePath = path18.normalize(pathname).replace(/^\.\.\//, "");
+        const filePath = path18.join(distDir, safePath);
         if (!filePath.startsWith(distDir)) {
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
         try {
-          const content = fs13.readFileSync(filePath);
-          const ext = path17.extname(filePath);
+          const content = fs14.readFileSync(filePath);
+          const ext = path18.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);
@@ -35268,14 +35645,14 @@ var init_dev_server = __esm({
         const files = [];
         const scan = (d, prefix) => {
           try {
-            for (const entry of fs13.readdirSync(d, { withFileTypes: true })) {
+            for (const entry of fs14.readdirSync(d, { withFileTypes: true })) {
               if (entry.name.startsWith(".") || entry.name.endsWith(".bak")) continue;
               const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
               if (entry.isDirectory()) {
                 files.push({ path: rel, size: 0, type: "dir" });
-                scan(path17.join(d, entry.name), rel);
+                scan(path18.join(d, entry.name), rel);
               } else {
-                const stat4 = fs13.statSync(path17.join(d, entry.name));
+                const stat4 = fs14.statSync(path18.join(d, entry.name));
                 files.push({ path: rel, size: stat4.size, type: "file" });
               }
             }
@@ -35298,16 +35675,16 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider directory not found: ${type}` });
           return;
         }
-        const fullPath = path17.resolve(dir, path17.normalize(filePath));
+        const fullPath = path18.resolve(dir, path18.normalize(filePath));
         if (!fullPath.startsWith(dir)) {
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
-        if (!fs13.existsSync(fullPath) || fs13.statSync(fullPath).isDirectory()) {
+        if (!fs14.existsSync(fullPath) || fs14.statSync(fullPath).isDirectory()) {
           this.json(res, 404, { error: `File not found: ${filePath}` });
           return;
         }
-        const content = fs13.readFileSync(fullPath, "utf-8");
+        const content = fs14.readFileSync(fullPath, "utf-8");
         this.json(res, 200, { type, path: filePath, content, lines: content.split("\n").length });
       }
       /** POST /api/providers/:type/file — write a file { path, content } */
@@ -35323,15 +35700,15 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider directory not found: ${type}` });
           return;
         }
-        const fullPath = path17.resolve(dir, path17.normalize(filePath));
+        const fullPath = path18.resolve(dir, path18.normalize(filePath));
         if (!fullPath.startsWith(dir)) {
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
         try {
-          if (fs13.existsSync(fullPath)) fs13.copyFileSync(fullPath, fullPath + ".bak");
-          fs13.mkdirSync(path17.dirname(fullPath), { recursive: true });
-          fs13.writeFileSync(fullPath, content, "utf-8");
+          if (fs14.existsSync(fullPath)) fs14.copyFileSync(fullPath, fullPath + ".bak");
+          fs14.mkdirSync(path18.dirname(fullPath), { recursive: true });
+          fs14.writeFileSync(fullPath, content, "utf-8");
           this.log(`File saved: ${fullPath} (${content.length} chars)`);
           this.providerLoader.reload();
           this.json(res, 200, { saved: true, path: filePath, chars: content.length });
@@ -35347,9 +35724,9 @@ var init_dev_server = __esm({
           return;
         }
         for (const name of ["scripts.js", "provider.json"]) {
-          const p = path17.join(dir, name);
-          if (fs13.existsSync(p)) {
-            const source = fs13.readFileSync(p, "utf-8");
+          const p = path18.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 });
             return;
           }
@@ -35368,11 +35745,11 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const target = fs13.existsSync(path17.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
-        const targetPath = path17.join(dir, target);
+        const target = fs14.existsSync(path18.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+        const targetPath = path18.join(dir, target);
         try {
-          if (fs13.existsSync(targetPath)) fs13.copyFileSync(targetPath, targetPath + ".bak");
-          fs13.writeFileSync(targetPath, source, "utf-8");
+          if (fs14.existsSync(targetPath)) fs14.copyFileSync(targetPath, targetPath + ".bak");
+          fs14.writeFileSync(targetPath, source, "utf-8");
           this.log(`Saved provider: ${targetPath} (${source.length} chars)`);
           this.providerLoader.reload();
           this.json(res, 200, { saved: true, path: targetPath, chars: source.length });
@@ -35529,21 +35906,21 @@ var init_dev_server = __esm({
         }
         let targetDir;
         targetDir = this.providerLoader.getUserProviderDir(category, type);
-        const jsonPath = path17.join(targetDir, "provider.json");
-        if (fs13.existsSync(jsonPath)) {
+        const jsonPath = path18.join(targetDir, "provider.json");
+        if (fs14.existsSync(jsonPath)) {
           this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
           return;
         }
         try {
           const result = generateFiles(type, name, category, { cdpPorts, cli, processName, installPath, binary, extensionId, version: version2, osPaths, processNames });
-          fs13.mkdirSync(targetDir, { recursive: true });
-          fs13.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+          fs14.mkdirSync(targetDir, { recursive: true });
+          fs14.writeFileSync(jsonPath, result["provider.json"], "utf-8");
           const createdFiles = ["provider.json"];
           if (result.files) {
             for (const [relPath, content] of Object.entries(result.files)) {
-              const fullPath = path17.join(targetDir, relPath);
-              fs13.mkdirSync(path17.dirname(fullPath), { recursive: true });
-              fs13.writeFileSync(fullPath, content, "utf-8");
+              const fullPath = path18.join(targetDir, relPath);
+              fs14.mkdirSync(path18.dirname(fullPath), { recursive: true });
+              fs14.writeFileSync(fullPath, content, "utf-8");
               createdFiles.push(relPath);
             }
           }
@@ -35592,45 +35969,45 @@ var init_dev_server = __esm({
       }
       // ─── Phase 2: Auto-Implement Backend ───
       getLatestScriptVersionDir(scriptsDir) {
-        if (!fs13.existsSync(scriptsDir)) return null;
-        const versions = fs13.readdirSync(scriptsDir).filter((d) => {
+        if (!fs14.existsSync(scriptsDir)) return null;
+        const versions = fs14.readdirSync(scriptsDir).filter((d) => {
           try {
-            return fs13.statSync(path17.join(scriptsDir, d)).isDirectory();
+            return fs14.statSync(path18.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 path18.join(scriptsDir, versions[0]);
       }
       resolveAutoImplWritableProviderDir(category, type, requestedDir) {
-        const canonicalUserDir = path17.resolve(this.providerLoader.getUserProviderDir(category, type));
-        const desiredDir = requestedDir ? path17.resolve(requestedDir) : canonicalUserDir;
-        const upstreamRoot = path17.resolve(this.providerLoader.getUpstreamDir());
-        if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path17.sep}`)) {
+        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}`)) {
           return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
         }
-        if (path17.basename(desiredDir) !== type) {
+        if (path18.basename(desiredDir) !== type) {
           return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
         }
         const sourceDir = this.findProviderDir(type);
         if (!sourceDir) {
           return { dir: null, reason: `Provider source directory not found for '${type}'` };
         }
-        if (!fs13.existsSync(desiredDir)) {
-          fs13.mkdirSync(path17.dirname(desiredDir), { recursive: true });
-          fs13.cpSync(sourceDir, desiredDir, { recursive: true });
+        if (!fs14.existsSync(desiredDir)) {
+          fs14.mkdirSync(path18.dirname(desiredDir), { recursive: true });
+          fs14.cpSync(sourceDir, desiredDir, { recursive: true });
           this.log(`Auto-implement writable copy created: ${desiredDir}`);
         }
-        const providerJson = path17.join(desiredDir, "provider.json");
-        if (!fs13.existsSync(providerJson)) {
+        const providerJson = path18.join(desiredDir, "provider.json");
+        if (!fs14.existsSync(providerJson)) {
           return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
         }
         try {
-          const providerData = JSON.parse(fs13.readFileSync(providerJson, "utf-8"));
+          const providerData = JSON.parse(fs14.readFileSync(providerJson, "utf-8"));
           if (providerData.disableUpstream !== true) {
             providerData.disableUpstream = true;
-            fs13.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
+            fs14.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
           }
         } catch (error48) {
           return {
@@ -35670,7 +36047,7 @@ var init_dev_server = __esm({
           setMode: "set_mode.js"
         };
         const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-        const scriptsDir = path17.join(providerDir, "scripts");
+        const scriptsDir = path18.join(providerDir, "scripts");
         const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
         if (latestScriptsDir) {
           lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -35678,10 +36055,10 @@ var init_dev_server = __esm({
           lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
           lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
           lines.push("");
-          for (const file2 of fs13.readdirSync(latestScriptsDir)) {
+          for (const file2 of fs14.readdirSync(latestScriptsDir)) {
             if (file2.endsWith(".js") && targetFileNames.has(file2)) {
               try {
-                const content = fs13.readFileSync(path17.join(latestScriptsDir, file2), "utf-8");
+                const content = fs14.readFileSync(path18.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -35691,14 +36068,14 @@ var init_dev_server = __esm({
               }
             }
           }
-          const refFiles = fs13.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+          const refFiles = fs14.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
           if (refFiles.length > 0) {
             lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
             lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
             lines.push("");
             for (const file2 of refFiles) {
               try {
-                const content = fs13.readFileSync(path17.join(latestScriptsDir, file2), "utf-8");
+                const content = fs14.readFileSync(path18.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -35739,11 +36116,11 @@ var init_dev_server = __esm({
             lines.push("");
           }
         }
-        const docsDir = path17.join(providerDir, "../../docs");
+        const docsDir = path18.join(providerDir, "../../docs");
         const loadGuide = (name) => {
           try {
-            const p = path17.join(docsDir, name);
-            if (fs13.existsSync(p)) return fs13.readFileSync(p, "utf-8");
+            const p = path18.join(docsDir, name);
+            if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
           } catch {
           }
           return null;
@@ -35916,7 +36293,7 @@ var init_dev_server = __esm({
           parseApproval: "parse_approval.js"
         };
         const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-        const scriptsDir = path17.join(providerDir, "scripts");
+        const scriptsDir = path18.join(providerDir, "scripts");
         const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
         if (latestScriptsDir) {
           lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -35924,11 +36301,11 @@ var init_dev_server = __esm({
           lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
           lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
           lines.push("");
-          for (const file2 of fs13.readdirSync(latestScriptsDir)) {
+          for (const file2 of fs14.readdirSync(latestScriptsDir)) {
             if (!file2.endsWith(".js")) continue;
             if (!targetFileNames.has(file2)) continue;
             try {
-              const content = fs13.readFileSync(path17.join(latestScriptsDir, file2), "utf-8");
+              const content = fs14.readFileSync(path18.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -35937,14 +36314,14 @@ var init_dev_server = __esm({
             } catch {
             }
           }
-          const refFiles = fs13.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+          const refFiles = fs14.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
           if (refFiles.length > 0) {
             lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
             lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
             lines.push("");
             for (const file2 of refFiles) {
               try {
-                const content = fs13.readFileSync(path17.join(latestScriptsDir, file2), "utf-8");
+                const content = fs14.readFileSync(path18.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -35977,11 +36354,11 @@ var init_dev_server = __esm({
             lines.push("");
           }
         }
-        const docsDir = path17.join(providerDir, "../../docs");
+        const docsDir = path18.join(providerDir, "../../docs");
         const loadGuide = (name) => {
           try {
-            const p = path17.join(docsDir, name);
-            if (fs13.existsSync(p)) return fs13.readFileSync(p, "utf-8");
+            const p = path18.join(docsDir, name);
+            if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
           } catch {
           }
           return null;
@@ -36243,7 +36620,7 @@ function getDefaultSessionHostEndpoint(appName = "adhdev") {
   }
   return {
     kind: "unix",
-    path: path22.join(os17.tmpdir(), `${appName}-session-host.sock`)
+    path: path22.join(os18.tmpdir(), `${appName}-session-host.sock`)
   };
 }
 function serializeEnvelope(envelope) {
@@ -36265,11 +36642,11 @@ function createLineParser(onEnvelope) {
     }
   };
 }
-var os17, path22, net2, import_crypto3, SessionHostClient;
+var os18, path22, net2, import_crypto3, SessionHostClient;
 var init_dist = __esm({
   "../../oss/packages/session-host-core/dist/index.mjs"() {
     "use strict";
-    os17 = __toESM(require("os"), 1);
+    os18 = __toESM(require("os"), 1);
     path22 = __toESM(require("path"), 1);
     net2 = __toESM(require("net"), 1);
     import_crypto3 = require("crypto");
@@ -36812,9 +37189,187 @@ var init_runtime_support = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/installer.ts
+function isExtensionInstalled(ide, marketplaceId) {
+  if (!ide.cliCommand) return false;
+  try {
+    const result = (0, import_child_process10.execSync)(`"${ide.cliCommand}" --list-extensions`, {
+      encoding: "utf-8",
+      timeout: 15e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const installed = result.trim().split("\n").map((e) => e.trim().toLowerCase());
+    return installed.includes(marketplaceId.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+async function installExtension(ide, extension) {
+  if (!ide.cliCommand) {
+    return {
+      extensionId: extension.id,
+      marketplaceId: extension.marketplaceId,
+      success: false,
+      alreadyInstalled: false,
+      error: `No CLI command found for ${ide.displayName}. Please install it manually.`
+    };
+  }
+  const alreadyInstalled = isExtensionInstalled(ide, extension.marketplaceId);
+  if (alreadyInstalled) {
+    return {
+      extensionId: extension.id,
+      marketplaceId: extension.marketplaceId,
+      success: true,
+      alreadyInstalled: true
+    };
+  }
+  if (extension.vsixUrl) {
+    try {
+      const tmpDir = (await import("os")).tmpdir();
+      const vsixPath = `${tmpDir}/adhdev-extension-latest.vsix`;
+      const res = await fetch(extension.vsixUrl);
+      if (res.ok) {
+        const buffer = Buffer.from(await res.arrayBuffer());
+        const fs18 = await import("fs");
+        fs18.writeFileSync(vsixPath, buffer);
+        return new Promise((resolve13) => {
+          const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
+          (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
+            resolve13({
+              extensionId: extension.id,
+              marketplaceId: extension.marketplaceId,
+              success: !error48,
+              alreadyInstalled: false,
+              error: error48 ? stderr || error48.message : void 0
+            });
+          });
+        });
+      }
+    } catch (e) {
+    }
+  }
+  return new Promise((resolve13) => {
+    const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
+    (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error48, stdout, stderr) => {
+      if (error48) {
+        resolve13({
+          extensionId: extension.id,
+          marketplaceId: extension.marketplaceId,
+          success: false,
+          alreadyInstalled: false,
+          error: stderr || error48.message
+        });
+      } else {
+        resolve13({
+          extensionId: extension.id,
+          marketplaceId: extension.marketplaceId,
+          success: true,
+          alreadyInstalled: false
+        });
+      }
+    });
+  });
+}
+async function installExtensions(ide, extensions, onProgress) {
+  const results = [];
+  for (let i = 0; i < extensions.length; i++) {
+    const ext = extensions[i];
+    const result = await installExtension(ide, ext);
+    results.push(result);
+    onProgress?.(i + 1, extensions.length, ext, result);
+  }
+  return results;
+}
+function getAIExtensions() {
+  return EXTENSION_CATALOG.filter((e) => e.category === "ai-agent");
+}
+function launchIDE(ide, workspacePath) {
+  if (!ide.cliCommand) return false;
+  try {
+    const args = workspacePath ? `"${workspacePath}"` : "";
+    (0, import_child_process10.exec)(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var import_child_process10, EXTENSION_CATALOG;
 var init_installer = __esm({
   "../../oss/packages/daemon-core/src/installer.ts"() {
     "use strict";
+    import_child_process10 = require("child_process");
+    EXTENSION_CATALOG = [
+      // AI Agent extensions
+      {
+        id: "roo-code",
+        name: "Roo Code",
+        displayName: "Roo Code (Roo Cline)",
+        marketplaceId: "rooveterinaryinc.roo-cline",
+        description: "Open-source AI coding assistant with multiple modes",
+        category: "ai-agent",
+        icon: "\u{1F998}",
+        recommended: true,
+        website: "https://roocode.com"
+      },
+      {
+        id: "github-copilot",
+        name: "GitHub Copilot",
+        displayName: "GitHub Copilot",
+        marketplaceId: "github.copilot",
+        description: "AI pair programmer by GitHub",
+        category: "ai-agent",
+        icon: "\u{1F916}",
+        recommended: true,
+        requiresApiKey: true,
+        apiKeyName: "GitHub account",
+        website: "https://github.com/features/copilot"
+      },
+      {
+        id: "copilot-chat",
+        name: "GitHub Copilot Chat",
+        displayName: "GitHub Copilot Chat",
+        marketplaceId: "github.copilot-chat",
+        description: "Chat interface for GitHub Copilot",
+        category: "ai-agent",
+        icon: "\u{1F4AC}",
+        recommended: true,
+        requiresApiKey: true,
+        apiKeyName: "GitHub account"
+      },
+      {
+        id: "cline",
+        name: "Cline",
+        displayName: "Cline",
+        marketplaceId: "saoudrizwan.claude-dev",
+        description: "Autonomous AI coding agent in your IDE",
+        category: "ai-agent",
+        icon: "\u{1F9E0}",
+        recommended: false,
+        requiresApiKey: true,
+        apiKeyName: "Anthropic/OpenAI API key"
+      },
+      {
+        id: "continue",
+        name: "Continue",
+        displayName: "Continue",
+        marketplaceId: "continue.continue",
+        description: "Open-source AI code assistant with custom models",
+        category: "ai-agent",
+        icon: "\u25B6\uFE0F",
+        recommended: false
+      },
+      {
+        id: "aider",
+        name: "Aider",
+        displayName: "Aider",
+        marketplaceId: "aider.aider",
+        description: "AI pair programming in your terminal",
+        category: "ai-agent",
+        icon: "\u{1F527}",
+        recommended: false,
+        requiresApiKey: true,
+        apiKeyName: "OpenAI/Anthropic API key"
+      }
+    ];
   }
 });
 
@@ -37019,6 +37574,18 @@ async function initDaemonComponents(config2) {
     detectedIdes: detectedIdesRef
   };
 }
+async function startDaemonDevSupport(options) {
+  const devServer = new DevServer({
+    providerLoader: options.components.providerLoader,
+    cdpManagers: options.components.cdpManagers,
+    instanceManager: options.components.instanceManager,
+    cliManager: options.components.cliManager,
+    logFn: options.logFn
+  });
+  await devServer.start();
+  options.components.providerLoader.watch();
+  return devServer;
+}
 async function shutdownDaemonComponents(components) {
   const {
     poller,
@@ -37079,6 +37646,84 @@ var init_daemon_lifecycle = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AcpProviderInstance: () => AcpProviderInstance,
+  AgentStreamPoller: () => AgentStreamPoller,
+  CdpDomHandlers: () => CdpDomHandlers,
+  CliProviderInstance: () => CliProviderInstance,
+  DAEMON_WS_PATH: () => DAEMON_WS_PATH,
+  DEFAULT_DAEMON_PORT: () => DEFAULT_DAEMON_PORT,
+  DaemonAgentStreamManager: () => DaemonAgentStreamManager,
+  DaemonCdpInitializer: () => DaemonCdpInitializer,
+  DaemonCdpManager: () => DaemonCdpManager,
+  DaemonCdpScanner: () => DaemonCdpScanner,
+  DaemonCliManager: () => DaemonCliManager,
+  DaemonCommandHandler: () => DaemonCommandHandler,
+  DaemonCommandRouter: () => DaemonCommandRouter,
+  DaemonStatusReporter: () => DaemonStatusReporter,
+  DevServer: () => DevServer,
+  IdeProviderInstance: () => IdeProviderInstance,
+  LOG: () => LOG,
+  NodePtyTransportFactory: () => NodePtyTransportFactory,
+  ProviderCliAdapter: () => ProviderCliAdapter,
+  ProviderInstanceManager: () => ProviderInstanceManager,
+  ProviderLoader: () => ProviderLoader,
+  SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory,
+  VersionArchive: () => VersionArchive,
+  appendRecentActivity: () => appendRecentActivity,
+  buildSessionEntries: () => buildSessionEntries,
+  buildStatusSnapshot: () => buildStatusSnapshot,
+  connectCdpManager: () => connectCdpManager,
+  detectAllVersions: () => detectAllVersions,
+  detectCLIs: () => detectCLIs,
+  detectIDEs: () => detectIDEs,
+  ensureSessionHostReady: () => ensureSessionHostReady,
+  findCdpManager: () => findCdpManager,
+  forwardAgentStreamsToIdeInstance: () => forwardAgentStreamsToIdeInstance,
+  getAIExtensions: () => getAIExtensions,
+  getAvailableIdeIds: () => getAvailableIdeIds,
+  getCurrentDaemonLogPath: () => getCurrentDaemonLogPath,
+  getDaemonLogDir: () => getDaemonLogDir,
+  getHostMemorySnapshot: () => getHostMemorySnapshot,
+  getLogLevel: () => getLogLevel,
+  getRecentActivity: () => getRecentActivity,
+  getRecentCommands: () => getRecentCommands,
+  getRecentLogs: () => getRecentLogs,
+  getSavedProviderSessions: () => getSavedProviderSessions,
+  getWorkspaceState: () => getWorkspaceState,
+  hasCdpManager: () => hasCdpManager,
+  initDaemonComponents: () => initDaemonComponents,
+  installExtensions: () => installExtensions,
+  installGlobalInterceptor: () => installGlobalInterceptor,
+  isCdpConnected: () => isCdpConnected,
+  isExtensionInstalled: () => isExtensionInstalled,
+  isIdeRunning: () => isIdeRunning,
+  isManagedStatusWaiting: () => isManagedStatusWaiting,
+  isManagedStatusWorking: () => isManagedStatusWorking,
+  isSetupComplete: () => isSetupComplete,
+  killIdeProcess: () => killIdeProcess,
+  launchIDE: () => launchIDE,
+  launchWithCdp: () => launchWithCdp,
+  listHostedCliRuntimes: () => listHostedCliRuntimes,
+  loadConfig: () => loadConfig,
+  logCommand: () => logCommand,
+  markSetupComplete: () => markSetupComplete,
+  maybeRunDaemonUpgradeHelperFromEnv: () => maybeRunDaemonUpgradeHelperFromEnv,
+  normalizeActiveChatData: () => normalizeActiveChatData,
+  normalizeManagedStatus: () => normalizeManagedStatus,
+  probeCdpPort: () => probeCdpPort,
+  readChatHistory: () => readChatHistory,
+  registerExtensionProviders: () => registerExtensionProviders,
+  resetConfig: () => resetConfig,
+  saveConfig: () => saveConfig,
+  setLogLevel: () => setLogLevel,
+  setupIdeInstance: () => setupIdeInstance,
+  shutdownDaemonComponents: () => shutdownDaemonComponents,
+  startDaemonDevSupport: () => startDaemonDevSupport,
+  updateConfig: () => updateConfig,
+  upsertSavedProviderSession: () => upsertSavedProviderSession
+});
 var init_src = __esm({
   "../../oss/packages/daemon-core/src/index.ts"() {
     "use strict";
@@ -37426,17 +38071,17 @@ function canPeerUsePrivilegedShareCommand(commandType, permission) {
       return false;
   }
 }
-var fs14, path18, os18, import_node_module2, esmRequire, logFile, log, logDebug, DaemonP2PSender;
+var fs15, path19, os19, import_node_module2, esmRequire, logFile, log, logDebug, DaemonP2PSender;
 var init_daemon_p2p = __esm({
   "src/daemon-p2p.ts"() {
     "use strict";
-    fs14 = __toESM(require("fs"));
+    fs15 = __toESM(require("fs"));
     init_src();
-    path18 = __toESM(require("path"));
-    os18 = __toESM(require("os"));
+    path19 = __toESM(require("path"));
+    os19 = __toESM(require("os"));
     import_node_module2 = require("module");
     esmRequire = (0, import_node_module2.createRequire)(__filename);
-    logFile = path18.join(os18.tmpdir(), "adhdev_daemon_p2p.log");
+    logFile = path19.join(os19.tmpdir(), "adhdev_daemon_p2p.log");
     log = (msg) => {
       LOG.info("P2P", `[${(/* @__PURE__ */ new Date()).toISOString()}] [P2P] ${msg}`);
     };
@@ -37504,17 +38149,17 @@ ${e?.stack || ""}`);
         const prebuildKey = `${platform11}-${arch3}`;
         try {
           const candidates = [
-            path18.join(__dirname, "node_modules", "node-datachannel"),
-            path18.join(__dirname, "..", "node_modules", "node-datachannel"),
-            path18.join(__dirname, "..", "..", "node_modules", "node-datachannel")
+            path19.join(__dirname, "node_modules", "node-datachannel"),
+            path19.join(__dirname, "..", "node_modules", "node-datachannel"),
+            path19.join(__dirname, "..", "..", "node_modules", "node-datachannel")
           ];
           for (const candidate of candidates) {
-            const prebuildPath = path18.join(candidate, "prebuilds", prebuildKey, "node_datachannel.node");
-            if (fs14.existsSync(prebuildPath)) {
-              const targetDir = path18.join(candidate, "build", "Release");
-              const targetPath = path18.join(targetDir, "node_datachannel.node");
-              fs14.mkdirSync(targetDir, { recursive: true });
-              fs14.copyFileSync(prebuildPath, targetPath);
+            const prebuildPath = path19.join(candidate, "prebuilds", prebuildKey, "node_datachannel.node");
+            if (fs15.existsSync(prebuildPath)) {
+              const targetDir = path19.join(candidate, "build", "Release");
+              const targetPath = path19.join(targetDir, "node_datachannel.node");
+              fs15.mkdirSync(targetDir, { recursive: true });
+              fs15.copyFileSync(prebuildPath, targetPath);
               try {
                 delete esmRequire.cache[esmRequire.resolve("node-datachannel")];
               } catch {
@@ -38424,23 +39069,23 @@ function buildSessionHostEnv(baseEnv) {
 }
 function resolveSessionHostEntry() {
   const packagedCandidates = [
-    path19.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
-    path19.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
+    path20.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
+    path20.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
   ];
   for (const candidate of packagedCandidates) {
-    if (fs15.existsSync(candidate)) {
+    if (fs16.existsSync(candidate)) {
       return candidate;
     }
   }
   return require.resolve("@adhdev/session-host-daemon");
 }
 function getSessionHostPidFile() {
-  return path19.join(os19.homedir(), ".adhdev", `${SESSION_HOST_APP_NAME}-session-host.pid`);
+  return path20.join(os20.homedir(), ".adhdev", `${SESSION_HOST_APP_NAME}-session-host.pid`);
 }
-function killPid(pid) {
+function killPid2(pid) {
   try {
     if (process.platform === "win32") {
-      (0, import_child_process9.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+      (0, import_child_process11.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
     } else {
       process.kill(pid, "SIGTERM");
     }
@@ -38453,26 +39098,26 @@ function stopSessionHost() {
   let stopped = false;
   const pidFile = getSessionHostPidFile();
   try {
-    if (fs15.existsSync(pidFile)) {
-      const pid = Number.parseInt(fs15.readFileSync(pidFile, "utf8").trim(), 10);
+    if (fs16.existsSync(pidFile)) {
+      const pid = Number.parseInt(fs16.readFileSync(pidFile, "utf8").trim(), 10);
       if (Number.isFinite(pid)) {
-        stopped = killPid(pid) || stopped;
+        stopped = killPid2(pid) || stopped;
       }
     }
   } catch {
   } finally {
     try {
-      fs15.unlinkSync(pidFile);
+      fs16.unlinkSync(pidFile);
     } catch {
     }
   }
   if (process.platform !== "win32") {
     try {
-      const raw = (0, import_child_process9.execFileSync)("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
+      const raw = (0, import_child_process11.execFileSync)("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
       for (const line of raw.split("\n")) {
         const pid = Number.parseInt(line.trim(), 10);
         if (Number.isFinite(pid)) {
-          stopped = killPid(pid) || stopped;
+          stopped = killPid2(pid) || stopped;
         }
       }
     } catch {
@@ -38483,7 +39128,7 @@ function stopSessionHost() {
 async function ensureSessionHostReady2() {
   const spawnHost = () => {
     const entry = resolveSessionHostEntry();
-    const child = (0, import_child_process9.spawn)(process.execPath, [entry], {
+    const child = (0, import_child_process11.spawn)(process.execPath, [entry], {
       detached: true,
       stdio: "ignore",
       windowsHide: true,
@@ -38513,46 +39158,75 @@ async function ensureSessionHostReady2() {
 async function listHostedCliRuntimes2(endpoint) {
   return listHostedCliRuntimes(endpoint);
 }
-var import_child_process9, fs15, os19, path19, SESSION_HOST_APP_NAME, SESSION_HOST_START_TIMEOUT_MS;
+var import_child_process11, fs16, os20, path20, SESSION_HOST_APP_NAME, SESSION_HOST_START_TIMEOUT_MS;
 var init_session_host = __esm({
   "src/session-host.ts"() {
     "use strict";
-    import_child_process9 = require("child_process");
-    fs15 = __toESM(require("fs"));
-    os19 = __toESM(require("os"));
-    path19 = __toESM(require("path"));
+    import_child_process11 = require("child_process");
+    fs16 = __toESM(require("fs"));
+    os20 = __toESM(require("os"));
+    path20 = __toESM(require("path"));
     init_src();
+    init_dist();
     SESSION_HOST_APP_NAME = process.env.ADHDEV_SESSION_HOST_NAME || "adhdev";
     SESSION_HOST_START_TIMEOUT_MS = 15e3;
   }
 });
 
+// src/version.ts
+function resolvePackageVersion(options) {
+  const injectedVersion = options?.injectedVersion || "unknown";
+  const dir = options?.dirname || __dirname;
+  const possiblePaths = [
+    (0, import_path2.join)(dir, "..", "..", "package.json"),
+    (0, import_path2.join)(dir, "..", "package.json"),
+    (0, import_path2.join)(dir, "package.json")
+  ];
+  for (const p of possiblePaths) {
+    try {
+      const data = JSON.parse((0, import_fs3.readFileSync)(p, "utf-8"));
+      if (data.version) return data.version;
+    } catch {
+    }
+  }
+  return injectedVersion;
+}
+var import_fs3, import_path2;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    import_fs3 = require("fs");
+    import_path2 = require("path");
+  }
+});
+
 // src/adhdev-daemon.ts
 var adhdev_daemon_exports = {};
 __export(adhdev_daemon_exports, {
   AdhdevDaemon: () => AdhdevDaemon,
+  getDaemonPid: () => getDaemonPid,
   isDaemonRunning: () => isDaemonRunning,
   stopDaemon: () => stopDaemon
 });
 function getDaemonPidFile() {
-  const dir = path20.join(os20.homedir(), ".adhdev");
-  if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
-  return path20.join(dir, "daemon.pid");
+  const dir = path21.join(os21.homedir(), ".adhdev");
+  if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
+  return path21.join(dir, "daemon.pid");
 }
 function writeDaemonPid(pid) {
-  fs16.writeFileSync(getDaemonPidFile(), String(pid), "utf-8");
+  fs17.writeFileSync(getDaemonPidFile(), String(pid), "utf-8");
 }
 function removeDaemonPid() {
   try {
-    fs16.unlinkSync(getDaemonPidFile());
+    fs17.unlinkSync(getDaemonPidFile());
   } catch (e) {
   }
 }
 function isDaemonRunning() {
   const pidFile = getDaemonPidFile();
   try {
-    if (!fs16.existsSync(pidFile)) return false;
-    const pid = parseInt(fs16.readFileSync(pidFile, "utf-8").trim());
+    if (!fs17.existsSync(pidFile)) return false;
+    const pid = parseInt(fs17.readFileSync(pidFile, "utf-8").trim());
     process.kill(pid, 0);
     return true;
   } catch {
@@ -38560,11 +39234,21 @@ function isDaemonRunning() {
     return false;
   }
 }
+function getDaemonPid() {
+  const pidFile = getDaemonPidFile();
+  try {
+    if (!fs17.existsSync(pidFile)) return null;
+    const pid = parseInt(fs17.readFileSync(pidFile, "utf-8").trim(), 10);
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
 function stopDaemon() {
   const pidFile = getDaemonPidFile();
   try {
-    if (!fs16.existsSync(pidFile)) return false;
-    const pid = parseInt(fs16.readFileSync(pidFile, "utf-8").trim());
+    if (!fs17.existsSync(pidFile)) return false;
+    const pid = parseInt(fs17.readFileSync(pidFile, "utf-8").trim());
     process.kill(pid, "SIGTERM");
     removeDaemonPid();
     return true;
@@ -38573,7 +39257,7 @@ function stopDaemon() {
     return false;
   }
 }
-var os20, fs16, path20, import_chalk2, pkgVersion, DANGEROUS_PATTERNS, AdhdevDaemon;
+var os21, fs17, path21, import_http, import_ws3, import_chalk2, pkgVersion, DANGEROUS_PATTERNS, AdhdevDaemon;
 var init_adhdev_daemon = __esm({
   "src/adhdev-daemon.ts"() {
     "use strict";
@@ -38583,30 +39267,14 @@ var init_adhdev_daemon = __esm({
     init_screenshot_controller();
     init_session_host();
     init_dist();
-    os20 = __toESM(require("os"));
-    fs16 = __toESM(require("fs"));
-    path20 = __toESM(require("path"));
+    os21 = __toESM(require("os"));
+    fs17 = __toESM(require("fs"));
+    path21 = __toESM(require("path"));
+    import_http = require("http");
+    import_ws3 = require("ws");
     import_chalk2 = __toESM(require("chalk"));
-    pkgVersion = "0.8.8";
-    if (pkgVersion === "unknown") {
-      try {
-        const possiblePaths = [
-          path20.join(__dirname, "..", "package.json"),
-          path20.join(__dirname, "package.json")
-        ];
-        for (const p of possiblePaths) {
-          try {
-            const data = JSON.parse(fs16.readFileSync(p, "utf-8"));
-            if (data.version) {
-              pkgVersion = data.version;
-              break;
-            }
-          } catch {
-          }
-        }
-      } catch {
-      }
-    }
+    init_version();
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.10" });
     DANGEROUS_PATTERNS = [
       /\brm\s+(-[a-z]*f|-[a-z]*r|--force|--recursive)/i,
       /\bsudo\b/i,
@@ -38620,6 +39288,9 @@ var init_adhdev_daemon = __esm({
       /\b:\/\)\s*\{/
     ];
     AdhdevDaemon = class {
+      localHttpServer = null;
+      localWss = null;
+      localClients = /* @__PURE__ */ new Set();
       serverConn = null;
       p2p = null;
       screenshotController = null;
@@ -38647,11 +39318,7 @@ var init_adhdev_daemon = __esm({
         return mode === "chat" || mode === "terminal";
       }
       async start(options = {}) {
-        try {
-          const { installGlobalInterceptor: installGlobalInterceptor2 } = require("./logging/logger");
-          installGlobalInterceptor2();
-        } catch {
-        }
+        installGlobalInterceptor();
         process.on("uncaughtException", (err) => {
           LOG.error("Daemon", `Uncaught exception: ${err?.message}
 ${err?.stack || ""}`);
@@ -38727,6 +39394,7 @@ ${err?.stack || ""}`);
             }
           });
           await this.components.cliManager.restoreHostedSessions();
+          await this.startLocalIpcServer();
           this.components.providerLoader.fetchLatest().then(({ updated }) => {
             if (updated) {
               this.components.providerLoader.reload();
@@ -38743,8 +39411,8 @@ ${err?.stack || ""}`);
             cliInfo: {
               type: "adhdev-daemon",
               version: pkgVersion,
-              platform: os20.platform(),
-              hostname: os20.hostname(),
+              platform: os21.platform(),
+              hostname: os21.hostname(),
               machineId: config2.machineId,
               instanceId
             }
@@ -38883,6 +39551,7 @@ ${err?.stack || ""}`);
         const cdpManagers = this.components?.cdpManagers;
         const cdpStatus = cdpManagers && cdpManagers.size > 0 ? `\u2705 ${[...cdpManagers.entries()].map(([k, m]) => `${k}:${m.getPort()}`).join(", ")}` : "\u274C not connected";
         console.log(`  ${import_chalk2.default.bold("CDP:")}     ${cdpStatus}`);
+        console.log(`  ${import_chalk2.default.bold("IPC:")}     ${import_chalk2.default.cyan(`ws://127.0.0.1:${this.localPort}${DAEMON_WS_PATH}`)}`);
         console.log(`  ${import_chalk2.default.bold("P2P:")}     ${this.p2p?.isAvailable ? "\u2705 available" : "\u274C unavailable"}`);
         const providerCount = this.components?.providerLoader.getAll().length ?? 0;
         console.log(`  ${import_chalk2.default.bold("Providers:")} ${providerCount > 0 ? `\u2705 ${providerCount} loaded` : "\u274C not loaded"}`);
@@ -38927,8 +39596,8 @@ ${err?.stack || ""}`);
               return;
             }
             const cwd = args?.dir || process.cwd();
-            const { exec: exec2 } = require("child_process");
-            exec2(cmdStr, { cwd, timeout: 6e4 }, (err, stdout, stderr) => {
+            const { exec: exec3 } = require("child_process");
+            exec3(cmdStr, { cwd, timeout: 6e4 }, (err, stdout, stderr) => {
               if (!this.serverConn) return;
               if (err) this.serverConn.sendMessage("log", { message: `\u274C ${err.message}`, level: "error" });
               else {
@@ -38999,6 +39668,135 @@ ${err?.stack || ""}`);
           return { success: false, error: e.message };
         }
       }
+      async startLocalIpcServer() {
+        if (this.localHttpServer || this.localWss) return;
+        this.localHttpServer = (0, import_http.createServer)((req, res) => {
+          const url2 = req.url || "/";
+          if (req.method === "GET" && url2 === "/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              ok: true,
+              pid: process.pid,
+              wsPath: DAEMON_WS_PATH,
+              port: this.localPort
+            }));
+            return;
+          }
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Not found" }));
+        });
+        this.localWss = new import_ws3.WebSocketServer({ noServer: true });
+        this.localWss.on("connection", (ws) => this.handleLocalIpcConnection(ws));
+        this.localHttpServer.on("upgrade", (req, socket, head) => {
+          const wsUrl = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
+          if (wsUrl.pathname !== DAEMON_WS_PATH) {
+            socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+            socket.destroy();
+            return;
+          }
+          this.localWss.handleUpgrade(req, socket, head, (ws) => {
+            this.localWss.emit("connection", ws, req);
+          });
+        });
+        await new Promise((resolve13, reject) => {
+          const cleanup = () => {
+            this.localHttpServer?.off("error", onError);
+            this.localHttpServer?.off("listening", onListening);
+          };
+          const onError = (error48) => {
+            cleanup();
+            reject(error48);
+          };
+          const onListening = () => {
+            cleanup();
+            resolve13();
+          };
+          this.localHttpServer.once("error", onError);
+          this.localHttpServer.once("listening", onListening);
+          this.localHttpServer.listen(this.localPort, "127.0.0.1");
+        });
+        LOG.info("IPC", `Local IPC listening on ws://127.0.0.1:${this.localPort}${DAEMON_WS_PATH}`);
+      }
+      handleLocalIpcConnection(ws) {
+        this.localClients.add(ws);
+        this.sendLocalIpcWelcome(ws);
+        ws.on("message", (raw) => {
+          void this.handleLocalIpcMessage(ws, raw.toString());
+        });
+        ws.on("close", () => {
+          this.localClients.delete(ws);
+        });
+        ws.on("error", () => {
+          this.localClients.delete(ws);
+        });
+      }
+      sendLocalIpcWelcome(ws) {
+        try {
+          const cliAgents = this.components ? this.components.instanceManager.collectAllStates().filter((state) => state?.category === "cli").map((state) => String(state?.instanceId || "")).filter(Boolean) : [];
+          ws.send(JSON.stringify({
+            type: "daemon:welcome",
+            payload: {
+              daemonVersion: pkgVersion,
+              serverConnected: this.serverConn?.isConnected() ?? false,
+              cdpConnected: (this.components?.cdpManagers.size || 0) > 0,
+              localPort: this.localPort,
+              cliAgents
+            }
+          }));
+        } catch (error48) {
+          LOG.warn("IPC", `Failed to send welcome: ${error48?.message || error48}`);
+        }
+      }
+      async handleLocalIpcMessage(ws, raw) {
+        let msg;
+        try {
+          msg = JSON.parse(raw);
+        } catch {
+          return;
+        }
+        if (!msg || typeof msg !== "object") return;
+        if (msg.type === "ext:register") {
+          this.sendLocalIpcWelcome(ws);
+          return;
+        }
+        if (msg.type !== "ext:command") return;
+        const payload = msg.payload && typeof msg.payload === "object" ? msg.payload : {};
+        const command = typeof payload.command === "string" ? payload.command : "";
+        const args = payload.args && typeof payload.args === "object" ? payload.args : {};
+        const requestId = typeof payload.requestId === "string" ? payload.requestId : typeof payload.messageId === "string" ? payload.messageId : `ipc-${Date.now()}`;
+        if (!command) {
+          ws.send(JSON.stringify({
+            type: "ext:command_result",
+            payload: {
+              requestId,
+              success: false,
+              error: "command required"
+            }
+          }));
+          return;
+        }
+        try {
+          const result = await this.components.router.execute(command, args, "ipc");
+          ws.send(JSON.stringify({
+            type: "ext:command_result",
+            payload: {
+              requestId,
+              success: !!result?.success,
+              result,
+              error: result?.success ? void 0 : result?.error
+            }
+          }));
+        } catch (error48) {
+          ws.send(JSON.stringify({
+            type: "ext:command_result",
+            payload: {
+              requestId,
+              success: false,
+              error: error48?.message || String(error48)
+            }
+          }));
+        }
+      }
       // ─── executeDaemonCommand / stopIde: Removed — now in DaemonCommandRouter ───
       sendResult(msg, success2, extra) {
         if (!msg.id) return;
@@ -39039,6 +39837,23 @@ ${err?.stack || ""}`);
           this.serverConn?.disconnect();
         } catch {
         }
+        try {
+          for (const client of this.localClients) {
+            client.close();
+          }
+          this.localClients.clear();
+          this.localWss?.close();
+          this.localWss = null;
+          await new Promise((resolve13) => {
+            if (!this.localHttpServer) {
+              resolve13();
+              return;
+            }
+            this.localHttpServer.close(() => resolve13());
+            this.localHttpServer = null;
+          });
+        } catch {
+        }
         removeDaemonPid();
         console.log(import_chalk2.default.green("  \u2713 ADHDev Daemon stopped.\n"));
         if (exitProcess) {
@@ -39112,10 +39927,10 @@ async function runWizard(options = {}) {
 }
 async function checkForUpdate() {
   try {
-    const { execSync: execSync6 } = await import("child_process");
+    const { execSync: execSync7 } = await import("child_process");
     let currentVersion = null;
     try {
-      currentVersion = execSync6("adhdev --version", {
+      currentVersion = execSync7("adhdev --version", {
         encoding: "utf-8",
         timeout: 3e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -39125,7 +39940,7 @@ async function checkForUpdate() {
     }
     let latestVersion = null;
     try {
-      latestVersion = execSync6("npm show adhdev version", {
+      latestVersion = execSync7("npm show adhdev version", {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -39147,7 +39962,7 @@ async function checkForUpdate() {
     }
     const spinner = (await import("ora")).default("Updating adhdev CLI...").start();
     try {
-      execSync6("npm install -g adhdev@latest", {
+      execSync7("npm install -g adhdev@latest", {
         encoding: "utf-8",
         timeout: 6e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -39203,11 +40018,12 @@ async function quickSetup() {
   console.log(`  ${import_chalk3.default.bold("Status:")}  ${loginResult ? import_chalk3.default.green("Ready to connect") : import_chalk3.default.yellow("Login required")}`);
   console.log();
   console.log(import_chalk3.default.gray("  Next steps:"));
-  console.log(import_chalk3.default.gray(`    ${loginResult ? "adhdev daemon              \u2014 Start the main daemon (required for all features)" : "adhdev setup               \u2014 Sign in to finish setup and enable the daemon"}`));
+  console.log(import_chalk3.default.gray(`    ${loginResult ? "adhdev daemon              \u2014 Start the main daemon (IDE / remote features)" : "adhdev setup               \u2014 Sign in to finish setup and enable the daemon"}`));
   console.log(import_chalk3.default.gray("    adhdev launch cursor       \u2014 Launch Cursor IDE with remote control"));
   console.log(import_chalk3.default.gray("    adhdev launch windsurf     \u2014 Launch Windsurf IDE with remote control"));
-  console.log(import_chalk3.default.gray("    adhdev launch gemini       \u2014 Start Gemini CLI agent via daemon"));
-  console.log(import_chalk3.default.gray("    adhdev launch claude       \u2014 Start Claude Code agent via daemon"));
+  console.log(import_chalk3.default.gray("    adhdev daemon              \u2014 Keep the daemon running for CLI agent launch"));
+  console.log(import_chalk3.default.gray("    adhdev launch gemini       \u2014 Start Gemini CLI agent"));
+  console.log(import_chalk3.default.gray("    adhdev launch claude       \u2014 Start Claude Code agent"));
   console.log(import_chalk3.default.gray("    adhdev status              \u2014 Check setup status"));
   console.log();
   console.log(import_chalk3.default.cyan("  Dashboard: https://adhf.dev/dashboard"));
@@ -39230,16 +40046,16 @@ async function loginFlow() {
   let verificationUrl;
   try {
     const config2 = loadConfig();
-    const os21 = await import("os");
+    const os22 = await import("os");
     const res = await fetch(`${SERVER_URL}/auth/cli/init`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         clientMachineId: config2.machineId,
         registeredMachineId: config2.registeredMachineId,
-        hostname: os21.hostname(),
-        platform: os21.platform(),
-        arch: os21.arch()
+        hostname: os22.hostname(),
+        platform: os22.platform(),
+        arch: os22.arch()
       })
     });
     if (!res.ok) {
@@ -39337,20 +40153,20 @@ async function startDaemonFlow() {
   try {
     const { AdhdevDaemon: AdhdevDaemon2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
     const daemon = new AdhdevDaemon2();
-    const { execSync: execSync6 } = await import("child_process");
-    const os21 = await import("os");
-    const path21 = await import("path");
-    const logPath = path21.join(os21.homedir(), ".adhdev", "daemon.log");
-    const platform11 = os21.platform();
+    const { execSync: execSync7 } = await import("child_process");
+    const { getCurrentDaemonLogPath: getCurrentDaemonLogPath2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const logPath = getCurrentDaemonLogPath2();
+    const os22 = await import("os");
+    const platform11 = os22.platform();
     try {
       if (platform11 === "win32") {
-        execSync6(`start /B adhdev daemon > "${logPath}" 2>&1`, {
+        execSync7("start /B adhdev daemon >NUL 2>&1", {
           timeout: 3e3,
           stdio: "ignore",
           shell: "cmd.exe"
         });
       } else {
-        execSync6(`nohup adhdev daemon > "${logPath}" 2>&1 &`, {
+        execSync7("nohup adhdev daemon >/dev/null 2>&1 &", {
           timeout: 3e3,
           stdio: "ignore"
         });
@@ -39398,7 +40214,7 @@ async function installCliOnly() {
   console.log(import_chalk3.default.gray("  The `adhdev` command lets you:"));
   console.log(import_chalk3.default.gray("  \u2022 Start the main daemon   (adhdev daemon)"));
   console.log(import_chalk3.default.gray("  \u2022 Launch IDE with CDP     (adhdev launch <ide>)"));
-  console.log(import_chalk3.default.gray("  \u2022 Start CLI agents        (adhdev launch <agent>)"));
+  console.log(import_chalk3.default.gray("  \u2022 Start CLI agents        (adhdev daemon && adhdev launch <agent>)"));
   console.log(import_chalk3.default.gray("  \u2022 Check setup status      (adhdev status)"));
   console.log();
   if (currentVersion) {