adhdev 0.7.42 → 0.7.44

package/dist/cli/index.js

@@ -508,18 +508,18 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs() {
-  const os21 = (0, import_os2.platform)();
+  const os22 = (0, import_os2.platform)();
   const results = [];
   for (const def of getMergedDefinitions()) {
     const cliPath = findCliCommand(def.cli);
-    const appPath = checkPathExists(def.paths[os21] || []);
+    const appPath = checkPathExists(def.paths[os22] || []);
     const installed = !!(cliPath || appPath);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os21 === "darwin") {
+    if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if ((0, import_fs2.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os21 === "win32") {
+    if (!resolvedCli && appPath && os22 === "win32") {
       const { dirname: dirname10 } = await import("path");
       const appDir = dirname10(appPath);
       const candidates = [
@@ -2539,8 +2539,6 @@ var init_chat_history = __esm({
       lastSeenCounts = /* @__PURE__ */ new Map();
       /** Last seen message hash per agent (deduplication) */
       lastSeenHashes = /* @__PURE__ */ new Map();
-      /** Last seen append-only terminal transcript per agent */
-      lastSeenTerminal = /* @__PURE__ */ new Map();
       rotated = false;
       /**
       * Append new messages to history
@@ -2598,51 +2596,10 @@ var init_chat_history = __esm({
         } catch {
         }
       }
-      appendTerminalHistory(agentType, terminalHistory, sessionTitle, instanceId) {
-        const next = String(terminalHistory || "");
-        if (!next.trim()) return;
-        try {
-          const dedupKey = instanceId ? `${agentType}:${instanceId}:terminal` : `${agentType}:terminal`;
-          const prev = this.lastSeenTerminal.get(dedupKey) || "";
-          if (prev === next) return;
-          let delta = "";
-          if (!prev) {
-            delta = next;
-          } else if (next.startsWith(prev)) {
-            delta = next.slice(prev.length);
-          } else if (prev.includes(next)) {
-            this.lastSeenTerminal.set(dedupKey, next);
-            return;
-          } else {
-            delta = `
-
-[terminal snapshot reset ${(/* @__PURE__ */ new Date()).toISOString()} | ${sessionTitle || agentType}]
-${next}`;
-          }
-          if (!delta) {
-            this.lastSeenTerminal.set(dedupKey, next);
-            return;
-          }
-          const dir = path4.join(HISTORY_DIR, this.sanitize(agentType));
-          fs3.mkdirSync(dir, { recursive: true });
-          const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-          const filePrefix = instanceId ? `${this.sanitize(instanceId)}_` : "";
-          const filePath = path4.join(dir, `${filePrefix}${date5}.terminal.log`);
-          fs3.appendFileSync(filePath, delta, "utf-8");
-          this.lastSeenTerminal.set(dedupKey, next);
-          if (!this.rotated) {
-            this.rotated = true;
-            this.rotateOldFiles().catch(() => {
-            });
-          }
-        } catch {
-        }
-      }
       /** Called when agent session is explicitly changed */
       onSessionChange(agentType) {
         this.lastSeenHashes.delete(agentType);
         this.lastSeenCounts.delete(agentType);
-        this.lastSeenTerminal.delete(`${agentType}:terminal`);
       }
       /** Delete history files older than 30 days */
       async rotateOldFiles() {
@@ -3488,11 +3445,6 @@ function truncateString(value, maxChars) {
   if (maxChars <= 12) return value.slice(0, Math.max(0, maxChars));
   return `${value.slice(0, maxChars - 12)}...[truncated]`;
 }
-function truncateStringTail(value, maxChars) {
-  if (value.length <= maxChars) return value;
-  if (maxChars <= 12) return value.slice(value.length - Math.max(0, maxChars));
-  return `...[truncated]${value.slice(value.length - (maxChars - 12))}`;
-}
 function trimStructuredStrings(value, maxChars) {
   if (typeof value === "string") return truncateString(value, maxChars);
   if (Array.isArray(value)) return value.map((item) => trimStructuredStrings(item, maxChars));
@@ -3566,11 +3518,10 @@ function normalizeActiveChatData(activeChat) {
         (button) => truncateString(String(button || ""), STATUS_MODAL_BUTTON_LIMIT)
       )
     } : activeChat.activeModal,
-    terminalHistory: activeChat.terminalHistory ? truncateStringTail(activeChat.terminalHistory, STATUS_TERMINAL_HISTORY_LIMIT) : activeChat.terminalHistory,
     inputContent: activeChat.inputContent ? truncateString(activeChat.inputContent, STATUS_INPUT_CONTENT_LIMIT) : activeChat.inputContent
   };
 }
-var WORKING_STATUSES, STATUS_ACTIVE_CHAT_MESSAGE_LIMIT, STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT, STATUS_ACTIVE_CHAT_STRING_LIMIT, STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT, STATUS_TERMINAL_HISTORY_LIMIT, STATUS_INPUT_CONTENT_LIMIT, STATUS_MODAL_MESSAGE_LIMIT, STATUS_MODAL_BUTTON_LIMIT;
+var WORKING_STATUSES, STATUS_ACTIVE_CHAT_MESSAGE_LIMIT, STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT, STATUS_ACTIVE_CHAT_STRING_LIMIT, STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT, STATUS_INPUT_CONTENT_LIMIT, STATUS_MODAL_MESSAGE_LIMIT, STATUS_MODAL_BUTTON_LIMIT;
 var init_normalize = __esm({
   "../../oss/packages/daemon-core/src/status/normalize.ts"() {
     "use strict";
@@ -3586,7 +3537,6 @@ var init_normalize = __esm({
     STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT = 96 * 1024;
     STATUS_ACTIVE_CHAT_STRING_LIMIT = 4 * 1024;
     STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT = 1024;
-    STATUS_TERMINAL_HISTORY_LIMIT = 8 * 1024;
     STATUS_INPUT_CONTENT_LIMIT = 2 * 1024;
     STATUS_MODAL_MESSAGE_LIMIT = 2 * 1024;
     STATUS_MODAL_BUTTON_LIMIT = 120;
@@ -5860,7 +5810,7 @@ var init_readdirp = __esm({
         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;
         }
@@ -5885,8 +5835,8 @@ var init_readdirp = __esm({
             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)
@@ -5926,20 +5876,20 @@ var init_readdirp = __esm({
           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) {
@@ -5996,16 +5946,16 @@ var init_readdirp = __esm({
 });
 
 // ../../oss/packages/daemon-core/node_modules/chokidar/handler.js
-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) {
@@ -6354,12 +6304,12 @@ var init_handler2 = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path18, fullPath, options, handlers) => {
+    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);
@@ -6370,7 +6320,7 @@ var init_handler2 = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path18,
+          path19,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -6385,7 +6335,7 @@ var init_handler2 = __esm({
             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) {
@@ -6416,7 +6366,7 @@ var init_handler2 = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path18, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path19, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -6438,7 +6388,7 @@ var init_handler2 = __esm({
             });
             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));
             }
           })
         };
@@ -6468,13 +6418,13 @@ var init_handler2 = __esm({
        * @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
         };
@@ -6484,12 +6434,12 @@ var init_handler2 = __esm({
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
           options.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(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
@@ -6511,7 +6461,7 @@ var init_handler2 = __esm({
         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) {
@@ -6525,11 +6475,11 @@ var init_handler2 = __esm({
                 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;
               }
@@ -6561,7 +6511,7 @@ var init_handler2 = __esm({
        * @param item basename of this item
        * @returns true if no more processing is needed for this entry.
        */
-      async _handleSymlink(entry, directory, path18, item) {
+      async _handleSymlink(entry, directory, path19, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -6571,7 +6521,7 @@ var init_handler2 = __esm({
           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;
@@ -6581,12 +6531,12 @@ var init_handler2 = __esm({
           if (dir.has(item)) {
             if (this.fsw._symlinkPaths.get(full) !== linkPath) {
               this.fsw._symlinkPaths.set(full, linkPath);
-              this.fsw._emit(EV.CHANGE, 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;
@@ -6616,9 +6566,9 @@ var init_handler2 = __esm({
             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) {
@@ -6627,8 +6577,8 @@ var init_handler2 = __esm({
           }
           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) => {
@@ -6697,13 +6647,13 @@ var init_handler2 = __esm({
        * @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);
@@ -6719,8 +6669,8 @@ var init_handler2 = __esm({
           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);
@@ -6730,29 +6680,29 @@ var init_handler2 = __esm({
               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;
           }
         }
       }
@@ -6787,24 +6737,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;
     }
   }
@@ -6867,19 +6817,19 @@ var init_chokidar = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path18) => toUnix(sp2.normalize(toUnix(path18)));
-    normalizeIgnored = (cwd = "") => (path18) => {
-      if (typeof path18 === "string") {
-        return normalizePathToUnix(sp2.isAbsolute(path18) ? path18 : sp2.join(cwd, path18));
+    normalizePathToUnix = (path19) => toUnix(sp2.normalize(toUnix(path19)));
+    normalizeIgnored = (cwd = "") => (path19) => {
+      if (typeof path19 === "string") {
+        return normalizePathToUnix(sp2.isAbsolute(path19) ? path19 : sp2.join(cwd, path19));
       } else {
-        return path18;
+        return path19;
       }
     };
-    getAbsolutePath = (path18, cwd) => {
-      if (sp2.isAbsolute(path18)) {
-        return path18;
+    getAbsolutePath = (path19, cwd) => {
+      if (sp2.isAbsolute(path19)) {
+        return path19;
       }
-      return sp2.join(cwd, path18);
+      return sp2.join(cwd, path19);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -6944,10 +6894,10 @@ var init_chokidar = __esm({
       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 = [];
@@ -7087,20 +7037,20 @@ var init_chokidar = __esm({
         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;
@@ -7122,17 +7072,17 @@ var init_chokidar = __esm({
           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
             });
           }
@@ -7196,38 +7146,38 @@ var init_chokidar = __esm({
        * @param stats arguments to be passed with event
        * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
        */
-      async _emit(event, 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) {
@@ -7245,16 +7195,16 @@ var init_chokidar = __esm({
               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);
@@ -7285,23 +7235,23 @@ var init_chokidar = __esm({
        * @param timeout duration of time to suppress duplicate actions
        * @returns tracking object or false if action should be suppressed
        */
-      _throttle(actionType, 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);
@@ -7309,7 +7259,7 @@ var init_chokidar = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path18, thr);
+        action.set(path19, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -7323,44 +7273,44 @@ var init_chokidar = __esm({
        * @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;
             }
@@ -7371,8 +7321,8 @@ var init_chokidar = __esm({
       /**
        * 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;
@@ -7382,17 +7332,17 @@ var init_chokidar = __esm({
           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
       // -----------------
@@ -7424,63 +7374,63 @@ var init_chokidar = __esm({
        * @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);
       }
@@ -8679,7 +8629,7 @@ function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs16 = require("fs");
+      const fs17 = require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
@@ -8688,8 +8638,8 @@ function detectCurrentWorkspace(ideId) {
           appName,
           "storage.json"
         );
-        if (fs16.existsSync(storagePath)) {
-          const data = JSON.parse(fs16.readFileSync(storagePath, "utf-8"));
+        if (fs17.existsSync(storagePath)) {
+          const data = JSON.parse(fs17.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -9093,6 +9043,9 @@ var init_ghostty_vt_backend = __esm({
       getText() {
         return this.terminal.formatPlainText({ trim: true }) || "";
       }
+      getCursorPosition() {
+        return this.terminal.getCursorPosition();
+      }
       dispose() {
         this.terminal.dispose();
       }
@@ -18245,6 +18198,13 @@ var init_xterm_backend = __esm({
         while (last > first && !lines[last - 1]?.trim()) last--;
         return lines.slice(first, last).join("\n");
       }
+      getCursorPosition() {
+        const buffer = this.terminal.buffer.active;
+        return {
+          col: Math.max(0, buffer.cursorX || 0),
+          row: Math.max(0, buffer.cursorY || 0)
+        };
+      }
       dispose() {
         this.terminal.dispose();
       }
@@ -18331,6 +18291,9 @@ var init_terminal_screen = __esm({
       getText() {
         return this.terminal.getText();
       }
+      getCursorPosition() {
+        return this.terminal.getCursorPosition();
+      }
       dispose() {
         this.terminal.dispose();
       }
@@ -18496,8 +18459,197 @@ var init_snapshot = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/src/commands/upgrade-helper.ts
+function getUpgradeLogPath() {
+  const home = os12.homedir();
+  const dir = path9.join(home, ".adhdev");
+  fs8.mkdirSync(dir, { recursive: true });
+  return path9.join(dir, "daemon-upgrade.log");
+}
+function appendUpgradeLog(message) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
+`;
+  try {
+    fs8.appendFileSync(getUpgradeLogPath(), line, "utf8");
+  } catch {
+  }
+}
+function getNpmExecutable() {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function killPid(pid) {
+  try {
+    if (process.platform === "win32") {
+      (0, import_child_process5.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((resolve12) => setTimeout(resolve12, 250));
+    } catch {
+      return;
+    }
+  }
+}
+function stopSessionHostProcesses(appName) {
+  const pidFile = path9.join(os12.homedir(), ".adhdev", `${appName}-session-host.pid`);
+  try {
+    if (fs8.existsSync(pidFile)) {
+      const pid = Number.parseInt(fs8.readFileSync(pidFile, "utf8").trim(), 10);
+      if (Number.isFinite(pid)) {
+        killPid(pid);
+      }
+    }
+  } catch {
+  } finally {
+    try {
+      fs8.unlinkSync(pidFile);
+    } catch {
+    }
+  }
+  if (process.platform !== "win32") {
+    try {
+      const raw = (0, import_child_process5.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(os12.homedir(), ".adhdev", "daemon.pid");
+  try {
+    fs8.unlinkSync(pidFile);
+  } catch {
+  }
+}
+function cleanupStaleGlobalInstallDirs(pkgName) {
+  const npmRoot = (0, import_child_process5.execFileSync)(getNpmExecutable(), ["root", "-g"], { encoding: "utf8" }).trim();
+  if (!npmRoot) return;
+  const npmPrefix = (0, import_child_process5.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 (!fs8.existsSync(scopeDir)) return;
+    for (const entry of fs8.readdirSync(scopeDir)) {
+      if (!entry.startsWith(`.${name}-`)) continue;
+      fs8.rmSync(path9.join(scopeDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale scoped staging dir: ${path9.join(scopeDir, entry)}`);
+    }
+  } else {
+    for (const entry of fs8.readdirSync(npmRoot)) {
+      if (!entry.startsWith(`.${pkgName}-`)) continue;
+      fs8.rmSync(path9.join(npmRoot, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale staging dir: ${path9.join(npmRoot, entry)}`);
+    }
+  }
+  if (fs8.existsSync(binDir)) {
+    for (const entry of fs8.readdirSync(binDir)) {
+      if (![...binNames].some((name) => entry.startsWith(`.${name}-`))) continue;
+      fs8.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_process6.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_process5.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_process6.spawn)(process.execPath, restartArgv, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      cwd: payload.cwd || process.cwd(),
+      env
+    });
+    child.unref();
+  } else {
+    appendUpgradeLog("No restart argv provided; upgrade completed without restart");
+  }
+}
+async function maybeRunDaemonUpgradeHelperFromEnv() {
+  const raw = process.env[UPGRADE_HELPER_ENV];
+  if (!raw) return false;
+  delete process.env[UPGRADE_HELPER_ENV];
+  try {
+    const payload = JSON.parse(raw);
+    await runDaemonUpgradeHelper(payload);
+    process.exit(0);
+  } catch (error48) {
+    appendUpgradeLog(`Upgrade helper failed: ${error48?.stack || error48?.message || String(error48)}`);
+    process.exit(1);
+  }
+}
+var import_child_process5, import_child_process6, fs8, os12, path9, UPGRADE_HELPER_ENV;
+var init_upgrade_helper = __esm({
+  "../../oss/packages/daemon-core/src/commands/upgrade-helper.ts"() {
+    "use strict";
+    import_child_process5 = require("child_process");
+    import_child_process6 = require("child_process");
+    fs8 = __toESM(require("fs"));
+    os12 = __toESM(require("os"));
+    path9 = __toESM(require("path"));
+    UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
+  }
+});
+
 // ../../oss/packages/daemon-core/src/commands/router.ts
-var fs8, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
+var fs9, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
 var init_router = __esm({
   "../../oss/packages/daemon-core/src/commands/router.ts"() {
     "use strict";
@@ -18513,7 +18665,8 @@ var init_router = __esm({
     init_logger();
     init_builders();
     init_snapshot();
-    fs8 = __toESM(require("fs"));
+    init_upgrade_helper();
+    fs9 = __toESM(require("fs"));
     CHAT_COMMANDS = [
       "send_chat",
       "new_chat",
@@ -18584,8 +18737,8 @@ var init_router = __esm({
               if (logs.length > 0) {
                 return { success: true, logs, totalBuffered: logs.length };
               }
-              if (fs8.existsSync(LOG_PATH)) {
-                const content = fs8.readFileSync(LOG_PATH, "utf-8");
+              if (fs9.existsSync(LOG_PATH)) {
+                const content = fs9.readFileSync(LOG_PATH, "utf-8");
                 const allLines = content.split("\n");
                 const recent = allLines.slice(-count).join("\n");
                 return { success: true, logs: recent, totalLines: allLines.length };
@@ -18733,31 +18886,35 @@ var init_router = __esm({
               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 path18 = require("path");
-                  const fs16 = require("fs");
-                  const pidFile = path18.join(process.env.HOME || process.env.USERPROFILE || "", ".adhdev", "daemon.pid");
-                  if (fs16.existsSync(pidFile)) fs16.unlinkSync(pidFile);
-                } catch {
-                }
-                const { spawn: spawn4 } = require("child_process");
-                const child = spawn4(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 };
@@ -19060,11 +19217,11 @@ var init_reporter = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/cli-adapters/pty-transport.ts
-var os12, pty, NodePtyRuntimeTransport, NodePtyTransportFactory;
+var os13, pty, NodePtyRuntimeTransport, NodePtyTransportFactory;
 var init_pty_transport = __esm({
   "../../oss/packages/daemon-core/src/cli-adapters/pty-transport.ts"() {
     "use strict";
-    os12 = __toESM(require("os"));
+    os13 = __toESM(require("os"));
     try {
       pty = require("node-pty");
     } catch {
@@ -19075,6 +19232,7 @@ var init_pty_transport = __esm({
         this.handle = handle;
       }
       ready = Promise.resolve();
+      terminalQueriesHandled = false;
       get pid() {
         return this.handle.pid;
       }
@@ -19101,7 +19259,7 @@ var init_pty_transport = __esm({
       spawn(command, args, options) {
         if (!pty) throw new Error("node-pty is not installed");
         const handle = pty.spawn(command, args, {
-          name: os12.platform() === "win32" ? "xterm-color" : "xterm-256color",
+          name: os13.platform() === "win32" ? "xterm-color" : "xterm-256color",
           cols: options.cols,
           rows: options.rows,
           cwd: options.cwd,
@@ -19128,24 +19286,50 @@ function stripTerminalNoise(str) {
 function sanitizeTerminalText(str) {
   return stripTerminalNoise(stripAnsi(str));
 }
+function buildCliSpawnEnv(baseEnv, overrides) {
+  const env = {};
+  const source = { ...baseEnv, ...overrides || {} };
+  for (const [key, value] of Object.entries(source)) {
+    if (typeof value !== "string") continue;
+    env[key] = value;
+  }
+  for (const key of Object.keys(env)) {
+    if (key === "INIT_CWD" || key === "NO_COLOR" || key === "FORCE_COLOR" || key === "npm_command" || key === "npm_execpath" || key === "npm_node_execpath" || key.startsWith("npm_") || key.startsWith("npm_config_") || key.startsWith("npm_package_") || key.startsWith("npm_lifecycle_") || key.startsWith("PNPM_") || key.startsWith("YARN_") || key.startsWith("BUN_")) {
+      delete env[key];
+    }
+  }
+  return env;
+}
+function computeTerminalQueryTail(buffer) {
+  const prefixes = ["\x1B[6n", "\x1B[?6n"];
+  const maxLength = prefixes.reduce((n, value) => Math.max(n, value.length), 0) - 1;
+  const start = Math.max(0, buffer.length - maxLength);
+  for (let i = start; i < buffer.length; i++) {
+    const suffix = buffer.slice(i);
+    if (prefixes.some((pattern) => suffix.length < pattern.length && pattern.startsWith(suffix))) {
+      return suffix;
+    }
+  }
+  return "";
+}
 function findBinary(name) {
-  const isWin = os13.platform() === "win32";
+  const isWin = os14.platform() === "win32";
   try {
     const cmd = isWin ? `where ${name}` : `which ${name}`;
-    return (0, import_child_process5.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n")[0].trim();
+    return (0, import_child_process7.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n")[0].trim();
   } catch {
     return isWin ? `${name}.cmd` : name;
   }
 }
 function isScriptBinary(binaryPath) {
-  if (!path9.isAbsolute(binaryPath)) return false;
+  if (!path10.isAbsolute(binaryPath)) return false;
   try {
-    const fs16 = require("fs");
-    const resolved = fs16.realpathSync(binaryPath);
+    const fs17 = require("fs");
+    const resolved = fs17.realpathSync(binaryPath);
     const head = Buffer.alloc(8);
-    const fd = fs16.openSync(resolved, "r");
-    fs16.readSync(fd, head, 0, 8, 0);
-    fs16.closeSync(fd);
+    const fd = fs17.openSync(resolved, "r");
+    fs17.readSync(fd, head, 0, 8, 0);
+    fs17.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;
@@ -19154,14 +19338,14 @@ function isScriptBinary(binaryPath) {
   }
 }
 function looksLikeMachOOrElf(filePath) {
-  if (!path9.isAbsolute(filePath)) return false;
+  if (!path10.isAbsolute(filePath)) return false;
   try {
-    const fs16 = require("fs");
-    const resolved = fs16.realpathSync(filePath);
+    const fs17 = require("fs");
+    const resolved = fs17.realpathSync(filePath);
     const buf = Buffer.alloc(8);
-    const fd = fs16.openSync(resolved, "r");
-    fs16.readSync(fd, buf, 0, 8, 0);
-    fs16.closeSync(fd);
+    const fd = fs17.openSync(resolved, "r");
+    fs17.readSync(fd, buf, 0, 8, 0);
+    fs17.closeSync(fd);
     let i = 0;
     if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
     const b2 = buf.subarray(i);
@@ -19177,7 +19361,7 @@ function looksLikeMachOOrElf(filePath) {
 }
 function shSingleQuote(arg) {
   if (/^[a-zA-Z0-9@%_+=:,./-]+$/.test(arg)) return arg;
-  if (os13.platform() === "win32") {
+  if (os14.platform() === "win32") {
     return `"${arg.replace(/"/g, '""')}"`;
   }
   return `'${arg.replace(/'/g, `'\\''`)}'`;
@@ -19214,36 +19398,6 @@ function promptLikelyVisible(screenText, promptSnippet) {
   ).length;
   return matched >= required2;
 }
-function splitHistoryLines(text) {
-  return String(text || "").split("\n").map((line) => line.replace(/\s+$/, ""));
-}
-function normalizeHistoryLine(line) {
-  return String(line || "").replace(/\s+/g, " ").trim();
-}
-function mergeTerminalHistory(existing, snapshot) {
-  const next = String(snapshot || "").trim();
-  if (!next) return existing;
-  const prev = String(existing || "").trim();
-  if (!prev) return next;
-  if (prev === next || prev.endsWith(next)) return prev;
-  const prevLines = splitHistoryLines(prev);
-  const nextLines = splitHistoryLines(next);
-  const prevNorm = prevLines.map(normalizeHistoryLine);
-  const nextNorm = nextLines.map(normalizeHistoryLine);
-  const maxOverlap = Math.min(prevLines.length, nextLines.length);
-  for (let overlap = maxOverlap; overlap >= 1; overlap -= 1) {
-    const prevTail = prevNorm.slice(prevNorm.length - overlap);
-    const nextHead = nextNorm.slice(0, overlap);
-    if (prevTail.every((line, index) => line === nextHead[index])) {
-      return [...prevLines, ...nextLines.slice(overlap)].join("\n").trim();
-    }
-  }
-  const compactPrev = prevNorm.join("\n");
-  const compactNext = nextNorm.join("\n");
-  if (compactPrev.includes(compactNext)) return prev;
-  return `${prev}
-${next}`.trim();
-}
 function parsePatternEntry(x) {
   if (x instanceof RegExp) return x;
   if (x && typeof x === "object" && typeof x.source === "string") {
@@ -19268,28 +19422,28 @@ function normalizeCliProviderForRuntime(raw) {
     }
   };
 }
-var os13, path9, import_child_process5, pty2, ProviderCliAdapter;
+var os14, path10, import_child_process7, pty2, ProviderCliAdapter;
 var init_provider_cli_adapter = __esm({
   "../../oss/packages/daemon-core/src/cli-adapters/provider-cli-adapter.ts"() {
     "use strict";
-    os13 = __toESM(require("os"));
-    path9 = __toESM(require("path"));
-    import_child_process5 = require("child_process");
+    os14 = __toESM(require("os"));
+    path10 = __toESM(require("path"));
+    import_child_process7 = require("child_process");
     init_logger();
     init_terminal_screen();
     init_pty_transport();
     try {
       pty2 = require("node-pty");
-      if (os13.platform() !== "win32") {
+      if (os14.platform() !== "win32") {
         try {
-          const fs16 = require("fs");
-          const ptyDir = path9.resolve(path9.dirname(require.resolve("node-pty")), "..");
-          const platformArch = `${os13.platform()}-${os13.arch()}`;
-          const helper = path9.join(ptyDir, "prebuilds", platformArch, "spawn-helper");
-          if (fs16.existsSync(helper)) {
-            const stat4 = fs16.statSync(helper);
+          const fs17 = require("fs");
+          const ptyDir = path10.resolve(path10.dirname(require.resolve("node-pty")), "..");
+          const platformArch = `${os14.platform()}-${os14.arch()}`;
+          const helper = path10.join(ptyDir, "prebuilds", platformArch, "spawn-helper");
+          if (fs17.existsSync(helper)) {
+            const stat4 = fs17.statSync(helper);
             if (!(stat4.mode & 73)) {
-              fs16.chmodSync(helper, stat4.mode | 493);
+              fs17.chmodSync(helper, stat4.mode | 493);
               LOG.info("CLI", "[node-pty] Fixed spawn-helper permissions");
             }
           }
@@ -19306,7 +19460,7 @@ var init_provider_cli_adapter = __esm({
         this.transportFactory = transportFactory;
         this.cliType = provider.type;
         this.cliName = provider.name;
-        this.workingDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os13.homedir()) : workingDir;
+        this.workingDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os14.homedir()) : workingDir;
         const t = provider.timeouts || {};
         this.timeouts = {
           ptyFlush: t.ptyFlush ?? 50,
@@ -19358,6 +19512,7 @@ var init_provider_cli_adapter = __esm({
       pendingOutputParseTimer = null;
       ptyOutputBuffer = "";
       ptyOutputFlushTimer = null;
+      pendingTerminalQueryTail = "";
       // Server log forwarding
       serverConn = null;
       logBuffer = [];
@@ -19389,9 +19544,7 @@ var init_provider_cli_adapter = __esm({
       /** Full accumulated raw PTY output (with ANSI) */
       accumulatedRawBuffer = "";
       /** Current visible terminal screen snapshot */
-      terminalScreen = new TerminalScreen(40, 120);
-      /** Rolling append-only terminal transcript built from screen snapshots */
-      terminalHistory = "";
+      terminalScreen = new TerminalScreen(30, 100);
       /** Max accumulated buffer size (last 50KB) */
       static MAX_ACCUMULATED_BUFFER = 5e4;
       currentTurnScope = null;
@@ -19413,15 +19566,13 @@ var init_provider_cli_adapter = __esm({
         return text.slice(start);
       }
       buildParseInput(baseMessages, partialResponse, scope) {
-        const buffer = scope ? this.sliceFromOffset(this.terminalHistory, scope.terminalHistoryStart) || this.sliceFromOffset(this.accumulatedBuffer, scope.bufferStart) || this.accumulatedBuffer : this.accumulatedBuffer;
+        const buffer = scope ? this.sliceFromOffset(this.accumulatedBuffer, scope.bufferStart) || this.accumulatedBuffer : this.accumulatedBuffer;
         const rawBuffer = scope ? this.sliceFromOffset(this.accumulatedRawBuffer, scope.rawBufferStart) || this.accumulatedRawBuffer : this.accumulatedRawBuffer;
-        const terminalHistory = scope ? this.sliceFromOffset(this.terminalHistory, scope.terminalHistoryStart) || this.terminalHistory : this.terminalHistory;
         return {
           buffer,
           rawBuffer,
           recentBuffer: buffer.slice(-1e3) || this.recentOutputBuffer,
           screenText: this.terminalScreen.getText(),
-          terminalHistory,
           messages: [...baseMessages],
           partialResponse
         };
@@ -19476,12 +19627,12 @@ var init_provider_cli_adapter = __esm({
         if (this.ptyProcess) return;
         const { spawn: spawnConfig } = this.provider;
         const binaryPath = findBinary(spawnConfig.command);
-        const isWin = os13.platform() === "win32";
+        const isWin = os14.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) {
@@ -19499,13 +19650,10 @@ var init_provider_cli_adapter = __esm({
           shellArgs = allArgs;
         }
         const ptyOpts = {
-          cols: 120,
-          rows: 40,
+          cols: 100,
+          rows: 30,
           cwd: this.workingDir,
-          env: {
-            ...process.env,
-            ...spawnConfig.env
-          }
+          env: buildCliSpawnEnv(process.env, spawnConfig.env)
         };
         try {
           this.ptyProcess = this.transportFactory.spawn(shellCmd, shellArgs, ptyOpts);
@@ -19523,8 +19671,8 @@ var init_provider_cli_adapter = __esm({
         }
         this.ptyProcess.onData((data) => {
           if (Date.now() < this.resizeSuppressUntil) return;
-          if (data.includes("\x1B[6n") || data.includes("\x1B[?6n")) {
-            this.ptyProcess?.write("\x1B[1;1R");
+          if (!this.ptyProcess?.terminalQueriesHandled) {
+            this.respondToTerminalQueries(data);
           }
           this.pendingOutputParseBuffer += data;
           if (!this.pendingOutputParseTimer) {
@@ -19559,8 +19707,8 @@ var init_provider_cli_adapter = __esm({
         this.spawnAt = Date.now();
         this.startupParseGate = true;
         this.startupBuffer = "";
-        this.terminalScreen.reset(40, 120);
-        this.terminalHistory = "";
+        this.terminalScreen.reset(30, 100);
+        this.pendingTerminalQueryTail = "";
         this.currentTurnScope = null;
         this.ready = false;
         await this.ptyProcess.ready;
@@ -19570,7 +19718,6 @@ var init_provider_cli_adapter = __esm({
       // ─── Output Handling ────────────────────────────
       handleOutput(rawData) {
         this.terminalScreen.write(rawData);
-        this.terminalHistory = mergeTerminalHistory(this.terminalHistory, this.terminalScreen.getText());
         const cleanData = sanitizeTerminalText(rawData);
         if (this.isWaitingForResponse && cleanData) {
           this.responseBuffer = (this.responseBuffer + cleanData).slice(-8e3);
@@ -19846,8 +19993,7 @@ var init_provider_cli_adapter = __esm({
           status: this.currentStatus,
           messages: [...this.committedMessages],
           workingDir: this.workingDir,
-          activeModal: this.activeModal,
-          terminalHistory: this.terminalHistory
+          activeModal: this.activeModal
         };
       }
       /**
@@ -19865,7 +20011,6 @@ var init_provider_cli_adapter = __esm({
             id: parsed.id || "cli_session",
             status: parsed.status || this.currentStatus,
             title: parsed.title || this.cliName,
-            terminalHistory: this.terminalHistory,
             messages: parsed.messages,
             activeModal: parsed.activeModal ?? this.activeModal
           };
@@ -19875,7 +20020,6 @@ var init_provider_cli_adapter = __esm({
           id: "cli_session",
           status: this.currentStatus,
           title: this.cliName,
-          terminalHistory: this.terminalHistory,
           messages: messages.slice(-50).map((message, index) => ({
             id: `msg_${index}`,
             role: message.role,
@@ -19943,10 +20087,9 @@ ${data.message || ""}`.trim();
           prompt: text,
           startedAt: Date.now(),
           bufferStart: this.accumulatedBuffer.length,
-          rawBufferStart: this.accumulatedRawBuffer.length,
-          terminalHistoryStart: this.terminalHistory.length
+          rawBufferStart: this.accumulatedRawBuffer.length
         };
-        LOG.info("CLI", `[${this.cliType}] sendMessage turn scope buffer=${this.currentTurnScope.bufferStart} raw=${this.currentTurnScope.rawBufferStart} terminal=${this.currentTurnScope.terminalHistoryStart} prompt=${JSON.stringify(text).slice(0, 120)}`);
+        LOG.info("CLI", `[${this.cliType}] sendMessage turn scope buffer=${this.currentTurnScope.bufferStart} raw=${this.currentTurnScope.rawBufferStart} prompt=${JSON.stringify(text).slice(0, 120)}`);
         this.submitRetryUsed = false;
         this.submitRetryPromptSnippet = extractPromptRetrySnippet(text);
         const normalizedPromptSnippet = normalizePromptText(this.submitRetryPromptSnippet);
@@ -20131,6 +20274,7 @@ ${data.message || ""}`.trim();
           this.pendingOutputParseTimer = null;
         }
         this.pendingOutputParseBuffer = "";
+        this.pendingTerminalQueryTail = "";
         if (this.ptyOutputFlushTimer) {
           clearTimeout(this.ptyOutputFlushTimer);
           this.ptyOutputFlushTimer = null;
@@ -20170,6 +20314,7 @@ ${data.message || ""}`.trim();
           this.pendingOutputParseTimer = null;
         }
         this.pendingOutputParseBuffer = "";
+        this.pendingTerminalQueryTail = "";
         if (this.ptyOutputFlushTimer) {
           clearTimeout(this.ptyOutputFlushTimer);
           this.ptyOutputFlushTimer = null;
@@ -20196,7 +20341,6 @@ ${data.message || ""}`.trim();
         this.syncMessageViews();
         this.accumulatedBuffer = "";
         this.accumulatedRawBuffer = "";
-        this.terminalHistory = "";
         this.currentTurnScope = null;
         this.submitRetryUsed = false;
         this.submitRetryPromptSnippet = "";
@@ -20205,6 +20349,7 @@ ${data.message || ""}`.trim();
           this.pendingOutputParseTimer = null;
         }
         this.pendingOutputParseBuffer = "";
+        this.pendingTerminalQueryTail = "";
         if (this.ptyOutputFlushTimer) {
           clearTimeout(this.ptyOutputFlushTimer);
           this.ptyOutputFlushTimer = null;
@@ -20266,7 +20411,6 @@ ${data.message || ""}`.trim();
           structuredMessages: this.structuredMessages.slice(-20),
           messageCount: this.committedMessages.length,
           screenText: sanitizeTerminalText(this.terminalScreen.getText()).slice(-4e3),
-          terminalHistory: this.terminalHistory.slice(-8e3),
           currentTurnScope: this.currentTurnScope,
           startupBuffer: this.startupBuffer.slice(-4e3),
           recentOutputBuffer: this.recentOutputBuffer.slice(-500),
@@ -20294,6 +20438,20 @@ ${data.message || ""}`.trim();
           ptyAlive: !!this.ptyProcess
         };
       }
+      respondToTerminalQueries(data) {
+        if (!this.ptyProcess || !data) return;
+        const combined = this.pendingTerminalQueryTail + data;
+        const regex = /\x1b\[(\?)?6n/g;
+        let match;
+        while ((match = regex.exec(combined)) !== null) {
+          const cursor = this.terminalScreen.getCursorPosition();
+          const row = Math.max(1, (cursor.row | 0) + 1);
+          const col = Math.max(1, (cursor.col | 0) + 1);
+          const response = match[1] ? `\x1B[?${row};${col}R` : `\x1B[${row};${col}R`;
+          this.ptyProcess.write(response);
+        }
+        this.pendingTerminalQueryTail = computeTerminalQueryTail(combined);
+      }
     };
   }
 });
@@ -20315,7 +20473,7 @@ var init_cli_provider_instance = __esm({
         this.cliArgs = cliArgs;
         this.type = provider.type;
         this.instanceId = instanceId || crypto3.randomUUID();
-        this.presentationMode = "terminal";
+        this.presentationMode = "chat";
         this.adapter = new ProviderCliAdapter(provider, workingDir, cliArgs, transportFactory);
         this.monitor = new StatusMonitor();
         this.historyWriter = new ChatHistoryWriter();
@@ -20362,14 +20520,6 @@ var init_cli_provider_instance = __esm({
         const parsedStatus = this.adapter.getScriptParsedStatus?.() || null;
         const runtime = this.adapter.getRuntimeMetadata();
         const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
-        if (adapterStatus.terminalHistory?.trim()) {
-          this.historyWriter.appendTerminalHistory(
-            this.type,
-            adapterStatus.terminalHistory,
-            `${this.provider.name} \xB7 ${dirName}`,
-            this.instanceId
-          );
-        }
         return {
           type: this.type,
           name: this.provider.name,
@@ -20382,7 +20532,6 @@ var init_cli_provider_instance = __esm({
             status: parsedStatus?.status || adapterStatus.status,
             messages: Array.isArray(parsedStatus?.messages) ? parsedStatus.messages : [],
             activeModal: parsedStatus?.activeModal ?? adapterStatus.activeModal,
-            terminalHistory: adapterStatus.terminalHistory,
             inputContent: ""
           },
           workspace: this.workingDir,
@@ -20807,10 +20956,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);
@@ -21122,11 +21271,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;
   });
 }
@@ -21369,7 +21518,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) {
@@ -21379,7 +21528,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;
@@ -21411,8 +21560,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")
@@ -34176,13 +34325,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}`);
     }
@@ -36867,12 +37016,12 @@ var init_contracts = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/providers/acp-provider-instance.ts
-var import_stream, import_child_process6, AcpProviderInstance;
+var import_stream, import_child_process8, AcpProviderInstance;
 var init_acp_provider_instance = __esm({
   "../../oss/packages/daemon-core/src/providers/acp-provider-instance.ts"() {
     "use strict";
     import_stream = require("stream");
-    import_child_process6 = require("child_process");
+    import_child_process8 = require("child_process");
     init_acp();
     init_contracts();
     init_status_monitor();
@@ -37196,7 +37345,7 @@ var init_acp_provider_instance = __esm({
         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"],
@@ -37768,12 +37917,12 @@ function colorize(color, text) {
   const fn2 = chalkApi?.[color];
   return typeof fn2 === "function" ? fn2(text) : text;
 }
-var os14, path10, crypto4, import_chalk, chalkApi, DaemonCliManager;
+var os15, path11, crypto4, import_chalk, chalkApi, DaemonCliManager;
 var init_cli_manager = __esm({
   "../../oss/packages/daemon-core/src/commands/cli-manager.ts"() {
     "use strict";
-    os14 = __toESM(require("os"));
-    path10 = __toESM(require("path"));
+    os15 = __toESM(require("os"));
+    path11 = __toESM(require("path"));
     crypto4 = __toESM(require("crypto"));
     import_chalk = __toESM(require("chalk"));
     init_provider_cli_adapter();
@@ -37896,7 +38045,7 @@ var init_cli_manager = __esm({
       async startSession(cliType, workingDir, cliArgs, initialModel) {
         const trimmed = (workingDir || "").trim();
         if (!trimmed) throw new Error("working directory required");
-        const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os14.homedir()) : path10.resolve(trimmed);
+        const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os15.homedir()) : path11.resolve(trimmed);
         const normalizedType = this.providerLoader.resolveAlias(cliType);
         const provider = this.providerLoader.getByAlias(cliType);
         const key = crypto4.randomUUID();
@@ -39152,7 +39301,7 @@ var init_provider_instance_manager = __esm({
 // ../../oss/packages/daemon-core/src/providers/version-archive.ts
 function runCommand(cmd, timeout = 1e4) {
   try {
-    return (0, import_child_process7.execSync)(cmd, {
+    return (0, import_child_process9.execSync)(cmd, {
       encoding: "utf-8",
       timeout,
       stdio: ["pipe", "pipe", "pipe"]
@@ -39184,19 +39333,19 @@ function getVersion(binary, versionCommand) {
 function checkPathExists2(paths) {
   for (const p of paths) {
     if (p.includes("*")) {
-      const home = os15.homedir();
-      const resolved = p.replace(/\*/g, home.split(path11.sep).pop() || "");
-      if (fs9.existsSync(resolved)) return resolved;
+      const home = os16.homedir();
+      const resolved = p.replace(/\*/g, home.split(path12.sep).pop() || "");
+      if (fs10.existsSync(resolved)) return resolved;
     } else {
-      if (fs9.existsSync(p)) return p;
+      if (fs10.existsSync(p)) return p;
     }
   }
   return null;
 }
 function getMacAppVersion(appPath) {
   if ((0, import_os3.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
-  const plistPath = path11.join(appPath, "Contents", "Info.plist");
-  if (!fs9.existsSync(plistPath)) return null;
+  const plistPath = path12.join(appPath, "Contents", "Info.plist");
+  if (!fs10.existsSync(plistPath)) return null;
   const raw = runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
 }
@@ -39222,8 +39371,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 && fs9.existsSync(bundled)) resolvedBin = bundled;
+        const bundled = path12.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
+        if (provider.cli && fs10.existsSync(bundled)) resolvedBin = bundled;
       }
       info.installed = !!(appPath || resolvedBin);
       info.path = appPath || null;
@@ -39259,16 +39408,16 @@ async function detectAllVersions(loader, archive) {
   }
   return results;
 }
-var fs9, path11, os15, import_child_process7, import_os3, ARCHIVE_PATH, MAX_ENTRIES_PER_PROVIDER, VersionArchive;
+var fs10, path12, os16, import_child_process9, import_os3, ARCHIVE_PATH, MAX_ENTRIES_PER_PROVIDER, VersionArchive;
 var init_version_archive = __esm({
   "../../oss/packages/daemon-core/src/providers/version-archive.ts"() {
     "use strict";
-    fs9 = __toESM(require("fs"));
-    path11 = __toESM(require("path"));
-    os15 = __toESM(require("os"));
-    import_child_process7 = require("child_process");
+    fs10 = __toESM(require("fs"));
+    path12 = __toESM(require("path"));
+    os16 = __toESM(require("os"));
+    import_child_process9 = require("child_process");
     import_os3 = require("os");
-    ARCHIVE_PATH = path11.join(os15.homedir(), ".adhdev", "version-history.json");
+    ARCHIVE_PATH = path12.join(os16.homedir(), ".adhdev", "version-history.json");
     MAX_ENTRIES_PER_PROVIDER = 20;
     VersionArchive = class {
       history = {};
@@ -39277,8 +39426,8 @@ var init_version_archive = __esm({
       }
       load() {
         try {
-          if (fs9.existsSync(ARCHIVE_PATH)) {
-            this.history = JSON.parse(fs9.readFileSync(ARCHIVE_PATH, "utf-8"));
+          if (fs10.existsSync(ARCHIVE_PATH)) {
+            this.history = JSON.parse(fs10.readFileSync(ARCHIVE_PATH, "utf-8"));
           }
         } catch {
           this.history = {};
@@ -39315,8 +39464,8 @@ var init_version_archive = __esm({
       }
       save() {
         try {
-          fs9.mkdirSync(path11.dirname(ARCHIVE_PATH), { recursive: true });
-          fs9.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
+          fs10.mkdirSync(path12.dirname(ARCHIVE_PATH), { recursive: true });
+          fs10.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
         } catch {
         }
       }
@@ -39836,18 +39985,18 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   let scriptsPath = "";
-  const directScripts = path12.join(dir, "scripts.js");
-  if (fs10.existsSync(directScripts)) {
+  const directScripts = path13.join(dir, "scripts.js");
+  if (fs11.existsSync(directScripts)) {
     scriptsPath = directScripts;
   } else {
-    const scriptsDir = path12.join(dir, "scripts");
-    if (fs10.existsSync(scriptsDir)) {
-      const versions = fs10.readdirSync(scriptsDir).filter((d) => {
-        return fs10.statSync(path12.join(scriptsDir, d)).isDirectory();
+    const scriptsDir = path13.join(dir, "scripts");
+    if (fs11.existsSync(scriptsDir)) {
+      const versions = fs11.readdirSync(scriptsDir).filter((d) => {
+        return fs11.statSync(path13.join(scriptsDir, d)).isDirectory();
       }).sort().reverse();
       for (const ver of versions) {
-        const p = path12.join(scriptsDir, ver, "scripts.js");
-        if (fs10.existsSync(p)) {
+        const p = path13.join(scriptsDir, ver, "scripts.js");
+        if (fs11.existsSync(p)) {
           scriptsPath = p;
           break;
         }
@@ -39859,7 +40008,7 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   try {
-    const source = fs10.readFileSync(scriptsPath, "utf-8");
+    const source = fs11.readFileSync(scriptsPath, "utf-8");
     const hints = {};
     const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
     let match;
@@ -40662,12 +40811,12 @@ async function handleDomContext(ctx, type, req, res) {
     ctx.json(res, 500, { error: `DOM context collection failed: ${e.message}` });
   }
 }
-var fs10, path12;
+var fs11, path13;
 var init_dev_cdp_handlers = __esm({
   "../../oss/packages/daemon-core/src/daemon/dev-cdp-handlers.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs"));
-    path12 = __toESM(require("path"));
+    fs11 = __toESM(require("fs"));
+    path13 = __toESM(require("path"));
     init_logger();
   }
 });
@@ -40929,45 +41078,45 @@ function resolveAutoImplReference(ctx, category, requestedReference, targetType)
   return fallback?.type || null;
 }
 function 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(path13.join(scriptsDir, d)).isDirectory();
+      return fs12.statSync(path14.join(scriptsDir, d)).isDirectory();
     } catch {
       return false;
     }
   }).sort((a, b2) => b2.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 (!fs11.existsSync(desiredDir)) {
-    fs11.mkdirSync(path13.dirname(desiredDir), { recursive: true });
-    fs11.cpSync(sourceDir, desiredDir, { recursive: true });
+  if (!fs12.existsSync(desiredDir)) {
+    fs12.mkdirSync(path14.dirname(desiredDir), { recursive: true });
+    fs12.cpSync(sourceDir, desiredDir, { recursive: true });
     ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
   }
-  const providerJson = path13.join(desiredDir, "provider.json");
-  if (!fs11.existsSync(providerJson)) {
+  const providerJson = path14.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 {
@@ -40980,15 +41129,15 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
 function loadAutoImplReferenceScripts(ctx, referenceType) {
   if (!referenceType) return {};
   const refDir = ctx.findProviderDir(referenceType);
-  if (!refDir || !fs11.existsSync(refDir)) return {};
+  if (!refDir || !fs12.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 fs11.readdirSync(latestDir)) {
+  for (const file2 of fs12.readdirSync(latestDir)) {
     if (!file2.endsWith(".js")) continue;
     try {
-      referenceScripts[file2] = fs11.readFileSync(path13.join(latestDir, file2), "utf-8");
+      referenceScripts[file2] = fs12.readFileSync(path14.join(latestDir, file2), "utf-8");
     } catch {
     }
   }
@@ -41039,16 +41188,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(os16.tmpdir(), "adhdev-autoimpl");
-    if (!fs11.existsSync(tmpDir)) fs11.mkdirSync(tmpDir, { recursive: true });
-    const promptFile = path13.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
-    fs11.writeFileSync(promptFile, prompt, "utf-8");
+    const tmpDir = path14.join(os17.tmpdir(), "adhdev-autoimpl");
+    if (!fs12.existsSync(tmpDir)) fs12.mkdirSync(tmpDir, { recursive: true });
+    const promptFile = path14.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
+    fs12.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 spawn4 = agentProvider?.spawn;
-    if (!spawn4?.command) {
+    const spawn5 = agentProvider?.spawn;
+    if (!spawn5?.command) {
       try {
-        fs11.unlinkSync(promptFile);
+        fs12.unlinkSync(promptFile);
       } catch {
       }
       ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -41056,21 +41205,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: ${spawn4.command} ${(spawn4.args || []).join(" ")}` } });
+      sendAutoImplSSE(ctx, { event: "progress", data: { function: "_init", status: "spawning", message: `Spawning ACP agent: ${spawn5.command} ${(spawn5.args || []).join(" ")}` } });
       ctx.autoImplStatus = { running: true, type, progress: [] };
       const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
       const { Readable: Readable3, Writable: Writable2 } = await import("stream");
       const { spawn: spawnFn2 } = await import("child_process");
-      const acpArgs = [...spawn4.args || []];
+      const acpArgs = [...spawn5.args || []];
       if (model) {
         acpArgs.push("--model", model);
         ctx.log(`Auto-implement ACP using model: ${model}`);
       }
-      const child2 = spawnFn2(spawn4.command, acpArgs, {
+      const child2 = spawnFn2(spawn5.command, acpArgs, {
         cwd: providerDir,
         stdio: ["pipe", "pipe", "pipe"],
-        shell: spawn4.shell ?? false,
-        env: { ...process.env, ...spawn4.env || {} }
+        shell: spawn5.shell ?? false,
+        env: { ...process.env, ...spawn5.env || {} }
       });
       ctx.autoImplProcess = child2;
       child2.stderr?.on("data", (d) => {
@@ -41149,7 +41298,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs11.unlinkSync(promptFile);
+          fs12.unlinkSync(promptFile);
         } catch {
         }
         ctx.log(`Auto-implement (ACP) ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -41180,7 +41329,7 @@ async function handleAutoImplement(ctx, type, req, res) {
       ctx.json(res, 202, {
         started: true,
         type,
-        agent: spawn4.command,
+        agent: spawn5.command,
         functions,
         providerDir,
         message: "ACP Auto-implement started. Connect to SSE for progress.",
@@ -41188,11 +41337,11 @@ async function handleAutoImplement(ctx, type, req, res) {
       });
       return;
     }
-    const command = spawn4.command;
+    const command = spawn5.command;
     const interactiveFlags = ["--yolo", "--interactive", "-i"];
-    const baseArgs = [...spawn4.args || []].filter((a) => !interactiveFlags.includes(a));
+    const baseArgs = [...spawn5.args || []].filter((a) => !interactiveFlags.includes(a));
     let shellCmd;
-    const isWin = os16.platform() === "win32";
+    const isWin = os17.platform() === "win32";
     const escapeArg = (a) => isWin ? `"${a.replace(/"/g, '""')}"` : `'${a.replace(/'/g, "'\\''")}'`;
     if (command === "claude") {
       const args = [...baseArgs, "--dangerously-skip-permissions"];
@@ -41235,13 +41384,13 @@ async function handleAutoImplement(ctx, type, req, res) {
     try {
       const pty3 = require("node-pty");
       ctx.log(`Auto-implement spawn (PTY): ${shellCmd}`);
-      const isWin2 = os16.platform() === "win32";
+      const isWin2 = os17.platform() === "win32";
       child = pty3.spawn(isWin2 ? "cmd.exe" : process.env.SHELL || "/bin/zsh", [isWin2 ? "/c" : "-c", shellCmd], {
         name: "xterm-256color",
         cols: 120,
         rows: 40,
         cwd: providerDir,
-        env: { ...process.env, ...spawn4.env || {} }
+        env: { ...process.env, ...spawn5.env || {} }
       });
       isPty = true;
     } catch (err) {
@@ -41253,7 +41402,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         stdio: ["pipe", "pipe", "pipe"],
         env: {
           ...process.env,
-          ...spawn4.env || {},
+          ...spawn5.env || {},
           ...command === "gemini" ? { SANDBOX: "1", GEMINI_CLI_NO_RELAUNCH: "1" } : {}
         }
       });
@@ -41329,7 +41478,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs11.unlinkSync(promptFile);
+          fs12.unlinkSync(promptFile);
         } catch {
         }
       });
@@ -41365,7 +41514,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs11.unlinkSync(promptFile);
+          fs12.unlinkSync(promptFile);
         } catch {
         }
         ctx.log(`Auto-implement ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -41412,7 +41561,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     setMode: "set_mode.js"
   };
   const targetFileNames = new Set(functions.map((fn2) => funcToFile[fn2]).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}\``);
@@ -41420,10 +41569,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 fs11.readdirSync(latestScriptsDir)) {
+    for (const file2 of fs12.readdirSync(latestScriptsDir)) {
       if (file2.endsWith(".js") && targetFileNames.has(file2)) {
         try {
-          const content = fs11.readFileSync(path13.join(latestScriptsDir, file2), "utf-8");
+          const content = fs12.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -41433,14 +41582,14 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
         }
       }
     }
-    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(path13.join(latestScriptsDir, file2), "utf-8");
+          const content = fs12.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -41481,11 +41630,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 (fs11.existsSync(p)) return fs11.readFileSync(p, "utf-8");
+      const p = path14.join(docsDir, name);
+      if (fs12.existsSync(p)) return fs12.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -41658,7 +41807,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     parseApproval: "parse_approval.js"
   };
   const targetFileNames = new Set(functions.map((fn2) => funcToFile[fn2]).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}\``);
@@ -41666,11 +41815,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 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(path13.join(latestScriptsDir, file2), "utf-8");
+        const content = fs12.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
         lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -41679,14 +41828,14 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       } 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(path13.join(latestScriptsDir, file2), "utf-8");
+          const content = fs12.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -41719,11 +41868,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 (fs11.existsSync(p)) return fs11.readFileSync(p, "utf-8");
+      const p = path14.join(docsDir, name);
+      if (fs12.existsSync(p)) return fs12.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -41886,25 +42035,25 @@ data: ${JSON.stringify(msg.data)}
     }
   }
 }
-var fs11, path13, os16;
+var fs12, path14, os17;
 var init_dev_auto_implement = __esm({
   "../../oss/packages/daemon-core/src/daemon/dev-auto-implement.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs"));
-    path13 = __toESM(require("path"));
-    os16 = __toESM(require("os"));
+    fs12 = __toESM(require("fs"));
+    path14 = __toESM(require("path"));
+    os17 = __toESM(require("os"));
     init_dev_server();
   }
 });
 
 // ../../oss/packages/daemon-core/src/daemon/dev-server.ts
-var http2, fs12, path14, DEV_SERVER_PORT, DevServer;
+var http2, fs13, path15, DEV_SERVER_PORT, DevServer;
 var init_dev_server = __esm({
   "../../oss/packages/daemon-core/src/daemon/dev-server.ts"() {
     "use strict";
     http2 = __toESM(require("http"));
-    fs12 = __toESM(require("fs"));
-    path14 = __toESM(require("path"));
+    fs13 = __toESM(require("fs"));
+    path15 = __toESM(require("path"));
     init_scaffold_template();
     init_version_archive();
     init_logger();
@@ -42003,8 +42152,8 @@ var init_dev_server = __esm({
       }
       getEndpointList() {
         return this.routes.map((r) => {
-          const path18 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-          return `${r.method.padEnd(5)} ${path18}`;
+          const path19 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+          return `${r.method.padEnd(5)} ${path19}`;
         });
       }
       async start(port = DEV_SERVER_PORT) {
@@ -42105,16 +42254,16 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const spawn4 = provider.spawn;
-        if (!spawn4) {
+        const spawn5 = provider.spawn;
+        if (!spawn5) {
           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(spawn4.command, [...spawn4.args || []], {
-            shell: spawn4.shell ?? false,
+          const child = spawnFn(spawn5.command, [...spawn5.args || []], {
+            shell: spawn5.shell ?? false,
             timeout: 5e3,
             stdio: ["pipe", "pipe", "pipe"]
           });
@@ -42146,7 +42295,7 @@ var init_dev_server = __esm({
           const elapsed = Date.now() - start;
           this.json(res, 200, {
             success: true,
-            command: `${spawn4.command} ${(spawn4.args || []).join(" ")}`,
+            command: `${spawn5.command} ${(spawn5.args || []).join(" ")}`,
             elapsed,
             stdout: stdout.trim(),
             stderr: stderr.trim(),
@@ -42156,7 +42305,7 @@ var init_dev_server = __esm({
           const elapsed = Date.now() - start;
           this.json(res, 200, {
             success: false,
-            command: `${spawn4.command} ${(spawn4.args || []).join(" ")}`,
+            command: `${spawn5.command} ${(spawn5.args || []).join(" ")}`,
             elapsed,
             error: e.message
           });
@@ -42286,12 +42435,12 @@ var init_dev_server = __esm({
       // ─── 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 (fs12.existsSync(path14.join(dir, "index.html"))) return dir;
+          if (fs13.existsSync(path15.join(dir, "index.html"))) return dir;
         }
         return null;
       }
@@ -42301,9 +42450,9 @@ var init_dev_server = __esm({
           this.json(res, 500, { error: "DevConsole not found. Run: npm run build -w packages/web-devconsole" });
           return;
         }
-        const htmlPath = path14.join(distDir, "index.html");
+        const htmlPath = path15.join(distDir, "index.html");
         try {
-          const html = fs12.readFileSync(htmlPath, "utf-8");
+          const html = fs13.readFileSync(htmlPath, "utf-8");
           res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
           res.end(html);
         } catch (e) {
@@ -42326,15 +42475,15 @@ var init_dev_server = __esm({
           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 = fs12.readFileSync(filePath);
-          const ext = path14.extname(filePath);
+          const content = fs13.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);
@@ -42442,14 +42591,14 @@ var init_dev_server = __esm({
         const files = [];
         const scan = (d, prefix) => {
           try {
-            for (const entry of fs12.readdirSync(d, { withFileTypes: true })) {
+            for (const entry of fs13.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 = fs12.statSync(path14.join(d, entry.name));
+                const stat4 = fs13.statSync(path15.join(d, entry.name));
                 files.push({ path: rel, size: stat4.size, type: "file" });
               }
             }
@@ -42472,16 +42621,16 @@ var init_dev_server = __esm({
           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 (!fs12.existsSync(fullPath) || fs12.statSync(fullPath).isDirectory()) {
+        if (!fs13.existsSync(fullPath) || fs13.statSync(fullPath).isDirectory()) {
           this.json(res, 404, { error: `File not found: ${filePath}` });
           return;
         }
-        const content = fs12.readFileSync(fullPath, "utf-8");
+        const content = fs13.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 } */
@@ -42497,15 +42646,15 @@ var init_dev_server = __esm({
           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 (fs12.existsSync(fullPath)) fs12.copyFileSync(fullPath, fullPath + ".bak");
-          fs12.mkdirSync(path14.dirname(fullPath), { recursive: true });
-          fs12.writeFileSync(fullPath, content, "utf-8");
+          if (fs13.existsSync(fullPath)) fs13.copyFileSync(fullPath, fullPath + ".bak");
+          fs13.mkdirSync(path15.dirname(fullPath), { recursive: true });
+          fs13.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 });
@@ -42521,9 +42670,9 @@ var init_dev_server = __esm({
           return;
         }
         for (const name of ["scripts.js", "provider.json"]) {
-          const p = path14.join(dir, name);
-          if (fs12.existsSync(p)) {
-            const source = fs12.readFileSync(p, "utf-8");
+          const p = path15.join(dir, name);
+          if (fs13.existsSync(p)) {
+            const source = fs13.readFileSync(p, "utf-8");
             this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
             return;
           }
@@ -42542,11 +42691,11 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const target = fs12.existsSync(path14.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
-        const targetPath = path14.join(dir, target);
+        const target = fs13.existsSync(path15.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+        const targetPath = path15.join(dir, target);
         try {
-          if (fs12.existsSync(targetPath)) fs12.copyFileSync(targetPath, targetPath + ".bak");
-          fs12.writeFileSync(targetPath, source, "utf-8");
+          if (fs13.existsSync(targetPath)) fs13.copyFileSync(targetPath, targetPath + ".bak");
+          fs13.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 });
@@ -42625,20 +42774,20 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const spawn4 = provider.spawn;
-        if (!spawn4) {
+        const spawn5 = provider.spawn;
+        if (!spawn5) {
           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 = [...spawn4.args || [], message];
-          const child = spawnFn(spawn4.command, args, {
-            shell: spawn4.shell ?? false,
+          const args = [...spawn5.args || [], message];
+          const child = spawnFn(spawn5.command, args, {
+            shell: spawn5.shell ?? false,
             timeout,
             stdio: ["pipe", "pipe", "pipe"],
-            env: { ...process.env, ...spawn4.env || {} }
+            env: { ...process.env, ...spawn5.env || {} }
           });
           let stdout = "";
           let stderr = "";
@@ -42703,21 +42852,21 @@ var init_dev_server = __esm({
         }
         let targetDir;
         targetDir = this.providerLoader.getUserProviderDir(category, type);
-        const jsonPath = path14.join(targetDir, "provider.json");
-        if (fs12.existsSync(jsonPath)) {
+        const jsonPath = path15.join(targetDir, "provider.json");
+        if (fs13.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 });
-          fs12.mkdirSync(targetDir, { recursive: true });
-          fs12.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+          fs13.mkdirSync(targetDir, { recursive: true });
+          fs13.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);
-              fs12.mkdirSync(path14.dirname(fullPath), { recursive: true });
-              fs12.writeFileSync(fullPath, content, "utf-8");
+              const fullPath = path15.join(targetDir, relPath);
+              fs13.mkdirSync(path15.dirname(fullPath), { recursive: true });
+              fs13.writeFileSync(fullPath, content, "utf-8");
               createdFiles.push(relPath);
             }
           }
@@ -42766,45 +42915,45 @@ var init_dev_server = __esm({
       }
       // ─── Phase 2: Auto-Implement Backend ───
       getLatestScriptVersionDir(scriptsDir) {
-        if (!fs12.existsSync(scriptsDir)) return null;
-        const versions = fs12.readdirSync(scriptsDir).filter((d) => {
+        if (!fs13.existsSync(scriptsDir)) return null;
+        const versions = fs13.readdirSync(scriptsDir).filter((d) => {
           try {
-            return fs12.statSync(path14.join(scriptsDir, d)).isDirectory();
+            return fs13.statSync(path15.join(scriptsDir, d)).isDirectory();
           } catch {
             return false;
           }
         }).sort((a, b2) => b2.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 (!fs12.existsSync(desiredDir)) {
-          fs12.mkdirSync(path14.dirname(desiredDir), { recursive: true });
-          fs12.cpSync(sourceDir, desiredDir, { recursive: true });
+        if (!fs13.existsSync(desiredDir)) {
+          fs13.mkdirSync(path15.dirname(desiredDir), { recursive: true });
+          fs13.cpSync(sourceDir, desiredDir, { recursive: true });
           this.log(`Auto-implement writable copy created: ${desiredDir}`);
         }
-        const providerJson = path14.join(desiredDir, "provider.json");
-        if (!fs12.existsSync(providerJson)) {
+        const providerJson = path15.join(desiredDir, "provider.json");
+        if (!fs13.existsSync(providerJson)) {
           return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
         }
         try {
-          const providerData = JSON.parse(fs12.readFileSync(providerJson, "utf-8"));
+          const providerData = JSON.parse(fs13.readFileSync(providerJson, "utf-8"));
           if (providerData.disableUpstream !== true) {
             providerData.disableUpstream = true;
-            fs12.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
+            fs13.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
           }
         } catch (error48) {
           return {
@@ -42844,7 +42993,7 @@ var init_dev_server = __esm({
           setMode: "set_mode.js"
         };
         const targetFileNames = new Set(functions.map((fn2) => funcToFile[fn2]).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}\``);
@@ -42852,10 +43001,10 @@ var init_dev_server = __esm({
           lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
           lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
           lines.push("");
-          for (const file2 of fs12.readdirSync(latestScriptsDir)) {
+          for (const file2 of fs13.readdirSync(latestScriptsDir)) {
             if (file2.endsWith(".js") && targetFileNames.has(file2)) {
               try {
-                const content = fs12.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
+                const content = fs13.readFileSync(path15.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -42865,14 +43014,14 @@ var init_dev_server = __esm({
               }
             }
           }
-          const refFiles = fs12.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+          const refFiles = fs13.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
           if (refFiles.length > 0) {
             lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
             lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
             lines.push("");
             for (const file2 of refFiles) {
               try {
-                const content = fs12.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
+                const content = fs13.readFileSync(path15.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -42913,11 +43062,11 @@ var init_dev_server = __esm({
             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 (fs12.existsSync(p)) return fs12.readFileSync(p, "utf-8");
+            const p = path15.join(docsDir, name);
+            if (fs13.existsSync(p)) return fs13.readFileSync(p, "utf-8");
           } catch {
           }
           return null;
@@ -43090,7 +43239,7 @@ var init_dev_server = __esm({
           parseApproval: "parse_approval.js"
         };
         const targetFileNames = new Set(functions.map((fn2) => funcToFile[fn2]).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}\``);
@@ -43098,11 +43247,11 @@ var init_dev_server = __esm({
           lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
           lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
           lines.push("");
-          for (const file2 of fs12.readdirSync(latestScriptsDir)) {
+          for (const file2 of fs13.readdirSync(latestScriptsDir)) {
             if (!file2.endsWith(".js")) continue;
             if (!targetFileNames.has(file2)) continue;
             try {
-              const content = fs12.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
+              const content = fs13.readFileSync(path15.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -43111,14 +43260,14 @@ var init_dev_server = __esm({
             } catch {
             }
           }
-          const refFiles = fs12.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+          const refFiles = fs13.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
           if (refFiles.length > 0) {
             lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
             lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
             lines.push("");
             for (const file2 of refFiles) {
               try {
-                const content = fs12.readFileSync(path14.join(latestScriptsDir, file2), "utf-8");
+                const content = fs13.readFileSync(path15.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -43151,11 +43300,11 @@ var init_dev_server = __esm({
             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 (fs12.existsSync(p)) return fs12.readFileSync(p, "utf-8");
+            const p = path15.join(docsDir, name);
+            if (fs13.existsSync(p)) return fs13.readFileSync(p, "utf-8");
           } catch {
           }
           return null;
@@ -43381,7 +43530,7 @@ function getDefaultSessionHostEndpoint(appName = "adhdev") {
   }
   return {
     kind: "unix",
-    path: path22.join(os17.tmpdir(), `${appName}-session-host.sock`)
+    path: path22.join(os18.tmpdir(), `${appName}-session-host.sock`)
   };
 }
 function serializeEnvelope(envelope) {
@@ -43403,11 +43552,11 @@ function createLineParser(onEnvelope) {
     }
   };
 }
-var os17, path22, net2, import_crypto3, SessionHostClient;
+var os18, path22, net2, import_crypto3, SessionHostClient;
 var init_dist = __esm({
   "../../oss/packages/session-host-core/dist/index.mjs"() {
     "use strict";
-    os17 = __toESM(require("os"), 1);
+    os18 = __toESM(require("os"), 1);
     path22 = __toESM(require("path"), 1);
     net2 = __toESM(require("net"), 1);
     import_crypto3 = require("crypto");
@@ -43523,6 +43672,7 @@ var init_session_host_transport = __esm({
         this.ready = this.boot();
       }
       ready;
+      terminalQueriesHandled = true;
       client;
       dataCallbacks = /* @__PURE__ */ new Set();
       exitCallbacks = /* @__PURE__ */ new Set();
@@ -43922,7 +44072,7 @@ var init_runtime_support = __esm({
 function isExtensionInstalled(ide, marketplaceId) {
   if (!ide.cliCommand) return false;
   try {
-    const result = (0, import_child_process8.execSync)(`"${ide.cliCommand}" --list-extensions`, {
+    const result = (0, import_child_process10.execSync)(`"${ide.cliCommand}" --list-extensions`, {
       encoding: "utf-8",
       timeout: 15e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -43959,11 +44109,11 @@ async function installExtension(ide, extension) {
       const res = await fetch(extension.vsixUrl);
       if (res.ok) {
         const buffer = Buffer.from(await res.arrayBuffer());
-        const fs16 = await import("fs");
-        fs16.writeFileSync(vsixPath, buffer);
+        const fs17 = await import("fs");
+        fs17.writeFileSync(vsixPath, buffer);
         return new Promise((resolve12) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
-          (0, import_child_process8.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
+          (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
             resolve12({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
@@ -43979,7 +44129,7 @@ async function installExtension(ide, extension) {
   }
   return new Promise((resolve12) => {
     const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
-    (0, import_child_process8.exec)(cmd, { timeout: 6e4 }, (error48, stdout, stderr) => {
+    (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error48, stdout, stderr) => {
       if (error48) {
         resolve12({
           extensionId: extension.id,
@@ -44016,17 +44166,17 @@ function launchIDE(ide, workspacePath) {
   if (!ide.cliCommand) return false;
   try {
     const args = workspacePath ? `"${workspacePath}"` : "";
-    (0, import_child_process8.exec)(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
+    (0, import_child_process10.exec)(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
     return true;
   } catch {
     return false;
   }
 }
-var import_child_process8, EXTENSION_CATALOG;
+var import_child_process10, EXTENSION_CATALOG;
 var init_installer = __esm({
   "../../oss/packages/daemon-core/src/installer.ts"() {
     "use strict";
-    import_child_process8 = require("child_process");
+    import_child_process10 = require("child_process");
     EXTENSION_CATALOG = [
       // AI Agent extensions
       {
@@ -44434,6 +44584,7 @@ __export(src_exports, {
   loadConfig: () => loadConfig,
   logCommand: () => logCommand,
   markSetupComplete: () => markSetupComplete,
+  maybeRunDaemonUpgradeHelperFromEnv: () => maybeRunDaemonUpgradeHelperFromEnv,
   normalizeActiveChatData: () => normalizeActiveChatData,
   normalizeManagedStatus: () => normalizeManagedStatus,
   probeCdpPort: () => probeCdpPort,
@@ -44463,6 +44614,7 @@ var init_src = __esm({
     init_initializer();
     init_handler();
     init_router();
+    init_upgrade_helper();
     init_reporter();
     init_builders();
     init_snapshot();
@@ -44792,17 +44944,17 @@ function canPeerUsePrivilegedShareCommand(commandType, permission) {
       return false;
   }
 }
-var fs13, path15, os18, import_node_module, esmRequire, logFile, log, logDebug, DaemonP2PSender;
+var fs14, path16, os19, import_node_module, esmRequire, logFile, log, logDebug, DaemonP2PSender;
 var init_daemon_p2p = __esm({
   "src/daemon-p2p.ts"() {
     "use strict";
-    fs13 = __toESM(require("fs"));
+    fs14 = __toESM(require("fs"));
     init_src();
-    path15 = __toESM(require("path"));
-    os18 = __toESM(require("os"));
+    path16 = __toESM(require("path"));
+    os19 = __toESM(require("os"));
     import_node_module = require("module");
     esmRequire = (0, import_node_module.createRequire)(__filename);
-    logFile = path15.join(os18.tmpdir(), "adhdev_daemon_p2p.log");
+    logFile = path16.join(os19.tmpdir(), "adhdev_daemon_p2p.log");
     log = (msg) => {
       LOG.info("P2P", `[${(/* @__PURE__ */ new Date()).toISOString()}] [P2P] ${msg}`);
     };
@@ -44870,17 +45022,17 @@ ${e?.stack || ""}`);
         const prebuildKey = `${platform11}-${arch3}`;
         try {
           const candidates = [
-            path15.join(__dirname, "node_modules", "node-datachannel"),
-            path15.join(__dirname, "..", "node_modules", "node-datachannel"),
-            path15.join(__dirname, "..", "..", "node_modules", "node-datachannel")
+            path16.join(__dirname, "node_modules", "node-datachannel"),
+            path16.join(__dirname, "..", "node_modules", "node-datachannel"),
+            path16.join(__dirname, "..", "..", "node_modules", "node-datachannel")
           ];
           for (const candidate of candidates) {
-            const prebuildPath = path15.join(candidate, "prebuilds", prebuildKey, "node_datachannel.node");
-            if (fs13.existsSync(prebuildPath)) {
-              const targetDir = path15.join(candidate, "build", "Release");
-              const targetPath = path15.join(targetDir, "node_datachannel.node");
-              fs13.mkdirSync(targetDir, { recursive: true });
-              fs13.copyFileSync(prebuildPath, targetPath);
+            const prebuildPath = path16.join(candidate, "prebuilds", prebuildKey, "node_datachannel.node");
+            if (fs14.existsSync(prebuildPath)) {
+              const targetDir = path16.join(candidate, "build", "Release");
+              const targetPath = path16.join(targetDir, "node_datachannel.node");
+              fs14.mkdirSync(targetDir, { recursive: true });
+              fs14.copyFileSync(prebuildPath, targetPath);
               try {
                 delete esmRequire.cache[esmRequire.resolve("node-datachannel")];
               } catch {
@@ -45782,23 +45934,23 @@ __export(session_host_exports, {
 });
 function resolveSessionHostEntry() {
   const packagedCandidates = [
-    path16.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
-    path16.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
+    path17.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
+    path17.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
   ];
   for (const candidate of packagedCandidates) {
-    if (fs14.existsSync(candidate)) {
+    if (fs15.existsSync(candidate)) {
       return candidate;
     }
   }
   return require.resolve("@adhdev/session-host-daemon");
 }
 function getSessionHostPidFile() {
-  return path16.join(os19.homedir(), ".adhdev", `${SESSION_HOST_APP_NAME}-session-host.pid`);
+  return path17.join(os20.homedir(), ".adhdev", `${SESSION_HOST_APP_NAME}-session-host.pid`);
 }
-function killPid(pid) {
+function killPid2(pid) {
   try {
     if (process.platform === "win32") {
-      (0, import_child_process9.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+      (0, import_child_process11.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
     } else {
       process.kill(pid, "SIGTERM");
     }
@@ -45811,26 +45963,26 @@ function stopSessionHost() {
   let stopped = false;
   const pidFile = getSessionHostPidFile();
   try {
-    if (fs14.existsSync(pidFile)) {
-      const pid = Number.parseInt(fs14.readFileSync(pidFile, "utf8").trim(), 10);
+    if (fs15.existsSync(pidFile)) {
+      const pid = Number.parseInt(fs15.readFileSync(pidFile, "utf8").trim(), 10);
       if (Number.isFinite(pid)) {
-        stopped = killPid(pid) || stopped;
+        stopped = killPid2(pid) || stopped;
       }
     }
   } catch {
   } finally {
     try {
-      fs14.unlinkSync(pidFile);
+      fs15.unlinkSync(pidFile);
     } catch {
     }
   }
   if (process.platform !== "win32") {
     try {
-      const raw = (0, import_child_process9.execFileSync)("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
+      const raw = (0, import_child_process11.execFileSync)("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
       for (const line of raw.split("\n")) {
         const pid = Number.parseInt(line.trim(), 10);
         if (Number.isFinite(pid)) {
-          stopped = killPid(pid) || stopped;
+          stopped = killPid2(pid) || stopped;
         }
       }
     } catch {
@@ -45843,7 +45995,7 @@ async function ensureSessionHostReady2() {
     appName: SESSION_HOST_APP_NAME,
     spawnHost: () => {
       const entry = resolveSessionHostEntry();
-      const child = (0, import_child_process9.spawn)(process.execPath, [entry], {
+      const child = (0, import_child_process11.spawn)(process.execPath, [entry], {
         detached: true,
         stdio: "ignore",
         windowsHide: true,
@@ -45859,14 +46011,14 @@ async function ensureSessionHostReady2() {
 async function listHostedCliRuntimes2(endpoint) {
   return listHostedCliRuntimes(endpoint);
 }
-var import_child_process9, fs14, os19, path16, SESSION_HOST_APP_NAME;
+var import_child_process11, fs15, os20, path17, SESSION_HOST_APP_NAME;
 var init_session_host = __esm({
   "src/session-host.ts"() {
     "use strict";
-    import_child_process9 = require("child_process");
-    fs14 = __toESM(require("fs"));
-    os19 = __toESM(require("os"));
-    path16 = __toESM(require("path"));
+    import_child_process11 = require("child_process");
+    fs15 = __toESM(require("fs"));
+    os20 = __toESM(require("os"));
+    path17 = __toESM(require("path"));
     init_src();
     SESSION_HOST_APP_NAME = process.env.ADHDEV_SESSION_HOST_NAME || "adhdev";
   }
@@ -45880,24 +46032,24 @@ __export(adhdev_daemon_exports, {
   stopDaemon: () => stopDaemon
 });
 function getDaemonPidFile() {
-  const dir = path17.join(os20.homedir(), ".adhdev");
-  if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
-  return path17.join(dir, "daemon.pid");
+  const dir = path18.join(os21.homedir(), ".adhdev");
+  if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
+  return path18.join(dir, "daemon.pid");
 }
 function writeDaemonPid(pid) {
-  fs15.writeFileSync(getDaemonPidFile(), String(pid), "utf-8");
+  fs16.writeFileSync(getDaemonPidFile(), String(pid), "utf-8");
 }
 function removeDaemonPid() {
   try {
-    fs15.unlinkSync(getDaemonPidFile());
+    fs16.unlinkSync(getDaemonPidFile());
   } catch (e) {
   }
 }
 function isDaemonRunning() {
   const pidFile = getDaemonPidFile();
   try {
-    if (!fs15.existsSync(pidFile)) return false;
-    const pid = parseInt(fs15.readFileSync(pidFile, "utf-8").trim());
+    if (!fs16.existsSync(pidFile)) return false;
+    const pid = parseInt(fs16.readFileSync(pidFile, "utf-8").trim());
     process.kill(pid, 0);
     return true;
   } catch {
@@ -45908,8 +46060,8 @@ function isDaemonRunning() {
 function stopDaemon() {
   const pidFile = getDaemonPidFile();
   try {
-    if (!fs15.existsSync(pidFile)) return false;
-    const pid = parseInt(fs15.readFileSync(pidFile, "utf-8").trim());
+    if (!fs16.existsSync(pidFile)) return false;
+    const pid = parseInt(fs16.readFileSync(pidFile, "utf-8").trim());
     process.kill(pid, "SIGTERM");
     removeDaemonPid();
     return true;
@@ -45918,7 +46070,7 @@ function stopDaemon() {
     return false;
   }
 }
-var os20, fs15, path17, import_chalk2, pkgVersion, DANGEROUS_PATTERNS, AdhdevDaemon;
+var os21, fs16, path18, import_chalk2, pkgVersion, DANGEROUS_PATTERNS, AdhdevDaemon;
 var init_adhdev_daemon = __esm({
   "src/adhdev-daemon.ts"() {
     "use strict";
@@ -45928,20 +46080,20 @@ var init_adhdev_daemon = __esm({
     init_screenshot_controller();
     init_session_host();
     init_dist();
-    os20 = __toESM(require("os"));
-    fs15 = __toESM(require("fs"));
-    path17 = __toESM(require("path"));
+    os21 = __toESM(require("os"));
+    fs16 = __toESM(require("fs"));
+    path18 = __toESM(require("path"));
     import_chalk2 = __toESM(require("chalk"));
-    pkgVersion = "0.7.42";
+    pkgVersion = "0.7.44";
     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 p of possiblePaths) {
           try {
-            const data = JSON.parse(fs15.readFileSync(p, "utf-8"));
+            const data = JSON.parse(fs16.readFileSync(p, "utf-8"));
             if (data.version) {
               pkgVersion = data.version;
               break;
@@ -46079,8 +46231,8 @@ ${err?.stack || ""}`);
             cliInfo: {
               type: "adhdev-daemon",
               version: pkgVersion,
-              platform: os20.platform(),
-              hostname: os20.hostname(),
+              platform: os21.platform(),
+              hostname: os21.hostname(),
               machineId: config2.machineId,
               instanceId
             }
@@ -46520,16 +46672,16 @@ async function loginFlow() {
   let verificationUrl;
   try {
     const config2 = loadConfig();
-    const os21 = await import("os");
+    const os22 = await import("os");
     const res = await fetch(`${SERVER_URL}/auth/cli/init`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         clientMachineId: config2.machineId,
         registeredMachineId: config2.registeredMachineId,
-        hostname: os21.hostname(),
-        platform: os21.platform(),
-        arch: os21.arch()
+        hostname: os22.hostname(),
+        platform: os22.platform(),
+        arch: os22.arch()
       })
     });
     if (!res.ok) {
@@ -46628,10 +46780,10 @@ async function startDaemonFlow() {
     const { AdhdevDaemon: AdhdevDaemon2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
     const daemon = new AdhdevDaemon2();
     const { execSync: execSync7 } = await import("child_process");
-    const os21 = await import("os");
-    const path18 = await import("path");
-    const logPath = path18.join(os21.homedir(), ".adhdev", "daemon.log");
-    const platform11 = os21.platform();
+    const os22 = await import("os");
+    const path19 = await import("path");
+    const logPath = path19.join(os22.homedir(), ".adhdev", "daemon.log");
+    const platform11 = os22.platform();
     try {
       if (platform11 === "win32") {
         execSync7(`start /B adhdev daemon > "${logPath}" 2>&1`, {
@@ -47267,7 +47419,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
     });
   });
   program2.command("standalone").description("\u{1F5A5}\uFE0F  Start ADHDev Standalone Server (Local Dashboard & Embedded Daemon)").option("-p, --port <port>", "Local HTTP/WS server port", "3847").option("--host <host>", "Bind to specific host (use 0.0.0.0 for LAN access)").option("--no-open", "Prevent opening browser automatically").option("--token <token>", "Require token authentication").option("--dev", "Enable Dev Mode").action(async (options) => {
-    const { spawn: spawn4, execSync: execSync7 } = await import("child_process");
+    const { spawn: spawn5, execSync: execSync7 } = await import("child_process");
     console.log(import_chalk5.default.cyan("\n  Starting ADHDev Standalone Server..."));
     const args = [];
     if (options.port) args.push("--port", options.port);
@@ -47285,7 +47437,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
       console.log(import_chalk5.default.gray("  Downloading and running via npx (this may take a moment)..."));
     }
     const spawnArgs = bin === "npx" ? npxArgs : args;
-    const child = spawn4(bin, spawnArgs, {
+    const child = spawn5(bin, spawnArgs, {
       stdio: "inherit",
       shell: process.platform === "win32"
     });
@@ -47322,7 +47474,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
   hideCommand(program2.command("daemon:restart").description("Restart ADHDev Daemon (stop \u2192 start)").option("-p, --port <port>", "Local WS server port", "19222").option("--server <url>", "Override server URL").option("--dev", "Enable Dev Mode").action(async (options) => {
     const { stopDaemon: stopDaemon2, isDaemonRunning: isDaemonRunning2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
     const { stopSessionHost: stopSessionHost2 } = await Promise.resolve().then(() => (init_session_host(), session_host_exports));
-    const { spawn: spawn4 } = await import("child_process");
+    const { spawn: spawn5 } = await import("child_process");
     if (isDaemonRunning2()) {
       console.log(import_chalk5.default.yellow("\n  Stopping existing daemon..."));
       stopDaemon2();
@@ -47334,7 +47486,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
     const args = ["daemon", "-p", options.port || "19222"];
     if (options.server) args.push("--server", options.server);
     if (options.dev) args.push("--dev");
-    const child = spawn4(process.execPath, [process.argv[1], ...args], {
+    const child = spawn5(process.execPath, [process.argv[1], ...args], {
       detached: true,
       stdio: "ignore",
       env: { ...process.env }
@@ -47353,7 +47505,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
   hideCommand(program2.command("daemon:upgrade").description("Upgrade ADHDev to latest version and restart daemon").option("--no-restart", "Upgrade only, skip daemon restart").action(async (options) => {
     const { isDaemonRunning: isDaemonRunning2, stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
     const { stopSessionHost: stopSessionHost2 } = await Promise.resolve().then(() => (init_session_host(), session_host_exports));
-    const { execSync: execSync7, spawn: spawn4 } = await import("child_process");
+    const { execSync: execSync7, spawn: spawn5 } = await import("child_process");
     const fsMod = await import("fs");
     const pathMod = await import("path");
     console.log(import_chalk5.default.bold("\n  \u{1F504} ADHDev Upgrade\n"));
@@ -47411,7 +47563,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
       await new Promise((r) => setTimeout(r, 2e3));
       stopSessionHost2();
       await new Promise((r) => setTimeout(r, 500));
-      const child = spawn4(process.execPath, [process.argv[1], "daemon", "-p", "19222"], {
+      const child = spawn5(process.execPath, [process.argv[1], "daemon", "-p", "19222"], {
         detached: true,
         stdio: "ignore",
         env: { ...process.env }
@@ -47620,35 +47772,35 @@ function registerProviderCommands(program2) {
       let osPaths = {};
       let processNames = {};
       if (category === "ide") {
-        const fs16 = await import("fs");
-        const path18 = await import("path");
-        const os21 = await import("os");
-        if (os21.platform() === "darwin") {
+        const fs17 = await import("fs");
+        const path19 = await import("path");
+        const os22 = await import("os");
+        if (os22.platform() === "darwin") {
           while (true) {
             const p = (await rl.question(`macOS Application Path (e.g. /Applications/${defaultName}.app): `)).trim() || `/Applications/${defaultName}.app`;
             if (p === "skip") break;
-            if (!fs16.existsSync(p)) {
+            if (!fs17.existsSync(p)) {
               console.log(import_chalk6.default.red(`  \u2717 Path not found: ${p}`));
               console.log(import_chalk6.default.gray(`    (Please provide the exact absolute path to the .app or binary, or type 'skip')`));
               continue;
             }
             console.log(import_chalk6.default.green(`  \u2713 Path verified: ${p}`));
             osPaths["darwin"] = [p];
-            processNames["darwin"] = path18.basename(p, ".app");
+            processNames["darwin"] = path19.basename(p, ".app");
             break;
           }
-        } else if (os21.platform() === "win32") {
+        } else if (os22.platform() === "win32") {
           while (true) {
             const p = (await rl.question(`Windows Executable Path (e.g. C:\\Program Files\\${defaultName}\\${defaultName}.exe): `)).trim();
             if (!p || p === "skip") break;
-            if (!fs16.existsSync(p)) {
+            if (!fs17.existsSync(p)) {
               console.log(import_chalk6.default.red(`  \u2717 Path not found: ${p}`));
               console.log(import_chalk6.default.gray(`    (Please provide the exact absolute path, or type 'skip')`));
               continue;
             }
             console.log(import_chalk6.default.green(`  \u2713 Path verified: ${p}`));
             osPaths["win32"] = [p];
-            processNames["win32"] = path18.basename(p, ".exe");
+            processNames["win32"] = path19.basename(p, ".exe");
             break;
           }
         }
@@ -48324,8 +48476,8 @@ function registerCdpCommands(program2) {
       }
       const output = typeof result === "string" ? result : JSON.stringify(result, null, 2);
       if (options.output) {
-        const fs16 = await import("fs");
-        fs16.writeFileSync(options.output, output, "utf-8");
+        const fs17 = await import("fs");
+        fs17.writeFileSync(options.output, output, "utf-8");
         console.log(import_chalk6.default.green(`
   \u2713 Saved to ${options.output} (${output.length} chars)
 `));
@@ -48428,8 +48580,8 @@ function registerCdpCommands(program2) {
         ws2.on("message", async (data) => {
           const msg = JSON.parse(data.toString());
           if (msg.id === 1 && msg.result?.data) {
-            const fs16 = await import("fs");
-            fs16.writeFileSync(options.output, Buffer.from(msg.result.data, "base64"));
+            const fs17 = await import("fs");
+            fs17.writeFileSync(options.output, Buffer.from(msg.result.data, "base64"));
             console.log(import_chalk6.default.green(`
   \u2713 Screenshot saved to ${options.output}
 `));
@@ -48478,29 +48630,35 @@ registerSetupCommands(program, _cliProviderLoader);
 registerDaemonCommands(program, pkgVersion2);
 registerProviderCommands(program);
 registerCdpCommands(program);
-if (process.argv.length <= 2) {
-  program.outputHelp();
-  console.log();
-  console.log(import_chalk7.default.gray("  Quick start:"));
-  console.log(import_chalk7.default.gray("    adhdev setup             \u2014 First-time setup & login"));
-  console.log(import_chalk7.default.gray("    adhdev daemon            \u2014 Start unified daemon (Required)"));
-  console.log(import_chalk7.default.gray("    adhdev standalone        \u2014 Start standalone local dashboard & daemon"));
-  console.log(import_chalk7.default.gray("    adhdev launch cursor     \u2014 Launch IDE with CDP (e.g. cursor, windsurf)"));
-  console.log(import_chalk7.default.gray("    adhdev launch claude     \u2014 Launch CLI agent (e.g. gemini, claude)"));
-  console.log(import_chalk7.default.gray("    adhdev status            \u2014 Check current setup"));
-  console.log(import_chalk7.default.gray("    adhdev update            \u2014 Upgrade to latest version"));
-  console.log();
-  console.log(import_chalk7.default.gray("  Advanced tools:"));
-  console.log(import_chalk7.default.gray("    adhdev provider ...      \u2014 Provider development commands"));
-  console.log(import_chalk7.default.gray("    adhdev cdp ...           \u2014 CDP debugging tools"));
-  console.log();
-} else {
-  program.parseAsync(process.argv).catch((err) => {
-    console.error(import_chalk7.default.red(`
+void (async () => {
+  const helperMode = await maybeRunDaemonUpgradeHelperFromEnv();
+  if (helperMode) {
+    return;
+  }
+  if (process.argv.length <= 2) {
+    program.outputHelp();
+    console.log();
+    console.log(import_chalk7.default.gray("  Quick start:"));
+    console.log(import_chalk7.default.gray("    adhdev setup             \u2014 First-time setup & login"));
+    console.log(import_chalk7.default.gray("    adhdev daemon            \u2014 Start unified daemon (Required)"));
+    console.log(import_chalk7.default.gray("    adhdev standalone        \u2014 Start standalone local dashboard & daemon"));
+    console.log(import_chalk7.default.gray("    adhdev launch cursor     \u2014 Launch IDE with CDP (e.g. cursor, windsurf)"));
+    console.log(import_chalk7.default.gray("    adhdev launch claude     \u2014 Launch CLI agent (e.g. gemini, claude)"));
+    console.log(import_chalk7.default.gray("    adhdev status            \u2014 Check current setup"));
+    console.log(import_chalk7.default.gray("    adhdev update            \u2014 Upgrade to latest version"));
+    console.log();
+    console.log(import_chalk7.default.gray("  Advanced tools:"));
+    console.log(import_chalk7.default.gray("    adhdev provider ...      \u2014 Provider development commands"));
+    console.log(import_chalk7.default.gray("    adhdev cdp ...           \u2014 CDP debugging tools"));
+    console.log();
+    return;
+  }
+  await program.parseAsync(process.argv);
+})().catch((err) => {
+  console.error(import_chalk7.default.red(`
 \u2717 ${err.message}`));
-    process.exit(1);
-  });
-}
+  process.exit(1);
+});
 /*! Bundled license information:
 
 chokidar/index.js: