adhdev 0.9.34 → 0.9.36

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" };
       }
@@ -12766,6 +12773,8 @@ var init_provider_cli_adapter = __esm({
       messages = [];
       committedMessages = [];
       structuredMessages = [];
+      committedMessagesActivitySignature = "";
+      committedMessagesChangedAt = 0;
       currentStatus = "starting";
       onStatusChange = null;
       responseBuffer = "";
@@ -12847,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;
@@ -12879,7 +12913,16 @@ var init_provider_cli_adapter = __esm({
         if (baseMessages.length <= _ProviderCliAdapter.PARSE_MESSAGE_TAIL_LIMIT) return baseMessages;
         return baseMessages.slice(-_ProviderCliAdapter.PARSE_MESSAGE_TAIL_LIMIT);
       }
+      messagesShareStableIdentity(left2, right2) {
+        if (left2 === right2) return true;
+        if (!left2 || !right2) return false;
+        if ((left2.role || "") !== (right2.role || "")) return false;
+        if (left2.id && right2.id && String(left2.id) === String(right2.id)) return true;
+        if (typeof left2.index === "number" && typeof right2.index === "number" && left2.index === right2.index) return true;
+        return false;
+      }
       messagesComparable(left2, right2) {
+        if (this.messagesShareStableIdentity(left2, right2)) return true;
         if (!left2 || !right2) return false;
         if ((left2.role || "") !== (right2.role || "")) return false;
         const leftText = normalizeComparableTranscriptText(left2.content);
@@ -12990,9 +13033,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 };
       }
@@ -14023,6 +14073,69 @@ var init_provider_cli_adapter = __esm({
         this.committedMessages = normalized;
         this.syncMessageViews();
       }
+      getSharedCommittedPrefixLength(parsedMessages) {
+        const committedMessages = this.committedMessages;
+        const max = Math.min(parsedMessages.length, committedMessages.length);
+        let index = 0;
+        while (index < max && this.messagesShareStableIdentity(parsedMessages[index], committedMessages[index])) {
+          index += 1;
+        }
+        return index;
+      }
+      hydrateCommittedPrefixForParsedStatus(parsedMessages) {
+        const sharedPrefixLength = this.getSharedCommittedPrefixLength(parsedMessages);
+        if (sharedPrefixLength !== this.committedMessages.length) return null;
+        const committedHydratedMessages = this.committedMessages.map((message, index) => {
+          const timestamp = typeof message.timestamp === "number" && Number.isFinite(message.timestamp) ? message.timestamp : this.lastOutputAt || this.currentTurnScope?.startedAt || Date.now();
+          const contentValue = message.content;
+          return {
+            role: message.role,
+            content: typeof contentValue === "string" ? contentValue : String(contentValue || ""),
+            timestamp,
+            receivedAt: typeof message.receivedAt === "number" && Number.isFinite(message.receivedAt) ? message.receivedAt : timestamp,
+            kind: message.kind,
+            id: message.id || `msg_${index}`,
+            index: typeof message.index === "number" ? message.index : index,
+            meta: message.meta,
+            senderName: message.senderName
+          };
+        });
+        const extraMessages = parsedMessages.slice(sharedPrefixLength);
+        if (extraMessages.length === 0) return committedHydratedMessages;
+        const extraHydratedMessages = hydrateCliParsedMessages(extraMessages, {
+          committedMessages: [],
+          scope: this.currentTurnScope,
+          lastOutputAt: this.lastOutputAt
+        }).map((message, offset) => ({
+          ...message,
+          id: message.id || `msg_${sharedPrefixLength + offset}`,
+          index: typeof message.index === "number" ? message.index : sharedPrefixLength + offset
+        }));
+        return [...committedHydratedMessages, ...extraHydratedMessages];
+      }
+      hydrateParsedMessagesForStatus(parsedMessages) {
+        return this.hydrateCommittedPrefixForParsedStatus(parsedMessages) || hydrateCliParsedMessages(parsedMessages, {
+          committedMessages: this.committedMessages,
+          scope: this.currentTurnScope,
+          lastOutputAt: this.lastOutputAt
+        });
+      }
+      buildCommittedChatMessages() {
+        return this.committedMessages.map((message, index) => {
+          const contentValue = message.content;
+          return buildChatMessage({
+            role: message.role,
+            content: typeof contentValue === "string" ? contentValue : String(contentValue || ""),
+            timestamp: message.timestamp,
+            kind: message.kind,
+            meta: message.meta,
+            senderName: message.senderName,
+            id: message.id || `msg_${index}`,
+            index: typeof message.index === "number" ? message.index : index,
+            receivedAt: typeof message.receivedAt === "number" ? message.receivedAt : message.timestamp
+          });
+        });
+      }
       /**
        * Script-based full parse — returns ReadChatResult.
        * Called by command handler / dashboard for rich content rendering.
@@ -14048,7 +14161,7 @@ var init_provider_cli_adapter = __esm({
             this.onStatusChange?.();
           }
         }
-        if (parsed && Array.isArray(parsed.messages)) {
+        if (parsed && Array.isArray(parsed.messages) && this.provider.allowInputDuringGeneration === true) {
           const hydratedForCommit = normalizeCliParsedMessages(parsed.messages, {
             committedMessages: this.committedMessages,
             scope: this.currentTurnScope,
@@ -14067,21 +14180,21 @@ var init_provider_cli_adapter = __esm({
         const shouldPreferCommittedMessages = !this.currentTurnScope && !this.activeModal && this.currentStatus === "idle";
         let result;
         if (parsed && Array.isArray(parsed.messages)) {
-          const parsedHydratedMessages = hydrateCliParsedMessages(parsed.messages, {
-            committedMessages: this.committedMessages,
-            scope: this.currentTurnScope,
-            lastOutputAt: this.lastOutputAt
-          });
-          const committedHydratedMessages = this.committedMessages.map((message, index) => buildChatMessage({
-            ...message,
-            id: message.id || `msg_${index}`,
-            index: typeof message.index === "number" ? message.index : index,
-            receivedAt: typeof message.receivedAt === "number" ? message.receivedAt : message.timestamp
-          }));
+          const parsedHydratedMessages = this.hydrateParsedMessagesForStatus(parsed.messages);
           const parsedLastAssistant = [...parsedHydratedMessages].reverse().find((message) => message.role === "assistant" && typeof message.content === "string" && message.content.trim());
-          const shouldAdoptParsedIdleReplay = !this.currentTurnScope && !this.activeModal && !!parsedLastAssistant && parsedTranscriptIsRicherThanCommitted(parsedHydratedMessages, committedHydratedMessages) && (this.currentStatus === "idle" || this.currentStatus === "generating" && this.isWaitingForResponse && parsed.status === "idle" && this.runDetectStatus(this.recentOutputBuffer) === "idle");
+          const shouldAdoptParsedIdleReplay = !this.currentTurnScope && !this.activeModal && !!parsedLastAssistant && parsedTranscriptIsRicherThanCommitted(parsedHydratedMessages, this.committedMessages) && (this.currentStatus === "idle" || this.currentStatus === "generating" && this.isWaitingForResponse && parsed.status === "idle" && this.runDetectStatus(this.recentOutputBuffer) === "idle");
           if (shouldAdoptParsedIdleReplay) {
-            this.committedMessages = normalizeCliParsedMessages(parsed.messages, {
+            this.committedMessages = this.getSharedCommittedPrefixLength(parsed.messages) === this.committedMessages.length ? parsedHydratedMessages.map((message) => ({
+              role: message.role,
+              content: typeof message.content === "string" ? message.content : String(message.content || ""),
+              timestamp: message.timestamp,
+              receivedAt: message.receivedAt,
+              kind: message.kind,
+              id: message.id,
+              index: message.index,
+              meta: message.meta,
+              senderName: message.senderName
+            })) : normalizeCliParsedMessages(parsed.messages, {
               committedMessages: this.committedMessages,
               scope: this.currentTurnScope,
               lastOutputAt: this.lastOutputAt
@@ -14100,15 +14213,9 @@ var init_provider_cli_adapter = __esm({
               this.onStatusChange?.();
             }
           }
-          const effectiveCommittedHydratedMessages = shouldAdoptParsedIdleReplay ? this.committedMessages.map((message, index) => buildChatMessage({
-            ...message,
-            id: message.id || `msg_${index}`,
-            index: typeof message.index === "number" ? message.index : index,
-            receivedAt: typeof message.receivedAt === "number" ? message.receivedAt : message.timestamp
-          })) : committedHydratedMessages;
-          const shouldPreferCommittedHistoryReplay = !this.currentTurnScope && !this.activeModal && effectiveCommittedHydratedMessages.length > parsedHydratedMessages.length;
+          const shouldPreferCommittedHistoryReplay = !this.currentTurnScope && !this.activeModal && this.committedMessages.length > parsedHydratedMessages.length;
           const shouldPreferCommittedIdleReplay = shouldPreferCommittedMessages && !shouldAdoptParsedIdleReplay;
-          const hydratedMessages = shouldPreferCommittedIdleReplay || shouldPreferCommittedHistoryReplay ? effectiveCommittedHydratedMessages : parsedHydratedMessages;
+          const hydratedMessages = shouldPreferCommittedIdleReplay || shouldPreferCommittedHistoryReplay ? this.buildCommittedChatMessages() : parsedHydratedMessages;
           result = {
             id: parsed.id || "cli_session",
             status: parsed.status || this.currentStatus,
@@ -15014,6 +15121,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;
@@ -15224,9 +15336,11 @@ var init_cli_provider_instance = __esm({
         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,
@@ -16059,10 +16173,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);
@@ -16374,11 +16488,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;
   });
 }
@@ -16621,7 +16735,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) {
@@ -16631,7 +16745,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;
@@ -16663,8 +16777,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")
@@ -29428,13 +29542,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}`);
     }
@@ -34176,7 +34290,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;
         }
@@ -34201,8 +34315,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)
@@ -34242,20 +34356,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) {
@@ -34312,16 +34426,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) {
@@ -34670,12 +34784,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);
@@ -34686,7 +34800,7 @@ var init_handler2 = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path35,
+          path36,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -34701,7 +34815,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) {
@@ -34732,7 +34846,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;
@@ -34754,7 +34868,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));
             }
           })
         };
@@ -34784,13 +34898,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
         };
@@ -34800,12 +34914,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
@@ -34827,7 +34941,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) {
@@ -34841,11 +34955,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;
               }
@@ -34877,7 +34991,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;
         }
@@ -34887,7 +35001,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;
@@ -34897,12 +35011,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;
@@ -34932,9 +35046,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) {
@@ -34943,8 +35057,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) => {
@@ -35013,13 +35127,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);
@@ -35035,8 +35149,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);
@@ -35046,29 +35160,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;
           }
         }
       }
@@ -35103,24 +35217,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;
     }
   }
@@ -35183,19 +35297,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 {
@@ -35260,10 +35374,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 = [];
@@ -35403,20 +35517,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;
@@ -35438,17 +35552,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
             });
           }
@@ -35512,38 +35626,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) {
@@ -35561,16 +35675,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);
@@ -35601,23 +35715,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);
@@ -35625,7 +35739,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() {
@@ -35639,44 +35753,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;
             }
@@ -35687,8 +35801,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;
@@ -35698,17 +35812,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
       // -----------------
@@ -35740,63 +35854,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);
       }
@@ -40933,6 +41047,9 @@ 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,
@@ -41145,6 +41262,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
@@ -45157,8 +45285,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) {
@@ -45427,20 +45555,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,
@@ -59276,15 +59391,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) {
@@ -77154,9 +77269,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;
@@ -77166,8 +77281,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
@@ -80685,16 +80800,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 {
@@ -80813,11 +80928,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;
         }
       }
@@ -80864,8 +80979,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;
@@ -80877,8 +80992,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;
@@ -82597,18 +82712,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);
@@ -85517,15 +85632,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) {
@@ -86142,7 +86257,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([
@@ -86173,9 +86288,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) {
@@ -88120,7 +88235,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.34" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.36" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -90663,6 +90778,7 @@ init_source();
 init_src();
 
 // src/cli/setup-commands.ts
+var import_node_path4 = __toESM(require("path"));
 init_source();
 init_src();
 
@@ -90815,8 +90931,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.`);
   }
@@ -90906,12 +91021,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,
@@ -90935,7 +91051,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
@@ -91055,6 +91171,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(`
@@ -91127,6 +91244,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(`
@@ -91220,6 +91338,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));
@@ -91303,6 +91422,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();
@@ -91404,7 +91524,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) {
@@ -91430,7 +91550,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 {
@@ -91454,10 +91574,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();
@@ -91466,19 +91586,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";
@@ -91558,6 +91678,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) {
@@ -91634,9 +91773,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;
 }
@@ -91939,12 +92075,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,
@@ -92040,7 +92282,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.
@@ -92499,114 +92741,10 @@ 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);
   });
 }
 
@@ -92615,7 +92753,7 @@ init_source();
 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();
 
@@ -92732,26 +92870,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]);
@@ -92817,7 +92955,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"?>
@@ -92856,7 +92994,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 {
@@ -92889,7 +93027,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)
@@ -92900,11 +93038,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() {
@@ -93098,11 +93236,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");
@@ -93186,8 +93324,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 });
@@ -93227,7 +93365,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 });
@@ -93416,7 +93554,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",
@@ -93464,7 +93602,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({
@@ -93489,7 +93627,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}`));
@@ -93531,7 +93669,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 = [
@@ -93602,7 +93740,7 @@ function getCliAutoFixVerification(provider, providerDir) {
   };
 }
 function hideCommand2(command) {
-  command.hideHelp?.();
+  command._hidden = true;
   return command;
 }
 async function createConfiguredProviderLoader2() {
@@ -93614,7 +93752,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;
@@ -93750,7 +93888,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) {
@@ -93763,7 +93901,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") {
@@ -93777,7 +93915,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;
           }
         }
@@ -94599,18 +94737,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);