adhdev 0.7.17 → 0.7.19

package/dist/index.js

@@ -505,18 +505,18 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs() {
-  const os19 = (0, import_os2.platform)();
+  const os20 = (0, import_os2.platform)();
   const results = [];
   for (const def of getMergedDefinitions()) {
     const cliPath = findCliCommand(def.cli);
-    const appPath = checkPathExists(def.paths[os19] || []);
+    const appPath = checkPathExists(def.paths[os20] || []);
     const installed = !!(cliPath || appPath);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os19 === "darwin") {
+    if (!resolvedCli && appPath && os20 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if ((0, import_fs2.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os19 === "win32") {
+    if (!resolvedCli && appPath && os20 === "win32") {
       const { dirname: dirname9 } = await import("path");
       const appDir = dirname9(appPath);
       const candidates = [
@@ -565,15 +565,15 @@ function parseVersion(raw) {
   return match ? match[1] : raw.split("\n")[0].slice(0, 100);
 }
 function execAsync(cmd, timeoutMs = 5e3) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const child = (0, import_child_process2.exec)(cmd, { encoding: "utf-8", timeout: timeoutMs }, (err, stdout) => {
       if (err || !stdout?.trim()) {
-        resolve11(null);
+        resolve12(null);
       } else {
-        resolve11(stdout.trim());
+        resolve12(stdout.trim());
       }
     });
-    child.on("error", () => resolve11(null));
+    child.on("error", () => resolve12(null));
   });
 }
 async function detectCLIs(providerLoader) {
@@ -960,7 +960,7 @@ var init_manager = __esm({
       * Returns multiple entries if multiple IDE windows are open on same port
       */
       static listAllTargets(port) {
-        return new Promise((resolve11) => {
+        return new Promise((resolve12) => {
           const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
             let data = "";
             res.on("data", (chunk) => data += chunk.toString());
@@ -976,16 +976,16 @@ var init_manager = __esm({
                   (t) => !isNonMain(t.title || "") && t.url?.includes("workbench.html") && !t.url?.includes("agent")
                 );
                 const fallbackPages = pages.filter((t) => !isNonMain(t.title || ""));
-                resolve11(mainPages.length > 0 ? mainPages : fallbackPages);
+                resolve12(mainPages.length > 0 ? mainPages : fallbackPages);
               } catch {
-                resolve11([]);
+                resolve12([]);
               }
             });
           });
-          req.on("error", () => resolve11([]));
+          req.on("error", () => resolve12([]));
           req.setTimeout(2e3, () => {
             req.destroy();
-            resolve11([]);
+            resolve12([]);
           });
         });
       }
@@ -1025,7 +1025,7 @@ var init_manager = __esm({
         }
       }
       findTargetOnPort(port) {
-        return new Promise((resolve11) => {
+        return new Promise((resolve12) => {
           const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
             let data = "";
             res.on("data", (chunk) => data += chunk.toString());
@@ -1036,7 +1036,7 @@ var init_manager = __esm({
                   (t) => (t.type === "page" || t.type === "browser" || t.type === "Page") && t.webSocketDebuggerUrl
                 );
                 if (pages.length === 0) {
-                  resolve11(targets.find((t) => t.webSocketDebuggerUrl) || null);
+                  resolve12(targets.find((t) => t.webSocketDebuggerUrl) || null);
                   return;
                 }
                 const mainPages = pages.filter((t) => !this.isNonMainTitle(t.title || ""));
@@ -1046,24 +1046,24 @@ var init_manager = __esm({
                   const specific = list.find((t) => t.id === this._targetId);
                   if (specific) {
                     this._pageTitle = specific.title || "";
-                    resolve11(specific);
+                    resolve12(specific);
                   } else {
                     this.log(`[CDP] Target ${this._targetId} not found in page list`);
-                    resolve11(null);
+                    resolve12(null);
                   }
                   return;
                 }
                 this._pageTitle = list[0]?.title || "";
-                resolve11(list[0]);
+                resolve12(list[0]);
               } catch {
-                resolve11(null);
+                resolve12(null);
               }
             });
           });
-          req.on("error", () => resolve11(null));
+          req.on("error", () => resolve12(null));
           req.setTimeout(2e3, () => {
             req.destroy();
-            resolve11(null);
+            resolve12(null);
           });
         });
       }
@@ -1074,7 +1074,7 @@ var init_manager = __esm({
         this.extensionProviders = providers;
       }
       connectToTarget(wsUrl) {
-        return new Promise((resolve11) => {
+        return new Promise((resolve12) => {
           this.ws = new import_ws.default(wsUrl);
           this.ws.on("open", async () => {
             this._connected = true;
@@ -1084,17 +1084,17 @@ var init_manager = __esm({
             }
             this.connectBrowserWs().catch(() => {
             });
-            resolve11(true);
+            resolve12(true);
           });
           this.ws.on("message", (data) => {
             try {
               const msg = JSON.parse(data.toString());
               if (msg.id && this.pending.has(msg.id)) {
-                const { resolve: resolve12, reject } = this.pending.get(msg.id);
+                const { resolve: resolve13, reject } = this.pending.get(msg.id);
                 this.pending.delete(msg.id);
                 this.failureCount = 0;
                 if (msg.error) reject(new Error(msg.error.message));
-                else resolve12(msg.result);
+                else resolve13(msg.result);
               } else if (msg.method === "Runtime.executionContextCreated") {
                 this.contexts.add(msg.params.context.id);
               } else if (msg.method === "Runtime.executionContextDestroyed") {
@@ -1117,7 +1117,7 @@ var init_manager = __esm({
           this.ws.on("error", (err) => {
             this.log(`[CDP] WebSocket error: ${err.message}`);
             this._connected = false;
-            resolve11(false);
+            resolve12(false);
           });
         });
       }
@@ -1131,7 +1131,7 @@ var init_manager = __esm({
             return;
           }
           this.log(`[CDP] Connecting browser WS for target discovery...`);
-          await new Promise((resolve11, reject) => {
+          await new Promise((resolve12, reject) => {
             this.browserWs = new import_ws.default(browserWsUrl);
             this.browserWs.on("open", async () => {
               this._browserConnected = true;
@@ -1141,16 +1141,16 @@ var init_manager = __esm({
               } catch (e) {
                 this.log(`[CDP] setDiscoverTargets failed: ${e.message}`);
               }
-              resolve11();
+              resolve12();
             });
             this.browserWs.on("message", (data) => {
               try {
                 const msg = JSON.parse(data.toString());
                 if (msg.id && this.browserPending.has(msg.id)) {
-                  const { resolve: resolve12, reject: reject2 } = this.browserPending.get(msg.id);
+                  const { resolve: resolve13, reject: reject2 } = this.browserPending.get(msg.id);
                   this.browserPending.delete(msg.id);
                   if (msg.error) reject2(new Error(msg.error.message));
-                  else resolve12(msg.result);
+                  else resolve13(msg.result);
                 }
               } catch {
               }
@@ -1170,31 +1170,31 @@ var init_manager = __esm({
         }
       }
       getBrowserWsUrl() {
-        return new Promise((resolve11) => {
+        return new Promise((resolve12) => {
           const req = http.get(`http://127.0.0.1:${this.port}/json/version`, (res) => {
             let data = "";
             res.on("data", (chunk) => data += chunk.toString());
             res.on("end", () => {
               try {
                 const info = JSON.parse(data);
-                resolve11(info.webSocketDebuggerUrl || null);
+                resolve12(info.webSocketDebuggerUrl || null);
               } catch {
-                resolve11(null);
+                resolve12(null);
               }
             });
           });
-          req.on("error", () => resolve11(null));
+          req.on("error", () => resolve12(null));
           req.setTimeout(3e3, () => {
             req.destroy();
-            resolve11(null);
+            resolve12(null);
           });
         });
       }
       sendBrowser(method, params = {}, timeoutMs = 15e3) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           if (!this.browserWs || !this._browserConnected) return reject(new Error("Browser WS not connected"));
           const id = this.browserMsgId++;
-          this.browserPending.set(id, { resolve: resolve11, reject });
+          this.browserPending.set(id, { resolve: resolve12, reject });
           this.browserWs.send(JSON.stringify({ id, method, params }));
           setTimeout(() => {
             if (this.browserPending.has(id)) {
@@ -1234,11 +1234,11 @@ var init_manager = __esm({
       }
       // ─── CDP Protocol ────────────────────────────────────────
       sendInternal(method, params = {}, timeoutMs = 15e3) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           if (!this.ws || !this._connected) return reject(new Error("CDP not connected"));
           if (this.ws.readyState !== import_ws.default.OPEN) return reject(new Error("WebSocket not open"));
           const id = this.msgId++;
-          this.pending.set(id, { resolve: resolve11, reject });
+          this.pending.set(id, { resolve: resolve12, reject });
           this.ws.send(JSON.stringify({ id, method, params }));
           setTimeout(() => {
             if (this.pending.has(id)) {
@@ -1487,7 +1487,7 @@ var init_manager = __esm({
         const browserWs = this.browserWs;
         let msgId = this.browserMsgId;
         const sendWs = (method, params = {}, sessionId) => {
-          return new Promise((resolve11, reject) => {
+          return new Promise((resolve12, reject) => {
             const mid = msgId++;
             this.browserMsgId = msgId;
             const handler = (raw) => {
@@ -1496,7 +1496,7 @@ var init_manager = __esm({
                 if (msg.id === mid) {
                   browserWs.removeListener("message", handler);
                   if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
-                  else resolve11(msg.result);
+                  else resolve12(msg.result);
                 }
               } catch {
               }
@@ -1687,14 +1687,14 @@ var init_manager = __esm({
         if (!ws2 || ws2.readyState !== import_ws.default.OPEN) {
           throw new Error("CDP not connected");
         }
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           const id = getNextId();
           pendingMap.set(id, {
             resolve: (result) => {
               if (result?.result?.subtype === "error") {
                 reject(new Error(result.result.description));
               } else {
-                resolve11(result?.result?.value);
+                resolve12(result?.result?.value);
               }
             },
             reject
@@ -1726,10 +1726,10 @@ var init_manager = __esm({
           throw new Error("CDP not connected");
         }
         const sendViaSession = (method, params = {}) => {
-          return new Promise((resolve11, reject) => {
+          return new Promise((resolve12, reject) => {
             const pendingMap = this._browserConnected ? this.browserPending : this.pending;
             const id = this._browserConnected ? this.browserMsgId++ : this.msgId++;
-            pendingMap.set(id, { resolve: resolve11, reject });
+            pendingMap.set(id, { resolve: resolve12, reject });
             ws2.send(JSON.stringify({ id, sessionId, method, params }));
             setTimeout(() => {
               if (pendingMap.has(id)) {
@@ -5301,7 +5301,7 @@ var init_handler = __esm({
         try {
           const http3 = await import("http");
           const postData = JSON.stringify(body);
-          const result = await new Promise((resolve11, reject) => {
+          const result = await new Promise((resolve12, reject) => {
             const req = http3.request({
               hostname: "127.0.0.1",
               port: 19280,
@@ -5313,9 +5313,9 @@ var init_handler = __esm({
               res.on("data", (chunk) => data += chunk);
               res.on("end", () => {
                 try {
-                  resolve11(JSON.parse(data));
+                  resolve12(JSON.parse(data));
                 } catch {
-                  resolve11({ raw: data });
+                  resolve12({ raw: data });
                 }
               });
             });
@@ -5333,15 +5333,15 @@ var init_handler = __esm({
         if (!providerType) return { success: false, error: "providerType required" };
         try {
           const http3 = await import("http");
-          const result = await new Promise((resolve11, reject) => {
+          const result = await new Promise((resolve12, reject) => {
             http3.get(`http://127.0.0.1:19280/api/providers/${providerType}/${endpoint}`, (res) => {
               let data = "";
               res.on("data", (chunk) => data += chunk);
               res.on("end", () => {
                 try {
-                  resolve11(JSON.parse(data));
+                  resolve12(JSON.parse(data));
                 } catch {
-                  resolve11({ raw: data });
+                  resolve12({ raw: data });
                 }
               });
             }).on("error", reject);
@@ -5355,7 +5355,7 @@ var init_handler = __esm({
         try {
           const http3 = await import("http");
           const postData = JSON.stringify(args || {});
-          const result = await new Promise((resolve11, reject) => {
+          const result = await new Promise((resolve12, reject) => {
             const req = http3.request({
               hostname: "127.0.0.1",
               port: 19280,
@@ -5367,9 +5367,9 @@ var init_handler = __esm({
               res.on("data", (chunk) => data += chunk);
               res.on("end", () => {
                 try {
-                  resolve11(JSON.parse(data));
+                  resolve12(JSON.parse(data));
                 } catch {
-                  resolve11({ raw: data });
+                  resolve12({ raw: data });
                 }
               });
             });
@@ -5490,7 +5490,7 @@ var init_readdirp = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
         if (wantBigintFsStats) {
-          this._stat = (path17) => statMethod(path17, { bigint: true });
+          this._stat = (path18) => statMethod(path18, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -5515,8 +5515,8 @@ var init_readdirp = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path17, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path17));
+              const { path: path18, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path18));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -5556,20 +5556,20 @@ var init_readdirp = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path17, depth) {
+      async _exploreDir(path18, depth) {
         let files;
         try {
-          files = await (0, import_promises.readdir)(path17, this._rdOptions);
+          files = await (0, import_promises.readdir)(path18, this._rdOptions);
         } catch (error48) {
           this._onError(error48);
         }
-        return { files, depth, path: path17 };
+        return { files, depth, path: path18 };
       }
-      async _formatEntry(dirent, path17) {
+      async _formatEntry(dirent, path18) {
         let entry;
         const basename7 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path17, basename7));
+          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path18, 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) {
@@ -5626,16 +5626,16 @@ var init_readdirp = __esm({
 });
 
 // ../../oss/packages/daemon-core/node_modules/chokidar/handler.js
-function createFsWatchInstance(path17, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path18, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path17);
-    emitRaw(rawEvent, evPath, { watchedPath: path17 });
-    if (evPath && path17 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path17, evPath), KEY_LISTENERS, sp.join(path17, evPath));
+    listener(path18);
+    emitRaw(rawEvent, evPath, { watchedPath: path18 });
+    if (evPath && path18 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path18, evPath), KEY_LISTENERS, sp.join(path18, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path17, {
+    return (0, import_node_fs.watch)(path18, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error48) {
@@ -5984,12 +5984,12 @@ var init_handler2 = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path17, fullPath, options, handlers) => {
+    setFsWatchListener = (path18, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path17, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path18, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -6000,7 +6000,7 @@ var init_handler2 = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path17,
+          path18,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -6015,7 +6015,7 @@ var init_handler2 = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error48.code === "EPERM") {
             try {
-              const fd = await (0, import_promises2.open)(path17, "r");
+              const fd = await (0, import_promises2.open)(path18, "r");
               await fd.close();
               broadcastErr(error48);
             } catch (err) {
@@ -6046,7 +6046,7 @@ var init_handler2 = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path17, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path18, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -6068,7 +6068,7 @@ var init_handler2 = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path17, curr));
+              foreach(cont.listeners, (listener2) => listener2(path18, curr));
             }
           })
         };
@@ -6098,13 +6098,13 @@ var init_handler2 = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path17, listener) {
+      _watchWithNodeFs(path18, listener) {
         const opts = this.fsw.options;
-        const directory = sp.dirname(path17);
-        const basename7 = sp.basename(path17);
+        const directory = sp.dirname(path18);
+        const basename7 = sp.basename(path18);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename7);
-        const absolutePath = sp.resolve(path17);
+        const absolutePath = sp.resolve(path18);
         const options = {
           persistent: opts.persistent
         };
@@ -6114,12 +6114,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(path17, absolutePath, options, {
+          closer = setFsWatchFileListener(path18, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path17, absolutePath, options, {
+          closer = setFsWatchListener(path18, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -6141,7 +6141,7 @@ var init_handler2 = __esm({
         let prevStats = stats;
         if (parent.has(basename7))
           return;
-        const listener = async (path17, newStats) => {
+        const listener = async (path18, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -6155,11 +6155,11 @@ var init_handler2 = __esm({
                 this.fsw._emit(EV.CHANGE, file2, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path17);
+                this.fsw._closeFile(path18);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file2, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path17, closer2);
+                  this.fsw._addPathCloser(path18, closer2);
               } else {
                 prevStats = newStats2;
               }
@@ -6191,7 +6191,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, path17, item) {
+      async _handleSymlink(entry, directory, path18, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -6201,7 +6201,7 @@ var init_handler2 = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await (0, import_promises2.realpath)(path17);
+            linkPath = await (0, import_promises2.realpath)(path18);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -6211,12 +6211,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, path17, entry.stats);
+              this.fsw._emit(EV.CHANGE, path18, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path17, entry.stats);
+            this.fsw._emit(EV.ADD, path18, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -6246,9 +6246,9 @@ var init_handler2 = __esm({
             return;
           }
           const item = entry.path;
-          let path17 = sp.join(directory, item);
+          let path18 = sp.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path17, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path18, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -6257,11 +6257,11 @@ var init_handler2 = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path17 = sp.join(dir, sp.relative(dir, path17));
-            this._addToNodeFs(path17, initialAdd, wh, depth + 1);
+            path18 = sp.join(dir, sp.relative(dir, path18));
+            this._addToNodeFs(path18, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           if (!stream)
             return reject();
           stream.once(STR_END, () => {
@@ -6270,7 +6270,7 @@ var init_handler2 = __esm({
               return;
             }
             const wasThrottled = throttler ? throttler.clear() : false;
-            resolve11(void 0);
+            resolve12(void 0);
             previous.getChildren().filter((item) => {
               return item !== directory && !current.has(item);
             }).forEach((item) => {
@@ -6327,13 +6327,13 @@ var init_handler2 = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path17, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path18, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path17) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path18) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path17);
+        const wh = this.fsw._getWatchHelpers(path18);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -6349,8 +6349,8 @@ var init_handler2 = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sp.resolve(path17);
-            const targetPath = follow ? await (0, import_promises2.realpath)(path17) : path17;
+            const absPath = sp.resolve(path18);
+            const targetPath = follow ? await (0, import_promises2.realpath)(path18) : path18;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -6360,29 +6360,29 @@ var init_handler2 = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await (0, import_promises2.realpath)(path17) : path17;
+            const targetPath = follow ? await (0, import_promises2.realpath)(path18) : path18;
             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, path17, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path18, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sp.resolve(path17), targetPath);
+              this.fsw._symlinkPaths.set(sp.resolve(path18), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path17, closer);
+            this.fsw._addPathCloser(path18, closer);
           return false;
         } catch (error48) {
           if (this.fsw._handleError(error48)) {
             ready();
-            return path17;
+            return path18;
           }
         }
       }
@@ -6417,24 +6417,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path17) {
-  if (typeof path17 !== "string")
+function normalizePath(path18) {
+  if (typeof path18 !== "string")
     throw new Error("string expected");
-  path17 = sp2.normalize(path17);
-  path17 = path17.replace(/\\/g, "/");
+  path18 = sp2.normalize(path18);
+  path18 = path18.replace(/\\/g, "/");
   let prepend = false;
-  if (path17.startsWith("//"))
+  if (path18.startsWith("//"))
     prepend = true;
-  path17 = path17.replace(DOUBLE_SLASH_RE, "/");
+  path18 = path18.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path17 = "/" + path17;
-  return path17;
+    path18 = "/" + path18;
+  return path18;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path17 = normalizePath(testString);
+  const path18 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path17, stats)) {
+    if (pattern(path18, stats)) {
       return true;
     }
   }
@@ -6497,19 +6497,19 @@ var init_chokidar = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path17) => toUnix(sp2.normalize(toUnix(path17)));
-    normalizeIgnored = (cwd = "") => (path17) => {
-      if (typeof path17 === "string") {
-        return normalizePathToUnix(sp2.isAbsolute(path17) ? path17 : sp2.join(cwd, path17));
+    normalizePathToUnix = (path18) => toUnix(sp2.normalize(toUnix(path18)));
+    normalizeIgnored = (cwd = "") => (path18) => {
+      if (typeof path18 === "string") {
+        return normalizePathToUnix(sp2.isAbsolute(path18) ? path18 : sp2.join(cwd, path18));
       } else {
-        return path17;
+        return path18;
       }
     };
-    getAbsolutePath = (path17, cwd) => {
-      if (sp2.isAbsolute(path17)) {
-        return path17;
+    getAbsolutePath = (path18, cwd) => {
+      if (sp2.isAbsolute(path18)) {
+        return path18;
       }
-      return sp2.join(cwd, path17);
+      return sp2.join(cwd, path18);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -6574,10 +6574,10 @@ var init_chokidar = __esm({
       dirParts;
       followSymlinks;
       statMethod;
-      constructor(path17, follow, fsw) {
+      constructor(path18, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path17;
-        this.path = path17 = path17.replace(REPLACER_RE, "");
+        const watchPath = path18;
+        this.path = path18 = path18.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sp2.resolve(watchPath);
         this.dirParts = [];
@@ -6717,20 +6717,20 @@ var init_chokidar = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path17) => {
-            const absPath = getAbsolutePath(path17, cwd);
+          paths = paths.map((path18) => {
+            const absPath = getAbsolutePath(path18, cwd);
             return absPath;
           });
         }
-        paths.forEach((path17) => {
-          this._removeIgnoredPath(path17);
+        paths.forEach((path18) => {
+          this._removeIgnoredPath(path18);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path17) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path17, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path18) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path18, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -6752,17 +6752,17 @@ var init_chokidar = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path17) => {
-          if (!sp2.isAbsolute(path17) && !this._closers.has(path17)) {
+        paths.forEach((path18) => {
+          if (!sp2.isAbsolute(path18) && !this._closers.has(path18)) {
             if (cwd)
-              path17 = sp2.join(cwd, path17);
-            path17 = sp2.resolve(path17);
+              path18 = sp2.join(cwd, path18);
+            path18 = sp2.resolve(path18);
           }
-          this._closePath(path17);
-          this._addIgnoredPath(path17);
-          if (this._watched.has(path17)) {
+          this._closePath(path18);
+          this._addIgnoredPath(path18);
+          if (this._watched.has(path18)) {
             this._addIgnoredPath({
-              path: path17,
+              path: path18,
               recursive: true
             });
           }
@@ -6826,38 +6826,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, path17, stats) {
+      async _emit(event, path18, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path17 = sp2.normalize(path17);
+          path18 = sp2.normalize(path18);
         if (opts.cwd)
-          path17 = sp2.relative(opts.cwd, path17);
-        const args = [path17];
+          path18 = sp2.relative(opts.cwd, path18);
+        const args = [path18];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path17))) {
+        if (awf && (pw = this._pendingWrites.get(path18))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path17, [event, ...args]);
+            this._pendingUnlinks.set(path18, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path18) => {
+              this._pendingUnlinks.forEach((entry, path19) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path18);
+                this._pendingUnlinks.delete(path19);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path17)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path18)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path17);
+            this._pendingUnlinks.delete(path18);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -6875,16 +6875,16 @@ var init_chokidar = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path17, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path18, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path17, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path18, 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, path17) : path17;
+          const fullPath = opts.cwd ? sp2.join(opts.cwd, path18) : path18;
           let stats2;
           try {
             stats2 = await (0, import_promises3.stat)(fullPath);
@@ -6915,23 +6915,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, path17, timeout) {
+      _throttle(actionType, path18, 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(path17);
+        const actionPath = action.get(path18);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path17);
+          const item = action.get(path18);
           const count = item ? item.count : 0;
-          action.delete(path17);
+          action.delete(path18);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -6939,7 +6939,7 @@ var init_chokidar = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path17, thr);
+        action.set(path18, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -6953,44 +6953,44 @@ var init_chokidar = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path17, threshold, event, awfEmit) {
+      _awaitWriteFinish(path18, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path17;
-        if (this.options.cwd && !sp2.isAbsolute(path17)) {
-          fullPath = sp2.join(this.options.cwd, path17);
+        let fullPath = path18;
+        if (this.options.cwd && !sp2.isAbsolute(path18)) {
+          fullPath = sp2.join(this.options.cwd, path18);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-            if (err || !writes.has(path17)) {
+            if (err || !writes.has(path18)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path17).lastChange = now2;
+              writes.get(path18).lastChange = now2;
             }
-            const pw = writes.get(path17);
+            const pw = writes.get(path18);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path17);
+              writes.delete(path18);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path17)) {
-          writes.set(path17, {
+        if (!writes.has(path18)) {
+          writes.set(path18, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path17);
+              writes.delete(path18);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -7001,8 +7001,8 @@ var init_chokidar = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path17, stats) {
-        if (this.options.atomic && DOT_RE.test(path17))
+      _isIgnored(path18, stats) {
+        if (this.options.atomic && DOT_RE.test(path18))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -7012,17 +7012,17 @@ var init_chokidar = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path17, stats);
+        return this._userIgnored(path18, stats);
       }
-      _isntIgnored(path17, stat4) {
-        return !this._isIgnored(path17, stat4);
+      _isntIgnored(path18, stat4) {
+        return !this._isIgnored(path18, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path17) {
-        return new WatchHelper(path17, this.options.followSymlinks, this);
+      _getWatchHelpers(path18) {
+        return new WatchHelper(path18, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -7054,63 +7054,63 @@ var init_chokidar = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path17 = sp2.join(directory, item);
-        const fullPath = sp2.resolve(path17);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path17) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path17, 100))
+        const path18 = sp2.join(directory, item);
+        const fullPath = sp2.resolve(path18);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path18) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path18, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path17);
+        const wp = this._getWatchedDir(path18);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path17, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path18, 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 = path17;
+        let relPath = path18;
         if (this.options.cwd)
-          relPath = sp2.relative(this.options.cwd, path17);
+          relPath = sp2.relative(this.options.cwd, path18);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path17);
+        this._watched.delete(path18);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path17))
-          this._emit(eventName, path17);
-        this._closePath(path17);
+        if (wasTracked && !this._isIgnored(path18))
+          this._emit(eventName, path18);
+        this._closePath(path18);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path17) {
-        this._closeFile(path17);
-        const dir = sp2.dirname(path17);
-        this._getWatchedDir(dir).remove(sp2.basename(path17));
+      _closePath(path18) {
+        this._closeFile(path18);
+        const dir = sp2.dirname(path18);
+        this._getWatchedDir(dir).remove(sp2.basename(path18));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path17) {
-        const closers = this._closers.get(path17);
+      _closeFile(path18) {
+        const closers = this._closers.get(path18);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path17);
+        this._closers.delete(path18);
       }
-      _addPathCloser(path17, closer) {
+      _addPathCloser(path18, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path17);
+        let list = this._closers.get(path18);
         if (!list) {
           list = [];
-          this._closers.set(path17, list);
+          this._closers.set(path18, list);
         }
         list.push(closer);
       }
@@ -7690,7 +7690,7 @@ var init_provider_loader = __esm({
           return { updated: false };
         }
         try {
-          const etag = await new Promise((resolve11, reject) => {
+          const etag = await new Promise((resolve12, reject) => {
             const options = {
               method: "HEAD",
               hostname: "github.com",
@@ -7708,7 +7708,7 @@ var init_provider_loader = __esm({
                   headers: { "User-Agent": "adhdev-launcher" },
                   timeout: 1e4
                 }, (res2) => {
-                  resolve11(res2.headers.etag || res2.headers["last-modified"] || "");
+                  resolve12(res2.headers.etag || res2.headers["last-modified"] || "");
                 });
                 req2.on("error", reject);
                 req2.on("timeout", () => {
@@ -7717,7 +7717,7 @@ var init_provider_loader = __esm({
                 });
                 req2.end();
               } else {
-                resolve11(res.headers.etag || res.headers["last-modified"] || "");
+                resolve12(res.headers.etag || res.headers["last-modified"] || "");
               }
             });
             req.on("error", reject);
@@ -7781,7 +7781,7 @@ var init_provider_loader = __esm({
       downloadFile(url2, destPath) {
         const https = require("https");
         const http3 = require("http");
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           const doRequest = (reqUrl, redirectCount = 0) => {
             if (redirectCount > 5) {
               reject(new Error("Too many redirects"));
@@ -7801,7 +7801,7 @@ var init_provider_loader = __esm({
               res.pipe(ws2);
               ws2.on("finish", () => {
                 ws2.close();
-                resolve11();
+                resolve12();
               });
               ws2.on("error", reject);
             });
@@ -8167,17 +8167,17 @@ async function findFreePort(ports) {
   throw new Error("No free port found");
 }
 function checkPortFree(port) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const server = net.createServer();
     server.unref();
-    server.on("error", () => resolve11(false));
+    server.on("error", () => resolve12(false));
     server.listen(port, "127.0.0.1", () => {
-      server.close(() => resolve11(true));
+      server.close(() => resolve12(true));
     });
   });
 }
 async function isCdpActive(port) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const req = require("http").get(`http://127.0.0.1:${port}/json/version`, {
       timeout: 2e3
     }, (res) => {
@@ -8186,16 +8186,16 @@ async function isCdpActive(port) {
       res.on("end", () => {
         try {
           const info = JSON.parse(data);
-          resolve11(!!info["WebKit-Version"] || !!info["Browser"]);
+          resolve12(!!info["WebKit-Version"] || !!info["Browser"]);
         } catch {
-          resolve11(false);
+          resolve12(false);
         }
       });
     });
-    req.on("error", () => resolve11(false));
+    req.on("error", () => resolve12(false));
     req.on("timeout", () => {
       req.destroy();
-      resolve11(false);
+      resolve12(false);
     });
   });
 }
@@ -8818,14 +8818,14 @@ var init_router = __esm({
               setTimeout(() => {
                 LOG.info("Upgrade", "Restarting daemon with new version...");
                 try {
-                  const path17 = require("path");
+                  const path18 = require("path");
                   const fs15 = require("fs");
-                  const pidFile = path17.join(process.env.HOME || process.env.USERPROFILE || "", ".adhdev", "daemon.pid");
+                  const pidFile = path18.join(process.env.HOME || process.env.USERPROFILE || "", ".adhdev", "daemon.pid");
                   if (fs15.existsSync(pidFile)) fs15.unlinkSync(pidFile);
                 } catch {
                 }
-                const { spawn: spawn3 } = require("child_process");
-                const child = spawn3(process.execPath, process.argv.slice(1), {
+                const { spawn: spawn4 } = require("child_process");
+                const child = spawn4(process.execPath, process.argv.slice(1), {
                   detached: true,
                   stdio: "ignore",
                   env: { ...process.env }
@@ -19320,7 +19320,7 @@ ${data.message || ""}`.trim();
         if (this.startupParseGate) {
           const deadline = Date.now() + 1e4;
           while (this.startupParseGate && Date.now() < deadline) {
-            await new Promise((resolve11) => setTimeout(resolve11, 50));
+            await new Promise((resolve12) => setTimeout(resolve12, 50));
           }
         }
         if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.currentStatus})`);
@@ -19488,17 +19488,17 @@ ${data.message || ""}`.trim();
         }
       }
       waitForStopped(timeoutMs) {
-        return new Promise((resolve11) => {
+        return new Promise((resolve12) => {
           const startedAt = Date.now();
           const timer = setInterval(() => {
             if (!this.ptyProcess || this.currentStatus === "stopped") {
               clearInterval(timer);
-              resolve11(true);
+              resolve12(true);
               return;
             }
             if (Date.now() - startedAt >= timeoutMs) {
               clearInterval(timer);
-              resolve11(false);
+              resolve12(false);
             }
           }, 100);
         });
@@ -20184,10 +20184,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path17) {
-  if (!path17)
+function getElementAtPath(obj, path18) {
+  if (!path18)
     return obj;
-  return path17.reduce((acc, key) => acc?.[key], obj);
+  return path18.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -20499,11 +20499,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path17, issues) {
+function prefixIssues(path18, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path17);
+    iss.path.unshift(path18);
     return iss;
   });
 }
@@ -20746,7 +20746,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path17 = []) => {
+  const processError = (error49, path18 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -20756,7 +20756,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path17, ...issue2.path];
+        const fullpath = [...path18, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -20788,8 +20788,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path17 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path17) {
+  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path18) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -33553,13 +33553,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path17 = ref.slice(1).split("/").filter(Boolean);
-  if (path17.length === 0) {
+  const path18 = ref.slice(1).split("/").filter(Boolean);
+  if (path18.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path17[0] === defsKey) {
-    const key = path17[1];
+  if (path18[0] === defsKey) {
+    const key = path18[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -35986,8 +35986,8 @@ var init_acp = __esm({
         this.#requestHandler = requestHandler;
         this.#notificationHandler = notificationHandler;
         this.#stream = stream;
-        this.#closedPromise = new Promise((resolve11) => {
-          this.#abortController.signal.addEventListener("abort", () => resolve11());
+        this.#closedPromise = new Promise((resolve12) => {
+          this.#abortController.signal.addEventListener("abort", () => resolve12());
         });
         this.#receive();
       }
@@ -36136,8 +36136,8 @@ var init_acp = __esm({
       }
       async sendRequest(method, params) {
         const id = this.#nextRequestId++;
-        const responsePromise = new Promise((resolve11, reject) => {
-          this.#pendingResponses.set(id, { resolve: resolve11, reject });
+        const responsePromise = new Promise((resolve12, reject) => {
+          this.#pendingResponses.set(id, { resolve: resolve12, reject });
         });
         await this.#sendMessage({ jsonrpc: "2.0", id, method, params });
         return responsePromise;
@@ -36672,13 +36672,13 @@ var init_acp_provider_instance = __esm({
             }
             this.currentStatus = "waiting_approval";
             this.detectStatusTransition();
-            const approved = await new Promise((resolve11) => {
-              this.permissionResolvers.push(resolve11);
+            const approved = await new Promise((resolve12) => {
+              this.permissionResolvers.push(resolve12);
               setTimeout(() => {
-                const idx = this.permissionResolvers.indexOf(resolve11);
+                const idx = this.permissionResolvers.indexOf(resolve12);
                 if (idx >= 0) {
                   this.permissionResolvers.splice(idx, 1);
-                  resolve11(false);
+                  resolve12(false);
                 }
               }, 3e5);
             });
@@ -40326,8 +40326,8 @@ async function handleAutoImplement(ctx, type, req, res) {
     fs11.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 spawn3 = agentProvider?.spawn;
-    if (!spawn3?.command) {
+    const spawn4 = agentProvider?.spawn;
+    if (!spawn4?.command) {
       try {
         fs11.unlinkSync(promptFile);
       } catch {
@@ -40337,21 +40337,21 @@ async function handleAutoImplement(ctx, type, req, res) {
     }
     const agentCategory = agentProvider?.category;
     if (agentCategory === "acp") {
-      sendAutoImplSSE(ctx, { event: "progress", data: { function: "_init", status: "spawning", message: `Spawning ACP agent: ${spawn3.command} ${(spawn3.args || []).join(" ")}` } });
+      sendAutoImplSSE(ctx, { event: "progress", data: { function: "_init", status: "spawning", message: `Spawning ACP agent: ${spawn4.command} ${(spawn4.args || []).join(" ")}` } });
       ctx.autoImplStatus = { running: true, type, progress: [] };
       const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
       const { Readable: Readable3, Writable: Writable2 } = await import("stream");
       const { spawn: spawnFn2 } = await import("child_process");
-      const acpArgs = [...spawn3.args || []];
+      const acpArgs = [...spawn4.args || []];
       if (model) {
         acpArgs.push("--model", model);
         ctx.log(`Auto-implement ACP using model: ${model}`);
       }
-      const child2 = spawnFn2(spawn3.command, acpArgs, {
+      const child2 = spawnFn2(spawn4.command, acpArgs, {
         cwd: providerDir,
         stdio: ["pipe", "pipe", "pipe"],
-        shell: spawn3.shell ?? false,
-        env: { ...process.env, ...spawn3.env || {} }
+        shell: spawn4.shell ?? false,
+        env: { ...process.env, ...spawn4.env || {} }
       });
       ctx.autoImplProcess = child2;
       child2.stderr?.on("data", (d) => {
@@ -40461,7 +40461,7 @@ async function handleAutoImplement(ctx, type, req, res) {
       ctx.json(res, 202, {
         started: true,
         type,
-        agent: spawn3.command,
+        agent: spawn4.command,
         functions,
         providerDir,
         message: "ACP Auto-implement started. Connect to SSE for progress.",
@@ -40469,9 +40469,9 @@ async function handleAutoImplement(ctx, type, req, res) {
       });
       return;
     }
-    const command = spawn3.command;
+    const command = spawn4.command;
     const interactiveFlags = ["--yolo", "--interactive", "-i"];
-    const baseArgs = [...spawn3.args || []].filter((a) => !interactiveFlags.includes(a));
+    const baseArgs = [...spawn4.args || []].filter((a) => !interactiveFlags.includes(a));
     let shellCmd;
     if (command === "claude") {
       const args = [...baseArgs, "--dangerously-skip-permissions"];
@@ -40515,7 +40515,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         cols: 120,
         rows: 40,
         cwd: providerDir,
-        env: { ...process.env, ...spawn3.env || {} }
+        env: { ...process.env, ...spawn4.env || {} }
       });
       isPty = true;
     } catch (err) {
@@ -40527,7 +40527,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         stdio: ["pipe", "pipe", "pipe"],
         env: {
           ...process.env,
-          ...spawn3.env || {},
+          ...spawn4.env || {},
           ...command === "gemini" ? { SANDBOX: "1", GEMINI_CLI_NO_RELAUNCH: "1" } : {}
         }
       });
@@ -41277,8 +41277,8 @@ var init_dev_server = __esm({
       }
       getEndpointList() {
         return this.routes.map((r) => {
-          const path17 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-          return `${r.method.padEnd(5)} ${path17}`;
+          const path18 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+          return `${r.method.padEnd(5)} ${path18}`;
         });
       }
       async start(port = DEV_SERVER_PORT) {
@@ -41309,15 +41309,15 @@ var init_dev_server = __esm({
             this.json(res, 500, { error: e.message });
           }
         });
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve12, reject) => {
           this.server.listen(port, "127.0.0.1", () => {
             this.log(`Dev server listening on http://127.0.0.1:${port}`);
-            resolve11();
+            resolve12();
           });
           this.server.on("error", (e) => {
             if (e.code === "EADDRINUSE") {
               this.log(`Port ${port} in use, skipping dev server`);
-              resolve11();
+              resolve12();
             } else {
               reject(e);
             }
@@ -41379,16 +41379,16 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const spawn3 = provider.spawn;
-        if (!spawn3) {
+        const spawn4 = provider.spawn;
+        if (!spawn4) {
           this.json(res, 400, { error: `Provider ${type} has no spawn config` });
           return;
         }
         const { spawn: spawnFn } = await import("child_process");
         const start = Date.now();
         try {
-          const child = spawnFn(spawn3.command, [...spawn3.args || []], {
-            shell: spawn3.shell ?? false,
+          const child = spawnFn(spawn4.command, [...spawn4.args || []], {
+            shell: spawn4.shell ?? false,
             timeout: 5e3,
             stdio: ["pipe", "pipe", "pipe"]
           });
@@ -41400,27 +41400,27 @@ var init_dev_server = __esm({
           child.stderr?.on("data", (d) => {
             stderr += d.toString().slice(0, 2e3);
           });
-          await new Promise((resolve11) => {
+          await new Promise((resolve12) => {
             const timer = setTimeout(() => {
               child.kill();
-              resolve11();
+              resolve12();
             }, 3e3);
             child.on("exit", () => {
               clearTimeout(timer);
-              resolve11();
+              resolve12();
             });
             child.stdout?.once("data", () => {
               setTimeout(() => {
                 child.kill();
                 clearTimeout(timer);
-                resolve11();
+                resolve12();
               }, 500);
             });
           });
           const elapsed = Date.now() - start;
           this.json(res, 200, {
             success: true,
-            command: `${spawn3.command} ${(spawn3.args || []).join(" ")}`,
+            command: `${spawn4.command} ${(spawn4.args || []).join(" ")}`,
             elapsed,
             stdout: stdout.trim(),
             stderr: stderr.trim(),
@@ -41430,7 +41430,7 @@ var init_dev_server = __esm({
           const elapsed = Date.now() - start;
           this.json(res, 200, {
             success: false,
-            command: `${spawn3.command} ${(spawn3.args || []).join(" ")}`,
+            command: `${spawn4.command} ${(spawn4.args || []).join(" ")}`,
             elapsed,
             error: e.message
           });
@@ -41899,20 +41899,20 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const spawn3 = provider.spawn;
-        if (!spawn3) {
+        const spawn4 = provider.spawn;
+        if (!spawn4) {
           this.json(res, 400, { error: `Provider ${type} has no spawn config` });
           return;
         }
         const { spawn: spawnFn } = await import("child_process");
         const start = Date.now();
         try {
-          const args = [...spawn3.args || [], message];
-          const child = spawnFn(spawn3.command, args, {
-            shell: spawn3.shell ?? false,
+          const args = [...spawn4.args || [], message];
+          const child = spawnFn(spawn4.command, args, {
+            shell: spawn4.shell ?? false,
             timeout,
             stdio: ["pipe", "pipe", "pipe"],
-            env: { ...process.env, ...spawn3.env || {} }
+            env: { ...process.env, ...spawn4.env || {} }
           });
           let stdout = "";
           let stderr = "";
@@ -41922,14 +41922,14 @@ var init_dev_server = __esm({
           child.stderr?.on("data", (d) => {
             stderr += d.toString();
           });
-          await new Promise((resolve11) => {
+          await new Promise((resolve12) => {
             const timer = setTimeout(() => {
               child.kill();
-              resolve11();
+              resolve12();
             }, timeout);
             child.on("exit", () => {
               clearTimeout(timer);
-              resolve11();
+              resolve12();
             });
           });
           const elapsed = Date.now() - start;
@@ -42585,14 +42585,14 @@ data: ${JSON.stringify(msg.data)}
         res.end(JSON.stringify(data, null, 2));
       }
       async readBody(req) {
-        return new Promise((resolve11) => {
+        return new Promise((resolve12) => {
           let body = "";
           req.on("data", (chunk) => body += chunk);
           req.on("end", () => {
             try {
-              resolve11(JSON.parse(body));
+              resolve12(JSON.parse(body));
             } catch {
-              resolve11({});
+              resolve12({});
             }
           });
         });
@@ -42646,18 +42646,536 @@ data: ${JSON.stringify(msg.data)}
 });
 
 // ../../oss/packages/session-host-core/dist/index.mjs
+function getDefaultSessionHostEndpoint(appName = "adhdev") {
+  if (process.platform === "win32") {
+    return {
+      kind: "pipe",
+      path: `\\\\.\\pipe\\${appName}-session-host`
+    };
+  }
+  return {
+    kind: "unix",
+    path: path22.join(os17.tmpdir(), `${appName}-session-host.sock`)
+  };
+}
+function serializeEnvelope(envelope) {
+  return `${JSON.stringify(envelope)}
+`;
+}
+function createLineParser(onEnvelope) {
+  let buffer = "";
+  return (chunk) => {
+    buffer += chunk.toString();
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex >= 0) {
+      const rawLine = buffer.slice(0, newlineIndex).trim();
+      buffer = buffer.slice(newlineIndex + 1);
+      if (rawLine) {
+        onEnvelope(JSON.parse(rawLine));
+      }
+      newlineIndex = buffer.indexOf("\n");
+    }
+  };
+}
+var os17, path22, net2, import_crypto3, SessionHostClient;
 var init_dist = __esm({
   "../../oss/packages/session-host-core/dist/index.mjs"() {
     "use strict";
+    os17 = __toESM(require("os"), 1);
+    path22 = __toESM(require("path"), 1);
+    net2 = __toESM(require("net"), 1);
+    import_crypto3 = require("crypto");
+    SessionHostClient = class {
+      endpoint;
+      socket = null;
+      requestWaiters = /* @__PURE__ */ new Map();
+      eventListeners = /* @__PURE__ */ new Set();
+      constructor(options = {}) {
+        this.endpoint = options.endpoint || getDefaultSessionHostEndpoint(options.appName || "adhdev");
+      }
+      async connect() {
+        if (this.socket && !this.socket.destroyed) return;
+        const socket = net2.createConnection(this.endpoint.path);
+        this.socket = socket;
+        socket.on("data", createLineParser((envelope) => {
+          if (envelope.kind === "response") {
+            const waiter = this.requestWaiters.get(envelope.requestId);
+            if (waiter) {
+              this.requestWaiters.delete(envelope.requestId);
+              waiter.resolve(envelope.response);
+            }
+            return;
+          }
+          if (envelope.kind === "event") {
+            for (const listener of this.eventListeners) listener(envelope.event);
+          }
+        }));
+        socket.on("error", (error48) => {
+          for (const waiter of this.requestWaiters.values()) {
+            waiter.reject(error48);
+          }
+          this.requestWaiters.clear();
+        });
+        await new Promise((resolve12, reject) => {
+          socket.once("connect", () => resolve12());
+          socket.once("error", reject);
+        });
+      }
+      onEvent(listener) {
+        this.eventListeners.add(listener);
+        return () => {
+          this.eventListeners.delete(listener);
+        };
+      }
+      async request(request) {
+        await this.connect();
+        if (!this.socket) throw new Error("Session host socket unavailable");
+        const requestId = (0, import_crypto3.randomUUID)();
+        const envelope = {
+          kind: "request",
+          requestId,
+          request
+        };
+        const response = await new Promise((resolve12, reject) => {
+          this.requestWaiters.set(requestId, { resolve: resolve12, reject });
+          this.socket?.write(serializeEnvelope(envelope));
+        });
+        return response;
+      }
+      async close() {
+        if (!this.socket) return;
+        const socket = this.socket;
+        this.socket = null;
+        for (const waiter of this.requestWaiters.values()) {
+          waiter.reject(new Error("Session host client closed"));
+        }
+        this.requestWaiters.clear();
+        await new Promise((resolve12) => {
+          let settled = false;
+          const done = () => {
+            if (settled) return;
+            settled = true;
+            resolve12();
+          };
+          socket.once("close", done);
+          socket.end();
+          socket.destroy();
+          setTimeout(done, 50);
+        });
+      }
+    };
   }
 });
 
 // ../../oss/packages/daemon-core/src/cli-adapters/session-host-transport.ts
+var SessionHostRuntimeTransport, SessionHostPtyTransportFactory;
 var init_session_host_transport = __esm({
   "../../oss/packages/daemon-core/src/cli-adapters/session-host-transport.ts"() {
     "use strict";
     init_dist();
     init_logger();
+    SessionHostRuntimeTransport = class {
+      constructor(options) {
+        this.options = options;
+        this.client = new SessionHostClient({
+          endpoint: options.endpoint,
+          appName: options.appName
+        });
+        this.ready = this.boot();
+      }
+      ready;
+      client;
+      dataCallbacks = /* @__PURE__ */ new Set();
+      exitCallbacks = /* @__PURE__ */ new Set();
+      pendingOutput = [];
+      operationChain = Promise.resolve();
+      unsubscribe = null;
+      currentPid = 0;
+      closed = false;
+      metadata = null;
+      get pid() {
+        return this.currentPid;
+      }
+      getMetadata() {
+        return this.metadata ? {
+          ...this.metadata,
+          writeOwner: this.metadata.writeOwner ? { ...this.metadata.writeOwner } : null,
+          attachedClients: this.metadata.attachedClients?.map((client) => ({ ...client })) || []
+        } : null;
+      }
+      onData(callback) {
+        this.dataCallbacks.add(callback);
+        if (this.pendingOutput.length > 0) {
+          for (const chunk of this.pendingOutput.splice(0)) {
+            callback(chunk);
+          }
+        }
+      }
+      onExit(callback) {
+        this.exitCallbacks.add(callback);
+      }
+      write(data) {
+        this.enqueue(async () => {
+          let response = await this.client.request({
+            type: "send_input",
+            payload: {
+              sessionId: this.options.runtimeId,
+              clientId: this.options.clientId,
+              data
+            }
+          });
+          if (!response.success && response.error?.startsWith("Write owned by ")) {
+            const ownerResponse = await this.client.request({
+              type: "acquire_write",
+              payload: {
+                sessionId: this.options.runtimeId,
+                clientId: this.options.clientId,
+                ownerType: "user",
+                force: true
+              }
+            });
+            if (ownerResponse.success && ownerResponse.result) {
+              this.updateMetadata(ownerResponse.result);
+              response = await this.client.request({
+                type: "send_input",
+                payload: {
+                  sessionId: this.options.runtimeId,
+                  clientId: this.options.clientId,
+                  data
+                }
+              });
+            }
+          }
+          if (!response.success) {
+            throw new Error(response.error || `Failed to write to runtime ${this.options.runtimeId}`);
+          }
+        });
+      }
+      resize(cols, rows) {
+        this.enqueue(async () => {
+          await this.client.request({
+            type: "resize_session",
+            payload: {
+              sessionId: this.options.runtimeId,
+              cols,
+              rows
+            }
+          });
+        });
+      }
+      kill() {
+        this.enqueue(async () => {
+          await this.client.request({
+            type: "stop_session",
+            payload: { sessionId: this.options.runtimeId }
+          });
+          await this.closeClient(false);
+        });
+      }
+      clearBuffer() {
+        this.enqueue(async () => {
+          const response = await this.client.request({
+            type: "clear_session_buffer",
+            payload: {
+              sessionId: this.options.runtimeId
+            }
+          });
+          if (!response.success) {
+            throw new Error(response.error || `Failed to clear runtime buffer ${this.options.runtimeId}`);
+          }
+          if (response.result) {
+            this.updateMetadata(response.result);
+          }
+        });
+      }
+      detach() {
+        this.enqueue(async () => {
+          await this.client.request({
+            type: "release_write",
+            payload: {
+              sessionId: this.options.runtimeId,
+              clientId: this.options.clientId
+            }
+          }).catch(() => ({ success: false }));
+          await this.client.request({
+            type: "detach_session",
+            payload: {
+              sessionId: this.options.runtimeId,
+              clientId: this.options.clientId
+            }
+          }).catch(() => ({ success: false }));
+          await this.closeClient(false);
+        });
+      }
+      async boot() {
+        await this.client.connect();
+        this.unsubscribe = this.client.onEvent((event) => this.handleEvent(event));
+        let record2 = null;
+        if (this.options.attachExisting) {
+          const existingRecords = await this.client.request({
+            type: "list_sessions",
+            payload: {}
+          });
+          const existingRecord = existingRecords.success && existingRecords.result ? existingRecords.result.find((item) => item.sessionId === this.options.runtimeId) || null : null;
+          if (existingRecord?.lifecycle === "interrupted") {
+            const resumeResponse = await this.client.request({
+              type: "resume_session",
+              payload: {
+                sessionId: this.options.runtimeId
+              }
+            });
+            if (!resumeResponse.success) {
+              LOG.warn("CLI", `[session-host:${this.options.runtimeId}] resume failed: ${resumeResponse.error || "unknown error"}`);
+            }
+          }
+          const attachResponse = await this.client.request({
+            type: "attach_session",
+            payload: {
+              sessionId: this.options.runtimeId,
+              clientId: this.options.clientId,
+              clientType: "daemon",
+              readOnly: false
+            }
+          });
+          if (!attachResponse.success || !attachResponse.result) {
+            throw new Error(attachResponse.error || `Failed to attach runtime ${this.options.runtimeId}`);
+          }
+          record2 = attachResponse.result;
+        } else {
+          const createResponse = await this.client.request({
+            type: "create_session",
+            payload: {
+              sessionId: this.options.runtimeId,
+              providerType: this.options.providerType,
+              category: this.options.category || "cli",
+              workspace: this.options.workspace,
+              launchCommand: {
+                command: this.options.command,
+                args: this.options.args,
+                env: this.options.spawnOptions.env
+              },
+              cols: this.options.spawnOptions.cols,
+              rows: this.options.spawnOptions.rows,
+              clientId: this.options.clientId,
+              clientType: "daemon",
+              meta: this.options.meta
+            }
+          });
+          if (!createResponse.success || !createResponse.result) {
+            throw new Error(createResponse.error || `Failed to create runtime ${this.options.runtimeId}`);
+          }
+          record2 = createResponse.result;
+        }
+        this.currentPid = record2.osPid || 0;
+        this.updateMetadata(record2);
+        const ownerResponse = await this.client.request({
+          type: "acquire_write",
+          payload: {
+            sessionId: this.options.runtimeId,
+            clientId: this.options.clientId,
+            ownerType: "agent",
+            force: !this.options.attachExisting
+          }
+        });
+        if (!ownerResponse.success) {
+          if (this.options.attachExisting && ownerResponse.error?.startsWith("Write owned by ")) {
+            LOG.info("CLI", `[session-host:${this.options.runtimeId}] attached without write ownership (${ownerResponse.error})`);
+          } else {
+            throw new Error(ownerResponse.error || `Failed to acquire write owner for ${this.options.runtimeId}`);
+          }
+        } else if (ownerResponse.result) {
+          this.updateMetadata(ownerResponse.result);
+        }
+        if (this.options.attachExisting) {
+          const snapshotResponse = await this.client.request({
+            type: "get_snapshot",
+            payload: {
+              sessionId: this.options.runtimeId
+            }
+          });
+          if (!snapshotResponse.success) {
+            throw new Error(snapshotResponse.error || `Failed to load snapshot for ${this.options.runtimeId}`);
+          }
+          const text = snapshotResponse.result?.text || "";
+          if (text) {
+            this.emitData(text);
+          }
+        }
+      }
+      handleEvent(event) {
+        if (event.sessionId !== this.options.runtimeId) return;
+        if ((event.type === "session_started" || event.type === "session_resumed") && typeof event.pid === "number") {
+          this.currentPid = event.pid;
+          return;
+        }
+        if (event.type === "write_owner_changed") {
+          this.metadata = {
+            ...this.metadata || { runtimeId: this.options.runtimeId },
+            writeOwner: event.owner ? {
+              clientId: event.owner.clientId,
+              ownerType: event.owner.ownerType
+            } : null
+          };
+          return;
+        }
+        if (event.type === "client_attached") {
+          const nextClients = new Map(
+            (this.metadata?.attachedClients || []).map((client) => [client.clientId, client])
+          );
+          nextClients.set(event.client.clientId, {
+            clientId: event.client.clientId,
+            type: event.client.type,
+            readOnly: event.client.readOnly
+          });
+          this.metadata = {
+            ...this.metadata || { runtimeId: this.options.runtimeId },
+            attachedClients: Array.from(nextClients.values())
+          };
+          return;
+        }
+        if (event.type === "client_detached") {
+          this.metadata = {
+            ...this.metadata || { runtimeId: this.options.runtimeId },
+            attachedClients: (this.metadata?.attachedClients || []).filter((client) => client.clientId !== event.clientId)
+          };
+          return;
+        }
+        if (event.type === "session_output") {
+          this.emitData(event.data);
+          return;
+        }
+        if (event.type === "session_cleared") {
+          this.pendingOutput.length = 0;
+          return;
+        }
+        if (event.type === "session_exit") {
+          for (const callback of this.exitCallbacks) {
+            callback({ exitCode: event.exitCode ?? 0 });
+          }
+          void this.closeClient(false);
+        }
+      }
+      emitData(data) {
+        if (this.dataCallbacks.size === 0) {
+          this.pendingOutput.push(data);
+          return;
+        }
+        for (const callback of this.dataCallbacks) {
+          callback(data);
+        }
+      }
+      updateMetadata(record2) {
+        this.metadata = {
+          runtimeId: record2.sessionId,
+          runtimeKey: record2.runtimeKey,
+          displayName: record2.displayName,
+          workspaceLabel: record2.workspaceLabel,
+          writeOwner: record2.writeOwner ? {
+            clientId: record2.writeOwner.clientId,
+            ownerType: record2.writeOwner.ownerType
+          } : null,
+          attachedClients: record2.attachedClients.map((client) => ({
+            clientId: client.clientId,
+            type: client.type,
+            readOnly: client.readOnly
+          }))
+        };
+      }
+      enqueue(action) {
+        this.operationChain = this.operationChain.then(() => this.ready).then(action).catch((error48) => {
+          LOG.warn("CLI", `[session-host:${this.options.runtimeId}] ${error48?.message || error48}`);
+        });
+      }
+      async closeClient(destroy = false) {
+        if (this.closed) return;
+        this.closed = true;
+        try {
+          this.unsubscribe?.();
+          this.unsubscribe = null;
+        } catch {
+        }
+        try {
+          await this.client.close();
+        } catch {
+          if (destroy) throw new Error(`Failed to close session host client: ${this.options.runtimeId}`);
+        }
+      }
+    };
+    SessionHostPtyTransportFactory = class {
+      constructor(options) {
+        this.options = options;
+      }
+      spawn(command, args, spawnOptions) {
+        return new SessionHostRuntimeTransport({
+          ...this.options,
+          command,
+          args,
+          spawnOptions
+        });
+      }
+    };
+  }
+});
+
+// ../../oss/packages/daemon-core/src/session-host/runtime-support.ts
+async function canConnect(endpoint) {
+  const client = new SessionHostClient({ endpoint });
+  try {
+    await client.connect();
+    await client.close();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForReady(endpoint, timeoutMs = STARTUP_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await canConnect(endpoint)) return;
+    await new Promise((resolve12) => setTimeout(resolve12, STARTUP_POLL_MS));
+  }
+  throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
+}
+async function ensureSessionHostReady(options) {
+  const endpoint = getDefaultSessionHostEndpoint(options.appName || "adhdev");
+  if (await canConnect(endpoint)) return endpoint;
+  options.spawnHost();
+  await waitForReady(endpoint, options.timeoutMs);
+  return endpoint;
+}
+async function listHostedCliRuntimes(endpoint) {
+  const client = new SessionHostClient({ endpoint });
+  try {
+    const response = await client.request({
+      type: "list_sessions",
+      payload: {}
+    });
+    if (!response.success || !response.result) {
+      return [];
+    }
+    return response.result.filter((record2) => record2.category === "cli" && ["running", "interrupted"].includes(record2.lifecycle)).sort((a, b2) => b2.lastActivityAt - a.lastActivityAt).map((record2) => ({
+      runtimeId: record2.sessionId,
+      runtimeKey: record2.runtimeKey,
+      displayName: record2.displayName,
+      workspaceLabel: record2.workspaceLabel,
+      lifecycle: record2.lifecycle,
+      recoveryState: typeof record2.meta?.runtimeRecoveryState === "string" ? String(record2.meta.runtimeRecoveryState) : null,
+      cliType: record2.providerType,
+      workspace: record2.workspace,
+      cliArgs: Array.isArray(record2.meta?.cliArgs) ? record2.meta.cliArgs : []
+    }));
+  } finally {
+    await client.close().catch(() => {
+    });
+  }
+}
+var STARTUP_TIMEOUT_MS, STARTUP_POLL_MS;
+var init_runtime_support = __esm({
+  "../../oss/packages/daemon-core/src/session-host/runtime-support.ts"() {
+    "use strict";
+    init_dist();
+    STARTUP_TIMEOUT_MS = 8e3;
+    STARTUP_POLL_MS = 200;
   }
 });
 
@@ -42966,6 +43484,7 @@ var init_src = __esm({
     init_provider_cli_adapter();
     init_pty_transport();
     init_session_host_transport();
+    init_runtime_support();
     init_installer();
     init_daemon_lifecycle();
   }
@@ -43163,9 +43682,9 @@ var init_server_connection = __esm({
           LOG.info("Server", `[ServerConn] Run 'adhdev setup' to re-authenticate.`);
           this.setState("disconnected");
           try {
-            const path17 = require("path");
+            const path18 = require("path");
             const fs15 = require("fs");
-            const configPath = path17.join(process.env.HOME || process.env.USERPROFILE || "", ".adhdev", "config.json");
+            const configPath = path18.join(process.env.HOME || process.env.USERPROFILE || "", ".adhdev", "config.json");
             if (fs15.existsSync(configPath)) {
               fs15.unlinkSync(configPath);
               LOG.info("Server", `[ServerConn] Config file removed. Re-run 'adhdev setup'.`);
@@ -43276,17 +43795,17 @@ function canPeerUsePrivilegedShareCommand(commandType, permission) {
       return false;
   }
 }
-var fs13, path15, os17, import_node_module, esmRequire, logFile, log, logDebug, DaemonP2PSender;
+var fs13, path15, os18, import_node_module, esmRequire, logFile, log, logDebug, DaemonP2PSender;
 var init_daemon_p2p = __esm({
   "src/daemon-p2p.ts"() {
     "use strict";
     fs13 = __toESM(require("fs"));
     init_src();
     path15 = __toESM(require("path"));
-    os17 = __toESM(require("os"));
+    os18 = __toESM(require("os"));
     import_node_module = require("module");
     esmRequire = (0, import_node_module.createRequire)(__filename);
-    logFile = path15.join(os17.tmpdir(), "adhdev_daemon_p2p.log");
+    logFile = path15.join(os18.tmpdir(), "adhdev_daemon_p2p.log");
     log = (msg) => {
       LOG.info("P2P", `[${(/* @__PURE__ */ new Date()).toISOString()}] [P2P] ${msg}`);
     };
@@ -43442,7 +43961,7 @@ ${e?.stack || ""}`);
       async fetchTurnCredentials() {
         try {
           const serverUrl = process.env.ADHDEV_SERVER_URL || "https://api.adhf.dev";
-          const configPath = path15.join(os17.homedir(), ".adhdev", "config.json");
+          const configPath = path15.join(os18.homedir(), ".adhdev", "config.json");
           let token = "";
           try {
             const config2 = JSON.parse(fs13.readFileSync(configPath, "utf-8"));
@@ -43450,13 +43969,13 @@ ${e?.stack || ""}`);
           } catch {
           }
           const http3 = esmRequire("https");
-          const data = await new Promise((resolve11, reject) => {
+          const data = await new Promise((resolve12, reject) => {
             const req = http3.get(`${serverUrl}/api/v1/turn/credentials`, {
               headers: { "Authorization": `Bearer ${token}` }
             }, (res) => {
               let d = "";
               res.on("data", (c) => d += c);
-              res.on("end", () => resolve11(d));
+              res.on("end", () => resolve12(d));
             });
             req.on("error", reject);
             req.setTimeout(5e3, () => {
@@ -44285,6 +44804,52 @@ var init_screenshot_controller = __esm({
   }
 });
 
+// src/session-host.ts
+function resolveSessionHostEntry() {
+  const localCandidates = [
+    path16.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
+    path16.resolve(__dirname, "../../vendor/session-host-daemon/index.js"),
+    path16.resolve(__dirname, "../../../oss/packages/session-host-daemon/dist/index.js")
+  ];
+  for (const candidate of localCandidates) {
+    if (require("fs").existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return require.resolve("@adhdev/session-host-daemon");
+}
+async function ensureSessionHostReady2() {
+  return ensureSessionHostReady({
+    appName: SESSION_HOST_APP_NAME,
+    spawnHost: () => {
+      const entry = resolveSessionHostEntry();
+      const child = (0, import_child_process8.spawn)(process.execPath, [entry], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: {
+          ...process.env,
+          ADHDEV_SESSION_HOST_NAME: SESSION_HOST_APP_NAME
+        }
+      });
+      child.unref();
+    }
+  });
+}
+async function listHostedCliRuntimes2(endpoint) {
+  return listHostedCliRuntimes(endpoint);
+}
+var import_child_process8, path16, SESSION_HOST_APP_NAME;
+var init_session_host = __esm({
+  "src/session-host.ts"() {
+    "use strict";
+    import_child_process8 = require("child_process");
+    path16 = __toESM(require("path"));
+    init_src();
+    SESSION_HOST_APP_NAME = process.env.ADHDEV_SESSION_HOST_NAME || "adhdev";
+  }
+});
+
 // src/adhdev-daemon.ts
 var adhdev_daemon_exports = {};
 __export(adhdev_daemon_exports, {
@@ -44293,9 +44858,9 @@ __export(adhdev_daemon_exports, {
   stopDaemon: () => stopDaemon
 });
 function getDaemonPidFile() {
-  const dir = path16.join(os18.homedir(), ".adhdev");
+  const dir = path17.join(os19.homedir(), ".adhdev");
   if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
-  return path16.join(dir, "daemon.pid");
+  return path17.join(dir, "daemon.pid");
 }
 function writeDaemonPid(pid) {
   fs14.writeFileSync(getDaemonPidFile(), String(pid), "utf-8");
@@ -44331,7 +44896,7 @@ function stopDaemon() {
     return false;
   }
 }
-var os18, fs14, path16, import_chalk2, pkgVersion, DANGEROUS_PATTERNS, AdhdevDaemon;
+var os19, fs14, path17, import_chalk2, pkgVersion, DANGEROUS_PATTERNS, AdhdevDaemon;
 var init_adhdev_daemon = __esm({
   "src/adhdev-daemon.ts"() {
     "use strict";
@@ -44339,16 +44904,17 @@ var init_adhdev_daemon = __esm({
     init_src();
     init_daemon_p2p();
     init_screenshot_controller();
-    os18 = __toESM(require("os"));
+    init_session_host();
+    os19 = __toESM(require("os"));
     fs14 = __toESM(require("fs"));
-    path16 = __toESM(require("path"));
+    path17 = __toESM(require("path"));
     import_chalk2 = __toESM(require("chalk"));
-    pkgVersion = "0.7.17";
+    pkgVersion = "0.7.19";
     if (pkgVersion === "unknown") {
       try {
         const possiblePaths = [
-          path16.join(__dirname, "..", "package.json"),
-          path16.join(__dirname, "package.json")
+          path17.join(__dirname, "..", "package.json"),
+          path17.join(__dirname, "package.json")
         ];
         for (const p of possiblePaths) {
           try {
@@ -44419,13 +44985,27 @@ ${err?.stack || ""}`);
           console.log(import_chalk2.default.gray("  Run `adhdev setup` first.\n"));
           process.exit(1);
         }
+        const sessionHostEndpoint = await ensureSessionHostReady2();
         this.components = await initDaemonComponents({
           providerLogFn: LOG.forComponent("Provider").asLogFn(),
           cliManagerDeps: {
             getServerConn: () => this.serverConn,
             getP2p: () => this.p2p,
             onStatusChange: () => this.statusReporter?.onStatusChange(),
-            removeAgentTracking: (key) => this.statusReporter?.removeAgentTracking(key)
+            removeAgentTracking: (key) => this.statusReporter?.removeAgentTracking(key),
+            createPtyTransportFactory: ({ runtimeId, providerType, workspace, cliArgs, attachExisting }) => new SessionHostPtyTransportFactory({
+              endpoint: sessionHostEndpoint,
+              clientId: `daemon_${config2.machineId}`,
+              runtimeId,
+              providerType,
+              workspace,
+              appName: process.env.ADHDEV_SESSION_HOST_NAME || "adhdev",
+              meta: {
+                cliArgs
+              },
+              attachExisting
+            }),
+            listHostedCliRuntimes: async () => listHostedCliRuntimes2(sessionHostEndpoint)
           },
           enabledIdes: config2.enabledIdes,
           onStatusChange: () => this.statusReporter?.onStatusChange(),
@@ -44442,6 +45022,7 @@ ${err?.stack || ""}`);
             forwardAgentStreamsToIdeInstance(this.components.instanceManager, ideType, streams);
           }
         });
+        await this.components.cliManager.restoreHostedSessions();
         this.components.providerLoader.fetchLatest().then(({ updated }) => {
           if (updated) {
             this.components.providerLoader.reload();
@@ -44458,8 +45039,8 @@ ${err?.stack || ""}`);
           cliInfo: {
             type: "adhdev-daemon",
             version: pkgVersion,
-            platform: os18.platform(),
-            hostname: os18.hostname(),
+            platform: os19.platform(),
+            hostname: os19.hostname(),
             machineId: config2.machineId,
             instanceId
           }
@@ -44898,16 +45479,16 @@ async function loginFlow() {
   let verificationUrl;
   try {
     const config2 = loadConfig();
-    const os19 = await import("os");
+    const os20 = 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: os19.hostname(),
-        platform: os19.platform(),
-        arch: os19.arch()
+        hostname: os20.hostname(),
+        platform: os20.platform(),
+        arch: os20.arch()
       })
     });
     if (!res.ok) {
@@ -45006,10 +45587,10 @@ async function startDaemonFlow() {
     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 os19 = await import("os");
-    const path17 = await import("path");
-    const logPath = path17.join(os19.homedir(), ".adhdev", "daemon.log");
-    const platform11 = os19.platform();
+    const os20 = await import("os");
+    const path18 = await import("path");
+    const logPath = path18.join(os20.homedir(), ".adhdev", "daemon.log");
+    const platform11 = os20.platform();
     try {
       if (platform11 === "win32") {
         execSync6(`start /B adhdev daemon > "${logPath}" 2>&1`, {