adhdev 0.9.33 → 0.9.35

package/dist/cli/index.js

@@ -10474,7 +10474,14 @@ var init_handler = __esm({
           await this._ctx.providerLoader.fetchLatest().catch(() => {
           });
           this._ctx.providerLoader.reload();
-          return { success: true };
+          this._ctx.providerLoader.registerToDetector();
+          const refreshedInstances = this._ctx.instanceManager ? this._ctx.instanceManager.refreshProviderDefinitions((providerType) => this._ctx.providerLoader.resolve(providerType)) : 0;
+          const providers = this._ctx.providerLoader.getAll().map((provider) => ({
+            type: provider.type,
+            name: provider.name,
+            category: provider.category
+          }));
+          return { success: true, refreshedInstances, providers };
         }
         return { success: false, error: "ProviderLoader not initialized" };
       }
@@ -12369,13 +12376,14 @@ function sliceFromOffset(text, start) {
 function hydrateCliParsedMessages(parsedMessages, options) {
   const { committedMessages, scope, lastOutputAt } = options;
   const referenceMessages = [...committedMessages];
+  const referenceComparables = referenceMessages.map((message) => normalizeComparableMessageContent(message?.content || ""));
   const usedReferenceIndexes = /* @__PURE__ */ new Set();
   const now = options.now ?? Date.now();
   const findReferenceTimestamp = (role, content, parsedIndex) => {
     const normalizedContent = normalizeComparableMessageContent(content);
     if (!normalizedContent) return void 0;
     const sameIndex = referenceMessages[parsedIndex];
-    if (sameIndex && !usedReferenceIndexes.has(parsedIndex) && sameIndex.role === role && normalizeComparableMessageContent(sameIndex.content) === normalizedContent && typeof sameIndex.timestamp === "number" && Number.isFinite(sameIndex.timestamp)) {
+    if (sameIndex && !usedReferenceIndexes.has(parsedIndex) && sameIndex.role === role && referenceComparables[parsedIndex] === normalizedContent && typeof sameIndex.timestamp === "number" && Number.isFinite(sameIndex.timestamp)) {
       usedReferenceIndexes.add(parsedIndex);
       return sameIndex.timestamp;
     }
@@ -12383,7 +12391,7 @@ function hydrateCliParsedMessages(parsedMessages, options) {
       if (usedReferenceIndexes.has(i)) continue;
       const candidate = referenceMessages[i];
       if (!candidate || candidate.role !== role) continue;
-      const candidateContent = normalizeComparableMessageContent(candidate.content);
+      const candidateContent = referenceComparables[i];
       if (!candidateContent) continue;
       const exactMatch = candidateContent === normalizedContent;
       const fuzzyMatch = candidateContent.includes(normalizedContent) || normalizedContent.includes(candidateContent);
@@ -12765,6 +12773,8 @@ var init_provider_cli_adapter = __esm({
       messages = [];
       committedMessages = [];
       structuredMessages = [];
+      committedMessagesActivitySignature = "";
+      committedMessagesChangedAt = 0;
       currentStatus = "starting";
       onStatusChange = null;
       responseBuffer = "";
@@ -12846,10 +12856,35 @@ var init_provider_cli_adapter = __esm({
       providerResolutionMeta;
       static FINISH_RETRY_DELAY_MS = 300;
       static MAX_FINISH_RETRIES = 2;
+      buildCommittedMessagesActivitySignature() {
+        const last = this.committedMessages[this.committedMessages.length - 1];
+        return [
+          String(this.committedMessages.length),
+          String(last?.role || ""),
+          String(last?.kind || ""),
+          String(last?.senderName || ""),
+          String(last?.timestamp || ""),
+          String(last?.receivedAt || ""),
+          normalizeComparableMessageContent(last?.content || "").slice(-240)
+        ].join("|");
+      }
       syncMessageViews() {
+        const signature = this.buildCommittedMessagesActivitySignature();
+        if (signature !== this.committedMessagesActivitySignature) {
+          this.committedMessagesActivitySignature = signature;
+          this.committedMessagesChangedAt = Date.now();
+        }
         this.messages = [...this.committedMessages];
         this.structuredMessages = [...this.committedMessages];
       }
+      getLastCommittedMessageActivityAt() {
+        const last = this.committedMessages[this.committedMessages.length - 1];
+        const messageTime = Math.max(
+          typeof last?.receivedAt === "number" && Number.isFinite(last.receivedAt) ? last.receivedAt : 0,
+          typeof last?.timestamp === "number" && Number.isFinite(last.timestamp) ? last.timestamp : 0
+        );
+        return Math.max(messageTime, this.committedMessagesChangedAt || 0);
+      }
       readTerminalScreenText(now = Date.now()) {
         const screenText = this.terminalScreen.getText() || "";
         this.lastScreenText = screenText;
@@ -12989,9 +13024,16 @@ var init_provider_cli_adapter = __esm({
       /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
       setCliScripts(scripts) {
         this.cliScripts = scripts;
+        this.parsedStatusCache = null;
+        this.parseErrorMessage = null;
         const scriptNames = listCliScriptNames(scripts);
         LOG.info("CLI", `[${this.cliType}] CLI scripts injected: [${scriptNames.join(", ")}]`);
       }
+      /** Refresh provider scripts/config used by this adapter without restarting the PTY runtime. */
+      refreshProviderDefinition(provider) {
+        this.provider = provider;
+        this.setCliScripts(provider.scripts || {});
+      }
       updateRuntimeSettings(settings) {
         this.runtimeSettings = { ...settings };
       }
@@ -13475,7 +13517,7 @@ var init_provider_cli_adapter = __esm({
           return;
         }
         if (this.currentTurnScope && !lastParsedAssistant) {
-          LOG.info(
+          LOG.debug(
             "CLI",
             `[${this.cliType}] Settled without assistant: prompt=${JSON.stringify(this.currentTurnScope.prompt).slice(0, 140)} responseBuffer=${JSON.stringify(summarizeCliTraceText(this.responseBuffer, 220)).slice(0, 260)} screen=${JSON.stringify(summarizeCliTraceText(screenText, 220)).slice(0, 260)} providerDir=${this.providerResolutionMeta.providerDir || "-"} scriptDir=${this.providerResolutionMeta.scriptDir || "-"}`
           );
@@ -14291,9 +14333,43 @@ var init_provider_cli_adapter = __esm({
       }
       armResponseTimeout() {
         if (this.responseTimeout) clearTimeout(this.responseTimeout);
+        const timeoutMs = this.timeouts.maxResponse;
+        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+          this.responseTimeout = null;
+          return;
+        }
         this.responseTimeout = setTimeout(() => {
-          if (this.isWaitingForResponse) this.finishResponse();
-        }, this.timeouts.maxResponse);
+          this.responseTimeout = null;
+          if (!this.isWaitingForResponse) return;
+          const detectedStatusBeforeEval = this.runDetectStatus(this.recentOutputBuffer);
+          this.recordTrace("response_timeout_check", {
+            timeoutMs,
+            detectedStatus: detectedStatusBeforeEval,
+            currentStatus: this.currentStatus,
+            isWaitingForResponse: this.isWaitingForResponse,
+            hasActionableApproval: this.hasActionableApproval(),
+            ...buildCliTraceParseSnapshot({
+              accumulatedBuffer: this.accumulatedBuffer,
+              accumulatedRawBuffer: this.accumulatedRawBuffer,
+              responseBuffer: this.responseBuffer,
+              partialResponse: this.responseBuffer,
+              scope: this.currentTurnScope
+            })
+          });
+          this.settledBuffer = this.recentOutputBuffer;
+          this.evaluateSettled();
+          if (this.isWaitingForResponse && !this.hasActionableApproval()) {
+            const detectedStatusAfterEval = this.runDetectStatus(this.recentOutputBuffer);
+            this.recordTrace("response_timeout_kept_open", {
+              timeoutMs,
+              detectedStatusBeforeEval,
+              detectedStatusAfterEval,
+              currentStatus: this.currentStatus,
+              isWaitingForResponse: this.isWaitingForResponse
+            });
+            this.armResponseTimeout();
+          }
+        }, timeoutMs);
       }
       writeSubmitKeyForRetry(mode) {
         void this.writeToPty(this.sendKey).catch((error48) => {
@@ -14979,6 +15055,11 @@ var init_cli_provider_instance = __esm({
       launchMode;
       startedAt = Date.now();
       onProviderSessionResolved;
+      refreshProviderDefinition(provider) {
+        if (provider.type !== this.type || provider.category !== "cli") return;
+        this.provider = provider;
+        this.adapter.refreshProviderDefinition(provider);
+      }
       // ─── Lifecycle ─────────────────────────────────
       async init(context) {
         this.context = context;
@@ -15184,6 +15265,22 @@ var init_cli_provider_instance = __esm({
       getPresentationMode() {
         return this.presentationMode;
       }
+      getHotChatSessionState() {
+        const adapterStatus = this.adapter.getStatus();
+        const autoApproveActive = adapterStatus.status === "waiting_approval" && this.shouldAutoApprove();
+        const visibleStatus = autoApproveActive ? "generating" : adapterStatus.status;
+        const runtime = this.adapter.getRuntimeMetadata();
+        const lastCommittedMessageActivityAt = typeof this.adapter.getLastCommittedMessageActivityAt === "function" ? this.adapter.getLastCommittedMessageActivityAt() : 0;
+        return {
+          id: this.instanceId,
+          status: visibleStatus,
+          lastMessageAt: lastCommittedMessageActivityAt || void 0,
+          runtimeLifecycle: runtime?.lifecycle ?? null,
+          runtimeSurfaceKind: runtime?.surfaceKind,
+          runtimeRestoredFromStorage: runtime?.restoredFromStorage === true,
+          runtimeRecoveryState: runtime?.recoveryState ?? null
+        };
+      }
       updateSettings(newSettings) {
         this.settings = { ...newSettings };
         this.adapter.updateRuntimeSettings?.(this.settings);
@@ -15339,6 +15436,15 @@ var init_cli_provider_instance = __esm({
               this.completedDebouncePending = { chatTitle, duration: duration3, timestamp: now };
               this.completedDebounceTimer = setTimeout(() => {
                 if (this.completedDebouncePending) {
+                  const latestStatus = this.adapter.getStatus();
+                  const latestAutoApproveActive = latestStatus.status === "waiting_approval" && this.shouldAutoApprove();
+                  const latestVisibleStatus = latestAutoApproveActive ? "generating" : latestStatus.status;
+                  if (latestVisibleStatus !== "idle") {
+                    LOG.info("CLI", `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
+                    this.completedDebouncePending = null;
+                    this.completedDebounceTimer = null;
+                    return;
+                  }
                   LOG.info("CLI", `[${this.type}] completed in ${this.completedDebouncePending.duration}s`);
                   this.pushEvent({ event: "agent:generating_completed", ...this.completedDebouncePending });
                   this.completedDebouncePending = null;
@@ -16001,10 +16107,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path35) {
-  if (!path35)
+function getElementAtPath(obj, path36) {
+  if (!path36)
     return obj;
-  return path35.reduce((acc, key) => acc?.[key], obj);
+  return path36.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -16316,11 +16422,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path35, issues) {
+function prefixIssues(path36, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path35);
+    iss.path.unshift(path36);
     return iss;
   });
 }
@@ -16563,7 +16669,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path35 = []) => {
+  const processError = (error49, path36 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -16573,7 +16679,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path35, ...issue2.path];
+        const fullpath = [...path36, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -16605,8 +16711,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path35 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path35) {
+  const path36 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path36) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -29370,13 +29476,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path35 = ref.slice(1).split("/").filter(Boolean);
-  if (path35.length === 0) {
+  const path36 = ref.slice(1).split("/").filter(Boolean);
+  if (path36.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path35[0] === defsKey) {
-    const key = path35[1];
+  if (path36[0] === defsKey) {
+    const key = path36[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -34118,7 +34224,7 @@ var init_readdirp = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
         if (wantBigintFsStats) {
-          this._stat = (path35) => statMethod(path35, { bigint: true });
+          this._stat = (path36) => statMethod(path36, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -34143,8 +34249,8 @@ var init_readdirp = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path35, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path35));
+              const { path: path36, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path36));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -34184,20 +34290,20 @@ var init_readdirp = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path35, depth) {
+      async _exploreDir(path36, depth) {
         let files;
         try {
-          files = await (0, import_promises.readdir)(path35, this._rdOptions);
+          files = await (0, import_promises.readdir)(path36, this._rdOptions);
         } catch (error48) {
           this._onError(error48);
         }
-        return { files, depth, path: path35 };
+        return { files, depth, path: path36 };
       }
-      async _formatEntry(dirent, path35) {
+      async _formatEntry(dirent, path36) {
         let entry;
         const basename10 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path35, basename10));
+          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path36, basename10));
           entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename10 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
@@ -34254,16 +34360,16 @@ var init_readdirp = __esm({
 });
 
 // ../../oss/packages/daemon-core/node_modules/chokidar/handler.js
-function createFsWatchInstance(path35, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path36, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path35);
-    emitRaw(rawEvent, evPath, { watchedPath: path35 });
-    if (evPath && path35 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path35, evPath), KEY_LISTENERS, sp.join(path35, evPath));
+    listener(path36);
+    emitRaw(rawEvent, evPath, { watchedPath: path36 });
+    if (evPath && path36 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path36, evPath), KEY_LISTENERS, sp.join(path36, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path35, {
+    return (0, import_node_fs.watch)(path36, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error48) {
@@ -34612,12 +34718,12 @@ var init_handler2 = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path35, fullPath, options, handlers) => {
+    setFsWatchListener = (path36, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path35, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path36, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -34628,7 +34734,7 @@ var init_handler2 = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path35,
+          path36,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -34643,7 +34749,7 @@ var init_handler2 = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error48.code === "EPERM") {
             try {
-              const fd = await (0, import_promises2.open)(path35, "r");
+              const fd = await (0, import_promises2.open)(path36, "r");
               await fd.close();
               broadcastErr(error48);
             } catch (err) {
@@ -34674,7 +34780,7 @@ var init_handler2 = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path35, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path36, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -34696,7 +34802,7 @@ var init_handler2 = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path35, curr));
+              foreach(cont.listeners, (listener2) => listener2(path36, curr));
             }
           })
         };
@@ -34726,13 +34832,13 @@ var init_handler2 = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path35, listener) {
+      _watchWithNodeFs(path36, listener) {
         const opts = this.fsw.options;
-        const directory = sp.dirname(path35);
-        const basename10 = sp.basename(path35);
+        const directory = sp.dirname(path36);
+        const basename10 = sp.basename(path36);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename10);
-        const absolutePath = sp.resolve(path35);
+        const absolutePath = sp.resolve(path36);
         const options = {
           persistent: opts.persistent
         };
@@ -34742,12 +34848,12 @@ var init_handler2 = __esm({
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
           options.interval = enableBin && isBinaryPath(basename10) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path35, absolutePath, options, {
+          closer = setFsWatchFileListener(path36, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path35, absolutePath, options, {
+          closer = setFsWatchListener(path36, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -34769,7 +34875,7 @@ var init_handler2 = __esm({
         let prevStats = stats;
         if (parent.has(basename10))
           return;
-        const listener = async (path35, newStats) => {
+        const listener = async (path36, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -34783,11 +34889,11 @@ var init_handler2 = __esm({
                 this.fsw._emit(EV.CHANGE, file2, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path35);
+                this.fsw._closeFile(path36);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file2, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path35, closer2);
+                  this.fsw._addPathCloser(path36, closer2);
               } else {
                 prevStats = newStats2;
               }
@@ -34819,7 +34925,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, path35, item) {
+      async _handleSymlink(entry, directory, path36, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -34829,7 +34935,7 @@ var init_handler2 = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await (0, import_promises2.realpath)(path35);
+            linkPath = await (0, import_promises2.realpath)(path36);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -34839,12 +34945,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, path35, entry.stats);
+              this.fsw._emit(EV.CHANGE, path36, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path35, entry.stats);
+            this.fsw._emit(EV.ADD, path36, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -34874,9 +34980,9 @@ var init_handler2 = __esm({
             return;
           }
           const item = entry.path;
-          let path35 = sp.join(directory, item);
+          let path36 = sp.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path35, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path36, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -34885,8 +34991,8 @@ var init_handler2 = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path35 = sp.join(dir, sp.relative(dir, path35));
-            this._addToNodeFs(path35, initialAdd, wh, depth + 1);
+            path36 = sp.join(dir, sp.relative(dir, path36));
+            this._addToNodeFs(path36, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve18, reject) => {
@@ -34955,13 +35061,13 @@ var init_handler2 = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path35, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path36, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path35) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path36) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path35);
+        const wh = this.fsw._getWatchHelpers(path36);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -34977,8 +35083,8 @@ var init_handler2 = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sp.resolve(path35);
-            const targetPath = follow ? await (0, import_promises2.realpath)(path35) : path35;
+            const absPath = sp.resolve(path36);
+            const targetPath = follow ? await (0, import_promises2.realpath)(path36) : path36;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -34988,29 +35094,29 @@ var init_handler2 = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await (0, import_promises2.realpath)(path35) : path35;
+            const targetPath = follow ? await (0, import_promises2.realpath)(path36) : path36;
             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, path35, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path36, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sp.resolve(path35), targetPath);
+              this.fsw._symlinkPaths.set(sp.resolve(path36), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path35, closer);
+            this.fsw._addPathCloser(path36, closer);
           return false;
         } catch (error48) {
           if (this.fsw._handleError(error48)) {
             ready();
-            return path35;
+            return path36;
           }
         }
       }
@@ -35045,24 +35151,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path35) {
-  if (typeof path35 !== "string")
+function normalizePath(path36) {
+  if (typeof path36 !== "string")
     throw new Error("string expected");
-  path35 = sp2.normalize(path35);
-  path35 = path35.replace(/\\/g, "/");
+  path36 = sp2.normalize(path36);
+  path36 = path36.replace(/\\/g, "/");
   let prepend = false;
-  if (path35.startsWith("//"))
+  if (path36.startsWith("//"))
     prepend = true;
-  path35 = path35.replace(DOUBLE_SLASH_RE, "/");
+  path36 = path36.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path35 = "/" + path35;
-  return path35;
+    path36 = "/" + path36;
+  return path36;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path35 = normalizePath(testString);
+  const path36 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path35, stats)) {
+    if (pattern(path36, stats)) {
       return true;
     }
   }
@@ -35125,19 +35231,19 @@ var init_chokidar = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path35) => toUnix(sp2.normalize(toUnix(path35)));
-    normalizeIgnored = (cwd = "") => (path35) => {
-      if (typeof path35 === "string") {
-        return normalizePathToUnix(sp2.isAbsolute(path35) ? path35 : sp2.join(cwd, path35));
+    normalizePathToUnix = (path36) => toUnix(sp2.normalize(toUnix(path36)));
+    normalizeIgnored = (cwd = "") => (path36) => {
+      if (typeof path36 === "string") {
+        return normalizePathToUnix(sp2.isAbsolute(path36) ? path36 : sp2.join(cwd, path36));
       } else {
-        return path35;
+        return path36;
       }
     };
-    getAbsolutePath = (path35, cwd) => {
-      if (sp2.isAbsolute(path35)) {
-        return path35;
+    getAbsolutePath = (path36, cwd) => {
+      if (sp2.isAbsolute(path36)) {
+        return path36;
       }
-      return sp2.join(cwd, path35);
+      return sp2.join(cwd, path36);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -35202,10 +35308,10 @@ var init_chokidar = __esm({
       dirParts;
       followSymlinks;
       statMethod;
-      constructor(path35, follow, fsw) {
+      constructor(path36, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path35;
-        this.path = path35 = path35.replace(REPLACER_RE, "");
+        const watchPath = path36;
+        this.path = path36 = path36.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sp2.resolve(watchPath);
         this.dirParts = [];
@@ -35345,20 +35451,20 @@ var init_chokidar = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path35) => {
-            const absPath = getAbsolutePath(path35, cwd);
+          paths = paths.map((path36) => {
+            const absPath = getAbsolutePath(path36, cwd);
             return absPath;
           });
         }
-        paths.forEach((path35) => {
-          this._removeIgnoredPath(path35);
+        paths.forEach((path36) => {
+          this._removeIgnoredPath(path36);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path35) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path35, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path36) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path36, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -35380,17 +35486,17 @@ var init_chokidar = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path35) => {
-          if (!sp2.isAbsolute(path35) && !this._closers.has(path35)) {
+        paths.forEach((path36) => {
+          if (!sp2.isAbsolute(path36) && !this._closers.has(path36)) {
             if (cwd)
-              path35 = sp2.join(cwd, path35);
-            path35 = sp2.resolve(path35);
+              path36 = sp2.join(cwd, path36);
+            path36 = sp2.resolve(path36);
           }
-          this._closePath(path35);
-          this._addIgnoredPath(path35);
-          if (this._watched.has(path35)) {
+          this._closePath(path36);
+          this._addIgnoredPath(path36);
+          if (this._watched.has(path36)) {
             this._addIgnoredPath({
-              path: path35,
+              path: path36,
               recursive: true
             });
           }
@@ -35454,38 +35560,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, path35, stats) {
+      async _emit(event, path36, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path35 = sp2.normalize(path35);
+          path36 = sp2.normalize(path36);
         if (opts.cwd)
-          path35 = sp2.relative(opts.cwd, path35);
-        const args = [path35];
+          path36 = sp2.relative(opts.cwd, path36);
+        const args = [path36];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path35))) {
+        if (awf && (pw = this._pendingWrites.get(path36))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path35, [event, ...args]);
+            this._pendingUnlinks.set(path36, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path36) => {
+              this._pendingUnlinks.forEach((entry, path37) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path36);
+                this._pendingUnlinks.delete(path37);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path35)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path36)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path35);
+            this._pendingUnlinks.delete(path36);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -35503,16 +35609,16 @@ var init_chokidar = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path35, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path36, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path35, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path36, 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, path35) : path35;
+          const fullPath = opts.cwd ? sp2.join(opts.cwd, path36) : path36;
           let stats2;
           try {
             stats2 = await (0, import_promises3.stat)(fullPath);
@@ -35543,23 +35649,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, path35, timeout) {
+      _throttle(actionType, path36, 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(path35);
+        const actionPath = action.get(path36);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path35);
+          const item = action.get(path36);
           const count = item ? item.count : 0;
-          action.delete(path35);
+          action.delete(path36);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -35567,7 +35673,7 @@ var init_chokidar = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path35, thr);
+        action.set(path36, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -35581,44 +35687,44 @@ var init_chokidar = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path35, threshold, event, awfEmit) {
+      _awaitWriteFinish(path36, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path35;
-        if (this.options.cwd && !sp2.isAbsolute(path35)) {
-          fullPath = sp2.join(this.options.cwd, path35);
+        let fullPath = path36;
+        if (this.options.cwd && !sp2.isAbsolute(path36)) {
+          fullPath = sp2.join(this.options.cwd, path36);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-            if (err || !writes.has(path35)) {
+            if (err || !writes.has(path36)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path35).lastChange = now2;
+              writes.get(path36).lastChange = now2;
             }
-            const pw = writes.get(path35);
+            const pw = writes.get(path36);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path35);
+              writes.delete(path36);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path35)) {
-          writes.set(path35, {
+        if (!writes.has(path36)) {
+          writes.set(path36, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path35);
+              writes.delete(path36);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -35629,8 +35735,8 @@ var init_chokidar = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path35, stats) {
-        if (this.options.atomic && DOT_RE.test(path35))
+      _isIgnored(path36, stats) {
+        if (this.options.atomic && DOT_RE.test(path36))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -35640,17 +35746,17 @@ var init_chokidar = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path35, stats);
+        return this._userIgnored(path36, stats);
       }
-      _isntIgnored(path35, stat4) {
-        return !this._isIgnored(path35, stat4);
+      _isntIgnored(path36, stat4) {
+        return !this._isIgnored(path36, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path35) {
-        return new WatchHelper(path35, this.options.followSymlinks, this);
+      _getWatchHelpers(path36) {
+        return new WatchHelper(path36, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -35682,63 +35788,63 @@ var init_chokidar = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path35 = sp2.join(directory, item);
-        const fullPath = sp2.resolve(path35);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path35) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path35, 100))
+        const path36 = sp2.join(directory, item);
+        const fullPath = sp2.resolve(path36);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path36) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path36, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path35);
+        const wp = this._getWatchedDir(path36);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path35, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path36, 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 = path35;
+        let relPath = path36;
         if (this.options.cwd)
-          relPath = sp2.relative(this.options.cwd, path35);
+          relPath = sp2.relative(this.options.cwd, path36);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path35);
+        this._watched.delete(path36);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path35))
-          this._emit(eventName, path35);
-        this._closePath(path35);
+        if (wasTracked && !this._isIgnored(path36))
+          this._emit(eventName, path36);
+        this._closePath(path36);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path35) {
-        this._closeFile(path35);
-        const dir = sp2.dirname(path35);
-        this._getWatchedDir(dir).remove(sp2.basename(path35));
+      _closePath(path36) {
+        this._closeFile(path36);
+        const dir = sp2.dirname(path36);
+        this._getWatchedDir(dir).remove(sp2.basename(path36));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path35) {
-        const closers = this._closers.get(path35);
+      _closeFile(path36) {
+        const closers = this._closers.get(path36);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path35);
+        this._closers.delete(path36);
       }
-      _addPathCloser(path35, closer) {
+      _addPathCloser(path36, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path35);
+        let list = this._closers.get(path36);
         if (!list) {
           list = [];
-          this._closers.set(path35, list);
+          this._closers.set(path36, list);
         }
         list.push(closer);
       }
@@ -38458,6 +38564,51 @@ function killPid(pid) {
     return false;
   }
 }
+function getWindowsProcessCommandLine(pid) {
+  const pidFilter = `ProcessId=${pid}`;
+  try {
+    const psOut = (0, import_child_process8.execFileSync)("powershell.exe", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-Command",
+      `(Get-CimInstance Win32_Process -Filter "${pidFilter}").CommandLine`
+    ], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (psOut) return psOut;
+  } catch {
+  }
+  try {
+    const wmicOut = (0, import_child_process8.execFileSync)("wmic", [
+      "process",
+      "where",
+      pidFilter,
+      "get",
+      "CommandLine"
+    ], { encoding: "utf8", timeout: 3e3, stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (wmicOut) return wmicOut;
+  } catch {
+  }
+  return null;
+}
+function getProcessCommandLine(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return null;
+  if (process.platform === "win32") return getWindowsProcessCommandLine(pid);
+  try {
+    const text = (0, import_child_process8.execFileSync)("ps", ["-o", "command=", "-p", String(pid)], {
+      encoding: "utf8",
+      timeout: 3e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return text || null;
+  } catch {
+    return null;
+  }
+}
+function isManagedSessionHostPid(pid) {
+  const commandLine = getProcessCommandLine(pid);
+  return !!commandLine && /session-host-daemon/i.test(commandLine);
+}
 async function waitForPidExit(pid, timeoutMs) {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
@@ -38474,7 +38625,7 @@ function stopSessionHostProcesses(appName) {
   try {
     if (fs8.existsSync(pidFile)) {
       const pid = Number.parseInt(fs8.readFileSync(pidFile, "utf8").trim(), 10);
-      if (Number.isFinite(pid)) {
+      if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
         killPid(pid);
       }
     }
@@ -38485,18 +38636,6 @@ function stopSessionHostProcesses(appName) {
     } catch {
     }
   }
-  if (process.platform !== "win32") {
-    try {
-      const raw = (0, import_child_process8.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 = path17.join(os20.homedir(), ".adhdev", "daemon.pid");
@@ -40838,6 +40977,23 @@ var init_forward = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/providers/provider-instance-manager.ts
+function projectHotChatSessionStatesFromProviderState(state) {
+  const project = (item) => ({
+    id: item.instanceId,
+    status: item.activeChat?.status || item.status,
+    unread: item.unread,
+    inboxBucket: item.inboxBucket,
+    lastMessageAt: item.lastMessageAt ?? item.activeChat?.lastMessageAt,
+    runtimeLifecycle: item.runtime?.lifecycle ?? null,
+    runtimeSurfaceKind: item.runtime?.surfaceKind,
+    runtimeRestoredFromStorage: item.runtime?.restoredFromStorage === true,
+    runtimeRecoveryState: item.runtime?.recoveryState ?? null
+  });
+  if (state.category === "ide") {
+    return [project(state), ...state.extensions.map(project)];
+  }
+  return [project(state)];
+}
 var ProviderInstanceManager;
 var init_provider_instance_manager = __esm({
   "../../oss/packages/daemon-core/src/providers/provider-instance-manager.ts"() {
@@ -40938,6 +41094,27 @@ var init_provider_instance_manager = __esm({
         }
         return states;
       }
+      collectHotChatSessionStates() {
+        const sessions = [];
+        for (const [id, instance] of this.instances) {
+          try {
+            const projected = instance.getHotChatSessionState?.();
+            if (Array.isArray(projected)) {
+              sessions.push(...projected.filter((session) => !!session?.id));
+              continue;
+            }
+            if (projected?.id) {
+              sessions.push(projected);
+              continue;
+            }
+            const state = instance.getState();
+            sessions.push(...projectHotChatSessionStatesFromProviderState(state));
+          } catch (e) {
+            LOG.warn("InstanceMgr", `[InstanceManager] Failed to collect hot chat metadata from ${id}: ${e.message}`);
+          }
+        }
+        return sessions;
+      }
       /**
       * Per-category status collect
       */
@@ -41019,6 +41196,17 @@ var init_provider_instance_manager = __esm({
         }
         return updated;
       }
+      refreshProviderDefinitions(resolveProvider) {
+        let refreshed = 0;
+        for (const instance of this.instances.values()) {
+          if (typeof instance.refreshProviderDefinition !== "function") continue;
+          const provider = resolveProvider(instance.type);
+          if (!provider || typeof provider !== "object") continue;
+          instance.refreshProviderDefinition(provider);
+          refreshed += 1;
+        }
+        return refreshed;
+      }
       // ─── cleanup ──────────────────────────────────────
       /**
       * All terminate
@@ -45031,8 +45219,8 @@ var init_dev_server = __esm({
       }
       getEndpointList() {
         return this.routes.map((r) => {
-          const path35 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-          return `${r.method.padEnd(5)} ${path35}`;
+          const path36 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+          return `${r.method.padEnd(5)} ${path36}`;
         });
       }
       async start(port = DEV_SERVER_PORT) {
@@ -45301,20 +45489,7 @@ var init_dev_server = __esm({
       async handleReload(_req, res) {
         try {
           this.providerLoader.reload();
-          let refreshedInstances = 0;
-          if (this.instanceManager) {
-            for (const id of this.instanceManager.listInstanceIds()) {
-              const instance = this.instanceManager.getInstance(id);
-              const providerType = typeof instance?.type === "string" ? instance.type : "";
-              if (!providerType) continue;
-              const resolved = this.providerLoader.resolve(providerType);
-              if (!resolved) continue;
-              if (instance && typeof instance === "object" && "provider" in instance) {
-                instance.provider = resolved;
-                refreshedInstances += 1;
-              }
-            }
-          }
+          const refreshedInstances = this.instanceManager ? this.instanceManager.refreshProviderDefinitions((providerType) => this.providerLoader.resolve(providerType)) : 0;
           const providers = this.providerLoader.getAll().map((p) => ({
             type: p.type,
             name: p.name,
@@ -59150,15 +59325,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path35 = [graph[toModel].parent, toModel];
+      const path36 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path35.unshift(graph[cur].parent);
+        path36.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path35;
+      fn.conversion = path36;
       return fn;
     }
     module2.exports = function(fromModel) {
@@ -77028,9 +77203,9 @@ var init_prompt = __esm({
     init_utils();
     init_baseUI();
     _ = {
-      set: (obj, path35 = "", value) => {
+      set: (obj, path36 = "", value) => {
         let pointer = obj;
-        path35.split(".").forEach((key, index, arr) => {
+        path36.split(".").forEach((key, index, arr) => {
           if (key === "__proto__" || key === "constructor") return;
           if (index === arr.length - 1) {
             pointer[key] = value;
@@ -77040,8 +77215,8 @@ var init_prompt = __esm({
           pointer = pointer[key];
         });
       },
-      get: (obj, path35 = "", defaultValue) => {
-        const travel = (regexp) => String.prototype.split.call(path35, regexp).filter(Boolean).reduce(
+      get: (obj, path36 = "", defaultValue) => {
+        const travel = (regexp) => String.prototype.split.call(path36, regexp).filter(Boolean).reduce(
           // @ts-expect-error implicit any on res[key]
           (res, key) => res !== null && res !== void 0 ? res[key] : res,
           obj
@@ -79678,19 +79853,20 @@ var init_screenshot_sender = __esm({
         }
         return sentAny;
       }
-      sendScreenshot(peers, base64Data) {
+      sendScreenshot(peers, base64Data, targetSessionId) {
         const buffer = Buffer.from(base64Data, "base64");
-        return this.sendScreenshotBuffer(peers, buffer);
+        return this.sendScreenshotBuffer(peers, buffer, targetSessionId);
       }
       /** Send screenshot as raw Buffer (no base64 conversion overhead) */
-      sendScreenshotBuffer(peers, buffer) {
+      sendScreenshotBuffer(peers, buffer, targetSessionId) {
         let sentAny = false;
         let debugOnce = !this._ssDebugDone;
         for (const [pid, peer] of peers.entries()) {
           if (debugOnce) {
-            logDebug(`sendScreenshot peer=${pid}: state=${peer.state}, hasCh=${!!peer.dataChannel}, ssActive=${peer.screenshotActive}, chOpen=${peer.dataChannel?.isOpen?.() ?? "N/A"}, bufSize=${buffer.length}`);
+            logDebug(`sendScreenshot peer=${pid}: state=${peer.state}, hasCh=${!!peer.dataChannel}, ssActive=${peer.screenshotActive}, target=${peer.screenshotTargetSessionId || "none"}, chOpen=${peer.dataChannel?.isOpen?.() ?? "N/A"}, bufSize=${buffer.length}`);
           }
           if (peer.state !== "connected" || !peer.dataChannel || !peer.screenshotActive) continue;
+          if (targetSessionId && peer.screenshotTargetSessionId !== targetSessionId) continue;
           try {
             if (!peer.dataChannel.isOpen()) continue;
             const header = Buffer.alloc(4);
@@ -79722,18 +79898,32 @@ async function initiateConnection(deps, peerId, sharePermission) {
     log("Cannot initiate \u2014 node-datachannel not available");
     return;
   }
+  const pid = peerId || `legacy_${Date.now()}`;
+  const existing = deps.peers.get(pid);
+  if (existing?.state === "connected") {
+    log(`initiateconnection() ignored for peer ${pid} \u2014 already connected`);
+    return;
+  }
+  if (existing?.state === "connecting") {
+    log(`initiateconnection() ignored for peer ${pid} \u2014 connection already in progress`);
+    return;
+  }
   const limits = deps.serverConn.getPlanLimits();
   if (limits && limits.maxP2PConnections !== -1) {
     let connectedCount = 0;
+    let reservedCount = 0;
     for (const peer of deps.peers.values()) {
       if (peer.state === "connected") connectedCount++;
+      if (peer.state === "connected" || peer.state === "connecting") reservedCount++;
     }
-    if (connectedCount >= limits.maxP2PConnections) {
+    if (reservedCount >= limits.maxP2PConnections) {
       let oldestPeer = null;
-      for (const [pid2, peer] of deps.peers) {
-        if (peer.state === "connected") {
-          if (!oldestPeer || peer.connectedAt < oldestPeer.at) {
-            oldestPeer = { id: pid2, at: peer.connectedAt };
+      if (connectedCount >= limits.maxP2PConnections) {
+        for (const [peerKey, peer] of deps.peers) {
+          if (peer.state === "connected") {
+            if (!oldestPeer || peer.connectedAt < oldestPeer.at) {
+              oldestPeer = { id: peerKey, at: peer.connectedAt };
+            }
           }
         }
       }
@@ -79751,19 +79941,12 @@ async function initiateConnection(deps, peerId, sharePermission) {
           }
         }
         disconnectPeer(deps.peers, oldestPeer.id, deps.notifyStateChange);
+      } else {
+        log(`P2P limit reached (${reservedCount}/${limits.maxP2PConnections}) with reserved connecting slot(s). Rejecting peer ${pid.slice(0, 12)}\u2026`);
+        return;
       }
     }
   }
-  const pid = peerId || `legacy_${Date.now()}`;
-  const existing = deps.peers.get(pid);
-  if (existing?.state === "connected") {
-    log(`initiateconnection() ignored for peer ${pid} \u2014 already connected`);
-    return;
-  }
-  if (existing?.state === "connecting") {
-    log(`initiateconnection() ignored for peer ${pid} \u2014 connection already in progress`);
-    return;
-  }
   log(`initiateconnection() for peer ${pid}...`);
   const mod = deps.nodeDatachannel;
   const PeerConnectionCtor = mod.PeerConnection || mod.default?.PeerConnection || mod.default || mod;
@@ -80122,14 +80305,19 @@ var init_daemon_p2p = __esm({
         }
         return false;
       }
-      /** Get the target session for the currently active screenshot request */
-      get screenshotTargetSessionId() {
+      /** Get all target sessions for active screenshot requests */
+      get screenshotTargetSessionIds() {
+        const targets = /* @__PURE__ */ new Set();
         for (const peer of this.peers.values()) {
           if (peer.screenshotActive && peer.state === "connected" && peer.screenshotTargetSessionId) {
-            return peer.screenshotTargetSessionId;
+            targets.add(peer.screenshotTargetSessionId);
           }
         }
-        return void 0;
+        return Array.from(targets);
+      }
+      /** Get the target session for the currently active screenshot request */
+      get screenshotTargetSessionId() {
+        return this.screenshotTargetSessionIds[0];
       }
       constructor(serverConn) {
         this.serverConn = serverConn;
@@ -80238,6 +80426,14 @@ ${e?.stack || ""}`);
         }
         return false;
       }
+      hasAnyNeedingFirstFrameForTarget(targetSessionId) {
+        for (const peer of this.peers.values()) {
+          if (peer.needsFirstFrame && peer.screenshotActive && peer.state === "connected" && peer.screenshotTargetSessionId === targetSessionId) {
+            return true;
+          }
+        }
+        return false;
+      }
       onStateChange(listener) {
         this.stateListeners.push(listener);
       }
@@ -80301,11 +80497,14 @@ ${e?.stack || ""}`);
         if (targetPeers.size === 0) return false;
         return this.screenshotSender.broadcastSessionOutput(targetPeers, sessionId, data);
       }
-      sendScreenshot(base64Data) {
-        return this.screenshotSender.sendScreenshot(this.peers, base64Data);
+      sendScreenshot(base64Data, targetSessionId) {
+        return this.screenshotSender.sendScreenshot(this.peers, base64Data, targetSessionId);
+      }
+      sendScreenshotBuffer(buffer, targetSessionId) {
+        return this.screenshotSender.sendScreenshotBuffer(this.peers, buffer, targetSessionId);
       }
-      sendScreenshotBuffer(buffer) {
-        return this.screenshotSender.sendScreenshotBuffer(this.peers, buffer);
+      sendScreenshotBufferForTarget(targetSessionId, buffer) {
+        return this.sendScreenshotBuffer(buffer, targetSessionId);
       }
       // ─── Handler registration (unchanged API) ───────
       onFileRequest(handler) {
@@ -80535,16 +80734,16 @@ var require_filesystem = __commonJS({
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync20 = (path35) => {
-      const fd = fs27.openSync(path35, "r");
+    var readFileSync20 = (path36) => {
+      const fd = fs27.openSync(path36, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
       const bytesRead = fs27.readSync(fd, buffer, 0, MAX_LENGTH, 0);
       fs27.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile = (path35) => new Promise((resolve18, reject) => {
-      fs27.open(path35, "r", (err, fd) => {
+    var readFile = (path36) => new Promise((resolve18, reject) => {
+      fs27.open(path36, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
@@ -80663,11 +80862,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path35) => {
-      if (path35) {
-        if (path35.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path36) => {
+      if (path36) {
+        if (path36.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path35.includes("/ld-linux-")) {
+        } else if (path36.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -80714,8 +80913,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile(SELF_PATH);
-        const path35 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path35);
+        const path36 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path36);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -80727,8 +80926,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = readFileSync20(SELF_PATH);
-        const path35 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path35);
+        const path36 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path36);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -82447,18 +82646,18 @@ var require_sharp = __commonJS({
       `@img/sharp-${runtimePlatform}/sharp.node`,
       "@img/sharp-wasm32/sharp.node"
     ];
-    var path35;
+    var path36;
     var sharp;
     var errors = [];
-    for (path35 of paths) {
+    for (path36 of paths) {
       try {
-        sharp = require(path35);
+        sharp = require(path36);
         break;
       } catch (err) {
         errors.push(err);
       }
     }
-    if (sharp && path35.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
+    if (sharp && path36.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
       const err = new Error("Prebuilt binaries for linux-x64 require v2 microarchitecture");
       err.code = "Unsupported CPU";
       errors.push(err);
@@ -85367,15 +85566,15 @@ var require_color = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path35 = [graph[toModel].parent, toModel];
+      const path36 = [graph[toModel].parent, toModel];
       let fn = conversions_default[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path35.unshift(graph[cur].parent);
+        path36.unshift(graph[cur].parent);
         fn = link(conversions_default[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path35;
+      fn.conversion = path36;
       return fn;
     }
     function route(fromModel) {
@@ -85992,7 +86191,7 @@ var require_channel = __commonJS({
 var require_output = __commonJS({
   "../../node_modules/sharp/lib/output.js"(exports2, module2) {
     "use strict";
-    var path35 = require("path");
+    var path36 = require("path");
     var is = require_is();
     var sharp = require_sharp();
     var formats = /* @__PURE__ */ new Map([
@@ -86023,9 +86222,9 @@ var require_output = __commonJS({
       let err;
       if (!is.string(fileOut)) {
         err = new Error("Missing output file path");
-      } else if (is.string(this.options.input.file) && path35.resolve(this.options.input.file) === path35.resolve(fileOut)) {
+      } else if (is.string(this.options.input.file) && path36.resolve(this.options.input.file) === path36.resolve(fileOut)) {
         err = new Error("Cannot use same file for input and output");
-      } else if (jp2Regex.test(path35.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+      } else if (jp2Regex.test(path36.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
         err = errJp2Save();
       }
       if (err) {
@@ -87029,6 +87228,7 @@ var init_screenshot_controller = __esm({
       lastSize = 0;
       lastHash = 0;
       staticFrameCount = 0;
+      targetFrameState = /* @__PURE__ */ new Map();
       currentInterval;
       // Quality profiles
       profileDirect;
@@ -87092,14 +87292,13 @@ var init_screenshot_controller = __esm({
       async tick() {
         if (!this.deps.isRunning()) return;
         const active = this.deps.isScreenshotActive();
-        const targetSessionId = this.deps.getScreenshotTargetSessionId();
-        if (active && !targetSessionId) {
+        const targetSessionIds = this.getActiveTargetSessionIds();
+        const isRelay = this.deps.isUsingRelay();
+        const profile = isRelay ? this.profileRelay : this.profileDirect;
+        if (active && targetSessionIds.length === 0) {
           this.timer = setTimeout(() => this.tick(), 500);
           return;
         }
-        const cdp = targetSessionId ? this.deps.getCdp(targetSessionId) : null;
-        const isRelay = this.deps.isUsingRelay();
-        const profile = isRelay ? this.profileRelay : this.profileDirect;
         this.checkBudgetReset();
         if (this.dailyBudgetMs > 0) {
           const now = Date.now();
@@ -87114,49 +87313,84 @@ var init_screenshot_controller = __esm({
           }
         }
         const budgetBlocked = this.budgetExhausted && isRelay;
-        if (!active || !cdp || budgetBlocked) {
+        if (!active || budgetBlocked) {
           this.staticFrameCount = 0;
+          this.targetFrameState.clear();
           this.currentInterval = profile.maxInterval;
           if (!active) this.lastActiveTimestamp = 0;
           this.timer = setTimeout(() => this.tick(), budgetBlocked ? 3e4 : this.currentInterval);
           return;
         }
         this.debugCount++;
-        try {
-          const buf = await cdp.captureScreenshot({ quality: profile.quality });
-          if (buf) {
+        let capturedAny = false;
+        let sentAnyFrame = false;
+        let anyFirstFrameAcrossTargets = false;
+        for (const targetSessionId of targetSessionIds) {
+          const cdp = this.deps.getCdp(targetSessionId);
+          if (!cdp) continue;
+          try {
+            const buf = await cdp.captureScreenshot({ quality: profile.quality });
+            if (!buf) {
+              if (this.debugCount <= 5) LOG.debug("Screenshot", `captureScreenshot returned null for target=${targetSessionId}`);
+              continue;
+            }
+            capturedAny = true;
+            const state = this.getTargetFrameState(targetSessionId);
             const hash2 = _ScreenshotController.fnvHash(buf);
-            const sizeMatch = buf.length === this.lastSize;
-            const hashMatch = hash2 === this.lastHash;
-            const anyNeedsFirstFrame = this.deps.hasAnyNeedingFirstFrame();
+            const sizeMatch = buf.length === state.lastSize;
+            const hashMatch = hash2 === state.lastHash;
+            const anyNeedsFirstFrame = this.deps.hasAnyNeedingFirstFrameForTarget?.(targetSessionId) ?? this.deps.hasAnyNeedingFirstFrame();
             const resizeTarget = anyNeedsFirstFrame ? profile.firstFrameLongEdge : profile.maxLongEdge;
+            anyFirstFrameAcrossTargets = anyFirstFrameAcrossTargets || anyNeedsFirstFrame;
             if (sizeMatch && hashMatch && !anyNeedsFirstFrame) {
-              this.staticFrameCount++;
-              if (this.staticFrameCount >= this.STATIC_THRESHOLD) {
+              state.staticFrameCount++;
+              if (state.staticFrameCount >= this.STATIC_THRESHOLD) {
                 this.currentInterval = Math.min(this.currentInterval + 200, profile.maxInterval);
               }
               if (this.debugCount <= 5 || this.debugCount % 50 === 0) {
-                LOG.debug("Screenshot", `skip (unchanged, static=${this.staticFrameCount}, interval=${this.currentInterval}ms, ${isRelay ? "RELAY" : "DIRECT"})`);
-              }
-            } else {
-              const normalizedBuf = await this.normalizeBuffer(buf, resizeTarget, profile.quality);
-              this.lastSize = buf.length;
-              this.lastHash = hash2;
-              this.staticFrameCount = 0;
-              this.currentInterval = profile.minInterval;
-              const sent = this.deps.sendScreenshotBuffer(normalizedBuf);
-              if (this.debugCount <= 3 || anyNeedsFirstFrame) {
-                LOG.debug("Screenshot", `sent: ${normalizedBuf.length} bytes, delivered=${sent}, interval=${this.currentInterval}ms, ${isRelay ? "RELAY" : "DIRECT"}${anyNeedsFirstFrame ? " (first-frame)" : ""}`);
+                LOG.debug("Screenshot", `skip target=${targetSessionId} (unchanged, static=${state.staticFrameCount}, interval=${this.currentInterval}ms, ${isRelay ? "RELAY" : "DIRECT"})`);
               }
+              continue;
             }
-          } else {
-            if (this.debugCount <= 5) LOG.debug("Screenshot", "captureScreenshot returned null");
+            const normalizedBuf = await this.normalizeBuffer(buf, resizeTarget, profile.quality);
+            state.lastSize = buf.length;
+            state.lastHash = hash2;
+            state.staticFrameCount = 0;
+            this.lastSize = buf.length;
+            this.lastHash = hash2;
+            this.staticFrameCount = 0;
+            this.currentInterval = profile.minInterval;
+            const sent = this.deps.sendScreenshotBufferForTarget ? this.deps.sendScreenshotBufferForTarget(targetSessionId, normalizedBuf) : this.deps.sendScreenshotBuffer(normalizedBuf);
+            sentAnyFrame = sentAnyFrame || sent;
+            if (this.debugCount <= 3 || anyNeedsFirstFrame) {
+              LOG.debug("Screenshot", `sent target=${targetSessionId}: ${normalizedBuf.length} bytes, delivered=${sent}, interval=${this.currentInterval}ms, ${isRelay ? "RELAY" : "DIRECT"}${anyNeedsFirstFrame ? " (first-frame)" : ""}`);
+            }
+          } catch (e) {
+            if (this.debugCount <= 5) LOG.warn("Screenshot", `error target=${targetSessionId}: ${e?.message}`);
           }
-        } catch (e) {
-          if (this.debugCount <= 5) LOG.warn("Screenshot", `error: ${e?.message}`);
+        }
+        if (!capturedAny) {
+          this.currentInterval = profile.maxInterval;
+        } else if (!sentAnyFrame && !anyFirstFrameAcrossTargets) {
+          this.currentInterval = Math.min(this.currentInterval + 200, profile.maxInterval);
         }
         this.timer = setTimeout(() => this.tick(), this.currentInterval);
       }
+      getActiveTargetSessionIds() {
+        const explicitTargets = this.deps.getScreenshotTargetSessionIds?.() || [];
+        const normalized = explicitTargets.map((target) => typeof target === "string" ? target.trim() : "").filter((target) => target.length > 0);
+        if (normalized.length > 0) return Array.from(new Set(normalized));
+        const legacyTarget = this.deps.getScreenshotTargetSessionId();
+        return legacyTarget ? [legacyTarget] : [];
+      }
+      getTargetFrameState(targetSessionId) {
+        let state = this.targetFrameState.get(targetSessionId);
+        if (!state) {
+          state = { lastSize: 0, lastHash: 0, staticFrameCount: 0 };
+          this.targetFrameState.set(targetSessionId, state);
+        }
+        return state;
+      }
       // ─── Budget ───────────────────────────────────
       checkBudgetReset() {
         const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -87373,7 +87607,7 @@ function killPid2(pid) {
     return false;
   }
 }
-function getWindowsProcessCommandLine(pid) {
+function getWindowsProcessCommandLine2(pid) {
   const pidFilter = `ProcessId=${pid}`;
   try {
     const psOut = (0, import_child_process13.execFileSync)("powershell.exe", [
@@ -87402,13 +87636,32 @@ function getWindowsProcessCommandLine(pid) {
   }
   return null;
 }
+function getProcessCommandLine2(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return null;
+  if (process.platform === "win32") return getWindowsProcessCommandLine2(pid);
+  try {
+    const text = (0, import_child_process13.execFileSync)("ps", ["-o", "command=", "-p", String(pid)], {
+      encoding: "utf8",
+      timeout: 3e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return text || null;
+  } catch {
+    return null;
+  }
+}
+function isManagedSessionHostPid2(pid) {
+  const commandLine = getProcessCommandLine2(pid);
+  if (!commandLine) return false;
+  return /session-host-daemon/i.test(commandLine);
+}
 function stopManagedSessionHostProcess() {
   let stopped = false;
   const pidFile = getSessionHostPidFile();
   try {
     if (fs22.existsSync(pidFile)) {
       const pid = Number.parseInt(fs22.readFileSync(pidFile, "utf8").trim(), 10);
-      if (Number.isFinite(pid) && pid !== process.pid) {
+      if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid2(pid)) {
         stopped = killPid2(pid) || stopped;
       }
     }
@@ -87422,40 +87675,7 @@ function stopManagedSessionHostProcess() {
   return stopped;
 }
 function stopSessionHost() {
-  let stopped = stopManagedSessionHostProcess();
-  if (process.platform === "win32") {
-    try {
-      const raw = (0, import_child_process13.execFileSync)("tasklist", ["/FO", "CSV", "/NH", "/FI", "IMAGENAME eq node.exe"], {
-        encoding: "utf8",
-        timeout: 5e3,
-        stdio: ["ignore", "pipe", "ignore"],
-        windowsHide: true
-      }).trim();
-      for (const line of raw.split(/\r?\n/)) {
-        const match = line.match(/^"node\.exe","(\d+)"/i);
-        if (!match) continue;
-        const candidatePid = Number.parseInt(match[1], 10);
-        if (!Number.isFinite(candidatePid) || candidatePid === process.pid) continue;
-        const commandLine = getWindowsProcessCommandLine(candidatePid);
-        if (commandLine?.includes("session-host-daemon")) {
-          stopped = killPid2(candidatePid) || stopped;
-        }
-      }
-    } catch {
-    }
-  } else {
-    try {
-      const raw = (0, import_child_process13.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) && pid !== process.pid && pid !== process.ppid) {
-          stopped = killPid2(pid) || stopped;
-        }
-      }
-    } catch {
-    }
-  }
-  return stopped;
+  return stopManagedSessionHostProcess();
 }
 async function ensureSessionHostReady2() {
   const quarantine = quarantineLegacyStandaloneSessions({
@@ -87712,10 +87932,65 @@ var init_session_host_controller = __esm({
 var adhdev_daemon_exports = {};
 __export(adhdev_daemon_exports, {
   AdhdevDaemon: () => AdhdevDaemon,
+  buildMandatoryUpdateInfoFromServerPayload: () => buildMandatoryUpdateInfoFromServerPayload,
+  buildMandatoryUpdateRequiredPayload: () => buildMandatoryUpdateRequiredPayload,
   getDaemonPid: () => getDaemonPid,
   isDaemonRunning: () => isDaemonRunning,
-  stopDaemon: () => stopDaemon
-});
+  stopDaemon: () => stopDaemon,
+  validateMandatoryUpdateTarget: () => validateMandatoryUpdateTarget,
+  verifyPublishedMandatoryUpdateTarget: () => verifyPublishedMandatoryUpdateTarget
+});
+function validateMandatoryUpdateTarget(targetVersion) {
+  if (typeof targetVersion !== "string") return { valid: false, error: "target version is required" };
+  if (targetVersion !== targetVersion.trim()) return { valid: false, error: "target version must not contain whitespace" };
+  const version2 = targetVersion;
+  if (!version2) return { valid: false, error: "target version is required" };
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z]+(?:\.[0-9A-Za-z]+)*)?(?:\+[0-9A-Za-z]+(?:\.[0-9A-Za-z]+)*)?$/.test(version2)) {
+    return { valid: false, error: `invalid semver target: ${version2}` };
+  }
+  return { valid: true };
+}
+function verifyPublishedMandatoryUpdateTarget(packageName, targetVersion, deps = {}) {
+  if (!/^(?:adhdev|@adhdev\/daemon-standalone)$/.test(packageName)) {
+    throw new Error(`invalid mandatory update package: ${packageName}`);
+  }
+  const validation = validateMandatoryUpdateTarget(targetVersion);
+  if (!validation.valid) throw new Error(validation.error || "invalid mandatory update target");
+  const run = deps.execFileSync || import_child_process14.execFileSync;
+  const npmExecutable = deps.npmExecutable || resolveCurrentGlobalInstallSurface({ packageName }).npmExecutable;
+  const published = String(run(npmExecutable, ["view", `${packageName}@${targetVersion}`, "version"], {
+    encoding: "utf-8",
+    timeout: 1e4,
+    stdio: ["pipe", "pipe", "pipe"],
+    ...process.platform === "win32" ? { shell: true, windowsHide: true } : {}
+  })).trim();
+  if (published !== targetVersion) {
+    throw new Error(`Published version mismatch: expected ${targetVersion}, got ${published || "unknown"}`);
+  }
+  return published;
+}
+function buildMandatoryUpdateInfoFromServerPayload(payload, fallbackVersion) {
+  const targetVersion = typeof payload?.latest === "string" && payload.latest ? payload.latest : fallbackVersion;
+  const validation = validateMandatoryUpdateTarget(targetVersion);
+  if (!validation.valid) return { info: null, error: validation.error || targetVersion };
+  return {
+    info: {
+      targetVersion,
+      reason: typeof payload?.reason === "string" && payload.reason.trim() ? payload.reason.trim() : "major_minor_mismatch",
+      minVersion: typeof payload?.minVersion === "string" && payload.minVersion.trim() ? payload.minVersion.trim() : void 0
+    }
+  };
+}
+function buildMandatoryUpdateRequiredPayload(pending, interactionId) {
+  return {
+    error: "A mandatory daemon update is pending. Finish current work and let the daemon update before starting a new session.",
+    code: "DAEMON_UPDATE_REQUIRED",
+    required: true,
+    latest: pending.targetVersion,
+    reason: pending.reason,
+    interactionId
+  };
+}
 function resolveDaemonPort(ref = {}) {
   return Number.isFinite(ref.port) && Number(ref.port) > 0 ? Number(ref.port) : DEFAULT_DAEMON_PORT;
 }
@@ -87742,7 +88017,7 @@ function removeDaemonPid(ref = {}) {
 function isDaemonRunning(ref = {}) {
   const port = resolveDaemonPort(ref);
   try {
-    const { execFileSync: execFileSync6 } = require("child_process");
+    const { execFileSync: execFileSync7 } = require("child_process");
     const probe = `
             const http = require('http');
             const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
@@ -87752,7 +88027,7 @@ function isDaemonRunning(ref = {}) {
             req.on('error', () => process.stdout.write('0'));
             req.on('timeout', () => { req.destroy(); process.stdout.write('0'); });
         `;
-    const result = execFileSync6(process.execPath, ["-e", probe], {
+    const result = execFileSync7(process.execPath, ["-e", probe], {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -87778,9 +88053,9 @@ function isDaemonRunning(ref = {}) {
 function isAdhdevProcess(pid) {
   try {
     if (process.platform === "win32") {
-      const { execFileSync: execFileSync6 } = require("child_process");
+      const { execFileSync: execFileSync7 } = require("child_process");
       try {
-        const psOut = execFileSync6("powershell.exe", [
+        const psOut = execFileSync7("powershell.exe", [
           "-NoProfile",
           "-NonInteractive",
           "-ExecutionPolicy",
@@ -87793,8 +88068,8 @@ function isAdhdevProcess(pid) {
         return true;
       }
     } else {
-      const { execFileSync: execFileSync6 } = require("child_process");
-      const cmdline = execFileSync6("ps", ["-o", "command=", "-p", String(pid)], {
+      const { execFileSync: execFileSync7 } = require("child_process");
+      const cmdline = execFileSync7("ps", ["-o", "command=", "-p", String(pid)], {
         encoding: "utf-8",
         timeout: 2e3,
         stdio: ["ignore", "pipe", "ignore"]
@@ -87808,7 +88083,7 @@ function isAdhdevProcess(pid) {
 function getDaemonHealthPid(ref = {}) {
   const port = resolveDaemonPort(ref);
   try {
-    const { execFileSync: execFileSync6 } = require("child_process");
+    const { execFileSync: execFileSync7 } = require("child_process");
     const probe = `
             const http = require('http');
             const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
@@ -87826,7 +88101,7 @@ function getDaemonHealthPid(ref = {}) {
             req.on('error', () => {});
             req.on('timeout', () => { req.destroy(); });
         `;
-    const result = execFileSync6(process.execPath, ["-e", probe], {
+    const result = execFileSync7(process.execPath, ["-e", probe], {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -87872,7 +88147,7 @@ function stopDaemon(ref = {}) {
     return false;
   }
 }
-var os28, fs23, path29, import_http, import_ws3, pkgVersion, AdhdevDaemon;
+var os28, fs23, path29, import_http, import_child_process14, import_ws3, pkgVersion, AdhdevDaemon;
 var init_adhdev_daemon = __esm({
   "src/adhdev-daemon.ts"() {
     "use strict";
@@ -87888,12 +88163,13 @@ var init_adhdev_daemon = __esm({
     fs23 = __toESM(require("fs"));
     path29 = __toESM(require("path"));
     import_http = require("http");
+    import_child_process14 = require("child_process");
     import_ws3 = require("ws");
     init_source();
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.33" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.35" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -87986,6 +88262,10 @@ var init_adhdev_daemon = __esm({
       getUpgradePackageName() {
         return process.argv[1]?.includes("daemon-standalone") ? "@adhdev/daemon-standalone" : "adhdev";
       }
+      getMandatoryUpdateBlockPayload(cmd, interactionId) {
+        if (!this.pendingMandatoryUpdate || !_AdhdevDaemon.MANDATORY_UPDATE_BLOCKED_COMMANDS.has(cmd)) return null;
+        return buildMandatoryUpdateRequiredPayload(this.pendingMandatoryUpdate, interactionId);
+      }
       hasBlockingSessionsForMandatoryUpdate() {
         if (!this.components) return false;
         const blocking = /* @__PURE__ */ new Set(["generating", "waiting_approval", "starting"]);
@@ -88011,15 +88291,7 @@ var init_adhdev_daemon = __esm({
         const pkgName = this.getUpgradePackageName();
         this.mandatoryUpgradeInFlight = true;
         try {
-          const { execSync: execSync8 } = await import("child_process");
-          const published = execSync8(`npm view ${pkgName}@${pending.targetVersion} version`, {
-            encoding: "utf-8",
-            timeout: 1e4,
-            stdio: ["pipe", "pipe", "pipe"]
-          }).trim();
-          if (published !== pending.targetVersion) {
-            throw new Error(`Published version mismatch: expected ${pending.targetVersion}, got ${published || "unknown"}`);
-          }
+          verifyPublishedMandatoryUpdateTarget(pkgName, pending.targetVersion);
           LOG.warn("Upgrade", `Applying mandatory daemon update (${pending.reason}) \u2192 v${pending.targetVersion}`);
           spawnDetachedDaemonUpgradeHelper({
             packageName: pkgName,
@@ -88121,7 +88393,7 @@ var init_adhdev_daemon = __esm({
         const now = Date.now();
         const cached2 = this.hotChatSnapshotCache;
         const sessions = cached2 && now - cached2.builtAt < _AdhdevDaemon.HOT_CHAT_SNAPSHOT_CACHE_TTL_MS ? cached2.sessions : (() => {
-          const built = this.buildLiveStatusSnapshot().sessions || [];
+          const built = this.components.instanceManager.collectHotChatSessionStates();
           this.hotChatSnapshotCache = { sessions: built, builtAt: now };
           return built;
         })();
@@ -88506,14 +88778,17 @@ ${err?.stack || ""}`);
               isRunning: () => this.running,
               isScreenshotActive: () => this.p2p?.screenshotActive ?? false,
               getScreenshotTargetSessionId: () => this.p2p?.screenshotTargetSessionId,
+              getScreenshotTargetSessionIds: () => this.p2p?.screenshotTargetSessionIds ?? [],
               isUsingRelay: () => this.p2p?.isUsingRelay ?? false,
               hasAnyNeedingFirstFrame: () => this.p2p?.hasAnyNeedingFirstFrame() ?? false,
+              hasAnyNeedingFirstFrameForTarget: (targetSessionId) => this.p2p?.hasAnyNeedingFirstFrameForTarget(targetSessionId) ?? false,
               getCdp: (targetSessionId) => {
                 if (targetSessionId) return this.getCdpFor(targetSessionId);
                 LOG.warn("P2P", "Screenshot requested without targetSessionId \u2014 cannot determine target session. Skipping frame.");
                 return null;
               },
-              sendScreenshotBuffer: (buf) => this.p2p.sendScreenshotBuffer(buf)
+              sendScreenshotBuffer: (buf) => this.p2p.sendScreenshotBuffer(buf),
+              sendScreenshotBufferForTarget: (targetSessionId, buf) => this.p2p.sendScreenshotBufferForTarget(targetSessionId, buf)
             }, planLimits ?? void 0);
             this.screenshotController.start();
             this.p2p.onScreenshotStart(() => this.screenshotController?.triggerImmediate());
@@ -88542,11 +88817,12 @@ ${err?.stack || ""}`);
           });
           this.serverConn.on("force_update_required", (msg) => {
             const payload = msg.payload;
-            this.pendingMandatoryUpdate = {
-              targetVersion: typeof payload.latest === "string" && payload.latest.trim() ? payload.latest.trim() : pkgVersion,
-              reason: typeof payload.reason === "string" && payload.reason.trim() ? payload.reason.trim() : "major_minor_mismatch",
-              minVersion: typeof payload.minVersion === "string" && payload.minVersion.trim() ? payload.minVersion.trim() : void 0
-            };
+            const parsedUpdate = buildMandatoryUpdateInfoFromServerPayload(payload, pkgVersion);
+            if (!parsedUpdate.info) {
+              LOG.error("Upgrade", `Ignoring invalid mandatory daemon update target from server: ${parsedUpdate.error || "unknown"}`);
+              return;
+            }
+            this.pendingMandatoryUpdate = parsedUpdate.info;
             LOG.warn("Upgrade", `Mandatory daemon update required (${this.pendingMandatoryUpdate.reason})`);
             void this.maybeApplyMandatoryUpdate("server-force-update");
           });
@@ -88657,15 +88933,9 @@ ${err?.stack || ""}`);
         const cmdStart = Date.now();
         const source = msg.ipcWs ? "ext" : typeof msg.source === "string" && msg.source.trim() ? msg.source : "ws";
         try {
-          if (this.pendingMandatoryUpdate && _AdhdevDaemon.MANDATORY_UPDATE_BLOCKED_COMMANDS.has(cmd)) {
-            this.sendResult(msg, false, {
-              error: "A mandatory daemon update is pending. Finish current work and let the daemon update before starting a new session.",
-              code: "DAEMON_UPDATE_REQUIRED",
-              required: true,
-              latest: this.pendingMandatoryUpdate.targetVersion,
-              reason: this.pendingMandatoryUpdate.reason,
-              interactionId
-            });
+          const mandatoryUpdateBlock = this.getMandatoryUpdateBlockPayload(cmd, interactionId);
+          if (mandatoryUpdateBlock) {
+            this.sendResult(msg, false, mandatoryUpdateBlock);
             return;
           }
           if (source === "api" && !loadConfig().allowServerApiProxy) {
@@ -88710,6 +88980,10 @@ ${err?.stack || ""}`);
         const interactionId = String(normalizedData._interactionId);
         const cmdStart = Date.now();
         try {
+          const mandatoryUpdateBlock = this.getMandatoryUpdateBlockPayload(cmdType, interactionId);
+          if (mandatoryUpdateBlock) {
+            return { success: false, ...mandatoryUpdateBlock };
+          }
           switch (cmdType) {
             case "get_runtime_snapshot": {
               const sessionId = typeof normalizedData.sessionId === "string" ? normalizedData.sessionId : "";
@@ -88888,8 +89162,22 @@ ${err?.stack || ""}`);
           }));
           return;
         }
+        const normalizedArgs = this.ensureInteractionContext(args);
+        const interactionId = String(normalizedArgs._interactionId);
+        const mandatoryUpdateBlock = this.getMandatoryUpdateBlockPayload(command, interactionId);
+        if (mandatoryUpdateBlock) {
+          ws.send(JSON.stringify({
+            type: "ext:command_result",
+            payload: {
+              requestId,
+              success: false,
+              ...mandatoryUpdateBlock
+            }
+          }));
+          return;
+        }
         try {
-          const result = await this.components.router.execute(command, args, "ipc");
+          const result = await this.components.router.execute(command, normalizedArgs, "ipc");
           ws.send(JSON.stringify({
             type: "ext:command_result",
             payload: {
@@ -89059,9 +89347,9 @@ async function runWizard(options = {}) {
 }
 async function checkForUpdate() {
   try {
-    const { execFileSync: execFileSync6 } = await import("child_process");
+    const { execFileSync: execFileSync7 } = await import("child_process");
     const currentVersion = resolvePackageVersion();
-    const latestVersion = readLatestPublishedCliVersion(execFileSync6);
+    const latestVersion = readLatestPublishedCliVersion(execFileSync7);
     if (!latestVersion) return;
     if (!currentVersion || !latestVersion || currentVersion === latestVersion) return;
     console.log(source_default.yellow(`  Update available: ${currentVersion} \u2192 ${latestVersion}`));
@@ -89078,7 +89366,7 @@ async function checkForUpdate() {
     const spinner = (await Promise.resolve().then(() => (init_ora(), ora_exports))).default("Updating adhdev CLI...").start();
     try {
       const installCommand = buildPinnedGlobalInstallCommand({ packageName: "adhdev", targetVersion: "latest" });
-      execFileSync6(installCommand.command, installCommand.args, {
+      execFileSync7(installCommand.command, installCommand.args, {
         encoding: "utf-8",
         timeout: 6e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -90424,6 +90712,7 @@ init_source();
 init_src();
 
 // src/cli/setup-commands.ts
+var import_node_path4 = __toESM(require("path"));
 init_source();
 init_src();
 
@@ -90576,8 +90865,7 @@ function parsePositiveInteger(value, fallback2) {
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback2;
 }
 function buildHistoryResumeLaunchPayload(cliType, session, overrideDir) {
-  const path35 = require("path");
-  const dir = typeof overrideDir === "string" && overrideDir.trim() ? path35.resolve(overrideDir.trim()) : typeof session.workspace === "string" && session.workspace.trim() ? path35.resolve(session.workspace.trim()) : "";
+  const dir = typeof overrideDir === "string" && overrideDir.trim() ? import_node_path4.default.resolve(overrideDir.trim()) : typeof session.workspace === "string" && session.workspace.trim() ? import_node_path4.default.resolve(session.workspace.trim()) : "";
   if (!dir) {
     throw new Error(`Saved history ${session.providerSessionId} is missing workspace metadata. Pass --dir to resume it explicitly.`);
   }
@@ -90667,12 +90955,13 @@ async function promptForSavedHistoryResumeSession(providerArg, sessions, options
   }
   return selected;
 }
-function registerSetupCommands(program2, providerLoader) {
+function registerSetupCommands(program2, getProviderLoader2) {
   program2.command("setup").description("Run the interactive setup wizard (detect IDEs, login)").option("-f, --force", "Force re-run setup even if already configured").action(async (options) => {
     const { runWizard: runWizard2 } = await Promise.resolve().then(() => (init_wizard(), wizard_exports));
     await runWizard2({ force: options.force });
   });
   program2.command("launch [target]").description("Launch IDE with CDP or start CLI agent").option("-w, --workspace <path>", "Workspace directory to open").option("-n, --new-window", "Open in a new window").option("-d, --dir <path>", "Working directory for CLI agent", process.cwd()).action(async (targetArg, options) => {
+    const providerLoader = await getProviderLoader2();
     const {
       detectIDEs: detectIDEs2,
       detectCLIs: detectCLIs2,
@@ -90696,7 +90985,7 @@ function registerSetupCommands(program2, providerLoader) {
           console.log(source_default.gray("  Then run: adhdev launch " + targetArg));
           process.exit(1);
         }
-        const resolvedDir = require("path").resolve(workingDir);
+        const resolvedDir = import_node_path4.default.resolve(workingDir);
         const result = await sendDaemonCommand("launch_cli", {
           cliType,
           dir: resolvedDir
@@ -90816,6 +91105,7 @@ function registerSetupCommands(program2, providerLoader) {
   });
   const history = program2.command("history").description("Browse and resume provider saved history");
   history.command("list <provider>").description("List saved history for a CLI or ACP provider").option("--json", "Print raw JSON output").option("--limit <count>", "Maximum number of saved history entries to show", "30").option("--offset <count>", "Skip the first N saved history entries", "0").option("--resumable", "Show only saved history entries that can resume immediately").option("--text <text>", "Filter saved history by title or preview substring").option("--workspace <text>", "Filter saved history by workspace path substring").option("--model <text>", "Filter saved history by model substring").option("--sort <mode>", "Sort by recent, oldest, or messages", "recent").action(async (providerArg, options) => {
+    const providerLoader = await getProviderLoader2();
     const providerTarget = resolveLaunchableProviderTarget(providerLoader, providerArg);
     if (!providerTarget) {
       console.log(source_default.red(`
@@ -90888,6 +91178,7 @@ function registerSetupCommands(program2, providerLoader) {
     printSavedHistorySessions(providerArg, providerTarget.resolvedType, sessions, hasMore);
   });
   history.command("resume <provider> [historySessionId]").description("Resume saved history for a CLI or ACP provider").option("-d, --dir <path>", "Override the saved workspace when resuming").option("--resumable", "When choosing interactively, hide entries that still need --dir").option("--text <text>", "When choosing interactively, filter by title or preview substring").option("--workspace <text>", "When choosing interactively, filter by workspace path substring").option("--model <text>", "When choosing interactively, filter by model substring").option("--sort <mode>", "When choosing interactively, sort by recent, oldest, or messages", "recent").action(async (providerArg, historySessionId, options) => {
+    const providerLoader = await getProviderLoader2();
     const providerTarget = resolveLaunchableProviderTarget(providerLoader, providerArg);
     if (!providerTarget) {
       console.log(source_default.red(`
@@ -90981,6 +91272,7 @@ function registerSetupCommands(program2, providerLoader) {
     }
   });
   program2.command("status").description("Show current ADHDev setup status").action(async () => {
+    const providerLoader = await getProviderLoader2();
     const { loadConfig: loadConfig2, detectIDEs: detectIDEs2, detectCLIs: detectCLIs2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     const { isDaemonRunning: isDaemonRunning2, getDaemonPid: getDaemonPid2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
     const { probeSessionHostStatus: probeSessionHostStatus2 } = await Promise.resolve().then(() => (init_session_host(), session_host_exports));
@@ -91064,6 +91356,7 @@ function registerSetupCommands(program2, providerLoader) {
     console.log();
   });
   program2.command("detect").description("Detect installed IDEs, CLI agents, and ACP agents").action(async () => {
+    const providerLoader = await getProviderLoader2();
     const { detectIDEs: detectIDEs2, detectCLIs: detectCLIs2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     console.log(source_default.bold("\n\u{1F50D} Detecting installed IDEs...\n"));
     const ides = await detectIDEs2();
@@ -91165,7 +91458,7 @@ function registerSetupCommands(program2, providerLoader) {
   program2.command("uninstall").description("Completely wipe all setting, configuration, stop daemon and uninstall service").option("-f, --force", "Skip confirmation prompt").action(async (options) => {
     const inquirer2 = await Promise.resolve().then(() => (init_lib(), lib_exports));
     const fs27 = await import("fs");
-    const path35 = await import("path");
+    const path36 = await import("path");
     const os31 = await import("os");
     const { spawnSync: spawnSync3 } = await import("child_process");
     if (!options.force) {
@@ -91191,7 +91484,7 @@ function registerSetupCommands(program2, providerLoader) {
     }
     console.log(source_default.gray("  Removing OS background service..."));
     spawnSync3(process.execPath, [process.argv[1], "service", "uninstall"], { stdio: "inherit" });
-    const adhdevDir = path35.join(os31.homedir(), ".adhdev");
+    const adhdevDir = path36.join(os31.homedir(), ".adhdev");
     if (fs27.existsSync(adhdevDir)) {
       console.log(source_default.gray(`  Deleting ${adhdevDir}...`));
       try {
@@ -91215,10 +91508,10 @@ init_src();
 
 // src/cli/runtime-tools.ts
 var fs24 = __toESM(require("fs"));
-var path30 = __toESM(require("path"));
+var path31 = __toESM(require("path"));
 function defaultPackageRoot() {
   const currentCliPath = process.argv[1] ? fs24.realpathSync.native(process.argv[1]) : process.cwd();
-  return path30.resolve(path30.dirname(currentCliPath), "../..");
+  return path31.resolve(path31.dirname(currentCliPath), "../..");
 }
 function normalizePath2(value) {
   return value.replace(/\\/g, "/").toLowerCase();
@@ -91227,19 +91520,19 @@ function shouldPreferSource(currentCliPath, packageRoot) {
   const normalizedCliPath = normalizePath2(currentCliPath || "");
   if (normalizedCliPath.includes("/src/cli/")) return true;
   if (normalizedCliPath.includes("/dist/cli/")) return false;
-  return fs24.existsSync(path30.join(packageRoot, "src", "cli", "index.ts"));
+  return fs24.existsSync(path31.join(packageRoot, "src", "cli", "index.ts"));
 }
 function getVendoredToolEntry(packageRoot, tool) {
   if (tool === "session-host-daemon") {
-    return path30.join(packageRoot, "vendor", "session-host-daemon", "index.js");
+    return path31.join(packageRoot, "vendor", "session-host-daemon", "index.js");
   }
-  return path30.join(packageRoot, "vendor", "terminal-mux-cli", "index.js");
+  return path31.join(packageRoot, "vendor", "terminal-mux-cli", "index.js");
 }
 function getSourceToolEntry(packageRoot, tool) {
   if (tool === "session-host-daemon") {
-    return path30.resolve(packageRoot, "../../oss/packages/session-host-daemon/src/index.ts");
+    return path31.resolve(packageRoot, "../../oss/packages/session-host-daemon/src/index.ts");
   }
-  return path30.resolve(packageRoot, "../../oss/packages/terminal-mux-cli/src/index.ts");
+  return path31.resolve(packageRoot, "../../oss/packages/terminal-mux-cli/src/index.ts");
 }
 function getGlobalToolCommand(tool) {
   return tool === "session-host-daemon" ? "adhdev-sessiond" : "adhmux";
@@ -91319,6 +91612,25 @@ async function createConfiguredProviderLoader(options = {}) {
   if (options.load) loader.loadAll();
   return loader;
 }
+var _sharedLoaderPromise = null;
+function getSharedCliProviderLoader() {
+  if (!_sharedLoaderPromise) {
+    _sharedLoaderPromise = (async () => {
+      const { ProviderLoader: ProviderLoader2, loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+      const config2 = loadConfig2();
+      const loader = new ProviderLoader2({
+        logFn: () => {
+        },
+        userDir: config2.providerDir,
+        sourceMode: config2.providerSourceMode
+      });
+      loader.loadAll();
+      loader.registerToDetector();
+      return loader;
+    })();
+  }
+  return _sharedLoaderPromise;
+}
 
 // src/cli/debug-trace-cli.ts
 function normalizeOptionalFilter(value) {
@@ -91395,9 +91707,6 @@ var DEFAULT_DAEMON_PORT_TEXT = String(DEFAULT_DAEMON_PORT);
 var DEV_SERVER_PORT2 = 19280;
 var DEV_SERVER_BASE_URL = `http://127.0.0.1:${DEV_SERVER_PORT2}`;
 function hideCommand(command) {
-  if (typeof command.hideHelp === "function") {
-    command.hideHelp();
-  }
   command._hidden = true;
   return command;
 }
@@ -91700,12 +92009,118 @@ async function handleTraceCommand(options) {
     console.log();
   }
 }
+async function runDaemonUpgrade(options, pkgVersion3) {
+  const { isDaemonRunning: isDaemonRunning2, stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
+  const { stopManagedSessionHostProcess: stopManagedSessionHostProcess2 } = await Promise.resolve().then(() => (init_session_host(), session_host_exports));
+  const { execSync: execSync8, spawn: spawn6 } = await import("child_process");
+  const fsMod = await import("fs");
+  const pathMod = await import("path");
+  console.log(source_default.bold("\n  \u{1F504} ADHDev Upgrade\n"));
+  const adhdevPath = process.argv[1];
+  const realPath = fsMod.realpathSync(adhdevPath);
+  const isLinked = realPath.includes(".openclaw") || realPath.includes("/src/");
+  const currentVersion = pkgVersion3;
+  console.log(`  ${source_default.bold("Current:")}  v${currentVersion}`);
+  console.log(`  ${source_default.bold("Install:")}  ${isLinked ? "npm link (dev)" : "npm global"}`);
+  if (isLinked) {
+    const projectRoot = pathMod.resolve(pathMod.dirname(realPath), "..");
+    const launcherDir = pathMod.join(projectRoot);
+    console.log(`  ${source_default.bold("Path:")}     ${launcherDir}`);
+    console.log(source_default.cyan("\n  Pulling latest..."));
+    try {
+      let gitRoot = launcherDir;
+      while (!fsMod.existsSync(pathMod.join(gitRoot, ".git")) && gitRoot !== "/") {
+        gitRoot = pathMod.dirname(gitRoot);
+      }
+      execSync8("git pull --rebase", { cwd: gitRoot, stdio: "inherit" });
+      console.log(source_default.cyan("\n  Building..."));
+      execSync8("npm run build", { cwd: launcherDir, stdio: "inherit" });
+      execSync8("npm link", { cwd: launcherDir, stdio: "inherit" });
+      console.log(source_default.green("\n  \u2713 Build complete"));
+    } catch (e) {
+      console.log(source_default.red(`
+  \u2717 Build failed: ${e?.message}
+`));
+      process.exit(1);
+    }
+  } else {
+    console.log(source_default.cyan("\n  Checking for updates..."));
+    let latest;
+    try {
+      latest = execSync8("npm view adhdev version", { encoding: "utf-8" }).trim();
+    } catch (e) {
+      console.log(source_default.red(`
+  \u2717 Failed to check latest version: ${e?.message}
+`));
+      process.exit(1);
+      return;
+    }
+    console.log(`  ${source_default.bold("Latest:")}   v${latest}`);
+    if (latest === currentVersion) {
+      console.log(source_default.green("\n  \u2713 Already on latest version.\n"));
+      if (!options.restart) return;
+    } else {
+      console.log(source_default.cyan(`
+  Upgrading v${currentVersion} \u2192 v${latest}...`));
+      const daemonWasRunning = options.restart !== false && isDaemonRunning2();
+      if (daemonWasRunning) {
+        stopDaemon2();
+        await new Promise((r) => setTimeout(r, 1e3));
+        stopManagedSessionHostProcess2();
+      }
+      const { spawnDetachedDaemonUpgradeHelper: spawnDetachedDaemonUpgradeHelper2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+      spawnDetachedDaemonUpgradeHelper2({
+        packageName: "adhdev",
+        targetVersion: latest,
+        parentPid: process.pid,
+        restartArgv: daemonWasRunning ? [process.argv[1], "daemon", "-p", DEFAULT_DAEMON_PORT_TEXT] : [],
+        cwd: process.cwd()
+      });
+      if (daemonWasRunning) {
+        console.log(source_default.cyan("  Upgrading and restarting daemon in background..."));
+      } else {
+        console.log(source_default.cyan("  Upgrading in background..."));
+        console.log(source_default.gray("  Start daemon when ready: adhdev daemon"));
+      }
+      console.log(source_default.gray(`  Progress: ~/.adhdev/daemon-upgrade.log
+`));
+      process.exit(0);
+      return;
+    }
+  }
+  if (options.restart !== false && isDaemonRunning2()) {
+    console.log(source_default.yellow("\n  Restarting daemon..."));
+    stopDaemon2();
+    await new Promise((r) => setTimeout(r, 2e3));
+    stopManagedSessionHostProcess2();
+    await new Promise((r) => setTimeout(r, 500));
+    const child = spawn6(process.execPath, [process.argv[1], "daemon", "-p", DEFAULT_DAEMON_PORT_TEXT], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env: { ...process.env }
+    });
+    child.unref();
+    await new Promise((r) => setTimeout(r, 3e3));
+    if (isDaemonRunning2()) {
+      console.log(source_default.green(`  \u2713 Daemon restarted with new version
+`));
+    } else {
+      console.log(source_default.yellow(`  \u26A0 Daemon not detected. Start manually: adhdev daemon
+`));
+    }
+  } else if (options.restart !== false) {
+    console.log(source_default.gray("\n  Daemon was not running. Start with: adhdev daemon\n"));
+  } else {
+    console.log(source_default.green("\n  \u2713 Upgrade complete (daemon not restarted)\n"));
+  }
+}
 function registerDaemonCommands(program2, pkgVersion3) {
   program2.command("daemon").description("\u{1F680} Start ADHDev Daemon \u2014 unified hub for IDE monitoring, agent management, and remote control").option("-p, --port <port>", "Local WS server port", DEFAULT_DAEMON_PORT_TEXT).option("--server <url>", "Override server URL for testing").option("--dev", "Enable Dev Mode \u2014 HTTP API on :19280 for script debugging + structured trace collection").option("--log-level <level>", "Console log level (debug|info|warn|error)").option("--trace", "Enable structured debug trace collection").option("--trace-content", "Include richer content snapshots in debug traces").option("--trace-buffer-size <count>", "Structured trace ring buffer size").action(async (options) => {
     const { AdhdevDaemon: AdhdevDaemon2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
     const daemon = new AdhdevDaemon2();
     await daemon.start({
-      localPort: parseInt(options.port) || DEFAULT_DAEMON_PORT,
+      localPort: parseInt(options.port, 10) || DEFAULT_DAEMON_PORT,
       serverUrl: options.server,
       foreground: true,
       dev: options.dev || false,
@@ -91801,7 +92216,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
     const { probeSessionHostStatus: probeSessionHostStatus2 } = await Promise.resolve().then(() => (init_session_host(), session_host_exports));
     const port = parseInt(options.port, 10) || DEFAULT_DAEMON_PORT;
     const config2 = loadConfig2();
-    const providerLoader = await createConfiguredProviderLoader();
+    const providerLoader = await getSharedCliProviderLoader();
     if (isDaemonRunning2({ port })) {
       console.log(source_default.green(`
   \u2713 ADHDev Daemon is running.
@@ -92260,123 +92675,19 @@ 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 { stopManagedSessionHostProcess: stopManagedSessionHostProcess2 } = await Promise.resolve().then(() => (init_session_host(), session_host_exports));
-    const { execSync: execSync8, spawn: spawn6 } = await import("child_process");
-    const fsMod = await import("fs");
-    const pathMod = await import("path");
-    console.log(source_default.bold("\n  \u{1F504} ADHDev Upgrade\n"));
-    const adhdevPath = process.argv[1];
-    const realPath = fsMod.realpathSync(adhdevPath);
-    const isLinked = realPath.includes(".openclaw") || realPath.includes("/src/");
-    const currentVersion = pkgVersion3;
-    console.log(`  ${source_default.bold("Current:")}  v${currentVersion}`);
-    console.log(`  ${source_default.bold("Install:")}  ${isLinked ? "npm link (dev)" : "npm global"}`);
-    if (isLinked) {
-      const projectRoot = pathMod.resolve(pathMod.dirname(realPath), "..");
-      const launcherDir = pathMod.join(projectRoot);
-      console.log(`  ${source_default.bold("Path:")}     ${launcherDir}`);
-      console.log(source_default.cyan("\n  Pulling latest..."));
-      try {
-        let gitRoot = launcherDir;
-        while (!fsMod.existsSync(pathMod.join(gitRoot, ".git")) && gitRoot !== "/") {
-          gitRoot = pathMod.dirname(gitRoot);
-        }
-        execSync8("git pull --rebase", { cwd: gitRoot, stdio: "inherit" });
-        console.log(source_default.cyan("\n  Building..."));
-        execSync8("npm run build", { cwd: launcherDir, stdio: "inherit" });
-        execSync8("npm link", { cwd: launcherDir, stdio: "inherit" });
-        console.log(source_default.green("\n  \u2713 Build complete"));
-      } catch (e) {
-        console.log(source_default.red(`
-  \u2717 Build failed: ${e?.message}
-`));
-        process.exit(1);
-      }
-    } else {
-      console.log(source_default.cyan("\n  Checking for updates..."));
-      let latest;
-      try {
-        latest = execSync8("npm view adhdev version", { encoding: "utf-8" }).trim();
-      } catch (e) {
-        console.log(source_default.red(`
-  \u2717 Failed to check latest version: ${e?.message}
-`));
-        process.exit(1);
-        return;
-      }
-      console.log(`  ${source_default.bold("Latest:")}   v${latest}`);
-      if (latest === currentVersion) {
-        console.log(source_default.green("\n  \u2713 Already on latest version.\n"));
-        if (!options.restart) return;
-      } else {
-        console.log(source_default.cyan(`
-  Upgrading v${currentVersion} \u2192 v${latest}...`));
-        const daemonWasRunning = options.restart !== false && isDaemonRunning2();
-        if (daemonWasRunning) {
-          stopDaemon2();
-          await new Promise((r) => setTimeout(r, 1e3));
-          stopManagedSessionHostProcess2();
-        }
-        const { spawnDetachedDaemonUpgradeHelper: spawnDetachedDaemonUpgradeHelper2 } = await Promise.resolve().then(() => (init_src(), src_exports));
-        spawnDetachedDaemonUpgradeHelper2({
-          packageName: "adhdev",
-          targetVersion: latest,
-          parentPid: process.pid,
-          restartArgv: daemonWasRunning ? [process.argv[1], "daemon", "-p", DEFAULT_DAEMON_PORT_TEXT] : [],
-          cwd: process.cwd()
-        });
-        if (daemonWasRunning) {
-          console.log(source_default.cyan("  Upgrading and restarting daemon in background..."));
-        } else {
-          console.log(source_default.cyan("  Upgrading in background..."));
-          console.log(source_default.gray("  Start daemon when ready: adhdev daemon"));
-        }
-        console.log(source_default.gray(`  Progress: ~/.adhdev/daemon-upgrade.log
-`));
-        process.exit(0);
-        return;
-      }
-    }
-    if (options.restart !== false && isDaemonRunning2()) {
-      console.log(source_default.yellow("\n  Restarting daemon..."));
-      stopDaemon2();
-      await new Promise((r) => setTimeout(r, 2e3));
-      stopManagedSessionHostProcess2();
-      await new Promise((r) => setTimeout(r, 500));
-      const child = spawn6(process.execPath, [process.argv[1], "daemon", "-p", DEFAULT_DAEMON_PORT_TEXT], {
-        detached: true,
-        stdio: "ignore",
-        windowsHide: true,
-        env: { ...process.env }
-      });
-      child.unref();
-      await new Promise((r) => setTimeout(r, 3e3));
-      if (isDaemonRunning2()) {
-        console.log(source_default.green(`  \u2713 Daemon restarted with new version
-`));
-      } else {
-        console.log(source_default.yellow(`  \u26A0 Daemon not detected. Start manually: adhdev daemon
-`));
-      }
-    } else if (options.restart !== false) {
-      console.log(source_default.gray("\n  Daemon was not running. Start with: adhdev daemon\n"));
-    } else {
-      console.log(source_default.green("\n  \u2713 Upgrade complete (daemon not restarted)\n"));
-    }
+    await runDaemonUpgrade(options, pkgVersion3);
   }));
   program2.command("update").description("\u{1F504} Update ADHDev to latest version and restart daemon (alias for daemon:upgrade)").option("--no-restart", "Upgrade only, skip daemon restart").action(async (options) => {
-    process.argv = [process.argv[0], process.argv[1], "daemon:upgrade", ...options.restart === false ? ["--no-restart"] : []];
-    await program2.parseAsync(process.argv);
+    await runDaemonUpgrade(options, pkgVersion3);
   });
 }
 
 // src/cli/doctor-commands.ts
 init_source();
-var import_child_process14 = require("child_process");
+var import_child_process15 = require("child_process");
 var fs26 = __toESM(require("fs"));
 var os30 = __toESM(require("os"));
-var path33 = __toESM(require("path"));
+var path34 = __toESM(require("path"));
 init_src();
 init_session_host();
 
@@ -92493,26 +92804,26 @@ function buildDoctorAdvice(input) {
 
 // src/cli/service-commands.ts
 var import_node_fs6 = __toESM(require("fs"));
-var import_node_path4 = __toESM(require("path"));
+var import_node_path5 = __toESM(require("path"));
 var import_node_os6 = __toESM(require("os"));
 var import_node_child_process6 = require("child_process");
 init_source();
 init_src();
 var DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS3 = 1500;
 var LAUNCHD_LABEL = "dev.adhf.daemon";
-var ADHDEV_DIR = import_node_path4.default.join(import_node_os6.default.homedir(), ".adhdev");
-var LOG_OUT = import_node_path4.default.join(ADHDEV_DIR, "daemon-launchd.out");
-var LOG_ERR = import_node_path4.default.join(ADHDEV_DIR, "daemon-launchd.err");
+var ADHDEV_DIR = import_node_path5.default.join(import_node_os6.default.homedir(), ".adhdev");
+var LOG_OUT = import_node_path5.default.join(ADHDEV_DIR, "daemon-launchd.out");
+var LOG_ERR = import_node_path5.default.join(ADHDEV_DIR, "daemon-launchd.err");
 var MAX_LOG_SIZE2 = 10 * 1024 * 1024;
 function getDarwinPlistPath() {
-  return import_node_path4.default.join(import_node_os6.default.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+  return import_node_path5.default.join(import_node_os6.default.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
 }
 function getWindowsStartupDir() {
-  const appData = process.env.APPDATA || import_node_path4.default.join(import_node_os6.default.homedir(), "AppData", "Roaming");
-  return import_node_path4.default.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+  const appData = process.env.APPDATA || import_node_path5.default.join(import_node_os6.default.homedir(), "AppData", "Roaming");
+  return import_node_path5.default.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
 }
 function getWindowsVbsPath() {
-  return import_node_path4.default.join(getWindowsStartupDir(), "adhdev-daemon.vbs");
+  return import_node_path5.default.join(getWindowsStartupDir(), "adhdev-daemon.vbs");
 }
 function resolveCliPath() {
   return import_node_fs6.default.realpathSync(process.argv[1]);
@@ -92578,7 +92889,7 @@ function rotateLogs() {
 }
 function buildPlist(nodeExe, cliExe) {
   const brewPrefix = import_node_fs6.default.existsSync("/opt/homebrew/bin") ? "/opt/homebrew/bin" : "/usr/local/bin";
-  const nodeDir = import_node_path4.default.dirname(nodeExe);
+  const nodeDir = import_node_path5.default.dirname(nodeExe);
   const pathEntries = /* @__PURE__ */ new Set([nodeDir, brewPrefix, "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]);
   const pathValue = Array.from(pathEntries).join(":");
   return `<?xml version="1.0" encoding="UTF-8"?>
@@ -92617,7 +92928,7 @@ function buildPlist(nodeExe, cliExe) {
 function installDarwin(nodeExe, cliExe) {
   const plistPath = getDarwinPlistPath();
   ensureDir(ADHDEV_DIR);
-  ensureDir(import_node_path4.default.dirname(plistPath));
+  ensureDir(import_node_path5.default.dirname(plistPath));
   import_node_fs6.default.writeFileSync(plistPath, buildPlist(nodeExe, cliExe), "utf-8");
   console.log(source_default.gray(`  Plist: ${plistPath}`));
   try {
@@ -92650,7 +92961,7 @@ function isInstalledDarwin() {
   return import_node_fs6.default.existsSync(getDarwinPlistPath());
 }
 function buildVbs(nodeExe, cliExe) {
-  const logFile = import_node_path4.default.join(ADHDEV_DIR, "daemon-service.log").replace(/\\/g, "\\\\");
+  const logFile = import_node_path5.default.join(ADHDEV_DIR, "daemon-service.log").replace(/\\/g, "\\\\");
   const escapedNodeExe = nodeExe.replace(/\\/g, "\\\\");
   const escapedCliExe = cliExe.replace(/\\/g, "\\\\");
   return `' ADHDev Daemon Auto-Start (generated by adhdev service install)
@@ -92661,11 +92972,11 @@ WshShell.Run "cmd.exe /c """"${escapedNodeExe}"""" """"${escapedCliExe}"""" daem
 function installWindows(nodeExe, cliExe) {
   const vbsPath = getWindowsVbsPath();
   ensureDir(ADHDEV_DIR);
-  ensureDir(import_node_path4.default.dirname(vbsPath));
+  ensureDir(import_node_path5.default.dirname(vbsPath));
   import_node_fs6.default.writeFileSync(vbsPath, buildVbs(nodeExe, cliExe), "utf-8");
   console.log(source_default.gray(`  Startup script: ${vbsPath}`));
   console.log(source_default.green("\n  \u2713 Registered in Startup folder \u2014 daemon will start on login (hidden)."));
-  console.log(source_default.gray(`  Logs: ${import_node_path4.default.join(ADHDEV_DIR, "daemon-service.log")}`));
+  console.log(source_default.gray(`  Logs: ${import_node_path5.default.join(ADHDEV_DIR, "daemon-service.log")}`));
   console.log(source_default.gray("  To start now without rebooting, run: adhdev daemon"));
 }
 function uninstallWindows() {
@@ -92859,11 +93170,11 @@ function formatBytes(bytes) {
 
 // src/cli/doctor-commands.ts
 function resolvePackageRoot() {
-  return path33.resolve(__dirname, "..", "..");
+  return path34.resolve(__dirname, "..", "..");
 }
 function isLinkedInstall(packageRoot) {
-  const normalized = path33.normalize(packageRoot);
-  return !normalized.includes(`${path33.sep}node_modules${path33.sep}adhdev`);
+  const normalized = path34.normalize(packageRoot);
+  return !normalized.includes(`${path34.sep}node_modules${path34.sep}adhdev`);
 }
 function formatCheck(check2) {
   const icon = check2.ok ? source_default.green("\u2713") : source_default.red("\u2717");
@@ -92947,8 +93258,8 @@ function probeSharpRuntime(packageRoot, nativeSharpPackage) {
   }
 }
 function probeConfigAccess() {
-  const configDir = path33.join(os30.homedir(), ".adhdev");
-  const configPath = path33.join(configDir, "config.json");
+  const configDir = path34.join(os30.homedir(), ".adhdev");
+  const configPath = path34.join(configDir, "config.json");
   const checks = [];
   try {
     fs26.mkdirSync(configDir, { recursive: true });
@@ -92988,7 +93299,7 @@ function probeConfigAccess() {
       fatal: true
     });
   }
-  const probePath = path33.join(configDir, `.doctor-write-${process.pid}-${Date.now()}.tmp`);
+  const probePath = path34.join(configDir, `.doctor-write-${process.pid}-${Date.now()}.tmp`);
   try {
     fs26.writeFileSync(probePath, "ok", "utf-8");
     fs26.rmSync(probePath, { force: true });
@@ -93015,7 +93326,7 @@ function findCommandPaths(command) {
   try {
     const bin = process.platform === "win32" ? "where.exe" : "which";
     const args = process.platform === "win32" ? [command] : ["-a", command];
-    const output = (0, import_child_process14.execFileSync)(bin, args, {
+    const output = (0, import_child_process15.execFileSync)(bin, args, {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -93030,7 +93341,7 @@ function probeCliBinary(commandPath, currentVersion) {
     currentVersion
   };
   try {
-    probe.version = (0, import_child_process14.execFileSync)(commandPath, ["--version"], {
+    probe.version = (0, import_child_process15.execFileSync)(commandPath, ["--version"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -93038,7 +93349,7 @@ function probeCliBinary(commandPath, currentVersion) {
     probe.versionError = error48?.stderr?.toString?.().trim() || error48?.message || "version probe failed";
   }
   try {
-    probe.helpText = (0, import_child_process14.execFileSync)(commandPath, ["--help"], {
+    probe.helpText = (0, import_child_process15.execFileSync)(commandPath, ["--help"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -93177,7 +93488,7 @@ function registerDoctorCommands(program2, pkgVersion3) {
       });
     }
     if (process.platform === "darwin") {
-      serviceDefinitionPath = path33.join(os30.homedir(), "Library", "LaunchAgents", "dev.adhf.daemon.plist");
+      serviceDefinitionPath = path34.join(os30.homedir(), "Library", "LaunchAgents", "dev.adhf.daemon.plist");
       if (fs26.existsSync(serviceDefinitionPath)) {
         serviceDefinitionCheck = evaluateServiceDefinitionDrift({
           serviceKind: "launchd",
@@ -93225,7 +93536,7 @@ function registerDoctorCommands(program2, pkgVersion3) {
     } catch {
     }
     try {
-      const providerLoader = await createConfiguredProviderLoader({ load: true });
+      const providerLoader = await getSharedCliProviderLoader();
       const cliResults = await detectCLIs(providerLoader);
       for (const cli of cliResults) {
         checks.push({
@@ -93250,7 +93561,7 @@ function registerDoctorCommands(program2, pkgVersion3) {
       serviceCheck: serviceDefinitionCheck || void 0,
       sourceCliExample: "node --import tsx packages/daemon-cloud/src/cli/index.ts doctor"
     });
-    const sessionHostLogPath = path33.join(os30.homedir(), ".adhdev", "logs", "session-host.log");
+    const sessionHostLogPath = path34.join(os30.homedir(), ".adhdev", "logs", "session-host.log");
     console.log(source_default.bold("\n\u{1FA7A} ADHDev Doctor\n"));
     console.log(source_default.gray(`  Version:   ${pkgVersion3}`));
     console.log(source_default.gray(`  Platform:  ${process.platform} ${process.arch}`));
@@ -93292,7 +93603,7 @@ function registerDoctorCommands(program2, pkgVersion3) {
 
 // src/cli/provider-commands.ts
 init_source();
-var path34 = __toESM(require("path"));
+var path35 = __toESM(require("path"));
 init_cdp_utils();
 var DEV_SERVER_PORT3 = 19280;
 var IDE_AUTO_FIX_FUNCTIONS = [
@@ -93363,7 +93674,7 @@ function getCliAutoFixVerification(provider, providerDir) {
   };
 }
 function hideCommand2(command) {
-  command.hideHelp?.();
+  command._hidden = true;
   return command;
 }
 async function createConfiguredProviderLoader2() {
@@ -93375,7 +93686,7 @@ function getProviderSourceCandidatePaths(options) {
   const results = [];
   for (const root of roots) {
     for (const name of relativeNames) {
-      results.push(path34.join(root, options.category, options.type, name));
+      results.push(path35.join(root, options.category, options.type, name));
     }
   }
   return results;
@@ -93511,7 +93822,7 @@ function registerProviderCommands(program2) {
       let processNames = {};
       if (category === "ide") {
         const fs27 = await import("fs");
-        const path35 = await import("path");
+        const path36 = await import("path");
         const os31 = await import("os");
         if (os31.platform() === "darwin") {
           while (true) {
@@ -93524,7 +93835,7 @@ function registerProviderCommands(program2) {
             }
             console.log(source_default.green(`  \u2713 Path verified: ${p}`));
             osPaths["darwin"] = [p];
-            processNames["darwin"] = path35.basename(p, ".app");
+            processNames["darwin"] = path36.basename(p, ".app");
             break;
           }
         } else if (os31.platform() === "win32") {
@@ -93538,7 +93849,7 @@ function registerProviderCommands(program2) {
             }
             console.log(source_default.green(`  \u2713 Path verified: ${p}`));
             osPaths["win32"] = [p];
-            processNames["win32"] = path35.basename(p, ".exe");
+            processNames["win32"] = path36.basename(p, ".exe");
             break;
           }
         }
@@ -94360,18 +94671,9 @@ if (process.platform === "win32") {
     process.exit(1);
   }
 }
-var cliConfig = loadConfig();
-var _cliProviderLoader = new ProviderLoader({
-  logFn: () => {
-  },
-  userDir: cliConfig.providerDir,
-  sourceMode: cliConfig.providerSourceMode
-});
-_cliProviderLoader.loadAll();
-_cliProviderLoader.registerToDetector();
 var program = new import_commander.Command();
 program.name("adhdev").description("\u{1F9A6} ADHDev \u2014 Agent Dashboard Hub for Dev").version(pkgVersion2);
-registerSetupCommands(program, _cliProviderLoader);
+registerSetupCommands(program, getSharedCliProviderLoader);
 registerDaemonCommands(program, pkgVersion2);
 registerDoctorCommands(program, pkgVersion2);
 registerProviderCommands(program);