adhdev 0.6.72 → 0.6.75

package/dist/index.js

@@ -517,8 +517,8 @@ async function detectIDEs() {
       if ((0, import_fs2.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os18 === "win32") {
-      const { dirname: dirname6 } = await import("path");
-      const appDir = dirname6(appPath);
+      const { dirname: dirname8 } = await import("path");
+      const appDir = dirname8(appPath);
       const candidates = [
         `${appDir}\\\\bin\\\\${def.cli}.cmd`,
         `${appDir}\\\\bin\\\\${def.cli}`,
@@ -561,15 +561,15 @@ var init_ide_detector = __esm({
 
 // ../../oss/packages/daemon-core/src/detection/cli-detector.ts
 function execAsync(cmd, timeoutMs = 5e3) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve10) => {
     const child = (0, import_child_process2.exec)(cmd, { encoding: "utf-8", timeout: timeoutMs }, (err, stdout) => {
       if (err || !stdout?.trim()) {
-        resolve7(null);
+        resolve10(null);
       } else {
-        resolve7(stdout.trim());
+        resolve10(stdout.trim());
       }
     });
-    child.on("error", () => resolve7(null));
+    child.on("error", () => resolve10(null));
   });
 }
 async function detectCLIs(providerLoader) {
@@ -693,8 +693,8 @@ function cleanOldLogs() {
 }
 function rotateSizeIfNeeded() {
   try {
-    const stat = fs2.statSync(currentLogFile);
-    if (stat.size > MAX_LOG_SIZE) {
+    const stat4 = fs2.statSync(currentLogFile);
+    if (stat4.size > MAX_LOG_SIZE) {
       const backup = currentLogFile.replace(".log", ".1.log");
       try {
         fs2.unlinkSync(backup);
@@ -823,8 +823,8 @@ var init_logger = __esm({
     try {
       const oldLog = path3.join(LOG_DIR, "daemon.log");
       if (fs2.existsSync(oldLog)) {
-        const stat = fs2.statSync(oldLog);
-        const oldDate = stat.mtime.toISOString().slice(0, 10);
+        const stat4 = fs2.statSync(oldLog);
+        const oldDate = stat4.mtime.toISOString().slice(0, 10);
         fs2.renameSync(oldLog, path3.join(LOG_DIR, `daemon-${oldDate}.log`));
       }
       const oldLogBackup = path3.join(LOG_DIR, "daemon.log.old");
@@ -948,7 +948,7 @@ var init_manager = __esm({
       * Returns multiple entries if multiple IDE windows are open on same port
       */
       static listAllTargets(port) {
-        return new Promise((resolve7) => {
+        return new Promise((resolve10) => {
           const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
             let data = "";
             res.on("data", (chunk) => data += chunk.toString());
@@ -964,16 +964,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 || ""));
-                resolve7(mainPages.length > 0 ? mainPages : fallbackPages);
+                resolve10(mainPages.length > 0 ? mainPages : fallbackPages);
               } catch {
-                resolve7([]);
+                resolve10([]);
               }
             });
           });
-          req.on("error", () => resolve7([]));
+          req.on("error", () => resolve10([]));
           req.setTimeout(2e3, () => {
             req.destroy();
-            resolve7([]);
+            resolve10([]);
           });
         });
       }
@@ -1013,7 +1013,7 @@ var init_manager = __esm({
         }
       }
       findTargetOnPort(port) {
-        return new Promise((resolve7) => {
+        return new Promise((resolve10) => {
           const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
             let data = "";
             res.on("data", (chunk) => data += chunk.toString());
@@ -1024,7 +1024,7 @@ var init_manager = __esm({
                   (t) => (t.type === "page" || t.type === "browser" || t.type === "Page") && t.webSocketDebuggerUrl
                 );
                 if (pages.length === 0) {
-                  resolve7(targets.find((t) => t.webSocketDebuggerUrl) || null);
+                  resolve10(targets.find((t) => t.webSocketDebuggerUrl) || null);
                   return;
                 }
                 const mainPages = pages.filter((t) => !this.isNonMainTitle(t.title || ""));
@@ -1034,24 +1034,24 @@ var init_manager = __esm({
                   const specific = list.find((t) => t.id === this._targetId);
                   if (specific) {
                     this._pageTitle = specific.title || "";
-                    resolve7(specific);
+                    resolve10(specific);
                   } else {
                     this.log(`[CDP] Target ${this._targetId} not found in page list`);
-                    resolve7(null);
+                    resolve10(null);
                   }
                   return;
                 }
                 this._pageTitle = list[0]?.title || "";
-                resolve7(list[0]);
+                resolve10(list[0]);
               } catch {
-                resolve7(null);
+                resolve10(null);
               }
             });
           });
-          req.on("error", () => resolve7(null));
+          req.on("error", () => resolve10(null));
           req.setTimeout(2e3, () => {
             req.destroy();
-            resolve7(null);
+            resolve10(null);
           });
         });
       }
@@ -1062,7 +1062,7 @@ var init_manager = __esm({
         this.extensionProviders = providers;
       }
       connectToTarget(wsUrl) {
-        return new Promise((resolve7) => {
+        return new Promise((resolve10) => {
           this.ws = new import_ws.default(wsUrl);
           this.ws.on("open", async () => {
             this._connected = true;
@@ -1072,17 +1072,17 @@ var init_manager = __esm({
             }
             this.connectBrowserWs().catch(() => {
             });
-            resolve7(true);
+            resolve10(true);
           });
           this.ws.on("message", (data) => {
             try {
               const msg = JSON.parse(data.toString());
               if (msg.id && this.pending.has(msg.id)) {
-                const { resolve: resolve8, reject } = this.pending.get(msg.id);
+                const { resolve: resolve11, reject } = this.pending.get(msg.id);
                 this.pending.delete(msg.id);
                 this.failureCount = 0;
                 if (msg.error) reject(new Error(msg.error.message));
-                else resolve8(msg.result);
+                else resolve11(msg.result);
               } else if (msg.method === "Runtime.executionContextCreated") {
                 this.contexts.add(msg.params.context.id);
               } else if (msg.method === "Runtime.executionContextDestroyed") {
@@ -1105,7 +1105,7 @@ var init_manager = __esm({
           this.ws.on("error", (err) => {
             this.log(`[CDP] WebSocket error: ${err.message}`);
             this._connected = false;
-            resolve7(false);
+            resolve10(false);
           });
         });
       }
@@ -1119,7 +1119,7 @@ var init_manager = __esm({
             return;
           }
           this.log(`[CDP] Connecting browser WS for target discovery...`);
-          await new Promise((resolve7, reject) => {
+          await new Promise((resolve10, reject) => {
             this.browserWs = new import_ws.default(browserWsUrl);
             this.browserWs.on("open", async () => {
               this._browserConnected = true;
@@ -1129,16 +1129,16 @@ var init_manager = __esm({
               } catch (e) {
                 this.log(`[CDP] setDiscoverTargets failed: ${e.message}`);
               }
-              resolve7();
+              resolve10();
             });
             this.browserWs.on("message", (data) => {
               try {
                 const msg = JSON.parse(data.toString());
                 if (msg.id && this.browserPending.has(msg.id)) {
-                  const { resolve: resolve8, reject: reject2 } = this.browserPending.get(msg.id);
+                  const { resolve: resolve11, reject: reject2 } = this.browserPending.get(msg.id);
                   this.browserPending.delete(msg.id);
                   if (msg.error) reject2(new Error(msg.error.message));
-                  else resolve8(msg.result);
+                  else resolve11(msg.result);
                 }
               } catch {
               }
@@ -1158,31 +1158,31 @@ var init_manager = __esm({
         }
       }
       getBrowserWsUrl() {
-        return new Promise((resolve7) => {
+        return new Promise((resolve10) => {
           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);
-                resolve7(info.webSocketDebuggerUrl || null);
+                resolve10(info.webSocketDebuggerUrl || null);
               } catch {
-                resolve7(null);
+                resolve10(null);
               }
             });
           });
-          req.on("error", () => resolve7(null));
+          req.on("error", () => resolve10(null));
           req.setTimeout(3e3, () => {
             req.destroy();
-            resolve7(null);
+            resolve10(null);
           });
         });
       }
       sendBrowser(method, params = {}, timeoutMs = 15e3) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve10, reject) => {
           if (!this.browserWs || !this._browserConnected) return reject(new Error("Browser WS not connected"));
           const id = this.browserMsgId++;
-          this.browserPending.set(id, { resolve: resolve7, reject });
+          this.browserPending.set(id, { resolve: resolve10, reject });
           this.browserWs.send(JSON.stringify({ id, method, params }));
           setTimeout(() => {
             if (this.browserPending.has(id)) {
@@ -1222,11 +1222,11 @@ var init_manager = __esm({
       }
       // ─── CDP Protocol ────────────────────────────────────────
       sendInternal(method, params = {}, timeoutMs = 15e3) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve10, 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: resolve7, reject });
+          this.pending.set(id, { resolve: resolve10, reject });
           this.ws.send(JSON.stringify({ id, method, params }));
           setTimeout(() => {
             if (this.pending.has(id)) {
@@ -1475,7 +1475,7 @@ var init_manager = __esm({
         const browserWs = this.browserWs;
         let msgId = this.browserMsgId;
         const sendWs = (method, params = {}, sessionId) => {
-          return new Promise((resolve7, reject) => {
+          return new Promise((resolve10, reject) => {
             const mid = msgId++;
             this.browserMsgId = msgId;
             const handler = (raw) => {
@@ -1484,7 +1484,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 resolve7(msg.result);
+                  else resolve10(msg.result);
                 }
               } catch {
               }
@@ -1666,14 +1666,14 @@ var init_manager = __esm({
         if (!ws2 || ws2.readyState !== import_ws.default.OPEN) {
           throw new Error("CDP not connected");
         }
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve10, reject) => {
           const id = getNextId();
           pendingMap.set(id, {
             resolve: (result) => {
               if (result?.result?.subtype === "error") {
                 reject(new Error(result.result.description));
               } else {
-                resolve7(result?.result?.value);
+                resolve10(result?.result?.value);
               }
             },
             reject
@@ -1705,10 +1705,10 @@ var init_manager = __esm({
           throw new Error("CDP not connected");
         }
         const sendViaSession = (method, params = {}) => {
-          return new Promise((resolve7, reject) => {
+          return new Promise((resolve10, reject) => {
             const pendingMap = this._browserConnected ? this.browserPending : this.pending;
             const id = this._browserConnected ? this.browserMsgId++ : this.msgId++;
-            pendingMap.set(id, { resolve: resolve7, reject });
+            pendingMap.set(id, { resolve: resolve10, reject });
             ws2.send(JSON.stringify({ id, sessionId, method, params }));
             setTimeout(() => {
               if (pendingMap.has(id)) {
@@ -2524,8 +2524,8 @@ ${next}`;
             const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl") || f.endsWith(".terminal.log"));
             for (const file2 of files) {
               const filePath = path4.join(dirPath, file2);
-              const stat = fs3.statSync(filePath);
-              if (stat.mtimeMs < cutoff) {
+              const stat4 = fs3.statSync(filePath);
+              if (stat4.mtimeMs < cutoff) {
                 fs3.unlinkSync(filePath);
               }
             }
@@ -5048,7 +5048,7 @@ var init_handler = __esm({
         try {
           const http3 = await import("http");
           const postData = JSON.stringify(body);
-          const result = await new Promise((resolve7, reject) => {
+          const result = await new Promise((resolve10, reject) => {
             const req = http3.request({
               hostname: "127.0.0.1",
               port: 19280,
@@ -5060,9 +5060,9 @@ var init_handler = __esm({
               res.on("data", (chunk) => data += chunk);
               res.on("end", () => {
                 try {
-                  resolve7(JSON.parse(data));
+                  resolve10(JSON.parse(data));
                 } catch {
-                  resolve7({ raw: data });
+                  resolve10({ raw: data });
                 }
               });
             });
@@ -5080,15 +5080,15 @@ var init_handler = __esm({
         if (!providerType) return { success: false, error: "providerType required" };
         try {
           const http3 = await import("http");
-          const result = await new Promise((resolve7, reject) => {
+          const result = await new Promise((resolve10, 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 {
-                  resolve7(JSON.parse(data));
+                  resolve10(JSON.parse(data));
                 } catch {
-                  resolve7({ raw: data });
+                  resolve10({ raw: data });
                 }
               });
             }).on("error", reject);
@@ -5102,7 +5102,7 @@ var init_handler = __esm({
         try {
           const http3 = await import("http");
           const postData = JSON.stringify(args || {});
-          const result = await new Promise((resolve7, reject) => {
+          const result = await new Promise((resolve10, reject) => {
             const req = http3.request({
               hostname: "127.0.0.1",
               port: 19280,
@@ -5114,9 +5114,9 @@ var init_handler = __esm({
               res.on("data", (chunk) => data += chunk);
               res.on("end", () => {
                 try {
-                  resolve7(JSON.parse(data));
+                  resolve10(JSON.parse(data));
                 } catch {
-                  resolve7({ raw: data });
+                  resolve10({ raw: data });
                 }
               });
             });
@@ -5133,6 +5133,1755 @@ var init_handler = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/node_modules/readdirp/index.js
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+var import_promises, import_node_path, import_node_stream, EntryTypes, defaultOptions, RECURSIVE_ERROR_CODE, NORMAL_FLOW_ERRORS, ALL_TYPES, DIR_TYPES, FILE_TYPES, isNormalFlowError, wantBigintFsStats, emptyFn, normalizeFilter, ReaddirpStream;
+var init_readdirp = __esm({
+  "../../oss/packages/daemon-core/node_modules/readdirp/index.js"() {
+    "use strict";
+    import_promises = require("fs/promises");
+    import_node_path = require("path");
+    import_node_stream = require("stream");
+    EntryTypes = {
+      FILE_TYPE: "files",
+      DIR_TYPE: "directories",
+      FILE_DIR_TYPE: "files_directories",
+      EVERYTHING_TYPE: "all"
+    };
+    defaultOptions = {
+      root: ".",
+      fileFilter: (_entryInfo) => true,
+      directoryFilter: (_entryInfo) => true,
+      type: EntryTypes.FILE_TYPE,
+      lstat: false,
+      depth: 2147483648,
+      alwaysStat: false,
+      highWaterMark: 4096
+    };
+    Object.freeze(defaultOptions);
+    RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+    NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+    ALL_TYPES = [
+      EntryTypes.DIR_TYPE,
+      EntryTypes.EVERYTHING_TYPE,
+      EntryTypes.FILE_DIR_TYPE,
+      EntryTypes.FILE_TYPE
+    ];
+    DIR_TYPES = /* @__PURE__ */ new Set([
+      EntryTypes.DIR_TYPE,
+      EntryTypes.EVERYTHING_TYPE,
+      EntryTypes.FILE_DIR_TYPE
+    ]);
+    FILE_TYPES = /* @__PURE__ */ new Set([
+      EntryTypes.EVERYTHING_TYPE,
+      EntryTypes.FILE_DIR_TYPE,
+      EntryTypes.FILE_TYPE
+    ]);
+    isNormalFlowError = (error48) => NORMAL_FLOW_ERRORS.has(error48.code);
+    wantBigintFsStats = process.platform === "win32";
+    emptyFn = (_entryInfo) => true;
+    normalizeFilter = (filter) => {
+      if (filter === void 0)
+        return emptyFn;
+      if (typeof filter === "function")
+        return filter;
+      if (typeof filter === "string") {
+        const fl2 = filter.trim();
+        return (entry) => entry.basename === fl2;
+      }
+      if (Array.isArray(filter)) {
+        const trItems = filter.map((item) => item.trim());
+        return (entry) => trItems.some((f) => entry.basename === f);
+      }
+      return emptyFn;
+    };
+    ReaddirpStream = class extends import_node_stream.Readable {
+      parents;
+      reading;
+      parent;
+      _stat;
+      _maxDepth;
+      _wantsDir;
+      _wantsFile;
+      _wantsEverything;
+      _root;
+      _isDirent;
+      _statsProp;
+      _rdOptions;
+      _fileFilter;
+      _directoryFilter;
+      constructor(options = {}) {
+        super({
+          objectMode: true,
+          autoDestroy: true,
+          highWaterMark: options.highWaterMark
+        });
+        const opts = { ...defaultOptions, ...options };
+        const { root, type } = opts;
+        this._fileFilter = normalizeFilter(opts.fileFilter);
+        this._directoryFilter = normalizeFilter(opts.directoryFilter);
+        const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
+        if (wantBigintFsStats) {
+          this._stat = (path15) => statMethod(path15, { bigint: true });
+        } else {
+          this._stat = statMethod;
+        }
+        this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+        this._wantsDir = type ? DIR_TYPES.has(type) : false;
+        this._wantsFile = type ? FILE_TYPES.has(type) : false;
+        this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+        this._root = (0, import_node_path.resolve)(root);
+        this._isDirent = !opts.alwaysStat;
+        this._statsProp = this._isDirent ? "dirent" : "stats";
+        this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+        this.parents = [this._exploreDir(root, 1)];
+        this.reading = false;
+        this.parent = void 0;
+      }
+      async _read(batch) {
+        if (this.reading)
+          return;
+        this.reading = true;
+        try {
+          while (!this.destroyed && batch > 0) {
+            const par = this.parent;
+            const fil = par && par.files;
+            if (fil && fil.length > 0) {
+              const { path: path15, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path15));
+              const awaited = await Promise.all(slice);
+              for (const entry of awaited) {
+                if (!entry)
+                  continue;
+                if (this.destroyed)
+                  return;
+                const entryType = await this._getEntryType(entry);
+                if (entryType === "directory" && this._directoryFilter(entry)) {
+                  if (depth <= this._maxDepth) {
+                    this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                  }
+                  if (this._wantsDir) {
+                    this.push(entry);
+                    batch--;
+                  }
+                } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+                  if (this._wantsFile) {
+                    this.push(entry);
+                    batch--;
+                  }
+                }
+              }
+            } else {
+              const parent = this.parents.pop();
+              if (!parent) {
+                this.push(null);
+                break;
+              }
+              this.parent = await parent;
+              if (this.destroyed)
+                return;
+            }
+          }
+        } catch (error48) {
+          this.destroy(error48);
+        } finally {
+          this.reading = false;
+        }
+      }
+      async _exploreDir(path15, depth) {
+        let files;
+        try {
+          files = await (0, import_promises.readdir)(path15, this._rdOptions);
+        } catch (error48) {
+          this._onError(error48);
+        }
+        return { files, depth, path: path15 };
+      }
+      async _formatEntry(dirent, path15) {
+        let entry;
+        const basename5 = this._isDirent ? dirent.name : dirent;
+        try {
+          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path15, basename5));
+          entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename5 };
+          entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+        } catch (err) {
+          this._onError(err);
+          return;
+        }
+        return entry;
+      }
+      _onError(err) {
+        if (isNormalFlowError(err) && !this.destroyed) {
+          this.emit("warn", err);
+        } else {
+          this.destroy(err);
+        }
+      }
+      async _getEntryType(entry) {
+        if (!entry && this._statsProp in entry) {
+          return "";
+        }
+        const stats = entry[this._statsProp];
+        if (stats.isFile())
+          return "file";
+        if (stats.isDirectory())
+          return "directory";
+        if (stats && stats.isSymbolicLink()) {
+          const full = entry.fullPath;
+          try {
+            const entryRealPath = await (0, import_promises.realpath)(full);
+            const entryRealPathStats = await (0, import_promises.lstat)(entryRealPath);
+            if (entryRealPathStats.isFile()) {
+              return "file";
+            }
+            if (entryRealPathStats.isDirectory()) {
+              const len = entryRealPath.length;
+              if (full.startsWith(entryRealPath) && full.substr(len, 1) === import_node_path.sep) {
+                const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+                recursiveError.code = RECURSIVE_ERROR_CODE;
+                return this._onError(recursiveError);
+              }
+              return "directory";
+            }
+          } catch (error48) {
+            this._onError(error48);
+            return "";
+          }
+        }
+      }
+      _includeAsFile(entry) {
+        const stats = entry && entry[this._statsProp];
+        return stats && this._wantsEverything && !stats.isDirectory();
+      }
+    };
+  }
+});
+
+// ../../oss/packages/daemon-core/node_modules/chokidar/handler.js
+function createFsWatchInstance(path15, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path15);
+    emitRaw(rawEvent, evPath, { watchedPath: path15 });
+    if (evPath && path15 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path15, evPath), KEY_LISTENERS, sp.join(path15, evPath));
+    }
+  };
+  try {
+    return (0, import_node_fs.watch)(path15, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error48) {
+    errHandler(error48);
+    return void 0;
+  }
+}
+var import_node_fs, import_promises2, import_node_os, sp, STR_DATA, STR_END, STR_CLOSE, EMPTY_FN, pl, isWindows, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH, statMethods, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, binaryExtensions, isBinaryPath, foreach, addAndConvert, clearItem, delFromSet, isEmptySet, FsWatchInstances, fsWatchBroadcast, setFsWatchListener, FsWatchFileInstances, setFsWatchFileListener, NodeFsHandler;
+var init_handler2 = __esm({
+  "../../oss/packages/daemon-core/node_modules/chokidar/handler.js"() {
+    "use strict";
+    import_node_fs = require("fs");
+    import_promises2 = require("fs/promises");
+    import_node_os = require("os");
+    sp = __toESM(require("path"), 1);
+    STR_DATA = "data";
+    STR_END = "end";
+    STR_CLOSE = "close";
+    EMPTY_FN = () => {
+    };
+    pl = process.platform;
+    isWindows = pl === "win32";
+    isMacos = pl === "darwin";
+    isLinux = pl === "linux";
+    isFreeBSD = pl === "freebsd";
+    isIBMi = (0, import_node_os.type)() === "OS400";
+    EVENTS = {
+      ALL: "all",
+      READY: "ready",
+      ADD: "add",
+      CHANGE: "change",
+      ADD_DIR: "addDir",
+      UNLINK: "unlink",
+      UNLINK_DIR: "unlinkDir",
+      RAW: "raw",
+      ERROR: "error"
+    };
+    EV = EVENTS;
+    THROTTLE_MODE_WATCH = "watch";
+    statMethods = { lstat: import_promises2.lstat, stat: import_promises2.stat };
+    KEY_LISTENERS = "listeners";
+    KEY_ERR = "errHandlers";
+    KEY_RAW = "rawEmitters";
+    HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+    binaryExtensions = /* @__PURE__ */ new Set([
+      "3dm",
+      "3ds",
+      "3g2",
+      "3gp",
+      "7z",
+      "a",
+      "aac",
+      "adp",
+      "afdesign",
+      "afphoto",
+      "afpub",
+      "ai",
+      "aif",
+      "aiff",
+      "alz",
+      "ape",
+      "apk",
+      "appimage",
+      "ar",
+      "arj",
+      "asf",
+      "au",
+      "avi",
+      "bak",
+      "baml",
+      "bh",
+      "bin",
+      "bk",
+      "bmp",
+      "btif",
+      "bz2",
+      "bzip2",
+      "cab",
+      "caf",
+      "cgm",
+      "class",
+      "cmx",
+      "cpio",
+      "cr2",
+      "cur",
+      "dat",
+      "dcm",
+      "deb",
+      "dex",
+      "djvu",
+      "dll",
+      "dmg",
+      "dng",
+      "doc",
+      "docm",
+      "docx",
+      "dot",
+      "dotm",
+      "dra",
+      "DS_Store",
+      "dsk",
+      "dts",
+      "dtshd",
+      "dvb",
+      "dwg",
+      "dxf",
+      "ecelp4800",
+      "ecelp7470",
+      "ecelp9600",
+      "egg",
+      "eol",
+      "eot",
+      "epub",
+      "exe",
+      "f4v",
+      "fbs",
+      "fh",
+      "fla",
+      "flac",
+      "flatpak",
+      "fli",
+      "flv",
+      "fpx",
+      "fst",
+      "fvt",
+      "g3",
+      "gh",
+      "gif",
+      "graffle",
+      "gz",
+      "gzip",
+      "h261",
+      "h263",
+      "h264",
+      "icns",
+      "ico",
+      "ief",
+      "img",
+      "ipa",
+      "iso",
+      "jar",
+      "jpeg",
+      "jpg",
+      "jpgv",
+      "jpm",
+      "jxr",
+      "key",
+      "ktx",
+      "lha",
+      "lib",
+      "lvp",
+      "lz",
+      "lzh",
+      "lzma",
+      "lzo",
+      "m3u",
+      "m4a",
+      "m4v",
+      "mar",
+      "mdi",
+      "mht",
+      "mid",
+      "midi",
+      "mj2",
+      "mka",
+      "mkv",
+      "mmr",
+      "mng",
+      "mobi",
+      "mov",
+      "movie",
+      "mp3",
+      "mp4",
+      "mp4a",
+      "mpeg",
+      "mpg",
+      "mpga",
+      "mxu",
+      "nef",
+      "npx",
+      "numbers",
+      "nupkg",
+      "o",
+      "odp",
+      "ods",
+      "odt",
+      "oga",
+      "ogg",
+      "ogv",
+      "otf",
+      "ott",
+      "pages",
+      "pbm",
+      "pcx",
+      "pdb",
+      "pdf",
+      "pea",
+      "pgm",
+      "pic",
+      "png",
+      "pnm",
+      "pot",
+      "potm",
+      "potx",
+      "ppa",
+      "ppam",
+      "ppm",
+      "pps",
+      "ppsm",
+      "ppsx",
+      "ppt",
+      "pptm",
+      "pptx",
+      "psd",
+      "pya",
+      "pyc",
+      "pyo",
+      "pyv",
+      "qt",
+      "rar",
+      "ras",
+      "raw",
+      "resources",
+      "rgb",
+      "rip",
+      "rlc",
+      "rmf",
+      "rmvb",
+      "rpm",
+      "rtf",
+      "rz",
+      "s3m",
+      "s7z",
+      "scpt",
+      "sgi",
+      "shar",
+      "snap",
+      "sil",
+      "sketch",
+      "slk",
+      "smv",
+      "snk",
+      "so",
+      "stl",
+      "suo",
+      "sub",
+      "swf",
+      "tar",
+      "tbz",
+      "tbz2",
+      "tga",
+      "tgz",
+      "thmx",
+      "tif",
+      "tiff",
+      "tlz",
+      "ttc",
+      "ttf",
+      "txz",
+      "udf",
+      "uvh",
+      "uvi",
+      "uvm",
+      "uvp",
+      "uvs",
+      "uvu",
+      "viv",
+      "vob",
+      "war",
+      "wav",
+      "wax",
+      "wbmp",
+      "wdp",
+      "weba",
+      "webm",
+      "webp",
+      "whl",
+      "wim",
+      "wm",
+      "wma",
+      "wmv",
+      "wmx",
+      "woff",
+      "woff2",
+      "wrm",
+      "wvx",
+      "xbm",
+      "xif",
+      "xla",
+      "xlam",
+      "xls",
+      "xlsb",
+      "xlsm",
+      "xlsx",
+      "xlt",
+      "xltm",
+      "xltx",
+      "xm",
+      "xmind",
+      "xpi",
+      "xpm",
+      "xwd",
+      "xz",
+      "z",
+      "zip",
+      "zipx"
+    ]);
+    isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
+    foreach = (val, fn2) => {
+      if (val instanceof Set) {
+        val.forEach(fn2);
+      } else {
+        fn2(val);
+      }
+    };
+    addAndConvert = (main, prop, item) => {
+      let container = main[prop];
+      if (!(container instanceof Set)) {
+        main[prop] = container = /* @__PURE__ */ new Set([container]);
+      }
+      container.add(item);
+    };
+    clearItem = (cont) => (key) => {
+      const set2 = cont[key];
+      if (set2 instanceof Set) {
+        set2.clear();
+      } else {
+        delete cont[key];
+      }
+    };
+    delFromSet = (main, prop, item) => {
+      const container = main[prop];
+      if (container instanceof Set) {
+        container.delete(item);
+      } else if (container === item) {
+        delete main[prop];
+      }
+    };
+    isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+    FsWatchInstances = /* @__PURE__ */ new Map();
+    fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+      const cont = FsWatchInstances.get(fullPath);
+      if (!cont)
+        return;
+      foreach(cont[listenerType], (listener) => {
+        listener(val1, val2, val3);
+      });
+    };
+    setFsWatchListener = (path15, fullPath, options, handlers) => {
+      const { listener, errHandler, rawEmitter } = handlers;
+      let cont = FsWatchInstances.get(fullPath);
+      let watcher;
+      if (!options.persistent) {
+        watcher = createFsWatchInstance(path15, options, listener, errHandler, rawEmitter);
+        if (!watcher)
+          return;
+        return watcher.close.bind(watcher);
+      }
+      if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_ERR, errHandler);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+      } else {
+        watcher = createFsWatchInstance(
+          path15,
+          options,
+          fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+          errHandler,
+          // no need to use broadcast here
+          fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+        );
+        if (!watcher)
+          return;
+        watcher.on(EV.ERROR, async (error48) => {
+          const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+          if (cont)
+            cont.watcherUnusable = true;
+          if (isWindows && error48.code === "EPERM") {
+            try {
+              const fd = await (0, import_promises2.open)(path15, "r");
+              await fd.close();
+              broadcastErr(error48);
+            } catch (err) {
+            }
+          } else {
+            broadcastErr(error48);
+          }
+        });
+        cont = {
+          listeners: listener,
+          errHandlers: errHandler,
+          rawEmitters: rawEmitter,
+          watcher
+        };
+        FsWatchInstances.set(fullPath, cont);
+      }
+      return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_ERR, errHandler);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+          cont.watcher.close();
+          FsWatchInstances.delete(fullPath);
+          HANDLER_KEYS.forEach(clearItem(cont));
+          cont.watcher = void 0;
+          Object.freeze(cont);
+        }
+      };
+    };
+    FsWatchFileInstances = /* @__PURE__ */ new Map();
+    setFsWatchFileListener = (path15, fullPath, options, handlers) => {
+      const { listener, rawEmitter } = handlers;
+      let cont = FsWatchFileInstances.get(fullPath);
+      const copts = cont && cont.options;
+      if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+        (0, import_node_fs.unwatchFile)(fullPath);
+        cont = void 0;
+      }
+      if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+      } else {
+        cont = {
+          listeners: listener,
+          rawEmitters: rawEmitter,
+          options,
+          watcher: (0, import_node_fs.watchFile)(fullPath, options, (curr, prev) => {
+            foreach(cont.rawEmitters, (rawEmitter2) => {
+              rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+            });
+            const currmtime = curr.mtimeMs;
+            if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+              foreach(cont.listeners, (listener2) => listener2(path15, curr));
+            }
+          })
+        };
+        FsWatchFileInstances.set(fullPath, cont);
+      }
+      return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+          FsWatchFileInstances.delete(fullPath);
+          (0, import_node_fs.unwatchFile)(fullPath);
+          cont.options = cont.watcher = void 0;
+          Object.freeze(cont);
+        }
+      };
+    };
+    NodeFsHandler = class {
+      fsw;
+      _boundHandleError;
+      constructor(fsW) {
+        this.fsw = fsW;
+        this._boundHandleError = (error48) => fsW._handleError(error48);
+      }
+      /**
+       * Watch file for changes with fs_watchFile or fs_watch.
+       * @param path to file or dir
+       * @param listener on fs change
+       * @returns closer for the watcher instance
+       */
+      _watchWithNodeFs(path15, listener) {
+        const opts = this.fsw.options;
+        const directory = sp.dirname(path15);
+        const basename5 = sp.basename(path15);
+        const parent = this.fsw._getWatchedDir(directory);
+        parent.add(basename5);
+        const absolutePath = sp.resolve(path15);
+        const options = {
+          persistent: opts.persistent
+        };
+        if (!listener)
+          listener = EMPTY_FN;
+        let closer;
+        if (opts.usePolling) {
+          const enableBin = opts.interval !== opts.binaryInterval;
+          options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
+          closer = setFsWatchFileListener(path15, absolutePath, options, {
+            listener,
+            rawEmitter: this.fsw._emitRaw
+          });
+        } else {
+          closer = setFsWatchListener(path15, absolutePath, options, {
+            listener,
+            errHandler: this._boundHandleError,
+            rawEmitter: this.fsw._emitRaw
+          });
+        }
+        return closer;
+      }
+      /**
+       * Watch a file and emit add event if warranted.
+       * @returns closer for the watcher instance
+       */
+      _handleFile(file2, stats, initialAdd) {
+        if (this.fsw.closed) {
+          return;
+        }
+        const dirname8 = sp.dirname(file2);
+        const basename5 = sp.basename(file2);
+        const parent = this.fsw._getWatchedDir(dirname8);
+        let prevStats = stats;
+        if (parent.has(basename5))
+          return;
+        const listener = async (path15, newStats) => {
+          if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
+            return;
+          if (!newStats || newStats.mtimeMs === 0) {
+            try {
+              const newStats2 = await (0, import_promises2.stat)(file2);
+              if (this.fsw.closed)
+                return;
+              const at2 = newStats2.atimeMs;
+              const mt2 = newStats2.mtimeMs;
+              if (!at2 || at2 <= mt2 || mt2 !== prevStats.mtimeMs) {
+                this.fsw._emit(EV.CHANGE, file2, newStats2);
+              }
+              if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+                this.fsw._closeFile(path15);
+                prevStats = newStats2;
+                const closer2 = this._watchWithNodeFs(file2, listener);
+                if (closer2)
+                  this.fsw._addPathCloser(path15, closer2);
+              } else {
+                prevStats = newStats2;
+              }
+            } catch (error48) {
+              this.fsw._remove(dirname8, basename5);
+            }
+          } else if (parent.has(basename5)) {
+            const at2 = newStats.atimeMs;
+            const mt2 = newStats.mtimeMs;
+            if (!at2 || at2 <= mt2 || mt2 !== prevStats.mtimeMs) {
+              this.fsw._emit(EV.CHANGE, file2, newStats);
+            }
+            prevStats = newStats;
+          }
+        };
+        const closer = this._watchWithNodeFs(file2, listener);
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file2)) {
+          if (!this.fsw._throttle(EV.ADD, file2, 0))
+            return;
+          this.fsw._emit(EV.ADD, file2, stats);
+        }
+        return closer;
+      }
+      /**
+       * Handle symlinks encountered while reading a dir.
+       * @param entry returned by readdirp
+       * @param directory path of dir being read
+       * @param path of this item
+       * @param item basename of this item
+       * @returns true if no more processing is needed for this entry.
+       */
+      async _handleSymlink(entry, directory, path15, item) {
+        if (this.fsw.closed) {
+          return;
+        }
+        const full = entry.fullPath;
+        const dir = this.fsw._getWatchedDir(directory);
+        if (!this.fsw.options.followSymlinks) {
+          this.fsw._incrReadyCount();
+          let linkPath;
+          try {
+            linkPath = await (0, import_promises2.realpath)(path15);
+          } catch (e) {
+            this.fsw._emitReady();
+            return true;
+          }
+          if (this.fsw.closed)
+            return;
+          if (dir.has(item)) {
+            if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+              this.fsw._symlinkPaths.set(full, linkPath);
+              this.fsw._emit(EV.CHANGE, path15, entry.stats);
+            }
+          } else {
+            dir.add(item);
+            this.fsw._symlinkPaths.set(full, linkPath);
+            this.fsw._emit(EV.ADD, path15, entry.stats);
+          }
+          this.fsw._emitReady();
+          return true;
+        }
+        if (this.fsw._symlinkPaths.has(full)) {
+          return true;
+        }
+        this.fsw._symlinkPaths.set(full, true);
+      }
+      _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+        directory = sp.join(directory, "");
+        const throttleKey = target ? `${directory}:${target}` : directory;
+        throttler = this.fsw._throttle("readdir", throttleKey, 1e3);
+        if (!throttler)
+          return;
+        const previous = this.fsw._getWatchedDir(wh.path);
+        const current = /* @__PURE__ */ new Set();
+        let stream = this.fsw._readdirp(directory, {
+          fileFilter: (entry) => wh.filterPath(entry),
+          directoryFilter: (entry) => wh.filterDir(entry)
+        });
+        if (!stream)
+          return;
+        stream.on(STR_DATA, async (entry) => {
+          if (this.fsw.closed) {
+            stream = void 0;
+            return;
+          }
+          const item = entry.path;
+          let path15 = sp.join(directory, item);
+          current.add(item);
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path15, item)) {
+            return;
+          }
+          if (this.fsw.closed) {
+            stream = void 0;
+            return;
+          }
+          if (item === target || !target && !previous.has(item)) {
+            this.fsw._incrReadyCount();
+            path15 = sp.join(dir, sp.relative(dir, path15));
+            this._addToNodeFs(path15, initialAdd, wh, depth + 1);
+          }
+        }).on(EV.ERROR, this._boundHandleError);
+        return new Promise((resolve10, reject) => {
+          if (!stream)
+            return reject();
+          stream.once(STR_END, () => {
+            if (this.fsw.closed) {
+              stream = void 0;
+              return;
+            }
+            const wasThrottled = throttler ? throttler.clear() : false;
+            resolve10(void 0);
+            previous.getChildren().filter((item) => {
+              return item !== directory && !current.has(item);
+            }).forEach((item) => {
+              this.fsw._remove(directory, item);
+            });
+            stream = void 0;
+            if (wasThrottled)
+              this._handleRead(directory, false, wh, target, dir, depth, throttler);
+          });
+        });
+      }
+      /**
+       * Read directory to add / remove files from `@watched` list and re-read it on change.
+       * @param dir fs path
+       * @param stats
+       * @param initialAdd
+       * @param depth relative to user-supplied path
+       * @param target child path targeted for watch
+       * @param wh Common watch helpers for this path
+       * @param realpath
+       * @returns closer for the watcher instance.
+       */
+      async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+        const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+        const tracked = parentDir.has(sp.basename(dir));
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+          this.fsw._emit(EV.ADD_DIR, dir, stats);
+        }
+        parentDir.add(sp.basename(dir));
+        this.fsw._getWatchedDir(dir);
+        let throttler;
+        let closer;
+        const oDepth = this.fsw.options.depth;
+        if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+          if (!target) {
+            await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+            if (this.fsw.closed)
+              return;
+          }
+          closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+            if (stats2 && stats2.mtimeMs === 0)
+              return;
+            this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+          });
+        }
+        return closer;
+      }
+      /**
+       * Handle added file, directory, or glob pattern.
+       * Delegates call to _handleFile / _handleDir after checks.
+       * @param path to file or ir
+       * @param initialAdd was the file added at watch instantiation?
+       * @param priorWh depth relative to user-supplied path
+       * @param depth Child path actually targeted for watch
+       * @param target Child path actually targeted for watch
+       */
+      async _addToNodeFs(path15, initialAdd, priorWh, depth, target) {
+        const ready = this.fsw._emitReady;
+        if (this.fsw._isIgnored(path15) || this.fsw.closed) {
+          ready();
+          return false;
+        }
+        const wh = this.fsw._getWatchHelpers(path15);
+        if (priorWh) {
+          wh.filterPath = (entry) => priorWh.filterPath(entry);
+          wh.filterDir = (entry) => priorWh.filterDir(entry);
+        }
+        try {
+          const stats = await statMethods[wh.statMethod](wh.watchPath);
+          if (this.fsw.closed)
+            return;
+          if (this.fsw._isIgnored(wh.watchPath, stats)) {
+            ready();
+            return false;
+          }
+          const follow = this.fsw.options.followSymlinks;
+          let closer;
+          if (stats.isDirectory()) {
+            const absPath = sp.resolve(path15);
+            const targetPath = follow ? await (0, import_promises2.realpath)(path15) : path15;
+            if (this.fsw.closed)
+              return;
+            closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+            if (this.fsw.closed)
+              return;
+            if (absPath !== targetPath && targetPath !== void 0) {
+              this.fsw._symlinkPaths.set(absPath, targetPath);
+            }
+          } else if (stats.isSymbolicLink()) {
+            const targetPath = follow ? await (0, import_promises2.realpath)(path15) : path15;
+            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, path15, wh, targetPath);
+            if (this.fsw.closed)
+              return;
+            if (targetPath !== void 0) {
+              this.fsw._symlinkPaths.set(sp.resolve(path15), targetPath);
+            }
+          } else {
+            closer = this._handleFile(wh.watchPath, stats, initialAdd);
+          }
+          ready();
+          if (closer)
+            this.fsw._addPathCloser(path15, closer);
+          return false;
+        } catch (error48) {
+          if (this.fsw._handleError(error48)) {
+            ready();
+            return path15;
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../../oss/packages/daemon-core/node_modules/chokidar/index.js
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string4) => matcher === string4;
+  if (matcher instanceof RegExp)
+    return (string4) => matcher.test(string4);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string4) => {
+      if (matcher.path === string4)
+        return true;
+      if (matcher.recursive) {
+        const relative3 = sp2.relative(matcher.path, string4);
+        if (!relative3) {
+          return false;
+        }
+        return !relative3.startsWith("..") && !sp2.isAbsolute(relative3);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path15) {
+  if (typeof path15 !== "string")
+    throw new Error("string expected");
+  path15 = sp2.normalize(path15);
+  path15 = path15.replace(/\\/g, "/");
+  let prepend = false;
+  if (path15.startsWith("//"))
+    prepend = true;
+  path15 = path15.replace(DOUBLE_SLASH_RE, "/");
+  if (prepend)
+    path15 = "/" + path15;
+  return path15;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path15 = normalizePath(testString);
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path15, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+}
+var import_node_events, import_node_fs2, import_promises3, sp2, SLASH, SLASH_SLASH, ONE_DOT, TWO_DOTS, STRING_TYPE, BACK_SLASH_RE, DOUBLE_SLASH_RE, DOT_RE, REPLACER_RE, isMatcherObject, unifyPaths, toUnix, normalizePathToUnix, normalizeIgnored, getAbsolutePath, EMPTY_SET, DirEntry, STAT_METHOD_F, STAT_METHOD_L, WatchHelper, FSWatcher;
+var init_chokidar = __esm({
+  "../../oss/packages/daemon-core/node_modules/chokidar/index.js"() {
+    "use strict";
+    import_node_events = require("events");
+    import_node_fs2 = require("fs");
+    import_promises3 = require("fs/promises");
+    sp2 = __toESM(require("path"), 1);
+    init_readdirp();
+    init_handler2();
+    SLASH = "/";
+    SLASH_SLASH = "//";
+    ONE_DOT = ".";
+    TWO_DOTS = "..";
+    STRING_TYPE = "string";
+    BACK_SLASH_RE = /\\/g;
+    DOUBLE_SLASH_RE = /\/\//g;
+    DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+    REPLACER_RE = /^\.[/\\]/;
+    isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+    unifyPaths = (paths_) => {
+      const paths = arrify(paths_).flat();
+      if (!paths.every((p) => typeof p === STRING_TYPE)) {
+        throw new TypeError(`Non-string provided as watch path: ${paths}`);
+      }
+      return paths.map(normalizePathToUnix);
+    };
+    toUnix = (string4) => {
+      let str = string4.replace(BACK_SLASH_RE, SLASH);
+      let prepend = false;
+      if (str.startsWith(SLASH_SLASH)) {
+        prepend = true;
+      }
+      str = str.replace(DOUBLE_SLASH_RE, SLASH);
+      if (prepend) {
+        str = SLASH + str;
+      }
+      return str;
+    };
+    normalizePathToUnix = (path15) => toUnix(sp2.normalize(toUnix(path15)));
+    normalizeIgnored = (cwd = "") => (path15) => {
+      if (typeof path15 === "string") {
+        return normalizePathToUnix(sp2.isAbsolute(path15) ? path15 : sp2.join(cwd, path15));
+      } else {
+        return path15;
+      }
+    };
+    getAbsolutePath = (path15, cwd) => {
+      if (sp2.isAbsolute(path15)) {
+        return path15;
+      }
+      return sp2.join(cwd, path15);
+    };
+    EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+    DirEntry = class {
+      path;
+      _removeWatcher;
+      items;
+      constructor(dir, removeWatcher) {
+        this.path = dir;
+        this._removeWatcher = removeWatcher;
+        this.items = /* @__PURE__ */ new Set();
+      }
+      add(item) {
+        const { items } = this;
+        if (!items)
+          return;
+        if (item !== ONE_DOT && item !== TWO_DOTS)
+          items.add(item);
+      }
+      async remove(item) {
+        const { items } = this;
+        if (!items)
+          return;
+        items.delete(item);
+        if (items.size > 0)
+          return;
+        const dir = this.path;
+        try {
+          await (0, import_promises3.readdir)(dir);
+        } catch (err) {
+          if (this._removeWatcher) {
+            this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
+          }
+        }
+      }
+      has(item) {
+        const { items } = this;
+        if (!items)
+          return;
+        return items.has(item);
+      }
+      getChildren() {
+        const { items } = this;
+        if (!items)
+          return [];
+        return [...items.values()];
+      }
+      dispose() {
+        this.items.clear();
+        this.path = "";
+        this._removeWatcher = EMPTY_FN;
+        this.items = EMPTY_SET;
+        Object.freeze(this);
+      }
+    };
+    STAT_METHOD_F = "stat";
+    STAT_METHOD_L = "lstat";
+    WatchHelper = class {
+      fsw;
+      path;
+      watchPath;
+      fullWatchPath;
+      dirParts;
+      followSymlinks;
+      statMethod;
+      constructor(path15, follow, fsw) {
+        this.fsw = fsw;
+        const watchPath = path15;
+        this.path = path15 = path15.replace(REPLACER_RE, "");
+        this.watchPath = watchPath;
+        this.fullWatchPath = sp2.resolve(watchPath);
+        this.dirParts = [];
+        this.dirParts.forEach((parts) => {
+          if (parts.length > 1)
+            parts.pop();
+        });
+        this.followSymlinks = follow;
+        this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+      }
+      entryPath(entry) {
+        return sp2.join(this.watchPath, sp2.relative(this.watchPath, entry.fullPath));
+      }
+      filterPath(entry) {
+        const { stats } = entry;
+        if (stats && stats.isSymbolicLink())
+          return this.filterDir(entry);
+        const resolvedPath = this.entryPath(entry);
+        return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+      }
+      filterDir(entry) {
+        return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+      }
+    };
+    FSWatcher = class extends import_node_events.EventEmitter {
+      closed;
+      options;
+      _closers;
+      _ignoredPaths;
+      _throttled;
+      _streams;
+      _symlinkPaths;
+      _watched;
+      _pendingWrites;
+      _pendingUnlinks;
+      _readyCount;
+      _emitReady;
+      _closePromise;
+      _userIgnored;
+      _readyEmitted;
+      _emitRaw;
+      _boundRemove;
+      _nodeFsHandler;
+      // Not indenting methods for history sake; for now.
+      constructor(_opts = {}) {
+        super();
+        this.closed = false;
+        this._closers = /* @__PURE__ */ new Map();
+        this._ignoredPaths = /* @__PURE__ */ new Set();
+        this._throttled = /* @__PURE__ */ new Map();
+        this._streams = /* @__PURE__ */ new Set();
+        this._symlinkPaths = /* @__PURE__ */ new Map();
+        this._watched = /* @__PURE__ */ new Map();
+        this._pendingWrites = /* @__PURE__ */ new Map();
+        this._pendingUnlinks = /* @__PURE__ */ new Map();
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        const awf = _opts.awaitWriteFinish;
+        const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
+        const opts = {
+          // Defaults
+          persistent: true,
+          ignoreInitial: false,
+          ignorePermissionErrors: false,
+          interval: 100,
+          binaryInterval: 300,
+          followSymlinks: true,
+          usePolling: false,
+          // useAsync: false,
+          atomic: true,
+          // NOTE: overwritten later (depends on usePolling)
+          ..._opts,
+          // Change format
+          ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+          awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+        };
+        if (isIBMi)
+          opts.usePolling = true;
+        if (opts.atomic === void 0)
+          opts.atomic = !opts.usePolling;
+        const envPoll = process.env.CHOKIDAR_USEPOLLING;
+        if (envPoll !== void 0) {
+          const envLower = envPoll.toLowerCase();
+          if (envLower === "false" || envLower === "0")
+            opts.usePolling = false;
+          else if (envLower === "true" || envLower === "1")
+            opts.usePolling = true;
+          else
+            opts.usePolling = !!envLower;
+        }
+        const envInterval = process.env.CHOKIDAR_INTERVAL;
+        if (envInterval)
+          opts.interval = Number.parseInt(envInterval, 10);
+        let readyCalls = 0;
+        this._emitReady = () => {
+          readyCalls++;
+          if (readyCalls >= this._readyCount) {
+            this._emitReady = EMPTY_FN;
+            this._readyEmitted = true;
+            process.nextTick(() => this.emit(EVENTS.READY));
+          }
+        };
+        this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+        this._boundRemove = this._remove.bind(this);
+        this.options = opts;
+        this._nodeFsHandler = new NodeFsHandler(this);
+        Object.freeze(opts);
+      }
+      _addIgnoredPath(matcher) {
+        if (isMatcherObject(matcher)) {
+          for (const ignored of this._ignoredPaths) {
+            if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+              return;
+            }
+          }
+        }
+        this._ignoredPaths.add(matcher);
+      }
+      _removeIgnoredPath(matcher) {
+        this._ignoredPaths.delete(matcher);
+        if (typeof matcher === "string") {
+          for (const ignored of this._ignoredPaths) {
+            if (isMatcherObject(ignored) && ignored.path === matcher) {
+              this._ignoredPaths.delete(ignored);
+            }
+          }
+        }
+      }
+      // Public methods
+      /**
+       * Adds paths to be watched on an existing FSWatcher instance.
+       * @param paths_ file or file list. Other arguments are unused
+       */
+      add(paths_, _origAdd, _internal) {
+        const { cwd } = this.options;
+        this.closed = false;
+        this._closePromise = void 0;
+        let paths = unifyPaths(paths_);
+        if (cwd) {
+          paths = paths.map((path15) => {
+            const absPath = getAbsolutePath(path15, cwd);
+            return absPath;
+          });
+        }
+        paths.forEach((path15) => {
+          this._removeIgnoredPath(path15);
+        });
+        this._userIgnored = void 0;
+        if (!this._readyCount)
+          this._readyCount = 0;
+        this._readyCount += paths.length;
+        Promise.all(paths.map(async (path15) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path15, !_internal, void 0, 0, _origAdd);
+          if (res)
+            this._emitReady();
+          return res;
+        })).then((results) => {
+          if (this.closed)
+            return;
+          results.forEach((item) => {
+            if (item)
+              this.add(sp2.dirname(item), sp2.basename(_origAdd || item));
+          });
+        });
+        return this;
+      }
+      /**
+       * Close watchers or start ignoring events from specified paths.
+       */
+      unwatch(paths_) {
+        if (this.closed)
+          return this;
+        const paths = unifyPaths(paths_);
+        const { cwd } = this.options;
+        paths.forEach((path15) => {
+          if (!sp2.isAbsolute(path15) && !this._closers.has(path15)) {
+            if (cwd)
+              path15 = sp2.join(cwd, path15);
+            path15 = sp2.resolve(path15);
+          }
+          this._closePath(path15);
+          this._addIgnoredPath(path15);
+          if (this._watched.has(path15)) {
+            this._addIgnoredPath({
+              path: path15,
+              recursive: true
+            });
+          }
+          this._userIgnored = void 0;
+        });
+        return this;
+      }
+      /**
+       * Close watchers and remove all listeners from watched paths.
+       */
+      close() {
+        if (this._closePromise) {
+          return this._closePromise;
+        }
+        this.closed = true;
+        this.removeAllListeners();
+        const closers = [];
+        this._closers.forEach((closerList) => closerList.forEach((closer) => {
+          const promise2 = closer();
+          if (promise2 instanceof Promise)
+            closers.push(promise2);
+        }));
+        this._streams.forEach((stream) => stream.destroy());
+        this._userIgnored = void 0;
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        this._watched.forEach((dirent) => dirent.dispose());
+        this._closers.clear();
+        this._watched.clear();
+        this._streams.clear();
+        this._symlinkPaths.clear();
+        this._throttled.clear();
+        this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+        return this._closePromise;
+      }
+      /**
+       * Expose list of watched paths
+       * @returns for chaining
+       */
+      getWatched() {
+        const watchList = {};
+        this._watched.forEach((entry, dir) => {
+          const key = this.options.cwd ? sp2.relative(this.options.cwd, dir) : dir;
+          const index = key || ONE_DOT;
+          watchList[index] = entry.getChildren().sort();
+        });
+        return watchList;
+      }
+      emitWithAll(event, args) {
+        this.emit(event, ...args);
+        if (event !== EVENTS.ERROR)
+          this.emit(EVENTS.ALL, event, ...args);
+      }
+      // Common helpers
+      // --------------
+      /**
+       * Normalize and emit events.
+       * Calling _emit DOES NOT MEAN emit() would be called!
+       * @param event Type of event
+       * @param path File or directory path
+       * @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, path15, stats) {
+        if (this.closed)
+          return;
+        const opts = this.options;
+        if (isWindows)
+          path15 = sp2.normalize(path15);
+        if (opts.cwd)
+          path15 = sp2.relative(opts.cwd, path15);
+        const args = [path15];
+        if (stats != null)
+          args.push(stats);
+        const awf = opts.awaitWriteFinish;
+        let pw;
+        if (awf && (pw = this._pendingWrites.get(path15))) {
+          pw.lastChange = /* @__PURE__ */ new Date();
+          return this;
+        }
+        if (opts.atomic) {
+          if (event === EVENTS.UNLINK) {
+            this._pendingUnlinks.set(path15, [event, ...args]);
+            setTimeout(() => {
+              this._pendingUnlinks.forEach((entry, path16) => {
+                this.emit(...entry);
+                this.emit(EVENTS.ALL, ...entry);
+                this._pendingUnlinks.delete(path16);
+              });
+            }, typeof opts.atomic === "number" ? opts.atomic : 100);
+            return this;
+          }
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path15)) {
+            event = EVENTS.CHANGE;
+            this._pendingUnlinks.delete(path15);
+          }
+        }
+        if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+          const awfEmit = (err, stats2) => {
+            if (err) {
+              event = EVENTS.ERROR;
+              args[0] = err;
+              this.emitWithAll(event, args);
+            } else if (stats2) {
+              if (args.length > 1) {
+                args[1] = stats2;
+              } else {
+                args.push(stats2);
+              }
+              this.emitWithAll(event, args);
+            }
+          };
+          this._awaitWriteFinish(path15, awf.stabilityThreshold, event, awfEmit);
+          return this;
+        }
+        if (event === EVENTS.CHANGE) {
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path15, 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, path15) : path15;
+          let stats2;
+          try {
+            stats2 = await (0, import_promises3.stat)(fullPath);
+          } catch (err) {
+          }
+          if (!stats2 || this.closed)
+            return;
+          args.push(stats2);
+        }
+        this.emitWithAll(event, args);
+        return this;
+      }
+      /**
+       * Common handler for errors
+       * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+       */
+      _handleError(error48) {
+        const code = error48 && error48.code;
+        if (error48 && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+          this.emit(EVENTS.ERROR, error48);
+        }
+        return error48 || this.closed;
+      }
+      /**
+       * Helper utility for throttling
+       * @param actionType type being throttled
+       * @param path being acted upon
+       * @param timeout duration of time to suppress duplicate actions
+       * @returns tracking object or false if action should be suppressed
+       */
+      _throttle(actionType, path15, 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(path15);
+        if (actionPath) {
+          actionPath.count++;
+          return false;
+        }
+        let timeoutObject;
+        const clear = () => {
+          const item = action.get(path15);
+          const count = item ? item.count : 0;
+          action.delete(path15);
+          clearTimeout(timeoutObject);
+          if (item)
+            clearTimeout(item.timeoutObject);
+          return count;
+        };
+        timeoutObject = setTimeout(clear, timeout);
+        const thr = { timeoutObject, clear, count: 0 };
+        action.set(path15, thr);
+        return thr;
+      }
+      _incrReadyCount() {
+        return this._readyCount++;
+      }
+      /**
+       * Awaits write operation to finish.
+       * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+       * @param path being acted upon
+       * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+       * @param event
+       * @param awfEmit Callback to be called when ready for event to be emitted.
+       */
+      _awaitWriteFinish(path15, threshold, event, awfEmit) {
+        const awf = this.options.awaitWriteFinish;
+        if (typeof awf !== "object")
+          return;
+        const pollInterval = awf.pollInterval;
+        let timeoutHandler;
+        let fullPath = path15;
+        if (this.options.cwd && !sp2.isAbsolute(path15)) {
+          fullPath = sp2.join(this.options.cwd, path15);
+        }
+        const now = /* @__PURE__ */ new Date();
+        const writes = this._pendingWrites;
+        function awaitWriteFinishFn(prevStat) {
+          (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
+            if (err || !writes.has(path15)) {
+              if (err && err.code !== "ENOENT")
+                awfEmit(err);
+              return;
+            }
+            const now2 = Number(/* @__PURE__ */ new Date());
+            if (prevStat && curStat.size !== prevStat.size) {
+              writes.get(path15).lastChange = now2;
+            }
+            const pw = writes.get(path15);
+            const df = now2 - pw.lastChange;
+            if (df >= threshold) {
+              writes.delete(path15);
+              awfEmit(void 0, curStat);
+            } else {
+              timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+            }
+          });
+        }
+        if (!writes.has(path15)) {
+          writes.set(path15, {
+            lastChange: now,
+            cancelWait: () => {
+              writes.delete(path15);
+              clearTimeout(timeoutHandler);
+              return event;
+            }
+          });
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+        }
+      }
+      /**
+       * Determines whether user has asked to ignore this path.
+       */
+      _isIgnored(path15, stats) {
+        if (this.options.atomic && DOT_RE.test(path15))
+          return true;
+        if (!this._userIgnored) {
+          const { cwd } = this.options;
+          const ign = this.options.ignored;
+          const ignored = (ign || []).map(normalizeIgnored(cwd));
+          const ignoredPaths = [...this._ignoredPaths];
+          const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+          this._userIgnored = anymatch(list, void 0);
+        }
+        return this._userIgnored(path15, stats);
+      }
+      _isntIgnored(path15, stat4) {
+        return !this._isIgnored(path15, stat4);
+      }
+      /**
+       * Provides a set of common helpers and properties relating to symlink handling.
+       * @param path file or directory pattern being watched
+       */
+      _getWatchHelpers(path15) {
+        return new WatchHelper(path15, this.options.followSymlinks, this);
+      }
+      // Directory helpers
+      // -----------------
+      /**
+       * Provides directory tracking objects
+       * @param directory path of the directory
+       */
+      _getWatchedDir(directory) {
+        const dir = sp2.resolve(directory);
+        if (!this._watched.has(dir))
+          this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+        return this._watched.get(dir);
+      }
+      // File helpers
+      // ------------
+      /**
+       * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+       */
+      _hasReadPermissions(stats) {
+        if (this.options.ignorePermissionErrors)
+          return true;
+        return Boolean(Number(stats.mode) & 256);
+      }
+      /**
+       * Handles emitting unlink events for
+       * files and directories, and via recursion, for
+       * files and directories within directories that are unlinked
+       * @param directory within which the following item is located
+       * @param item      base path of item/directory
+       */
+      _remove(directory, item, isDirectory) {
+        const path15 = sp2.join(directory, item);
+        const fullPath = sp2.resolve(path15);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path15) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path15, 100))
+          return;
+        if (!isDirectory && this._watched.size === 1) {
+          this.add(directory, item, true);
+        }
+        const wp = this._getWatchedDir(path15);
+        const nestedDirectoryChildren = wp.getChildren();
+        nestedDirectoryChildren.forEach((nested) => this._remove(path15, 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 = path15;
+        if (this.options.cwd)
+          relPath = sp2.relative(this.options.cwd, path15);
+        if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+          const event = this._pendingWrites.get(relPath).cancelWait();
+          if (event === EVENTS.ADD)
+            return;
+        }
+        this._watched.delete(path15);
+        this._watched.delete(fullPath);
+        const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+        if (wasTracked && !this._isIgnored(path15))
+          this._emit(eventName, path15);
+        this._closePath(path15);
+      }
+      /**
+       * Closes all watchers for a path
+       */
+      _closePath(path15) {
+        this._closeFile(path15);
+        const dir = sp2.dirname(path15);
+        this._getWatchedDir(dir).remove(sp2.basename(path15));
+      }
+      /**
+       * Closes only file-specific watchers
+       */
+      _closeFile(path15) {
+        const closers = this._closers.get(path15);
+        if (!closers)
+          return;
+        closers.forEach((closer) => closer());
+        this._closers.delete(path15);
+      }
+      _addPathCloser(path15, closer) {
+        if (!closer)
+          return;
+        let list = this._closers.get(path15);
+        if (!list) {
+          list = [];
+          this._closers.set(path15, list);
+        }
+        list.push(closer);
+      }
+      _readdirp(root, opts) {
+        if (this.closed)
+          return;
+        const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+        let stream = readdirp(root, options);
+        this._streams.add(stream);
+        stream.once(STR_CLOSE, () => {
+          stream = void 0;
+        });
+        stream.once(STR_END, () => {
+          if (stream) {
+            this._streams.delete(stream);
+            stream = void 0;
+          }
+        });
+        return stream;
+      }
+    };
+  }
+});
+
 // ../../oss/packages/daemon-core/src/providers/provider-loader.ts
 var fs5, path6, os7, ProviderLoader;
 var init_provider_loader = __esm({
@@ -5141,11 +6890,11 @@ var init_provider_loader = __esm({
     fs5 = __toESM(require("fs"));
     path6 = __toESM(require("path"));
     os7 = __toESM(require("os"));
+    init_chokidar();
     init_ide_detector();
     init_logger();
     ProviderLoader = class _ProviderLoader {
       providers = /* @__PURE__ */ new Map();
-      builtinDirs;
       userDir;
       upstreamDir;
       disableUpstream;
@@ -5160,36 +6909,31 @@ var init_provider_loader = __esm({
       static GITHUB_TARBALL_URL = "https://github.com/vilmire/adhdev-providers/archive/refs/heads/main.tar.gz";
       static META_FILE = ".meta.json";
       constructor(options) {
-        if (options?.builtinDir) {
-          this.builtinDirs = Array.isArray(options.builtinDir) ? options.builtinDir : [options.builtinDir];
+        this.logFn = options?.logFn || LOG.forComponent("Provider").asLogFn();
+        const defaultProvidersDir = path6.join(os7.homedir(), ".adhdev", "providers");
+        if (options?.userDir) {
+          this.userDir = options.userDir;
+          this.log(`Config 'providerDir' applied: ${this.userDir}`);
         } else {
-          this.builtinDirs = [];
+          const localRepoPath = path6.resolve(__dirname, "../../../../../adhdev-providers");
+          if (fs5.existsSync(localRepoPath)) {
+            this.userDir = localRepoPath;
+            this.log(`Auto-detected local public repository: ${this.userDir} (Dev workspace speedup)`);
+          } else {
+            this.userDir = defaultProvidersDir;
+            this.log(`Using default user providers directory: ${this.userDir}`);
+          }
         }
-        const defaultProvidersDir = path6.join(os7.homedir(), ".adhdev", "providers");
-        this.userDir = options?.userDir || defaultProvidersDir;
         this.upstreamDir = path6.join(defaultProvidersDir, ".upstream");
         this.disableUpstream = options?.disableUpstream ?? false;
-        this.logFn = options?.logFn || LOG.forComponent("Provider").asLogFn();
       }
       log(msg) {
         this.logFn(`[ProviderLoader] ${msg}`);
       }
       // ─── Public API ────────────────────────────────
       /**
-      * Ordered builtin roots used for local fallback/reference data.
-      */
-      getBuiltinDirs() {
-        return [...this.builtinDirs];
-      }
-      /**
-      * Primary builtin root used for local scaffolding/reference flows.
-      */
-      getPrimaryBuiltinDir() {
-        return this.builtinDirs[0];
-      }
-      /**
-      * User override root (~/.adhdev/providers by default).
-      */
+       * User override root (~/.adhdev/providers by default).
+       */
       getUserDir() {
         return this.userDir;
       }
@@ -5200,11 +6944,11 @@ var init_provider_loader = __esm({
         return this.upstreamDir;
       }
       /**
-      * Provider search order for on-disk lookups.
-      * Highest-priority editable overrides come first.
-      */
+       * Provider search order for on-disk lookups.
+       * Highest-priority editable overrides come first.
+       */
       getProviderRoots() {
-        return [this.userDir, this.upstreamDir, ...this.builtinDirs];
+        return [this.userDir, this.upstreamDir];
       }
       /**
       * Canonical provider directory shape for a given root.
@@ -5225,16 +6969,9 @@ var init_provider_loader = __esm({
         return this.getProviderDir(this.upstreamDir, category, type);
       }
       /**
-       * Canonical builtin directory for a provider.
+       * Find the on-disk directory for a provider by type.
+       * Search order: user override → upstream.
        */
-      getBuiltinProviderDir(category, type) {
-        const builtinRoot = this.getPrimaryBuiltinDir();
-        return builtinRoot ? this.getProviderDir(builtinRoot, category, type) : "";
-      }
-      /**
-      * Find the on-disk directory for a provider by type.
-      * Search order: user override → upstream → builtin fallback.
-      */
       findProviderDir(type) {
         return this.findProviderDirInternal(type);
       }
@@ -5599,13 +7336,12 @@ var init_provider_loader = __esm({
           }
         }
         const result = this.buildScriptWrappersFromDir(dir);
-        this.log(`  [loadScriptsFromDir] ${type}: built wrappers from ${dir} (${Object.keys(result).length} scripts)`);
         this.scriptsCache.set(dir, result);
         return result;
       }
       /**
-      * Hot-reload: start watching for file changes
-      */
+       * Hot-reload: start watching for file changes
+       */
       watch() {
         this.stopWatch();
         const watchDir = (dir) => {
@@ -5617,18 +7353,27 @@ var init_provider_loader = __esm({
             }
           }
           try {
-            const watcher = fs5.watch(dir, { recursive: true }, (event, filename) => {
-              if (filename?.endsWith(".js") || filename?.endsWith(".json")) {
-                this.log(`File changed: ${filename}, reloading...`);
-                this.loadAll();
-              }
+            const watcher = watch(dir, {
+              ignored: /(^|[\/\\])\.\./,
+              // ignore dotfiles
+              persistent: true,
+              ignoreInitial: true,
+              awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
             });
+            const handleChange = (filePath) => {
+              if (filePath.endsWith(".js") || filePath.endsWith(".json")) {
+                this.log(`File changed: ${path6.basename(filePath)}, reloading...`);
+                this.reload();
+              }
+            };
+            watcher.on("add", handleChange).on("change", handleChange).on("unlink", handleChange);
+            watcher.on("error", (err) => this.log(`Watch error: ${err.message}`));
             this.watchers.push(watcher);
+            this.log(`Hot-reload watcher active: ${dir}`);
           } catch (e) {
             this.log(`Watch failed for ${dir}: ${e.message}`);
           }
         };
-        this.builtinDirs.forEach((dir) => watchDir(dir));
         watchDir(this.userDir);
       }
       /**
@@ -5689,7 +7434,7 @@ var init_provider_loader = __esm({
           return { updated: false };
         }
         try {
-          const etag = await new Promise((resolve7, reject) => {
+          const etag = await new Promise((resolve10, reject) => {
             const options = {
               method: "HEAD",
               hostname: "github.com",
@@ -5707,7 +7452,7 @@ var init_provider_loader = __esm({
                   headers: { "User-Agent": "adhdev-launcher" },
                   timeout: 1e4
                 }, (res2) => {
-                  resolve7(res2.headers.etag || res2.headers["last-modified"] || "");
+                  resolve10(res2.headers.etag || res2.headers["last-modified"] || "");
                 });
                 req2.on("error", reject);
                 req2.on("timeout", () => {
@@ -5716,7 +7461,7 @@ var init_provider_loader = __esm({
                 });
                 req2.end();
               } else {
-                resolve7(res.headers.etag || res.headers["last-modified"] || "");
+                resolve10(res.headers.etag || res.headers["last-modified"] || "");
               }
             });
             req.on("error", reject);
@@ -5780,7 +7525,7 @@ var init_provider_loader = __esm({
       downloadFile(url2, destPath) {
         const https = require("https");
         const http3 = require("http");
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve10, reject) => {
           const doRequest = (reqUrl, redirectCount = 0) => {
             if (redirectCount > 5) {
               reject(new Error("Too many redirects"));
@@ -5800,7 +7545,7 @@ var init_provider_loader = __esm({
               res.pipe(ws2);
               ws2.on("finish", () => {
                 ws2.close();
-                resolve7();
+                resolve10();
               });
               ws2.on("error", reject);
             });
@@ -6072,8 +7817,8 @@ var init_provider_loader = __esm({
                 const existed = this.providers.has(mod.type);
                 this.providers.set(mod.type, mod);
                 count++;
-                const source = d.startsWith(this.userDir) && !d.includes(".upstream") ? "user" : d.startsWith(this.upstreamDir) ? "upstream" : "builtin";
-                const overrideWarning = existed && source === "user" ? " \u26A0 OVERRIDES builtin/upstream" : "";
+                const source = d.startsWith(this.userDir) && !d.includes(".upstream") ? "user" : "upstream";
+                const overrideWarning = existed && source === "user" ? " \u26A0 OVERRIDES upstream" : "";
                 this.log(`  ${existed ? "\u{1F504}" : "\u2705"} ${mod.type} (${mod.category}) \u2014 ${mod.name} [${source}]${overrideWarning}`);
               }
             } catch (e) {
@@ -6120,9 +7865,9 @@ var init_provider_loader = __esm({
         }
       }
       compareVersions(a, b2) {
-        const normalize2 = (v2) => v2.split(/[-_+]/)[0].split(".").map((x) => parseInt(x, 10) || 0);
-        const pa2 = normalize2(a);
-        const pb = normalize2(b2);
+        const normalize3 = (v2) => v2.split(/[-_+]/)[0].split(".").map((x) => parseInt(x, 10) || 0);
+        const pa2 = normalize3(a);
+        const pb = normalize3(b2);
         for (let i = 0; i < Math.max(pa2.length, pb.length); i++) {
           const va2 = pa2[i] || 0;
           const vb = pb[i] || 0;
@@ -6166,17 +7911,17 @@ async function findFreePort(ports) {
   throw new Error("No free port found");
 }
 function checkPortFree(port) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve10) => {
     const server = net.createServer();
     server.unref();
-    server.on("error", () => resolve7(false));
+    server.on("error", () => resolve10(false));
     server.listen(port, "127.0.0.1", () => {
-      server.close(() => resolve7(true));
+      server.close(() => resolve10(true));
     });
   });
 }
 async function isCdpActive(port) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve10) => {
     const req = require("http").get(`http://127.0.0.1:${port}/json/version`, {
       timeout: 2e3
     }, (res) => {
@@ -6185,16 +7930,16 @@ async function isCdpActive(port) {
       res.on("end", () => {
         try {
           const info = JSON.parse(data);
-          resolve7(!!info["WebKit-Version"] || !!info["Browser"]);
+          resolve10(!!info["WebKit-Version"] || !!info["Browser"]);
         } catch {
-          resolve7(false);
+          resolve10(false);
         }
       });
     });
-    req.on("error", () => resolve7(false));
+    req.on("error", () => resolve10(false));
     req.on("timeout", () => {
       req.destroy();
-      resolve7(false);
+      resolve10(false);
     });
   });
 }
@@ -6539,8 +8284,8 @@ function cleanOldFiles() {
 }
 function checkSize() {
   try {
-    const stat = fs6.statSync(currentFile);
-    if (stat.size > MAX_FILE_SIZE) {
+    const stat4 = fs6.statSync(currentFile);
+    if (stat4.size > MAX_FILE_SIZE) {
       const backup = currentFile.replace(".jsonl", ".1.jsonl");
       try {
         fs6.unlinkSync(backup);
@@ -16523,9 +18268,9 @@ var init_provider_cli_adapter = __esm({
           const platformArch = `${os12.platform()}-${os12.arch()}`;
           const helper = path9.join(ptyDir, "prebuilds", platformArch, "spawn-helper");
           if (fs13.existsSync(helper)) {
-            const stat = fs13.statSync(helper);
-            if (!(stat.mode & 73)) {
-              fs13.chmodSync(helper, stat.mode | 493);
+            const stat4 = fs13.statSync(helper);
+            if (!(stat4.mode & 73)) {
+              fs13.chmodSync(helper, stat4.mode | 493);
               LOG.info("CLI", "[node-pty] Fixed spawn-helper permissions");
             }
           }
@@ -16588,6 +18333,8 @@ var init_provider_cli_adapter = __esm({
       spawnAt = 0;
       // PTY I/O
       onPtyDataCallback = null;
+      pendingOutputParseBuffer = "";
+      pendingOutputParseTimer = null;
       ptyOutputBuffer = "";
       ptyOutputFlushTimer = null;
       // Server log forwarding
@@ -16683,6 +18430,16 @@ var init_provider_cli_adapter = __esm({
       setOnPtyData(callback) {
         this.onPtyDataCallback = callback;
       }
+      flushPendingOutputParse() {
+        if (this.pendingOutputParseTimer) {
+          clearTimeout(this.pendingOutputParseTimer);
+          this.pendingOutputParseTimer = null;
+        }
+        if (!this.pendingOutputParseBuffer) return;
+        const rawData = this.pendingOutputParseBuffer;
+        this.pendingOutputParseBuffer = "";
+        this.handleOutput(rawData);
+      }
       async spawn() {
         if (this.ptyProcess) return;
         if (!pty) throw new Error("node-pty is not installed");
@@ -16731,7 +18488,17 @@ var init_provider_cli_adapter = __esm({
           }
         }
         this.ptyProcess.onData((data) => {
-          this.handleOutput(data);
+          if (Date.now() < this.resizeSuppressUntil) return;
+          if (data.includes("\x1B[6n") || data.includes("\x1B[?6n")) {
+            this.ptyProcess?.write("\x1B[1;1R");
+          }
+          this.pendingOutputParseBuffer += data;
+          if (!this.pendingOutputParseTimer) {
+            this.pendingOutputParseTimer = setTimeout(() => {
+              this.pendingOutputParseTimer = null;
+              this.flushPendingOutputParse();
+            }, this.timeouts.ptyFlush);
+          }
           if (this.onPtyDataCallback) {
             this.ptyOutputBuffer += data;
             if (!this.ptyOutputFlushTimer) {
@@ -16747,6 +18514,7 @@ var init_provider_cli_adapter = __esm({
         });
         this.ptyProcess.onExit(({ exitCode }) => {
           LOG.info("CLI", `[${this.cliType}] Exit code ${exitCode}`);
+          this.flushPendingOutputParse();
           this.ptyProcess = null;
           this.setStatus("stopped", "pty_exit");
           this.ready = false;
@@ -16766,10 +18534,6 @@ var init_provider_cli_adapter = __esm({
       }
       // ─── Output Handling ────────────────────────────
       handleOutput(rawData) {
-        if (Date.now() < this.resizeSuppressUntil) return;
-        if (rawData.includes("\x1B[6n") || rawData.includes("\x1B[?6n")) {
-          this.ptyProcess?.write("\x1B[1;1R");
-        }
         this.terminalScreen.write(rawData);
         this.terminalHistory = mergeTerminalHistory(this.terminalHistory, this.terminalScreen.getText());
         const cleanData = stripAnsi(rawData);
@@ -17120,7 +18884,7 @@ ${data.message || ""}`.trim();
         if (this.startupParseGate) {
           const deadline = Date.now() + 1e4;
           while (this.startupParseGate && Date.now() < deadline) {
-            await new Promise((resolve7) => setTimeout(resolve7, 50));
+            await new Promise((resolve10) => setTimeout(resolve10, 50));
           }
         }
         if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.currentStatus})`);
@@ -17257,6 +19021,16 @@ ${data.message || ""}`.trim();
           clearTimeout(this.submitRetryTimer);
           this.submitRetryTimer = null;
         }
+        if (this.pendingOutputParseTimer) {
+          clearTimeout(this.pendingOutputParseTimer);
+          this.pendingOutputParseTimer = null;
+        }
+        this.pendingOutputParseBuffer = "";
+        if (this.ptyOutputFlushTimer) {
+          clearTimeout(this.ptyOutputFlushTimer);
+          this.ptyOutputFlushTimer = null;
+        }
+        this.ptyOutputBuffer = "";
         if (this.ptyProcess) {
           this.ptyProcess.write("");
           setTimeout(() => {
@@ -17282,6 +19056,16 @@ ${data.message || ""}`.trim();
         this.currentTurnScope = null;
         this.submitRetryUsed = false;
         this.submitRetryPromptSnippet = "";
+        if (this.pendingOutputParseTimer) {
+          clearTimeout(this.pendingOutputParseTimer);
+          this.pendingOutputParseTimer = null;
+        }
+        this.pendingOutputParseBuffer = "";
+        if (this.ptyOutputFlushTimer) {
+          clearTimeout(this.ptyOutputFlushTimer);
+          this.ptyOutputFlushTimer = null;
+        }
+        this.ptyOutputBuffer = "";
         this.terminalScreen.reset();
         this.onStatusChange?.();
       }
@@ -17359,6 +19143,8 @@ ${data.message || ""}`.trim();
           scriptNames: Object.keys(this.cliScripts).filter((k) => typeof this.cliScripts[k] === "function"),
           statusHistory: this.statusHistory.slice(-30),
           timeouts: this.timeouts,
+          pendingOutputParseBufferLength: this.pendingOutputParseBuffer.length,
+          pendingOutputParseScheduled: !!this.pendingOutputParseTimer,
           ptyAlive: !!this.ptyProcess
         };
       }
@@ -33663,8 +35449,8 @@ var init_acp = __esm({
         this.#requestHandler = requestHandler;
         this.#notificationHandler = notificationHandler;
         this.#stream = stream;
-        this.#closedPromise = new Promise((resolve7) => {
-          this.#abortController.signal.addEventListener("abort", () => resolve7());
+        this.#closedPromise = new Promise((resolve10) => {
+          this.#abortController.signal.addEventListener("abort", () => resolve10());
         });
         this.#receive();
       }
@@ -33813,8 +35599,8 @@ var init_acp = __esm({
       }
       async sendRequest(method, params) {
         const id = this.#nextRequestId++;
-        const responsePromise = new Promise((resolve7, reject) => {
-          this.#pendingResponses.set(id, { resolve: resolve7, reject });
+        const responsePromise = new Promise((resolve10, reject) => {
+          this.#pendingResponses.set(id, { resolve: resolve10, reject });
         });
         await this.#sendMessage({ jsonrpc: "2.0", id, method, params });
         return responsePromise;
@@ -34346,13 +36132,13 @@ var init_acp_provider_instance = __esm({
             }
             this.currentStatus = "waiting_approval";
             this.detectStatusTransition();
-            const approved = await new Promise((resolve7) => {
-              this.permissionResolvers.push(resolve7);
+            const approved = await new Promise((resolve10) => {
+              this.permissionResolvers.push(resolve10);
               setTimeout(() => {
-                const idx = this.permissionResolvers.indexOf(resolve7);
+                const idx = this.permissionResolvers.indexOf(resolve10);
                 if (idx >= 0) {
                   this.permissionResolvers.splice(idx, 1);
-                  resolve7(false);
+                  resolve10(false);
                 }
               }, 3e5);
             });
@@ -36544,15 +38330,15 @@ var init_dev_server = __esm({
             this.json(res, 500, { error: e.message });
           }
         });
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve10, reject) => {
           this.server.listen(port, "127.0.0.1", () => {
             this.log(`Dev server listening on http://127.0.0.1:${port}`);
-            resolve7();
+            resolve10();
           });
           this.server.on("error", (e) => {
             if (e.code === "EADDRINUSE") {
               this.log(`Port ${port} in use, skipping dev server`);
-              resolve7();
+              resolve10();
             } else {
               reject(e);
             }
@@ -36635,20 +38421,20 @@ var init_dev_server = __esm({
           child.stderr?.on("data", (d) => {
             stderr += d.toString().slice(0, 2e3);
           });
-          await new Promise((resolve7) => {
+          await new Promise((resolve10) => {
             const timer = setTimeout(() => {
               child.kill();
-              resolve7();
+              resolve10();
             }, 3e3);
             child.on("exit", () => {
               clearTimeout(timer);
-              resolve7();
+              resolve10();
             });
             child.stdout?.once("data", () => {
               setTimeout(() => {
                 child.kill();
                 clearTimeout(timer);
-                resolve7();
+                resolve10();
               }, 500);
             });
           });
@@ -37075,8 +38861,8 @@ var init_dev_server = __esm({
                 files.push({ path: rel, size: 0, type: "dir" });
                 scan(path12.join(d, entry.name), rel);
               } else {
-                const stat = fs10.statSync(path12.join(d, entry.name));
-                files.push({ path: rel, size: stat.size, type: "file" });
+                const stat4 = fs10.statSync(path12.join(d, entry.name));
+                files.push({ path: rel, size: stat4.size, type: "file" });
               }
             }
           } catch {
@@ -37392,14 +39178,14 @@ var init_dev_server = __esm({
           child.stderr?.on("data", (d) => {
             stderr += d.toString();
           });
-          await new Promise((resolve7) => {
+          await new Promise((resolve10) => {
             const timer = setTimeout(() => {
               child.kill();
-              resolve7();
+              resolve10();
             }, timeout);
             child.on("exit", () => {
               clearTimeout(timer);
-              resolve7();
+              resolve10();
             });
           });
           const elapsed = Date.now() - start;
@@ -38243,25 +40029,63 @@ var init_dev_server = __esm({
         const ref = this.providerLoader.resolve(desired) || this.providerLoader.getMeta(desired);
         if (ref?.category === category) return desired;
         const all = this.providerLoader.getAll();
-        const fallback = all.find((p) => p.category === category && p.type !== targetType);
+        const fallback = all.filter((p) => p.category === category && p.type !== targetType).sort((a, b2) => String(a.type || "").localeCompare(String(b2.type || ""), void 0, { numeric: true, sensitivity: "base" }))[0];
         return fallback?.type || null;
       }
-      loadAutoImplReferenceScripts(category, referenceType) {
-        if (!referenceType) return {};
-        const refDir = this.providerLoader.getUpstreamProviderDir(category, referenceType);
-        if (!fs10.existsSync(refDir)) return {};
-        const referenceScripts = {};
-        const scriptsDir = path12.join(refDir, "scripts");
-        if (!fs10.existsSync(scriptsDir)) return referenceScripts;
+      getLatestScriptVersionDir(scriptsDir) {
+        if (!fs10.existsSync(scriptsDir)) return null;
         const versions = fs10.readdirSync(scriptsDir).filter((d) => {
           try {
             return fs10.statSync(path12.join(scriptsDir, d)).isDirectory();
           } catch {
             return false;
           }
-        }).sort().reverse();
-        if (versions.length === 0) return referenceScripts;
-        const latestDir = path12.join(scriptsDir, versions[0]);
+        }).sort((a, b2) => b2.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
+        if (versions.length === 0) return null;
+        return path12.join(scriptsDir, versions[0]);
+      }
+      resolveAutoImplWritableProviderDir(category, type, requestedDir) {
+        const canonicalUserDir = path12.resolve(this.providerLoader.getUserProviderDir(category, type));
+        const desiredDir = requestedDir ? path12.resolve(requestedDir) : canonicalUserDir;
+        if (desiredDir !== canonicalUserDir) {
+          return null;
+        }
+        const userRoot = path12.resolve(this.providerLoader.getUserDir());
+        if (desiredDir !== userRoot && !desiredDir.startsWith(`${userRoot}${path12.sep}`)) {
+          return null;
+        }
+        const sourceDir = this.findProviderDir(type);
+        if (!sourceDir) {
+          return null;
+        }
+        if (!fs10.existsSync(desiredDir)) {
+          fs10.mkdirSync(path12.dirname(desiredDir), { recursive: true });
+          fs10.cpSync(sourceDir, desiredDir, { recursive: true });
+          this.log(`Auto-implement writable copy created: ${desiredDir}`);
+        }
+        const providerJson = path12.join(desiredDir, "provider.json");
+        if (!fs10.existsSync(providerJson)) {
+          return null;
+        }
+        try {
+          const providerData = JSON.parse(fs10.readFileSync(providerJson, "utf-8"));
+          if (providerData.disableUpstream !== true) {
+            providerData.disableUpstream = true;
+            fs10.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
+          }
+        } catch {
+          return null;
+        }
+        return desiredDir;
+      }
+      loadAutoImplReferenceScripts(referenceType) {
+        if (!referenceType) return {};
+        const refDir = this.findProviderDir(referenceType);
+        if (!refDir || !fs10.existsSync(refDir)) return {};
+        const referenceScripts = {};
+        const scriptsDir = path12.join(refDir, "scripts");
+        const latestDir = this.getLatestScriptVersionDir(scriptsDir);
+        if (!latestDir) return referenceScripts;
         for (const file2 of fs10.readdirSync(latestDir)) {
           if (!file2.endsWith(".js")) continue;
           try {
@@ -38273,7 +40097,7 @@ var init_dev_server = __esm({
       }
       async handleAutoImplement(type, req, res) {
         const body = await this.readBody(req);
-        const { agent = "claude-cli", functions, reference = "antigravity", model, comment } = body;
+        const { agent = "claude-cli", functions, reference, model, comment, providerDir: requestedProviderDir } = body;
         if (!functions || !Array.isArray(functions) || functions.length === 0) {
           this.json(res, 400, { error: 'functions[] is required (e.g. ["readChat", "sendMessage"])' });
           return;
@@ -38287,9 +40111,11 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const providerDir = this.findProviderDir(type);
+        const providerDir = this.resolveAutoImplWritableProviderDir(provider.category, type, requestedProviderDir);
         if (!providerDir) {
-          this.json(res, 404, { error: `Provider directory not found: ${type}` });
+          this.json(res, 409, {
+            error: `Auto-implement only writes to the canonical user provider directory for '${type}'.`
+          });
           return;
         }
         try {
@@ -38311,7 +40137,7 @@ var init_dev_server = __esm({
               message: `Loading reference script (${resolvedReference || "none"})...`
             }
           });
-          const referenceScripts = this.loadAutoImplReferenceScripts(provider.category, resolvedReference);
+          const referenceScripts = this.loadAutoImplReferenceScripts(resolvedReference);
           const prompt = this.buildAutoImplPrompt(type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference);
           const tmpDir = path12.join(os15.tmpdir(), "adhdev-autoimpl");
           if (!fs10.existsSync(tmpDir)) fs10.mkdirSync(tmpDir, { recursive: true });
@@ -38333,7 +40159,7 @@ var init_dev_server = __esm({
             this.sendAutoImplSSE({ event: "progress", data: { function: "_init", status: "spawning", message: `Spawning ACP agent: ${spawn3.command} ${(spawn3.args || []).join(" ")}` } });
             this.autoImplStatus = { running: true, type, progress: [] };
             const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
-            const { Readable: Readable2, Writable: Writable2 } = await import("stream");
+            const { Readable: Readable3, Writable: Writable2 } = await import("stream");
             const { spawn: spawnFn2 } = await import("child_process");
             const acpArgs = [...spawn3.args || []];
             if (model) {
@@ -38352,7 +40178,7 @@ var init_dev_server = __esm({
               this.sendAutoImplSSE({ event: "output", data: { chunk, stream: "stderr" } });
             });
             const webStdin = Writable2.toWeb(child2.stdin);
-            const webStdout = Readable2.toWeb(child2.stdout);
+            const webStdout = Readable3.toWeb(child2.stdout);
             const stream = ndJsonStream2(webStdin, webStdout);
             const connection = new ClientSideConnection2((_agent) => ({
               // Auto-approve all tool calls for auto-implement
@@ -38667,29 +40493,20 @@ var init_dev_server = __esm({
         lines.push("These are the files you need to EDIT. They contain TODO stubs \u2014 replace them with working implementations.");
         lines.push("");
         const scriptsDir = path12.join(providerDir, "scripts");
-        if (fs10.existsSync(scriptsDir)) {
-          const versions = fs10.readdirSync(scriptsDir).filter((d) => {
-            try {
-              return fs10.statSync(path12.join(scriptsDir, d)).isDirectory();
-            } catch {
-              return false;
-            }
-          }).sort().reverse();
-          if (versions.length > 0) {
-            const vDir = path12.join(scriptsDir, versions[0]);
-            lines.push(`Scripts version directory: \`${vDir}\``);
-            lines.push("");
-            for (const file2 of fs10.readdirSync(vDir)) {
-              if (file2.endsWith(".js")) {
-                try {
-                  const content = fs10.readFileSync(path12.join(vDir, file2), "utf-8");
-                  lines.push(`### \`${file2}\``);
-                  lines.push("```javascript");
-                  lines.push(content);
-                  lines.push("```");
-                  lines.push("");
-                } catch {
-                }
+        const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
+        if (latestScriptsDir) {
+          lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
+          lines.push("");
+          for (const file2 of fs10.readdirSync(latestScriptsDir)) {
+            if (file2.endsWith(".js")) {
+              try {
+                const content = fs10.readFileSync(path12.join(latestScriptsDir, file2), "utf-8");
+                lines.push(`### \`${file2}\``);
+                lines.push("```javascript");
+                lines.push(content);
+                lines.push("```");
+                lines.push("");
+              } catch {
               }
             }
           }
@@ -38770,7 +40587,7 @@ var init_dev_server = __esm({
         lines.push("## Rules");
         lines.push("1. **Scripts WITHOUT params** \u2192 IIFE: `(() => { ... })()`");
         lines.push("2. **Scripts WITH params** \u2192 arrow: `(params) => { ... }` \u2014 router calls `(${script})(${JSON.stringify(params)})`");
-        lines.push("3. Use CSS selectors from the DOM analysis above");
+        lines.push("3. If live DOM analysis is included above, use it. Otherwise, discover selectors yourself via CDP before coding.");
         lines.push("4. Always wrap in try-catch, return `JSON.stringify(result)`");
         lines.push("5. Do NOT modify `scripts.js` router \u2014 only edit individual `*.js` files");
         lines.push("6. All scripts run in the browser (CDP evaluate) \u2014 use DOM APIs only");
@@ -38819,8 +40636,12 @@ var init_dev_server = __esm({
         lines.push("   - `listSessions`: If sessions are unmounted when the panel is closed, try to explicitly interact with the UI to open the history/sessions view (e.g., clicking a history icon usually found near the chat header) BEFORE scraping.");
         lines.push("   - `switchSession`: Prove your switch was successful by subsequently calling `readChat` and explicitly checking that the chat context has actually changed.");
         lines.push("");
-        lines.push("## YOU MUST EXPLORE THE DOM YOURSELF!");
-        lines.push("I have NOT provided you with the DOM snapshot. You MUST use your command-line tools to discover the IDE structure dynamically!");
+        lines.push("## DOM Exploration");
+        if (domContext) {
+          lines.push("A lightweight DOM snapshot is included above, but you MUST still verify selectors yourself before finalizing the scripts.");
+        } else {
+          lines.push("No DOM snapshot is included here. You MUST use your command-line tools to discover the IDE structure dynamically.");
+        }
         lines.push("");
         lines.push("### 1. Evaluate JS to explore IDE DOM");
         lines.push("Use cURL to run JavaScript inside the IDE:");
@@ -38907,29 +40728,20 @@ var init_dev_server = __esm({
         lines.push("These are the files you need to edit. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
         lines.push("");
         const scriptsDir = path12.join(providerDir, "scripts");
-        if (fs10.existsSync(scriptsDir)) {
-          const versions = fs10.readdirSync(scriptsDir).filter((d) => {
+        const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
+        if (latestScriptsDir) {
+          lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
+          lines.push("");
+          for (const file2 of fs10.readdirSync(latestScriptsDir)) {
+            if (!file2.endsWith(".js")) continue;
             try {
-              return fs10.statSync(path12.join(scriptsDir, d)).isDirectory();
+              const content = fs10.readFileSync(path12.join(latestScriptsDir, file2), "utf-8");
+              lines.push(`### \`${file2}\``);
+              lines.push("```javascript");
+              lines.push(content);
+              lines.push("```");
+              lines.push("");
             } catch {
-              return false;
-            }
-          }).sort().reverse();
-          if (versions.length > 0) {
-            const vDir = path12.join(scriptsDir, versions[0]);
-            lines.push(`Scripts version directory: \`${vDir}\``);
-            lines.push("");
-            for (const file2 of fs10.readdirSync(vDir)) {
-              if (!file2.endsWith(".js")) continue;
-              try {
-                const content = fs10.readFileSync(path12.join(vDir, file2), "utf-8");
-                lines.push(`### \`${file2}\``);
-                lines.push("```javascript");
-                lines.push(content);
-                lines.push("```");
-                lines.push("");
-              } catch {
-              }
             }
           }
         }
@@ -39143,14 +40955,14 @@ data: ${JSON.stringify(msg.data)}
         res.end(JSON.stringify(data, null, 2));
       }
       async readBody(req) {
-        return new Promise((resolve7) => {
+        return new Promise((resolve10) => {
           let body = "";
           req.on("data", (chunk) => body += chunk);
           req.on("end", () => {
             try {
-              resolve7(JSON.parse(body));
+              resolve10(JSON.parse(body));
             } catch {
-              resolve7({});
+              resolve10({});
             }
           });
         });
@@ -39586,6 +41398,7 @@ var init_daemon_lifecycle = __esm({
     init_provider_loader();
     init_version_archive();
     init_provider_instance_manager();
+    init_dev_server();
     init_ide_detector();
     init_logger();
     init_config();
@@ -40079,13 +41892,13 @@ ${e?.stack || ""}`);
           } catch {
           }
           const http3 = esmRequire("https");
-          const data = await new Promise((resolve7, reject) => {
+          const data = await new Promise((resolve10, 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", () => resolve7(d));
+              res.on("end", () => resolve10(d));
             });
             req.on("error", reject);
             req.setTimeout(5e3, () => {
@@ -40941,7 +42754,7 @@ var init_adhdev_daemon = __esm({
     fs12 = __toESM(require("fs"));
     path14 = __toESM(require("path"));
     import_chalk2 = __toESM(require("chalk"));
-    pkgVersion = "0.6.72";
+    pkgVersion = "0.6.75";
     if (pkgVersion === "unknown") {
       try {
         const possiblePaths = [
@@ -41166,7 +42979,7 @@ ${err?.stack || ""}`);
         this.running = true;
         process.on("SIGINT", () => this.stop());
         process.on("SIGTERM", () => this.stop());
-        if (options.dev) {
+        if (options.dev && this.components) {
           const devServer = new DevServer({
             providerLoader: this.components.providerLoader,
             cdpManagers: this.components.cdpManagers,
@@ -41759,6 +43572,9 @@ async function installCliOnly() {
 });
 /*! Bundled license information:
 
+chokidar/index.js:
+  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
+
 @xterm/xterm/lib/xterm.mjs:
   (**
    * Copyright (c) 2014-2024 The xterm.js authors. All rights reserved.