@adhdev/daemon-standalone 0.7.43 → 0.7.45

package/dist/index.js

@@ -283,10 +283,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path18) {
-  if (!path18)
+function getElementAtPath(obj, path19) {
+  if (!path19)
     return obj;
-  return path18.reduce((acc, key) => acc?.[key], obj);
+  return path19.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -598,11 +598,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path18, issues) {
+function prefixIssues(path19, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path18);
+    iss.path.unshift(path19);
     return iss;
   });
 }
@@ -845,7 +845,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path18 = []) => {
+  const processError = (error49, path19 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -855,7 +855,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -887,8 +887,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path18) {
+  const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path19) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13652,13 +13652,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path18 = ref.slice(1).split("/").filter(Boolean);
-  if (path18.length === 0) {
+  const path19 = ref.slice(1).split("/").filter(Boolean);
+  if (path19.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path18[0] === defsKey) {
-    const key = path18[1];
+  if (path19[0] === defsKey) {
+    const key = path19[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -16334,9 +16334,9 @@ var init_acp = __esm({
 // src/index.ts
 var import_http = require("http");
 var import_ws2 = require("ws");
-var path17 = __toESM(require("path"));
-var fs12 = __toESM(require("fs"));
-var os17 = __toESM(require("os"));
+var path18 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var os18 = __toESM(require("os"));
 
 // ../daemon-core/dist/index.mjs
 var import_os = require("os");
@@ -16346,9 +16346,9 @@ var import_crypto2 = require("crypto");
 var fs2 = __toESM(require("fs"), 1);
 var path3 = __toESM(require("path"), 1);
 var os4 = __toESM(require("os"), 1);
-var os11 = __toESM(require("os"), 1);
 var os12 = __toESM(require("os"), 1);
-var path9 = __toESM(require("path"), 1);
+var os13 = __toESM(require("os"), 1);
+var path10 = __toESM(require("path"), 1);
 var import_child_process = require("child_process");
 var fs = __toESM(require("fs"), 1);
 var os2 = __toESM(require("os"), 1);
@@ -16469,7 +16469,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path18) => statMethod(path18, { bigint: true });
+      this._stat = (path19) => statMethod(path19, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -16494,8 +16494,8 @@ var ReaddirpStream = class extends import_node_stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path18, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path18));
+          const { path: path19, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path19));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -16535,20 +16535,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path18, depth) {
+  async _exploreDir(path19, depth) {
     let files;
     try {
-      files = await (0, import_promises.readdir)(path18, this._rdOptions);
+      files = await (0, import_promises.readdir)(path19, this._rdOptions);
     } catch (error48) {
       this._onError(error48);
     }
-    return { files, depth, path: path18 };
+    return { files, depth, path: path19 };
   }
-  async _formatEntry(dirent, path18) {
+  async _formatEntry(dirent, path19) {
     let entry;
     const basename7 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path18, basename7));
+      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path19, basename7));
       entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename7 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -16948,16 +16948,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path18, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path19, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path18);
-    emitRaw(rawEvent, evPath, { watchedPath: path18 });
-    if (evPath && path18 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path18, evPath), KEY_LISTENERS, sp.join(path18, evPath));
+    listener(path19);
+    emitRaw(rawEvent, evPath, { watchedPath: path19 });
+    if (evPath && path19 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path19, evPath), KEY_LISTENERS, sp.join(path19, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path18, {
+    return (0, import_node_fs.watch)(path19, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error48) {
@@ -16973,12 +16973,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path18, fullPath, options, handlers) => {
+var setFsWatchListener = (path19, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path18, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path19, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -16989,7 +16989,7 @@ var setFsWatchListener = (path18, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path18,
+      path19,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -17004,7 +17004,7 @@ var setFsWatchListener = (path18, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error48.code === "EPERM") {
         try {
-          const fd = await (0, import_promises2.open)(path18, "r");
+          const fd = await (0, import_promises2.open)(path19, "r");
           await fd.close();
           broadcastErr(error48);
         } catch (err) {
@@ -17035,7 +17035,7 @@ var setFsWatchListener = (path18, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path18, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path19, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -17057,7 +17057,7 @@ var setFsWatchFileListener = (path18, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path18, curr));
+          foreach(cont.listeners, (listener2) => listener2(path19, curr));
         }
       })
     };
@@ -17087,13 +17087,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path18, listener) {
+  _watchWithNodeFs(path19, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path18);
-    const basename7 = sp.basename(path18);
+    const directory = sp.dirname(path19);
+    const basename7 = sp.basename(path19);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename7);
-    const absolutePath = sp.resolve(path18);
+    const absolutePath = sp.resolve(path19);
     const options = {
       persistent: opts.persistent
     };
@@ -17103,12 +17103,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path18, absolutePath, options, {
+      closer = setFsWatchFileListener(path19, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path18, absolutePath, options, {
+      closer = setFsWatchListener(path19, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -17130,7 +17130,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename7))
       return;
-    const listener = async (path18, newStats) => {
+    const listener = async (path19, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -17144,11 +17144,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file2, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path18);
+            this.fsw._closeFile(path19);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file2, listener);
             if (closer2)
-              this.fsw._addPathCloser(path18, closer2);
+              this.fsw._addPathCloser(path19, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -17180,7 +17180,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path18, item) {
+  async _handleSymlink(entry, directory, path19, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -17190,7 +17190,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises2.realpath)(path18);
+        linkPath = await (0, import_promises2.realpath)(path19);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -17200,12 +17200,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path18, entry.stats);
+          this.fsw._emit(EV.CHANGE, path19, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path18, entry.stats);
+        this.fsw._emit(EV.ADD, path19, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -17235,9 +17235,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path18 = sp.join(directory, item);
+      let path19 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path18, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path19, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -17246,8 +17246,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path18 = sp.join(dir, sp.relative(dir, path18));
-        this._addToNodeFs(path18, initialAdd, wh, depth + 1);
+        path19 = sp.join(dir, sp.relative(dir, path19));
+        this._addToNodeFs(path19, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve12, reject) => {
@@ -17316,13 +17316,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path18, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path19, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path18) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path19) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path18);
+    const wh = this.fsw._getWatchHelpers(path19);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -17338,8 +17338,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path18);
-        const targetPath = follow ? await (0, import_promises2.realpath)(path18) : path18;
+        const absPath = sp.resolve(path19);
+        const targetPath = follow ? await (0, import_promises2.realpath)(path19) : path19;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -17349,29 +17349,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises2.realpath)(path18) : path18;
+        const targetPath = follow ? await (0, import_promises2.realpath)(path19) : path19;
         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, path18, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path19, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path18), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path19), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path18, closer);
+        this.fsw._addPathCloser(path19, closer);
       return false;
     } catch (error48) {
       if (this.fsw._handleError(error48)) {
         ready();
-        return path18;
+        return path19;
       }
     }
   }
@@ -17414,24 +17414,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path18) {
-  if (typeof path18 !== "string")
+function normalizePath(path19) {
+  if (typeof path19 !== "string")
     throw new Error("string expected");
-  path18 = sp2.normalize(path18);
-  path18 = path18.replace(/\\/g, "/");
+  path19 = sp2.normalize(path19);
+  path19 = path19.replace(/\\/g, "/");
   let prepend = false;
-  if (path18.startsWith("//"))
+  if (path19.startsWith("//"))
     prepend = true;
-  path18 = path18.replace(DOUBLE_SLASH_RE, "/");
+  path19 = path19.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path18 = "/" + path18;
-  return path18;
+    path19 = "/" + path19;
+  return path19;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path18 = normalizePath(testString);
+  const path19 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path18, stats)) {
+    if (pattern(path19, stats)) {
       return true;
     }
   }
@@ -17469,19 +17469,19 @@ var toUnix = (string4) => {
   }
   return str;
 };
-var normalizePathToUnix = (path18) => toUnix(sp2.normalize(toUnix(path18)));
-var normalizeIgnored = (cwd = "") => (path18) => {
-  if (typeof path18 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path18) ? path18 : sp2.join(cwd, path18));
+var normalizePathToUnix = (path19) => toUnix(sp2.normalize(toUnix(path19)));
+var normalizeIgnored = (cwd = "") => (path19) => {
+  if (typeof path19 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path19) ? path19 : sp2.join(cwd, path19));
   } else {
-    return path18;
+    return path19;
   }
 };
-var getAbsolutePath = (path18, cwd) => {
-  if (sp2.isAbsolute(path18)) {
-    return path18;
+var getAbsolutePath = (path19, cwd) => {
+  if (sp2.isAbsolute(path19)) {
+    return path19;
   }
-  return sp2.join(cwd, path18);
+  return sp2.join(cwd, path19);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -17546,10 +17546,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path18, follow, fsw) {
+  constructor(path19, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path18;
-    this.path = path18 = path18.replace(REPLACER_RE, "");
+    const watchPath = path19;
+    this.path = path19 = path19.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -17689,20 +17689,20 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path18) => {
-        const absPath = getAbsolutePath(path18, cwd);
+      paths = paths.map((path19) => {
+        const absPath = getAbsolutePath(path19, cwd);
         return absPath;
       });
     }
-    paths.forEach((path18) => {
-      this._removeIgnoredPath(path18);
+    paths.forEach((path19) => {
+      this._removeIgnoredPath(path19);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path18) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path18, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path19) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path19, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -17724,17 +17724,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path18) => {
-      if (!sp2.isAbsolute(path18) && !this._closers.has(path18)) {
+    paths.forEach((path19) => {
+      if (!sp2.isAbsolute(path19) && !this._closers.has(path19)) {
         if (cwd)
-          path18 = sp2.join(cwd, path18);
-        path18 = sp2.resolve(path18);
+          path19 = sp2.join(cwd, path19);
+        path19 = sp2.resolve(path19);
       }
-      this._closePath(path18);
-      this._addIgnoredPath(path18);
-      if (this._watched.has(path18)) {
+      this._closePath(path19);
+      this._addIgnoredPath(path19);
+      if (this._watched.has(path19)) {
         this._addIgnoredPath({
-          path: path18,
+          path: path19,
           recursive: true
         });
       }
@@ -17798,38 +17798,38 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @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, path18, stats) {
+  async _emit(event, path19, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path18 = sp2.normalize(path18);
+      path19 = sp2.normalize(path19);
     if (opts.cwd)
-      path18 = sp2.relative(opts.cwd, path18);
-    const args = [path18];
+      path19 = sp2.relative(opts.cwd, path19);
+    const args = [path19];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path18))) {
+    if (awf && (pw = this._pendingWrites.get(path19))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path18, [event, ...args]);
+        this._pendingUnlinks.set(path19, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path19) => {
+          this._pendingUnlinks.forEach((entry, path20) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path19);
+            this._pendingUnlinks.delete(path20);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path18)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path19)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path18);
+        this._pendingUnlinks.delete(path19);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -17847,16 +17847,16 @@ var FSWatcher = class extends import_node_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path18, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path19, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path18, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path19, 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, path18) : path18;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path19) : path19;
       let stats2;
       try {
         stats2 = await (0, import_promises3.stat)(fullPath);
@@ -17887,23 +17887,23 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path18, timeout) {
+  _throttle(actionType, path19, 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(path18);
+    const actionPath = action.get(path19);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path18);
+      const item = action.get(path19);
       const count = item ? item.count : 0;
-      action.delete(path18);
+      action.delete(path19);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -17911,7 +17911,7 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path18, thr);
+    action.set(path19, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -17925,44 +17925,44 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path18, threshold, event, awfEmit) {
+  _awaitWriteFinish(path19, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path18;
-    if (this.options.cwd && !sp2.isAbsolute(path18)) {
-      fullPath = sp2.join(this.options.cwd, path18);
+    let fullPath = path19;
+    if (this.options.cwd && !sp2.isAbsolute(path19)) {
+      fullPath = sp2.join(this.options.cwd, path19);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path18)) {
+        if (err || !writes.has(path19)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path18).lastChange = now2;
+          writes.get(path19).lastChange = now2;
         }
-        const pw = writes.get(path18);
+        const pw = writes.get(path19);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path18);
+          writes.delete(path19);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path18)) {
-      writes.set(path18, {
+    if (!writes.has(path19)) {
+      writes.set(path19, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path18);
+          writes.delete(path19);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -17973,8 +17973,8 @@ var FSWatcher = class extends import_node_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path18, stats) {
-    if (this.options.atomic && DOT_RE.test(path18))
+  _isIgnored(path19, stats) {
+    if (this.options.atomic && DOT_RE.test(path19))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -17984,17 +17984,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path18, stats);
+    return this._userIgnored(path19, stats);
   }
-  _isntIgnored(path18, stat4) {
-    return !this._isIgnored(path18, stat4);
+  _isntIgnored(path19, stat4) {
+    return !this._isIgnored(path19, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path18) {
-    return new WatchHelper(path18, this.options.followSymlinks, this);
+  _getWatchHelpers(path19) {
+    return new WatchHelper(path19, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -18026,63 +18026,63 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path18 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path18);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path18) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path18, 100))
+    const path19 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path19);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path19) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path19, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path18);
+    const wp = this._getWatchedDir(path19);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path18, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path19, 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 = path18;
+    let relPath = path19;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path18);
+      relPath = sp2.relative(this.options.cwd, path19);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path18);
+    this._watched.delete(path19);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path18))
-      this._emit(eventName, path18);
-    this._closePath(path18);
+    if (wasTracked && !this._isIgnored(path19))
+      this._emit(eventName, path19);
+    this._closePath(path19);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path18) {
-    this._closeFile(path18);
-    const dir = sp2.dirname(path18);
-    this._getWatchedDir(dir).remove(sp2.basename(path18));
+  _closePath(path19) {
+    this._closeFile(path19);
+    const dir = sp2.dirname(path19);
+    this._getWatchedDir(dir).remove(sp2.basename(path19));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path18) {
-    const closers = this._closers.get(path18);
+  _closeFile(path19) {
+    const closers = this._closers.get(path19);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path18);
+    this._closers.delete(path19);
   }
-  _addPathCloser(path18, closer) {
+  _addPathCloser(path19, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path18);
+    let list = this._closers.get(path19);
     if (!list) {
       list = [];
-      this._closers.set(path18, list);
+      this._closers.set(path19, list);
     }
     list.push(closer);
   }
@@ -18115,28 +18115,33 @@ var fs6 = __toESM(require("fs"), 1);
 var path8 = __toESM(require("path"), 1);
 var os9 = __toESM(require("os"), 1);
 var os10 = __toESM(require("os"), 1);
+var import_child_process6 = require("child_process");
+var import_child_process7 = require("child_process");
 var fs7 = __toESM(require("fs"), 1);
-var os13 = __toESM(require("os"), 1);
-var path10 = __toESM(require("path"), 1);
+var os11 = __toESM(require("os"), 1);
+var path9 = __toESM(require("path"), 1);
+var fs8 = __toESM(require("fs"), 1);
+var os14 = __toESM(require("os"), 1);
+var path11 = __toESM(require("path"), 1);
 var crypto4 = __toESM(require("crypto"), 1);
 var import_chalk = __toESM(require("chalk"), 1);
 var crypto3 = __toESM(require("crypto"), 1);
 var import_stream = require("stream");
-var import_child_process6 = require("child_process");
+var import_child_process8 = require("child_process");
 init_acp();
-var fs8 = __toESM(require("fs"), 1);
-var path11 = __toESM(require("path"), 1);
-var os14 = __toESM(require("os"), 1);
-var import_child_process7 = require("child_process");
-var import_os3 = require("os");
-var http2 = __toESM(require("http"), 1);
-var fs11 = __toESM(require("fs"), 1);
-var path14 = __toESM(require("path"), 1);
 var fs9 = __toESM(require("fs"), 1);
 var path12 = __toESM(require("path"), 1);
+var os15 = __toESM(require("os"), 1);
+var import_child_process9 = require("child_process");
+var import_os3 = require("os");
+var http2 = __toESM(require("http"), 1);
+var fs12 = __toESM(require("fs"), 1);
+var path15 = __toESM(require("path"), 1);
 var fs10 = __toESM(require("fs"), 1);
 var path13 = __toESM(require("path"), 1);
-var os15 = __toESM(require("os"), 1);
+var fs11 = __toESM(require("fs"), 1);
+var path14 = __toESM(require("path"), 1);
+var os16 = __toESM(require("os"), 1);
 
 // ../session-host-core/dist/index.mjs
 var os = __toESM(require("os"), 1);
@@ -18996,7 +19001,7 @@ var init_pty_transport = __esm2({
       spawn(command, args, options) {
         if (!pty) throw new Error("node-pty is not installed");
         const handle = pty.spawn(command, args, {
-          name: os11.platform() === "win32" ? "xterm-color" : "xterm-256color",
+          name: os12.platform() === "win32" ? "xterm-color" : "xterm-256color",
           cols: options.cols,
           rows: options.rows,
           cwd: options.cwd,
@@ -19048,7 +19053,7 @@ function computeTerminalQueryTail(buffer) {
   return "";
 }
 function findBinary(name) {
-  const isWin = os12.platform() === "win32";
+  const isWin = os13.platform() === "win32";
   try {
     const cmd = isWin ? `where ${name}` : `which ${name}`;
     return (0, import_child_process.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n")[0].trim();
@@ -19057,14 +19062,14 @@ function findBinary(name) {
   }
 }
 function isScriptBinary(binaryPath) {
-  if (!path9.isAbsolute(binaryPath)) return false;
+  if (!path10.isAbsolute(binaryPath)) return false;
   try {
-    const fs122 = __require("fs");
-    const resolved = fs122.realpathSync(binaryPath);
+    const fs132 = __require("fs");
+    const resolved = fs132.realpathSync(binaryPath);
     const head = Buffer.alloc(8);
-    const fd = fs122.openSync(resolved, "r");
-    fs122.readSync(fd, head, 0, 8, 0);
-    fs122.closeSync(fd);
+    const fd = fs132.openSync(resolved, "r");
+    fs132.readSync(fd, head, 0, 8, 0);
+    fs132.closeSync(fd);
     let i = 0;
     if (head[0] === 239 && head[1] === 187 && head[2] === 191) i = 3;
     return head[i] === 35 && head[i + 1] === 33;
@@ -19073,14 +19078,14 @@ function isScriptBinary(binaryPath) {
   }
 }
 function looksLikeMachOOrElf(filePath) {
-  if (!path9.isAbsolute(filePath)) return false;
+  if (!path10.isAbsolute(filePath)) return false;
   try {
-    const fs122 = __require("fs");
-    const resolved = fs122.realpathSync(filePath);
+    const fs132 = __require("fs");
+    const resolved = fs132.realpathSync(filePath);
     const buf = Buffer.alloc(8);
-    const fd = fs122.openSync(resolved, "r");
-    fs122.readSync(fd, buf, 0, 8, 0);
-    fs122.closeSync(fd);
+    const fd = fs132.openSync(resolved, "r");
+    fs132.readSync(fd, buf, 0, 8, 0);
+    fs132.closeSync(fd);
     let i = 0;
     if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
     const b = buf.subarray(i);
@@ -19096,12 +19101,12 @@ function looksLikeMachOOrElf(filePath) {
 }
 function shSingleQuote(arg) {
   if (/^[a-zA-Z0-9@%_+=:,./-]+$/.test(arg)) return arg;
-  if (os12.platform() === "win32") {
+  if (os13.platform() === "win32") {
     return `"${arg.replace(/"/g, '""')}"`;
   }
   return `'${arg.replace(/'/g, `'\\''`)}'`;
 }
-function estimatePromptDisplayLines(text, cols = 100) {
+function estimatePromptDisplayLines(text, cols = 80) {
   const normalized = String(text || "").replace(/\r/g, "");
   if (!normalized) return 1;
   return normalized.split("\n").reduce((sum, line) => sum + Math.max(1, Math.ceil(Math.max(1, line.length) / cols)), 0);
@@ -19167,16 +19172,16 @@ var init_provider_cli_adapter = __esm2({
     init_pty_transport();
     try {
       pty2 = __require("node-pty");
-      if (os12.platform() !== "win32") {
+      if (os13.platform() !== "win32") {
         try {
-          const fs122 = __require("fs");
-          const ptyDir = path9.resolve(path9.dirname(__require.resolve("node-pty")), "..");
-          const platformArch = `${os12.platform()}-${os12.arch()}`;
-          const helper = path9.join(ptyDir, "prebuilds", platformArch, "spawn-helper");
-          if (fs122.existsSync(helper)) {
-            const stat4 = fs122.statSync(helper);
+          const fs132 = __require("fs");
+          const ptyDir = path10.resolve(path10.dirname(__require.resolve("node-pty")), "..");
+          const platformArch = `${os13.platform()}-${os13.arch()}`;
+          const helper = path10.join(ptyDir, "prebuilds", platformArch, "spawn-helper");
+          if (fs132.existsSync(helper)) {
+            const stat4 = fs132.statSync(helper);
             if (!(stat4.mode & 73)) {
-              fs122.chmodSync(helper, stat4.mode | 493);
+              fs132.chmodSync(helper, stat4.mode | 493);
               LOG.info("CLI", "[node-pty] Fixed spawn-helper permissions");
             }
           }
@@ -19193,7 +19198,7 @@ var init_provider_cli_adapter = __esm2({
         this.transportFactory = transportFactory;
         this.cliType = provider.type;
         this.cliName = provider.name;
-        this.workingDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os12.homedir()) : workingDir;
+        this.workingDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os13.homedir()) : workingDir;
         const t = provider.timeouts || {};
         this.timeouts = {
           ptyFlush: t.ptyFlush ?? 50,
@@ -19360,12 +19365,12 @@ var init_provider_cli_adapter = __esm2({
         if (this.ptyProcess) return;
         const { spawn: spawnConfig } = this.provider;
         const binaryPath = findBinary(spawnConfig.command);
-        const isWin = os12.platform() === "win32";
+        const isWin = os13.platform() === "win32";
         const allArgs = [...spawnConfig.args, ...this.extraArgs];
         LOG.info("CLI", `[${this.cliType}] Spawning in ${this.workingDir}`);
         let shellCmd;
         let shellArgs;
-        const useShellUnix = !isWin && (!!spawnConfig.shell || !path9.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
+        const useShellUnix = !isWin && (!!spawnConfig.shell || !path10.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
         const useShell = isWin ? !!spawnConfig.shell : useShellUnix;
         if (useShell) {
           if (!spawnConfig.shell && !isWin) {
@@ -19383,8 +19388,8 @@ var init_provider_cli_adapter = __esm2({
           shellArgs = allArgs;
         }
         const ptyOpts = {
-          cols: 100,
-          rows: 30,
+          cols: 80,
+          rows: 24,
           cwd: this.workingDir,
           env: buildCliSpawnEnv(process.env, spawnConfig.env)
         };
@@ -19440,7 +19445,7 @@ var init_provider_cli_adapter = __esm2({
         this.spawnAt = Date.now();
         this.startupParseGate = true;
         this.startupBuffer = "";
-        this.terminalScreen.reset(30, 100);
+        this.terminalScreen.reset(24, 80);
         this.pendingTerminalQueryTail = "";
         this.currentTurnScope = null;
         this.ready = false;
@@ -20452,18 +20457,18 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs() {
-  const os162 = (0, import_os2.platform)();
+  const os172 = (0, import_os2.platform)();
   const results = [];
   for (const def of getMergedDefinitions()) {
     const cliPath = findCliCommand(def.cli);
-    const appPath = checkPathExists(def.paths[os162] || []);
+    const appPath = checkPathExists(def.paths[os172] || []);
     const installed = !!(cliPath || appPath);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os162 === "darwin") {
+    if (!resolvedCli && appPath && os172 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if ((0, import_fs2.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os162 === "win32") {
+    if (!resolvedCli && appPath && os172 === "win32") {
       const { dirname: dirname72 } = await import("path");
       const appDir = dirname72(appPath);
       const candidates = [
@@ -26249,7 +26254,7 @@ function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs122 = __require("fs");
+      const fs132 = __require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
@@ -26258,8 +26263,8 @@ function detectCurrentWorkspace(ideId) {
           appName,
           "storage.json"
         );
-        if (fs122.existsSync(storagePath)) {
-          const data = JSON.parse(fs122.readFileSync(storagePath, "utf-8"));
+        if (fs132.existsSync(storagePath)) {
+          const data = JSON.parse(fs132.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -26663,6 +26668,182 @@ function buildStatusSnapshot(options) {
     availableProviders: buildAvailableProviders(options.providerLoader)
   };
 }
+var UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
+function getUpgradeLogPath() {
+  const home = os11.homedir();
+  const dir = path9.join(home, ".adhdev");
+  fs7.mkdirSync(dir, { recursive: true });
+  return path9.join(dir, "daemon-upgrade.log");
+}
+function appendUpgradeLog(message) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
+`;
+  try {
+    fs7.appendFileSync(getUpgradeLogPath(), line, "utf8");
+  } catch {
+  }
+}
+function getNpmExecutable() {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function killPid(pid) {
+  try {
+    if (process.platform === "win32") {
+      (0, import_child_process6.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+    } else {
+      process.kill(pid, "SIGTERM");
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForPidExit(pid, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      process.kill(pid, 0);
+      await new Promise((resolve92) => setTimeout(resolve92, 250));
+    } catch {
+      return;
+    }
+  }
+}
+function stopSessionHostProcesses(appName) {
+  const pidFile = path9.join(os11.homedir(), ".adhdev", `${appName}-session-host.pid`);
+  try {
+    if (fs7.existsSync(pidFile)) {
+      const pid = Number.parseInt(fs7.readFileSync(pidFile, "utf8").trim(), 10);
+      if (Number.isFinite(pid)) {
+        killPid(pid);
+      }
+    }
+  } catch {
+  } finally {
+    try {
+      fs7.unlinkSync(pidFile);
+    } catch {
+    }
+  }
+  if (process.platform !== "win32") {
+    try {
+      const raw = (0, import_child_process6.execFileSync)("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
+      for (const line of raw.split("\n")) {
+        const pid = Number.parseInt(line.trim(), 10);
+        if (Number.isFinite(pid)) {
+          killPid(pid);
+        }
+      }
+    } catch {
+    }
+  }
+}
+function removeDaemonPidFile() {
+  const pidFile = path9.join(os11.homedir(), ".adhdev", "daemon.pid");
+  try {
+    fs7.unlinkSync(pidFile);
+  } catch {
+  }
+}
+function cleanupStaleGlobalInstallDirs(pkgName) {
+  const npmRoot = (0, import_child_process6.execFileSync)(getNpmExecutable(), ["root", "-g"], { encoding: "utf8" }).trim();
+  if (!npmRoot) return;
+  const npmPrefix = (0, import_child_process6.execFileSync)(getNpmExecutable(), ["prefix", "-g"], { encoding: "utf8" }).trim();
+  const binDir = process.platform === "win32" ? npmPrefix : path9.join(npmPrefix, "bin");
+  const packageBaseName = pkgName.startsWith("@") ? pkgName.split("/")[1] : pkgName;
+  const binNames = /* @__PURE__ */ new Set([packageBaseName]);
+  if (pkgName === "@adhdev/daemon-standalone") {
+    binNames.add("adhdev-standalone");
+  }
+  if (pkgName.startsWith("@")) {
+    const [scope, name] = pkgName.split("/");
+    const scopeDir = path9.join(npmRoot, scope);
+    if (!fs7.existsSync(scopeDir)) return;
+    for (const entry of fs7.readdirSync(scopeDir)) {
+      if (!entry.startsWith(`.${name}-`)) continue;
+      fs7.rmSync(path9.join(scopeDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale scoped staging dir: ${path9.join(scopeDir, entry)}`);
+    }
+  } else {
+    for (const entry of fs7.readdirSync(npmRoot)) {
+      if (!entry.startsWith(`.${pkgName}-`)) continue;
+      fs7.rmSync(path9.join(npmRoot, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale staging dir: ${path9.join(npmRoot, entry)}`);
+    }
+  }
+  if (fs7.existsSync(binDir)) {
+    for (const entry of fs7.readdirSync(binDir)) {
+      if (![...binNames].some((name) => entry.startsWith(`.${name}-`))) continue;
+      fs7.rmSync(path9.join(binDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale bin staging entry: ${path9.join(binDir, entry)}`);
+    }
+  }
+}
+function spawnDetachedDaemonUpgradeHelper(payload) {
+  const env = { ...process.env, [UPGRADE_HELPER_ENV]: JSON.stringify(payload) };
+  const child = (0, import_child_process7.spawn)(process.execPath, process.argv.slice(1), {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    cwd: payload.cwd || process.cwd(),
+    env
+  });
+  child.unref();
+}
+async function runDaemonUpgradeHelper(payload) {
+  const restartArgv = Array.isArray(payload.restartArgv) ? payload.restartArgv : [];
+  const sessionHostAppName = payload.sessionHostAppName || process.env.ADHDEV_SESSION_HOST_NAME || "adhdev";
+  appendUpgradeLog(`Upgrade helper started for ${payload.packageName}@${payload.targetVersion}`);
+  if (Number.isFinite(payload.parentPid) && payload.parentPid > 0) {
+    appendUpgradeLog(`Waiting for parent pid ${payload.parentPid} to exit`);
+    await waitForPidExit(payload.parentPid, 15e3);
+  }
+  stopSessionHostProcesses(sessionHostAppName);
+  removeDaemonPidFile();
+  cleanupStaleGlobalInstallDirs(payload.packageName);
+  const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
+  appendUpgradeLog(`Installing ${spec}`);
+  const installOutput = (0, import_child_process6.execFileSync)(
+    getNpmExecutable(),
+    ["install", "-g", spec, "--force"],
+    {
+      encoding: "utf8",
+      stdio: "pipe",
+      maxBuffer: 20 * 1024 * 1024
+    }
+  );
+  if (installOutput.trim()) {
+    appendUpgradeLog(installOutput.trim());
+  }
+  if (restartArgv.length > 0) {
+    const env = { ...process.env };
+    delete env[UPGRADE_HELPER_ENV];
+    appendUpgradeLog(`Restarting daemon with args: ${restartArgv.join(" ")}`);
+    const child = (0, import_child_process7.spawn)(process.execPath, restartArgv, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      cwd: payload.cwd || process.cwd(),
+      env
+    });
+    child.unref();
+  } else {
+    appendUpgradeLog("No restart argv provided; upgrade completed without restart");
+  }
+}
+async function maybeRunDaemonUpgradeHelperFromEnv() {
+  const raw = process.env[UPGRADE_HELPER_ENV];
+  if (!raw) return false;
+  delete process.env[UPGRADE_HELPER_ENV];
+  try {
+    const payload = JSON.parse(raw);
+    await runDaemonUpgradeHelper(payload);
+    process.exit(0);
+  } catch (error48) {
+    appendUpgradeLog(`Upgrade helper failed: ${error48?.stack || error48?.message || String(error48)}`);
+    process.exit(1);
+  }
+}
 var CHAT_COMMANDS = [
   "send_chat",
   "new_chat",
@@ -26733,8 +26914,8 @@ var DaemonCommandRouter = class {
           if (logs.length > 0) {
             return { success: true, logs, totalBuffered: logs.length };
           }
-          if (fs7.existsSync(LOG_PATH)) {
-            const content = fs7.readFileSync(LOG_PATH, "utf-8");
+          if (fs8.existsSync(LOG_PATH)) {
+            const content = fs8.readFileSync(LOG_PATH, "utf-8");
             const allLines = content.split("\n");
             const recent = allLines.slice(-count).join("\n");
             return { success: true, logs: recent, totalLines: allLines.length };
@@ -26882,31 +27063,35 @@ var DaemonCommandRouter = class {
           const pkgName = isStandalone ? "@adhdev/daemon-standalone" : "adhdev";
           const latest = execSync7(`npm view ${pkgName} version`, { encoding: "utf-8", timeout: 1e4 }).trim();
           LOG.info("Upgrade", `Latest ${pkgName}: v${latest}`);
-          execSync7(`npm install -g ${pkgName}@latest --force`, {
-            encoding: "utf-8",
-            timeout: 12e4,
-            stdio: ["pipe", "pipe", "pipe"]
+          let currentInstalled = null;
+          try {
+            const currentJson = execSync7(`npm ls -g ${pkgName} --depth=0 --json`, {
+              encoding: "utf-8",
+              timeout: 1e4,
+              stdio: ["pipe", "pipe", "pipe"]
+            }).trim();
+            const parsed = JSON.parse(currentJson);
+            currentInstalled = parsed?.dependencies?.[pkgName]?.version || null;
+          } catch {
+          }
+          if (currentInstalled === latest) {
+            LOG.info("Upgrade", `Already on latest version v${latest}; skipping install`);
+            return { success: true, upgraded: false, alreadyLatest: true, version: latest };
+          }
+          spawnDetachedDaemonUpgradeHelper({
+            packageName: pkgName,
+            targetVersion: latest,
+            parentPid: process.pid,
+            restartArgv: process.argv.slice(1),
+            cwd: process.cwd(),
+            sessionHostAppName: process.env.ADHDEV_SESSION_HOST_NAME || "adhdev"
           });
-          LOG.info("Upgrade", `\u2705 Upgraded to v${latest}`);
+          LOG.info("Upgrade", `Scheduled detached upgrade to v${latest}`);
           setTimeout(() => {
-            LOG.info("Upgrade", "Restarting daemon with new version...");
-            try {
-              const path152 = __require("path");
-              const fs122 = __require("fs");
-              const pidFile = path152.join(process.env.HOME || process.env.USERPROFILE || "", ".adhdev", "daemon.pid");
-              if (fs122.existsSync(pidFile)) fs122.unlinkSync(pidFile);
-            } catch {
-            }
-            const { spawn: spawn32 } = __require("child_process");
-            const child = spawn32(process.execPath, process.argv.slice(1), {
-              detached: true,
-              stdio: "ignore",
-              env: { ...process.env }
-            });
-            child.unref();
+            LOG.info("Upgrade", "Exiting daemon so detached upgrader can continue...");
             process.exit(0);
           }, 3e3);
-          return { success: true, upgraded: true, version: latest };
+          return { success: true, upgraded: true, version: latest, restarting: true };
         } catch (e) {
           LOG.error("Upgrade", `Failed: ${e.message}`);
           return { success: false, error: e.message };
@@ -27548,7 +27733,7 @@ var AcpProviderInstance = class {
     this.errorMessage = null;
     this.errorReason = null;
     this.stderrBuffer = [];
-    this.process = (0, import_child_process6.spawn)(command, args, {
+    this.process = (0, import_child_process8.spawn)(command, args, {
       cwd: this.workingDir,
       env,
       stdio: ["pipe", "pipe", "pipe"],
@@ -28229,7 +28414,7 @@ var DaemonCliManager = class {
   async startSession(cliType, workingDir, cliArgs, initialModel) {
     const trimmed = (workingDir || "").trim();
     if (!trimmed) throw new Error("working directory required");
-    const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os13.homedir()) : path10.resolve(trimmed);
+    const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os14.homedir()) : path11.resolve(trimmed);
     const normalizedType = this.providerLoader.resolveAlias(cliType);
     const provider = this.providerLoader.getByAlias(cliType);
     const key = crypto4.randomUUID();
@@ -29410,7 +29595,7 @@ var ProviderInstanceManager = class {
     this.eventListeners = [];
   }
 };
-var ARCHIVE_PATH = path11.join(os14.homedir(), ".adhdev", "version-history.json");
+var ARCHIVE_PATH = path12.join(os15.homedir(), ".adhdev", "version-history.json");
 var MAX_ENTRIES_PER_PROVIDER = 20;
 var VersionArchive = class {
   history = {};
@@ -29419,8 +29604,8 @@ var VersionArchive = class {
   }
   load() {
     try {
-      if (fs8.existsSync(ARCHIVE_PATH)) {
-        this.history = JSON.parse(fs8.readFileSync(ARCHIVE_PATH, "utf-8"));
+      if (fs9.existsSync(ARCHIVE_PATH)) {
+        this.history = JSON.parse(fs9.readFileSync(ARCHIVE_PATH, "utf-8"));
       }
     } catch {
       this.history = {};
@@ -29457,15 +29642,15 @@ var VersionArchive = class {
   }
   save() {
     try {
-      fs8.mkdirSync(path11.dirname(ARCHIVE_PATH), { recursive: true });
-      fs8.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
+      fs9.mkdirSync(path12.dirname(ARCHIVE_PATH), { recursive: true });
+      fs9.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
     } catch {
     }
   }
 };
 function runCommand(cmd, timeout = 1e4) {
   try {
-    return (0, import_child_process7.execSync)(cmd, {
+    return (0, import_child_process9.execSync)(cmd, {
       encoding: "utf-8",
       timeout,
       stdio: ["pipe", "pipe", "pipe"]
@@ -29497,19 +29682,19 @@ function getVersion(binary, versionCommand) {
 function checkPathExists2(paths) {
   for (const p of paths) {
     if (p.includes("*")) {
-      const home = os14.homedir();
-      const resolved = p.replace(/\*/g, home.split(path11.sep).pop() || "");
-      if (fs8.existsSync(resolved)) return resolved;
+      const home = os15.homedir();
+      const resolved = p.replace(/\*/g, home.split(path12.sep).pop() || "");
+      if (fs9.existsSync(resolved)) return resolved;
     } else {
-      if (fs8.existsSync(p)) return p;
+      if (fs9.existsSync(p)) return p;
     }
   }
   return null;
 }
 function getMacAppVersion(appPath) {
   if ((0, import_os3.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
-  const plistPath = path11.join(appPath, "Contents", "Info.plist");
-  if (!fs8.existsSync(plistPath)) return null;
+  const plistPath = path12.join(appPath, "Contents", "Info.plist");
+  if (!fs9.existsSync(plistPath)) return null;
   const raw = runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
 }
@@ -29535,8 +29720,8 @@ async function detectAllVersions(loader, archive) {
       const cliBin = provider.cli ? findBinary2(provider.cli) : null;
       let resolvedBin = cliBin;
       if (!resolvedBin && appPath && currentOs === "darwin") {
-        const bundled = path11.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-        if (provider.cli && fs8.existsSync(bundled)) resolvedBin = bundled;
+        const bundled = path12.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
+        if (provider.cli && fs9.existsSync(bundled)) resolvedBin = bundled;
       }
       info.installed = !!(appPath || resolvedBin);
       info.path = appPath || null;
@@ -30078,18 +30263,18 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   let scriptsPath = "";
-  const directScripts = path12.join(dir, "scripts.js");
-  if (fs9.existsSync(directScripts)) {
+  const directScripts = path13.join(dir, "scripts.js");
+  if (fs10.existsSync(directScripts)) {
     scriptsPath = directScripts;
   } else {
-    const scriptsDir = path12.join(dir, "scripts");
-    if (fs9.existsSync(scriptsDir)) {
-      const versions = fs9.readdirSync(scriptsDir).filter((d) => {
-        return fs9.statSync(path12.join(scriptsDir, d)).isDirectory();
+    const scriptsDir = path13.join(dir, "scripts");
+    if (fs10.existsSync(scriptsDir)) {
+      const versions = fs10.readdirSync(scriptsDir).filter((d) => {
+        return fs10.statSync(path13.join(scriptsDir, d)).isDirectory();
       }).sort().reverse();
       for (const ver of versions) {
-        const p = path12.join(scriptsDir, ver, "scripts.js");
-        if (fs9.existsSync(p)) {
+        const p = path13.join(scriptsDir, ver, "scripts.js");
+        if (fs10.existsSync(p)) {
           scriptsPath = p;
           break;
         }
@@ -30101,7 +30286,7 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   try {
-    const source = fs9.readFileSync(scriptsPath, "utf-8");
+    const source = fs10.readFileSync(scriptsPath, "utf-8");
     const hints = {};
     const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
     let match;
@@ -31153,45 +31338,45 @@ function resolveAutoImplReference(ctx, category, requestedReference, targetType)
   return fallback?.type || null;
 }
 function getLatestScriptVersionDir(scriptsDir) {
-  if (!fs10.existsSync(scriptsDir)) return null;
-  const versions = fs10.readdirSync(scriptsDir).filter((d) => {
+  if (!fs11.existsSync(scriptsDir)) return null;
+  const versions = fs11.readdirSync(scriptsDir).filter((d) => {
     try {
-      return fs10.statSync(path13.join(scriptsDir, d)).isDirectory();
+      return fs11.statSync(path14.join(scriptsDir, d)).isDirectory();
     } catch {
       return false;
     }
   }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
   if (versions.length === 0) return null;
-  return path13.join(scriptsDir, versions[0]);
+  return path14.join(scriptsDir, versions[0]);
 }
 function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
-  const canonicalUserDir = path13.resolve(ctx.providerLoader.getUserProviderDir(category, type));
-  const desiredDir = requestedDir ? path13.resolve(requestedDir) : canonicalUserDir;
-  const upstreamRoot = path13.resolve(ctx.providerLoader.getUpstreamDir());
-  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path13.sep}`)) {
+  const canonicalUserDir = path14.resolve(ctx.providerLoader.getUserProviderDir(category, type));
+  const desiredDir = requestedDir ? path14.resolve(requestedDir) : canonicalUserDir;
+  const upstreamRoot = path14.resolve(ctx.providerLoader.getUpstreamDir());
+  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path14.sep}`)) {
     return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
   }
-  if (path13.basename(desiredDir) !== type) {
+  if (path14.basename(desiredDir) !== type) {
     return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
   }
   const sourceDir = ctx.findProviderDir(type);
   if (!sourceDir) {
     return { dir: null, reason: `Provider source directory not found for '${type}'` };
   }
-  if (!fs10.existsSync(desiredDir)) {
-    fs10.mkdirSync(path13.dirname(desiredDir), { recursive: true });
-    fs10.cpSync(sourceDir, desiredDir, { recursive: true });
+  if (!fs11.existsSync(desiredDir)) {
+    fs11.mkdirSync(path14.dirname(desiredDir), { recursive: true });
+    fs11.cpSync(sourceDir, desiredDir, { recursive: true });
     ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
   }
-  const providerJson = path13.join(desiredDir, "provider.json");
-  if (!fs10.existsSync(providerJson)) {
+  const providerJson = path14.join(desiredDir, "provider.json");
+  if (!fs11.existsSync(providerJson)) {
     return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
   }
   try {
-    const providerData = JSON.parse(fs10.readFileSync(providerJson, "utf-8"));
+    const providerData = JSON.parse(fs11.readFileSync(providerJson, "utf-8"));
     if (providerData.disableUpstream !== true) {
       providerData.disableUpstream = true;
-      fs10.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
+      fs11.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
     }
   } catch (error48) {
     return {
@@ -31204,15 +31389,15 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
 function loadAutoImplReferenceScripts(ctx, referenceType) {
   if (!referenceType) return {};
   const refDir = ctx.findProviderDir(referenceType);
-  if (!refDir || !fs10.existsSync(refDir)) return {};
+  if (!refDir || !fs11.existsSync(refDir)) return {};
   const referenceScripts = {};
-  const scriptsDir = path13.join(refDir, "scripts");
+  const scriptsDir = path14.join(refDir, "scripts");
   const latestDir = getLatestScriptVersionDir(scriptsDir);
   if (!latestDir) return referenceScripts;
-  for (const file2 of fs10.readdirSync(latestDir)) {
+  for (const file2 of fs11.readdirSync(latestDir)) {
     if (!file2.endsWith(".js")) continue;
     try {
-      referenceScripts[file2] = fs10.readFileSync(path13.join(latestDir, file2), "utf-8");
+      referenceScripts[file2] = fs11.readFileSync(path14.join(latestDir, file2), "utf-8");
     } catch {
     }
   }
@@ -31263,16 +31448,16 @@ async function handleAutoImplement(ctx, type, req, res) {
     });
     const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
     const prompt = buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference);
-    const tmpDir = path13.join(os15.tmpdir(), "adhdev-autoimpl");
-    if (!fs10.existsSync(tmpDir)) fs10.mkdirSync(tmpDir, { recursive: true });
-    const promptFile = path13.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
-    fs10.writeFileSync(promptFile, prompt, "utf-8");
+    const tmpDir = path14.join(os16.tmpdir(), "adhdev-autoimpl");
+    if (!fs11.existsSync(tmpDir)) fs11.mkdirSync(tmpDir, { recursive: true });
+    const promptFile = path14.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
+    fs11.writeFileSync(promptFile, prompt, "utf-8");
     ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
     const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
-    const spawn32 = agentProvider?.spawn;
-    if (!spawn32?.command) {
+    const spawn42 = agentProvider?.spawn;
+    if (!spawn42?.command) {
       try {
-        fs10.unlinkSync(promptFile);
+        fs11.unlinkSync(promptFile);
       } catch {
       }
       ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -31280,21 +31465,21 @@ async function handleAutoImplement(ctx, type, req, res) {
     }
     const agentCategory = agentProvider?.category;
     if (agentCategory === "acp") {
-      sendAutoImplSSE(ctx, { event: "progress", data: { function: "_init", status: "spawning", message: `Spawning ACP agent: ${spawn32.command} ${(spawn32.args || []).join(" ")}` } });
+      sendAutoImplSSE(ctx, { event: "progress", data: { function: "_init", status: "spawning", message: `Spawning ACP agent: ${spawn42.command} ${(spawn42.args || []).join(" ")}` } });
       ctx.autoImplStatus = { running: true, type, progress: [] };
       const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
       const { Readable: Readable22, Writable: Writable2 } = await import("stream");
       const { spawn: spawnFn2 } = await import("child_process");
-      const acpArgs = [...spawn32.args || []];
+      const acpArgs = [...spawn42.args || []];
       if (model) {
         acpArgs.push("--model", model);
         ctx.log(`Auto-implement ACP using model: ${model}`);
       }
-      const child2 = spawnFn2(spawn32.command, acpArgs, {
+      const child2 = spawnFn2(spawn42.command, acpArgs, {
         cwd: providerDir,
         stdio: ["pipe", "pipe", "pipe"],
-        shell: spawn32.shell ?? false,
-        env: { ...process.env, ...spawn32.env || {} }
+        shell: spawn42.shell ?? false,
+        env: { ...process.env, ...spawn42.env || {} }
       });
       ctx.autoImplProcess = child2;
       child2.stderr?.on("data", (d) => {
@@ -31373,7 +31558,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs10.unlinkSync(promptFile);
+          fs11.unlinkSync(promptFile);
         } catch {
         }
         ctx.log(`Auto-implement (ACP) ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -31404,7 +31589,7 @@ async function handleAutoImplement(ctx, type, req, res) {
       ctx.json(res, 202, {
         started: true,
         type,
-        agent: spawn32.command,
+        agent: spawn42.command,
         functions,
         providerDir,
         message: "ACP Auto-implement started. Connect to SSE for progress.",
@@ -31412,11 +31597,11 @@ async function handleAutoImplement(ctx, type, req, res) {
       });
       return;
     }
-    const command = spawn32.command;
+    const command = spawn42.command;
     const interactiveFlags = ["--yolo", "--interactive", "-i"];
-    const baseArgs = [...spawn32.args || []].filter((a) => !interactiveFlags.includes(a));
+    const baseArgs = [...spawn42.args || []].filter((a) => !interactiveFlags.includes(a));
     let shellCmd;
-    const isWin = os15.platform() === "win32";
+    const isWin = os16.platform() === "win32";
     const escapeArg = (a) => isWin ? `"${a.replace(/"/g, '""')}"` : `'${a.replace(/'/g, "'\\''")}'`;
     if (command === "claude") {
       const args = [...baseArgs, "--dangerously-skip-permissions"];
@@ -31459,13 +31644,13 @@ async function handleAutoImplement(ctx, type, req, res) {
     try {
       const pty3 = __require("node-pty");
       ctx.log(`Auto-implement spawn (PTY): ${shellCmd}`);
-      const isWin2 = os15.platform() === "win32";
+      const isWin2 = os16.platform() === "win32";
       child = pty3.spawn(isWin2 ? "cmd.exe" : process.env.SHELL || "/bin/zsh", [isWin2 ? "/c" : "-c", shellCmd], {
         name: "xterm-256color",
         cols: 120,
         rows: 40,
         cwd: providerDir,
-        env: { ...process.env, ...spawn32.env || {} }
+        env: { ...process.env, ...spawn42.env || {} }
       });
       isPty = true;
     } catch (err) {
@@ -31477,7 +31662,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         stdio: ["pipe", "pipe", "pipe"],
         env: {
           ...process.env,
-          ...spawn32.env || {},
+          ...spawn42.env || {},
           ...command === "gemini" ? { SANDBOX: "1", GEMINI_CLI_NO_RELAUNCH: "1" } : {}
         }
       });
@@ -31553,7 +31738,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs10.unlinkSync(promptFile);
+          fs11.unlinkSync(promptFile);
         } catch {
         }
       });
@@ -31589,7 +31774,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs10.unlinkSync(promptFile);
+          fs11.unlinkSync(promptFile);
         } catch {
         }
         ctx.log(`Auto-implement ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -31636,7 +31821,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     setMode: "set_mode.js"
   };
   const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-  const scriptsDir = path13.join(providerDir, "scripts");
+  const scriptsDir = path14.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -31644,10 +31829,10 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
     lines.push("");
-    for (const file2 of fs10.readdirSync(latestScriptsDir)) {
+    for (const file2 of fs11.readdirSync(latestScriptsDir)) {
       if (file2.endsWith(".js") && targetFileNames.has(file2)) {
         try {
-          const content = fs10.readFileSync(path13.join(latestScriptsDir, file2), "utf-8");
+          const content = fs11.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -31657,14 +31842,14 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
         }
       }
     }
-    const refFiles = fs10.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs11.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file2 of refFiles) {
         try {
-          const content = fs10.readFileSync(path13.join(latestScriptsDir, file2), "utf-8");
+          const content = fs11.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -31705,11 +31890,11 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
       lines.push("");
     }
   }
-  const docsDir = path13.join(providerDir, "../../docs");
+  const docsDir = path14.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path13.join(docsDir, name);
-      if (fs10.existsSync(p)) return fs10.readFileSync(p, "utf-8");
+      const p = path14.join(docsDir, name);
+      if (fs11.existsSync(p)) return fs11.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -31882,7 +32067,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     parseApproval: "parse_approval.js"
   };
   const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-  const scriptsDir = path13.join(providerDir, "scripts");
+  const scriptsDir = path14.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -31890,11 +32075,11 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
     lines.push("");
-    for (const file2 of fs10.readdirSync(latestScriptsDir)) {
+    for (const file2 of fs11.readdirSync(latestScriptsDir)) {
       if (!file2.endsWith(".js")) continue;
       if (!targetFileNames.has(file2)) continue;
       try {
-        const content = fs10.readFileSync(path13.join(latestScriptsDir, file2), "utf-8");
+        const content = fs11.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
         lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -31903,14 +32088,14 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       } catch {
       }
     }
-    const refFiles = fs10.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs11.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file2 of refFiles) {
         try {
-          const content = fs10.readFileSync(path13.join(latestScriptsDir, file2), "utf-8");
+          const content = fs11.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -31943,11 +32128,11 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       lines.push("");
     }
   }
-  const docsDir = path13.join(providerDir, "../../docs");
+  const docsDir = path14.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path13.join(docsDir, name);
-      if (fs10.existsSync(p)) return fs10.readFileSync(p, "utf-8");
+      const p = path14.join(docsDir, name);
+      if (fs11.existsSync(p)) return fs11.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -32202,8 +32387,8 @@ var DevServer = class _DevServer {
   }
   getEndpointList() {
     return this.routes.map((r) => {
-      const path152 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-      return `${r.method.padEnd(5)} ${path152}`;
+      const path162 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+      return `${r.method.padEnd(5)} ${path162}`;
     });
   }
   async start(port = DEV_SERVER_PORT) {
@@ -32304,16 +32489,16 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const spawn32 = provider.spawn;
-    if (!spawn32) {
+    const spawn42 = provider.spawn;
+    if (!spawn42) {
       this.json(res, 400, { error: `Provider ${type} has no spawn config` });
       return;
     }
     const { spawn: spawnFn } = await import("child_process");
     const start = Date.now();
     try {
-      const child = spawnFn(spawn32.command, [...spawn32.args || []], {
-        shell: spawn32.shell ?? false,
+      const child = spawnFn(spawn42.command, [...spawn42.args || []], {
+        shell: spawn42.shell ?? false,
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -32345,7 +32530,7 @@ var DevServer = class _DevServer {
       const elapsed = Date.now() - start;
       this.json(res, 200, {
         success: true,
-        command: `${spawn32.command} ${(spawn32.args || []).join(" ")}`,
+        command: `${spawn42.command} ${(spawn42.args || []).join(" ")}`,
         elapsed,
         stdout: stdout.trim(),
         stderr: stderr.trim(),
@@ -32355,7 +32540,7 @@ var DevServer = class _DevServer {
       const elapsed = Date.now() - start;
       this.json(res, 200, {
         success: false,
-        command: `${spawn32.command} ${(spawn32.args || []).join(" ")}`,
+        command: `${spawn42.command} ${(spawn42.args || []).join(" ")}`,
         elapsed,
         error: e.message
       });
@@ -32485,12 +32670,12 @@ var DevServer = class _DevServer {
   // ─── DevConsole SPA ───
   getConsoleDistDir() {
     const candidates = [
-      path14.resolve(__dirname, "../../web-devconsole/dist"),
-      path14.resolve(__dirname, "../../../web-devconsole/dist"),
-      path14.join(process.cwd(), "packages/web-devconsole/dist")
+      path15.resolve(__dirname, "../../web-devconsole/dist"),
+      path15.resolve(__dirname, "../../../web-devconsole/dist"),
+      path15.join(process.cwd(), "packages/web-devconsole/dist")
     ];
     for (const dir of candidates) {
-      if (fs11.existsSync(path14.join(dir, "index.html"))) return dir;
+      if (fs12.existsSync(path15.join(dir, "index.html"))) return dir;
     }
     return null;
   }
@@ -32500,9 +32685,9 @@ var DevServer = class _DevServer {
       this.json(res, 500, { error: "DevConsole not found. Run: npm run build -w packages/web-devconsole" });
       return;
     }
-    const htmlPath = path14.join(distDir, "index.html");
+    const htmlPath = path15.join(distDir, "index.html");
     try {
-      const html = fs11.readFileSync(htmlPath, "utf-8");
+      const html = fs12.readFileSync(htmlPath, "utf-8");
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
       res.end(html);
     } catch (e) {
@@ -32525,15 +32710,15 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: "Not found" });
       return;
     }
-    const safePath = path14.normalize(pathname).replace(/^\.\.\//, "");
-    const filePath = path14.join(distDir, safePath);
+    const safePath = path15.normalize(pathname).replace(/^\.\.\//, "");
+    const filePath = path15.join(distDir, safePath);
     if (!filePath.startsWith(distDir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
     try {
-      const content = fs11.readFileSync(filePath);
-      const ext = path14.extname(filePath);
+      const content = fs12.readFileSync(filePath);
+      const ext = path15.extname(filePath);
       const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
       res.end(content);
@@ -32641,14 +32826,14 @@ var DevServer = class _DevServer {
     const files = [];
     const scan = (d, prefix) => {
       try {
-        for (const entry of fs11.readdirSync(d, { withFileTypes: true })) {
+        for (const entry of fs12.readdirSync(d, { withFileTypes: true })) {
           if (entry.name.startsWith(".") || entry.name.endsWith(".bak")) continue;
           const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
           if (entry.isDirectory()) {
             files.push({ path: rel, size: 0, type: "dir" });
-            scan(path14.join(d, entry.name), rel);
+            scan(path15.join(d, entry.name), rel);
           } else {
-            const stat4 = fs11.statSync(path14.join(d, entry.name));
+            const stat4 = fs12.statSync(path15.join(d, entry.name));
             files.push({ path: rel, size: stat4.size, type: "file" });
           }
         }
@@ -32671,16 +32856,16 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path14.resolve(dir, path14.normalize(filePath));
+    const fullPath = path15.resolve(dir, path15.normalize(filePath));
     if (!fullPath.startsWith(dir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
-    if (!fs11.existsSync(fullPath) || fs11.statSync(fullPath).isDirectory()) {
+    if (!fs12.existsSync(fullPath) || fs12.statSync(fullPath).isDirectory()) {
       this.json(res, 404, { error: `File not found: ${filePath}` });
       return;
     }
-    const content = fs11.readFileSync(fullPath, "utf-8");
+    const content = fs12.readFileSync(fullPath, "utf-8");
     this.json(res, 200, { type, path: filePath, content, lines: content.split("\n").length });
   }
   /** POST /api/providers/:type/file — write a file { path, content } */
@@ -32696,15 +32881,15 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path14.resolve(dir, path14.normalize(filePath));
+    const fullPath = path15.resolve(dir, path15.normalize(filePath));
     if (!fullPath.startsWith(dir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
     try {
-      if (fs11.existsSync(fullPath)) fs11.copyFileSync(fullPath, fullPath + ".bak");
-      fs11.mkdirSync(path14.dirname(fullPath), { recursive: true });
-      fs11.writeFileSync(fullPath, content, "utf-8");
+      if (fs12.existsSync(fullPath)) fs12.copyFileSync(fullPath, fullPath + ".bak");
+      fs12.mkdirSync(path15.dirname(fullPath), { recursive: true });
+      fs12.writeFileSync(fullPath, content, "utf-8");
       this.log(`File saved: ${fullPath} (${content.length} chars)`);
       this.providerLoader.reload();
       this.json(res, 200, { saved: true, path: filePath, chars: content.length });
@@ -32720,9 +32905,9 @@ var DevServer = class _DevServer {
       return;
     }
     for (const name of ["scripts.js", "provider.json"]) {
-      const p = path14.join(dir, name);
-      if (fs11.existsSync(p)) {
-        const source = fs11.readFileSync(p, "utf-8");
+      const p = path15.join(dir, name);
+      if (fs12.existsSync(p)) {
+        const source = fs12.readFileSync(p, "utf-8");
         this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
         return;
       }
@@ -32741,11 +32926,11 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const target = fs11.existsSync(path14.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
-    const targetPath = path14.join(dir, target);
+    const target = fs12.existsSync(path15.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+    const targetPath = path15.join(dir, target);
     try {
-      if (fs11.existsSync(targetPath)) fs11.copyFileSync(targetPath, targetPath + ".bak");
-      fs11.writeFileSync(targetPath, source, "utf-8");
+      if (fs12.existsSync(targetPath)) fs12.copyFileSync(targetPath, targetPath + ".bak");
+      fs12.writeFileSync(targetPath, source, "utf-8");
       this.log(`Saved provider: ${targetPath} (${source.length} chars)`);
       this.providerLoader.reload();
       this.json(res, 200, { saved: true, path: targetPath, chars: source.length });
@@ -32824,20 +33009,20 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const spawn32 = provider.spawn;
-    if (!spawn32) {
+    const spawn42 = provider.spawn;
+    if (!spawn42) {
       this.json(res, 400, { error: `Provider ${type} has no spawn config` });
       return;
     }
     const { spawn: spawnFn } = await import("child_process");
     const start = Date.now();
     try {
-      const args = [...spawn32.args || [], message];
-      const child = spawnFn(spawn32.command, args, {
-        shell: spawn32.shell ?? false,
+      const args = [...spawn42.args || [], message];
+      const child = spawnFn(spawn42.command, args, {
+        shell: spawn42.shell ?? false,
         timeout,
         stdio: ["pipe", "pipe", "pipe"],
-        env: { ...process.env, ...spawn32.env || {} }
+        env: { ...process.env, ...spawn42.env || {} }
       });
       let stdout = "";
       let stderr = "";
@@ -32902,21 +33087,21 @@ var DevServer = class _DevServer {
     }
     let targetDir;
     targetDir = this.providerLoader.getUserProviderDir(category, type);
-    const jsonPath = path14.join(targetDir, "provider.json");
-    if (fs11.existsSync(jsonPath)) {
+    const jsonPath = path15.join(targetDir, "provider.json");
+    if (fs12.existsSync(jsonPath)) {
       this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
       return;
     }
     try {
       const result = generateFiles(type, name, category, { cdpPorts, cli, processName, installPath, binary, extensionId, version: version2, osPaths, processNames });
-      fs11.mkdirSync(targetDir, { recursive: true });
-      fs11.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+      fs12.mkdirSync(targetDir, { recursive: true });
+      fs12.writeFileSync(jsonPath, result["provider.json"], "utf-8");
       const createdFiles = ["provider.json"];
       if (result.files) {
         for (const [relPath, content] of Object.entries(result.files)) {
-          const fullPath = path14.join(targetDir, relPath);
-          fs11.mkdirSync(path14.dirname(fullPath), { recursive: true });
-          fs11.writeFileSync(fullPath, content, "utf-8");
+          const fullPath = path15.join(targetDir, relPath);
+          fs12.mkdirSync(path15.dirname(fullPath), { recursive: true });
+          fs12.writeFileSync(fullPath, content, "utf-8");
           createdFiles.push(relPath);
         }
       }
@@ -32965,45 +33150,45 @@ var DevServer = class _DevServer {
   }
   // ─── Phase 2: Auto-Implement Backend ───
   getLatestScriptVersionDir(scriptsDir) {
-    if (!fs11.existsSync(scriptsDir)) return null;
-    const versions = fs11.readdirSync(scriptsDir).filter((d) => {
+    if (!fs12.existsSync(scriptsDir)) return null;
+    const versions = fs12.readdirSync(scriptsDir).filter((d) => {
       try {
-        return fs11.statSync(path14.join(scriptsDir, d)).isDirectory();
+        return fs12.statSync(path15.join(scriptsDir, d)).isDirectory();
       } catch {
         return false;
       }
     }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
     if (versions.length === 0) return null;
-    return path14.join(scriptsDir, versions[0]);
+    return path15.join(scriptsDir, versions[0]);
   }
   resolveAutoImplWritableProviderDir(category, type, requestedDir) {
-    const canonicalUserDir = path14.resolve(this.providerLoader.getUserProviderDir(category, type));
-    const desiredDir = requestedDir ? path14.resolve(requestedDir) : canonicalUserDir;
-    const upstreamRoot = path14.resolve(this.providerLoader.getUpstreamDir());
-    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path14.sep}`)) {
+    const canonicalUserDir = path15.resolve(this.providerLoader.getUserProviderDir(category, type));
+    const desiredDir = requestedDir ? path15.resolve(requestedDir) : canonicalUserDir;
+    const upstreamRoot = path15.resolve(this.providerLoader.getUpstreamDir());
+    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path15.sep}`)) {
       return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
     }
-    if (path14.basename(desiredDir) !== type) {
+    if (path15.basename(desiredDir) !== type) {
       return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
     }
     const sourceDir = this.findProviderDir(type);
     if (!sourceDir) {
       return { dir: null, reason: `Provider source directory not found for '${type}'` };
     }
-    if (!fs11.existsSync(desiredDir)) {
-      fs11.mkdirSync(path14.dirname(desiredDir), { recursive: true });
-      fs11.cpSync(sourceDir, desiredDir, { recursive: true });
+    if (!fs12.existsSync(desiredDir)) {
+      fs12.mkdirSync(path15.dirname(desiredDir), { recursive: true });
+      fs12.cpSync(sourceDir, desiredDir, { recursive: true });
       this.log(`Auto-implement writable copy created: ${desiredDir}`);
     }
-    const providerJson = path14.join(desiredDir, "provider.json");
-    if (!fs11.existsSync(providerJson)) {
+    const providerJson = path15.join(desiredDir, "provider.json");
+    if (!fs12.existsSync(providerJson)) {
       return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
     }
     try {
-      const providerData = JSON.parse(fs11.readFileSync(providerJson, "utf-8"));
+      const providerData = JSON.parse(fs12.readFileSync(providerJson, "utf-8"));
       if (providerData.disableUpstream !== true) {
         providerData.disableUpstream = true;
-        fs11.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
+        fs12.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
       }
     } catch (error48) {
       return {
@@ -33043,7 +33228,7 @@ var DevServer = class _DevServer {
       setMode: "set_mode.js"
     };
     const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-    const scriptsDir = path14.join(providerDir, "scripts");
+    const scriptsDir = path15.join(providerDir, "scripts");
     const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
     if (latestScriptsDir) {
       lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -33051,10 +33236,10 @@ var DevServer = class _DevServer {
       lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
       lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
       lines.push("");
-      for (const file2 of fs11.readdirSync(latestScriptsDir)) {
+      for (const file2 of fs12.readdirSync(latestScriptsDir)) {
         if (file2.endsWith(".js") && targetFileNames.has(file2)) {
           try {
-            const content = fs11.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
+            const content = fs12.readFileSync(path15.join(latestScriptsDir, file2), "utf-8");
             lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -33064,14 +33249,14 @@ var DevServer = class _DevServer {
           }
         }
       }
-      const refFiles = fs11.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+      const refFiles = fs12.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
       if (refFiles.length > 0) {
         lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
         lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
         lines.push("");
         for (const file2 of refFiles) {
           try {
-            const content = fs11.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
+            const content = fs12.readFileSync(path15.join(latestScriptsDir, file2), "utf-8");
             lines.push(`### \`${file2}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -33112,11 +33297,11 @@ var DevServer = class _DevServer {
         lines.push("");
       }
     }
-    const docsDir = path14.join(providerDir, "../../docs");
+    const docsDir = path15.join(providerDir, "../../docs");
     const loadGuide = (name) => {
       try {
-        const p = path14.join(docsDir, name);
-        if (fs11.existsSync(p)) return fs11.readFileSync(p, "utf-8");
+        const p = path15.join(docsDir, name);
+        if (fs12.existsSync(p)) return fs12.readFileSync(p, "utf-8");
       } catch {
       }
       return null;
@@ -33289,7 +33474,7 @@ var DevServer = class _DevServer {
       parseApproval: "parse_approval.js"
     };
     const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-    const scriptsDir = path14.join(providerDir, "scripts");
+    const scriptsDir = path15.join(providerDir, "scripts");
     const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
     if (latestScriptsDir) {
       lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -33297,11 +33482,11 @@ var DevServer = class _DevServer {
       lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
       lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
       lines.push("");
-      for (const file2 of fs11.readdirSync(latestScriptsDir)) {
+      for (const file2 of fs12.readdirSync(latestScriptsDir)) {
         if (!file2.endsWith(".js")) continue;
         if (!targetFileNames.has(file2)) continue;
         try {
-          const content = fs11.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
+          const content = fs12.readFileSync(path15.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -33310,14 +33495,14 @@ var DevServer = class _DevServer {
         } catch {
         }
       }
-      const refFiles = fs11.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+      const refFiles = fs12.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
       if (refFiles.length > 0) {
         lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
         lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
         lines.push("");
         for (const file2 of refFiles) {
           try {
-            const content = fs11.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
+            const content = fs12.readFileSync(path15.join(latestScriptsDir, file2), "utf-8");
             lines.push(`### \`${file2}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -33350,11 +33535,11 @@ var DevServer = class _DevServer {
         lines.push("");
       }
     }
-    const docsDir = path14.join(providerDir, "../../docs");
+    const docsDir = path15.join(providerDir, "../../docs");
     const loadGuide = (name) => {
       try {
-        const p = path14.join(docsDir, name);
-        if (fs11.existsSync(p)) return fs11.readFileSync(p, "utf-8");
+        const p = path15.join(docsDir, name);
+        if (fs12.existsSync(p)) return fs12.readFileSync(p, "utf-8");
       } catch {
       }
       return null;
@@ -34208,8 +34393,8 @@ async function shutdownDaemonComponents(components) {
 }
 
 // src/session-host.ts
-var import_child_process8 = require("child_process");
-var path15 = __toESM(require("path"));
+var import_child_process10 = require("child_process");
+var path16 = __toESM(require("path"));
 var SESSION_HOST_APP_NAME = process.env.ADHDEV_SESSION_HOST_NAME || "adhdev";
 function buildSessionHostEnv(baseEnv) {
   const env = {};
@@ -34227,8 +34412,8 @@ function buildSessionHostEnv(baseEnv) {
 }
 function resolveSessionHostEntry() {
   const localCandidates = [
-    path15.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
-    path15.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
+    path16.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
+    path16.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
   ];
   for (const candidate of localCandidates) {
     if (require("fs").existsSync(candidate)) {
@@ -34239,7 +34424,7 @@ function resolveSessionHostEntry() {
 }
 async function runSessionHostCli(args) {
   const entry = resolveSessionHostEntry();
-  const child = (0, import_child_process8.spawn)(process.execPath, [entry, ...args], {
+  const child = (0, import_child_process10.spawn)(process.execPath, [entry, ...args], {
     stdio: "inherit",
     env: buildSessionHostEnv(process.env)
   });
@@ -34253,7 +34438,7 @@ async function ensureSessionHostReady2() {
     appName: SESSION_HOST_APP_NAME,
     spawnHost: () => {
       const entry = resolveSessionHostEntry();
-      const child = (0, import_child_process8.spawn)(process.execPath, [entry], {
+      const child = (0, import_child_process10.spawn)(process.execPath, [entry], {
         detached: true,
         stdio: "ignore",
         windowsHide: true,
@@ -34442,12 +34627,12 @@ var pkgVersion = process.env.ADHDEV_PKG_VERSION || "unknown";
 if (pkgVersion === "unknown") {
   try {
     const possiblePaths = [
-      path17.join(__dirname, "..", "package.json"),
-      path17.join(__dirname, "package.json")
+      path18.join(__dirname, "..", "package.json"),
+      path18.join(__dirname, "package.json")
     ];
     for (const candidate of possiblePaths) {
       try {
-        const data = JSON.parse(fs12.readFileSync(candidate, "utf-8"));
+        const data = JSON.parse(fs13.readFileSync(candidate, "utf-8"));
         if (data.version) {
           pkgVersion = data.version;
           break;
@@ -34510,6 +34695,10 @@ var StandaloneServer = class {
   isTerminalCliSession(sessionId) {
     return this.getCliPresentationMode(sessionId) === "terminal";
   }
+  isCliSession(sessionId) {
+    const mode = this.getCliPresentationMode(sessionId);
+    return mode === "chat" || mode === "terminal";
+  }
   async start(options = {}) {
     const port = options.port || DEFAULT_PORT;
     const host = options.host || "127.0.0.1";
@@ -34521,7 +34710,7 @@ var StandaloneServer = class {
         getServerConn: () => null,
         getP2p: () => ({
           broadcastPtyOutput: (key, data) => {
-            if (this.clients.size === 0 || !this.isTerminalCliSession(key)) return;
+            if (this.clients.size === 0 || !this.isCliSession(key)) return;
             const msg = JSON.stringify({ type: "pty_output", sessionId: key, data });
             for (const client of this.clients) {
               if (client.readyState === 1) {
@@ -34736,9 +34925,9 @@ var StandaloneServer = class {
         return;
       }
       if (action === "snapshot" && method === "GET") {
-        if (!this.isTerminalCliSession(sessionId)) {
+        if (!this.isCliSession(sessionId)) {
           res.writeHead(409, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "CLI session is not in terminal mode", code: "CLI_VIEW_MODE_NOT_TERMINAL" }));
+          res.end(JSON.stringify({ error: "CLI session runtime unavailable", code: "CLI_RUNTIME_UNAVAILABLE" }));
           return;
         }
         void (async () => {
@@ -34790,9 +34979,9 @@ var StandaloneServer = class {
     }
     if (publicDir) {
       const filePath = url2 === "/" ? "/index.html" : url2;
-      const fullPath = path17.join(publicDir, filePath);
-      if (fs12.existsSync(fullPath) && fs12.statSync(fullPath).isFile()) {
-        const ext = path17.extname(fullPath);
+      const fullPath = path18.join(publicDir, filePath);
+      if (fs13.existsSync(fullPath) && fs13.statSync(fullPath).isFile()) {
+        const ext = path18.extname(fullPath);
         const mimeTypes = {
           ".html": "text/html",
           ".js": "application/javascript",
@@ -34804,13 +34993,13 @@ var StandaloneServer = class {
           ".woff2": "font/woff2"
         };
         res.writeHead(200, { "Content-Type": mimeTypes[ext] || "application/octet-stream" });
-        fs12.createReadStream(fullPath).pipe(res);
+        fs13.createReadStream(fullPath).pipe(res);
         return;
       }
-      const indexPath = path17.join(publicDir, "index.html");
-      if (fs12.existsSync(indexPath) && !url2.startsWith("/api/")) {
+      const indexPath = path18.join(publicDir, "index.html");
+      if (fs13.existsSync(indexPath) && !url2.startsWith("/api/")) {
         res.writeHead(200, { "Content-Type": "text/html" });
-        fs12.createReadStream(indexPath).pipe(res);
+        fs13.createReadStream(indexPath).pipe(res);
         return;
       }
     }
@@ -34862,9 +35051,9 @@ var StandaloneServer = class {
     req.on("aborted", cleanup);
   }
   async handleRuntimeEvents(req, res, sessionId) {
-    if (!this.isTerminalCliSession(sessionId)) {
+    if (!this.isCliSession(sessionId)) {
       res.writeHead(409, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "CLI session is not in terminal mode", code: "CLI_VIEW_MODE_NOT_TERMINAL" }));
+      res.end(JSON.stringify({ error: "CLI session runtime unavailable", code: "CLI_RUNTIME_UNAVAILABLE" }));
       return;
     }
     const client = await this.createSessionHostClient();
@@ -34886,7 +35075,7 @@ var StandaloneServer = class {
     }
     const writeEvent = (event) => {
       if (event.sessionId !== sessionId) return;
-      if (!this.isTerminalCliSession(sessionId)) return;
+      if (!this.isCliSession(sessionId)) return;
       res.write(`event: ${event.type}
 `);
       res.write(`data: ${JSON.stringify(event)}
@@ -34974,7 +35163,7 @@ var StandaloneServer = class {
       const states = this.components.instanceManager.collectAllStates();
       for (const state of states) {
         const sessionId = typeof state?.instanceId === "string" ? state.instanceId : "";
-        if (!sessionId || state?.category !== "cli" || state?.mode !== "terminal") continue;
+        if (!sessionId || state?.category !== "cli") continue;
         const snapshot = await client.request({
           type: "get_snapshot",
           payload: { sessionId }
@@ -35051,7 +35240,7 @@ var StandaloneServer = class {
   }
   // ─── Network ───
   getLanIPs() {
-    const interfaces = os17.networkInterfaces();
+    const interfaces = os18.networkInterfaces();
     const ips = [];
     for (const iface of Object.values(interfaces)) {
       if (!iface) continue;
@@ -35095,6 +35284,10 @@ var StandaloneServer = class {
   }
 };
 async function main() {
+  const helperMode = await maybeRunDaemonUpgradeHelperFromEnv();
+  if (helperMode) {
+    return;
+  }
   const args = process.argv.slice(2);
   const primaryCommand = args[0] || "";
   if (primaryCommand === "attach") {
@@ -35161,12 +35354,12 @@ Runtime commands:
   }
   if (!options.publicDir) {
     const candidates = [
-      path17.join(__dirname, "../../web-standalone/dist"),
-      path17.join(__dirname, "../public"),
-      path17.join(process.cwd(), "public")
+      path18.join(__dirname, "../../web-standalone/dist"),
+      path18.join(__dirname, "../public"),
+      path18.join(process.cwd(), "public")
     ];
     for (const candidate of candidates) {
-      if (fs12.existsSync(path17.join(candidate, "index.html"))) {
+      if (fs13.existsSync(path18.join(candidate, "index.html"))) {
         options.publicDir = candidate;
         break;
       }