@adhdev/daemon-core 0.6.77 → 0.6.79

package/dist/index.js

@@ -1814,6 +1814,8 @@ __export(index_exports, {
   isCdpConnected: () => isCdpConnected,
   isExtensionInstalled: () => isExtensionInstalled,
   isIdeRunning: () => isIdeRunning,
+  isManagedStatusWaiting: () => isManagedStatusWaiting,
+  isManagedStatusWorking: () => isManagedStatusWorking,
   isSetupComplete: () => isSetupComplete,
   killIdeProcess: () => killIdeProcess,
   launchIDE: () => launchIDE,
@@ -1821,6 +1823,8 @@ __export(index_exports, {
   loadConfig: () => loadConfig,
   logCommand: () => logCommand,
   markSetupComplete: () => markSetupComplete,
+  normalizeActiveChatData: () => normalizeActiveChatData,
+  normalizeManagedStatus: () => normalizeManagedStatus,
   probeCdpPort: () => probeCdpPort,
   readChatHistory: () => readChatHistory,
   registerExtensionProviders: () => registerExtensionProviders,
@@ -2711,9 +2715,12 @@ var DaemonCdpManager = class {
     };
     try {
       const { targetInfos } = await sendWs("Target.getTargets");
-      const webviewIframes = (targetInfos || []).filter(
-        (t) => t.type === "iframe" && (t.url || "").includes("vscode-webview")
-      );
+      const pageWebviewUrls = await this.getCurrentPageWebviewUrls();
+      const webviewIframes = (targetInfos || []).filter((t) => {
+        if (t.type !== "iframe" || !(t.url || "").includes("vscode-webview")) return false;
+        if (pageWebviewUrls.size === 0) return true;
+        return pageWebviewUrls.has(t.url || "");
+      });
       if (webviewIframes.length === 0) {
         this.log("[CDP] evaluateInWebviewFrame: no webview iframes found");
         return null;
@@ -2800,6 +2807,7 @@ var DaemonCdpManager = class {
         const result = await this.sendInternal("Target.getTargets");
         allTargets = result?.targetInfos || [];
       }
+      const pageWebviewUrls = await this.getCurrentPageWebviewUrls();
       const iframes = allTargets.filter((t) => t.type === "iframe");
       const typeMap = /* @__PURE__ */ new Map();
       for (const t of allTargets) {
@@ -2825,6 +2833,7 @@ var DaemonCdpManager = class {
         const url = target.url || "";
         const hasWebview = url.includes("vscode-webview");
         if (!hasWebview) continue;
+        if (pageWebviewUrls.size > 0 && !pageWebviewUrls.has(url)) continue;
         for (const known of this.extensionProviders) {
           if (known.extensionIdPattern.test(url)) {
             agents.push({
@@ -2972,6 +2981,22 @@ var DaemonCdpManager = class {
   getAgentSessions() {
     return this.agentSessions;
   }
+  async getCurrentPageWebviewUrls() {
+    if (!this.isConnected) return /* @__PURE__ */ new Set();
+    try {
+      const raw = await this.evaluate(
+        `JSON.stringify(Array.from(document.querySelectorAll('iframe,webview'))
+                    .map((el) => el.src || el.getAttribute('src') || '')
+                    .filter((src) => typeof src === 'string' && src.includes('vscode-webview')))`,
+        5e3
+      );
+      const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+      if (!Array.isArray(parsed)) return /* @__PURE__ */ new Set();
+      return new Set(parsed.filter((src) => typeof src === "string" && src.length > 0));
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
   // ─── Screenshot ──────────────────────────────────────────
   async captureScreenshot(opts) {
     if (!this.isConnected) return null;
@@ -4443,6 +4468,45 @@ var DaemonCdpInitializer = class {
   }
 };
 
+// src/status/normalize.ts
+var WORKING_STATUSES = /* @__PURE__ */ new Set([
+  "generating",
+  "streaming",
+  "loading",
+  "loading_reference",
+  "thinking",
+  "active"
+]);
+function hasApprovalButtons(activeModal) {
+  return (activeModal?.buttons?.length ?? 0) > 0;
+}
+function normalizeManagedStatus(status, opts) {
+  if (hasApprovalButtons(opts?.activeModal)) return "waiting_approval";
+  const normalized = String(status || "idle").trim().toLowerCase();
+  if (normalized === "waiting_approval") return "waiting_approval";
+  if (WORKING_STATUSES.has(normalized)) return "generating";
+  if (normalized === "error") return "error";
+  if (normalized === "stopped") return "stopped";
+  if (normalized === "starting") return "starting";
+  if (normalized === "panel_hidden") return "panel_hidden";
+  if (normalized === "not_monitored") return "not_monitored";
+  if (normalized === "disconnected") return "disconnected";
+  return "idle";
+}
+function isManagedStatusWorking(status) {
+  return normalizeManagedStatus(status) === "generating";
+}
+function isManagedStatusWaiting(status, opts) {
+  return normalizeManagedStatus(status, opts) === "waiting_approval";
+}
+function normalizeActiveChatData(activeChat) {
+  if (!activeChat) return activeChat;
+  return {
+    ...activeChat,
+    status: normalizeManagedStatus(activeChat.status, { activeModal: activeChat.activeModal })
+  };
+}
+
 // src/status/builders.ts
 function findCdpManager(cdpManagers, key) {
   const exact = cdpManagers.get(key);
@@ -4476,13 +4540,13 @@ function buildManagedIdes(ideStates, cdpManagers, opts) {
       workspace: state.workspace || null,
       terminals: 0,
       aiAgents: [],
-      activeChat: state.activeChat,
+      activeChat: normalizeActiveChatData(state.activeChat),
       chats: [],
       agentStreams: state.extensions.map((ext) => ({
         agentType: ext.type,
         agentName: ext.name,
         extensionId: ext.type,
-        status: ext.status || "idle",
+        status: normalizeManagedStatus(ext.status, { activeModal: ext.activeChat?.activeModal || null }),
         messages: ext.activeChat?.messages || [],
         inputContent: ext.activeChat?.inputContent || "",
         activeModal: ext.activeChat?.activeModal || null
@@ -4522,10 +4586,10 @@ function buildManagedClis(cliStates) {
     instanceId: s.instanceId,
     cliType: s.type,
     cliName: s.name,
-    status: s.status,
+    status: normalizeManagedStatus(s.status, { activeModal: s.activeChat?.activeModal || null }),
     mode: "terminal",
     workspace: s.workspace || "",
-    activeChat: s.activeChat
+    activeChat: normalizeActiveChatData(s.activeChat)
   }));
 }
 function buildManagedAcps(acpStates) {
@@ -4533,10 +4597,10 @@ function buildManagedAcps(acpStates) {
     id: s.instanceId,
     acpType: s.type,
     acpName: s.name,
-    status: s.status,
+    status: normalizeManagedStatus(s.status, { activeModal: s.activeChat?.activeModal || null }),
     mode: "chat",
     workspace: s.workspace || "",
-    activeChat: s.activeChat,
+    activeChat: normalizeActiveChatData(s.activeChat),
     currentModel: s.currentModel,
     currentPlan: s.currentPlan,
     acpConfigOptions: s.acpConfigOptions,
@@ -4623,8 +4687,8 @@ async function handleReadChat(h, args) {
     }
     if (h.agentStream) {
       const cdp2 = h.getCdp();
-      if (cdp2) {
-        const streams = await h.agentStream.collectAgentStreams(cdp2);
+      if (cdp2 && h.currentIdeType) {
+        const streams = await h.agentStream.collectAgentStreams(cdp2, h.currentIdeType);
         const stream = streams.find((s) => s.agentType === provider.type);
         if (stream) {
           h.historyWriter.appendNewMessages(
@@ -4748,8 +4812,8 @@ async function handleSendChat(h, args) {
     } catch (e) {
       _log(`Extension script error: ${e.message}`);
     }
-    if (h.agentStream && h.getCdp()) {
-      const ok = await h.agentStream.sendToAgent(h.getCdp(), provider.type, text, h.currentIdeType);
+    if (h.agentStream && h.getCdp() && h.currentIdeType) {
+      const ok = await h.agentStream.sendToAgent(h.getCdp(), h.currentIdeType, provider.type, text, h.currentIdeType);
       if (ok) {
         _log(`AgentStreamManager sent OK`);
         return _logSendSuccess("agent-stream");
@@ -4868,9 +4932,9 @@ async function handleSendChat(h, args) {
 }
 async function handleListChats(h, args) {
   const provider = h.getProvider(args?.agentType);
-  if (provider?.category === "extension" && h.agentStream && h.getCdp()) {
+  if (provider?.category === "extension" && h.agentStream && h.getCdp() && h.currentIdeType) {
     try {
-      const chats = await h.agentStream.listAgentChats(h.getCdp(), provider.type);
+      const chats = await h.agentStream.listAgentChats(h.getCdp(), h.currentIdeType, provider.type);
       LOG.info("Command", `[list_chats] Extension: ${chats.length} chats`);
       return { success: true, chats };
     } catch (e) {
@@ -4929,8 +4993,8 @@ async function handleNewChat(h, args) {
     }
     return { success: false, error: "new_chat not supported by this CLI provider" };
   }
-  if (provider?.category === "extension" && h.agentStream && h.getCdp()) {
-    const ok = await h.agentStream.newAgentSession(h.getCdp(), provider.type, h.currentIdeType);
+  if (provider?.category === "extension" && h.agentStream && h.getCdp() && h.currentIdeType) {
+    const ok = await h.agentStream.newAgentSession(h.getCdp(), h.currentIdeType, provider.type, h.currentIdeType);
     return { success: ok };
   }
   try {
@@ -4958,8 +5022,8 @@ async function handleSwitchChat(h, args) {
   const sessionId = args?.sessionId || args?.id || args?.chatId;
   if (!sessionId) return { success: false, error: "sessionId required" };
   LOG.info("Command", `[switch_chat] sessionId=${sessionId}, ideType=${ideType}`);
-  if (provider?.category === "extension" && h.agentStream && h.getCdp()) {
-    const ok = await h.agentStream.switchAgentSession(h.getCdp(), provider.type, sessionId);
+  if (provider?.category === "extension" && h.agentStream && h.getCdp() && h.currentIdeType) {
+    const ok = await h.agentStream.switchAgentSession(h.getCdp(), h.currentIdeType, provider.type, sessionId);
     return { success: ok, result: ok ? "switched" : "failed" };
   }
   const cdp = h.getCdp(ideType);
@@ -5225,9 +5289,10 @@ async function handleResolveAction(h, args) {
     LOG.info("Command", `[resolveAction] CLI PTY \u2192 buttonIndex=${buttonIndex} "${buttons[buttonIndex] ?? "?"}"`);
     return { success: true, buttonIndex, button: buttons[buttonIndex] ?? button };
   }
-  if (provider?.category === "extension" && h.agentStream && h.getCdp()) {
+  if (provider?.category === "extension" && h.agentStream && h.getCdp() && h.currentIdeType) {
     const ok = await h.agentStream.resolveAgentAction(
       h.getCdp(),
+      h.currentIdeType,
       provider.type,
       action,
       h.currentIdeType
@@ -5592,14 +5657,14 @@ async function handleFileListBrowse(h, args) {
 init_config();
 init_logger();
 async function handleAgentStreamSwitch(h, args) {
-  if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
+  if (!h.agentStream || !h.getCdp() || !h.currentIdeType) return { success: false, error: "AgentStream or CDP not available" };
   const agentType = args?.agentType || args?.agent || null;
-  await h.agentStream.switchActiveAgent(h.getCdp(), agentType);
+  await h.agentStream.switchActiveAgent(h.getCdp(), h.currentIdeType, agentType);
   return { success: true, activeAgent: agentType };
 }
 async function handleAgentStreamRead(h, args) {
-  if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const streams = await h.agentStream.collectAgentStreams(h.getCdp());
+  if (!h.agentStream || !h.getCdp() || !h.currentIdeType) return { success: false, error: "AgentStream or CDP not available" };
+  const streams = await h.agentStream.collectAgentStreams(h.getCdp(), h.currentIdeType);
   return { success: true, streams };
 }
 async function handleAgentStreamSend(h, args) {
@@ -5621,47 +5686,53 @@ async function handleAgentStreamSend(h, args) {
     }
   }
   if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const resolvedAgent = agentType || h.agentStream.activeAgentType;
+  const resolvedAgent = agentType || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
   if (!resolvedAgent) return { success: false, error: "agentType required" };
-  const ok = await h.agentStream.sendToAgent(h.getCdp(), resolvedAgent, text, h.currentIdeType);
+  if (!h.currentIdeType) return { success: false, error: "ideType required" };
+  const ok = await h.agentStream.sendToAgent(h.getCdp(), h.currentIdeType, resolvedAgent, text, h.currentIdeType);
   return { success: ok };
 }
 async function handleAgentStreamResolve(h, args) {
   if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
+  const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
   const action = args?.action || "approve";
   if (!agentType) return { success: false, error: "agentType required" };
-  const ok = await h.agentStream.resolveAgentAction(h.getCdp(), agentType, action, h.currentIdeType);
+  if (!h.currentIdeType) return { success: false, error: "ideType required" };
+  const ok = await h.agentStream.resolveAgentAction(h.getCdp(), h.currentIdeType, agentType, action, h.currentIdeType);
   return { success: ok };
 }
 async function handleAgentStreamNew(h, args) {
   if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
+  const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
   if (!agentType) return { success: false, error: "agentType required" };
-  const ok = await h.agentStream.newAgentSession(h.getCdp(), agentType, h.currentIdeType);
+  if (!h.currentIdeType) return { success: false, error: "ideType required" };
+  const ok = await h.agentStream.newAgentSession(h.getCdp(), h.currentIdeType, agentType, h.currentIdeType);
   return { success: ok };
 }
 async function handleAgentStreamListChats(h, args) {
   if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
+  const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
   if (!agentType) return { success: false, error: "agentType required" };
-  const chats = await h.agentStream.listAgentChats(h.getCdp(), agentType);
+  if (!h.currentIdeType) return { success: false, error: "ideType required" };
+  const chats = await h.agentStream.listAgentChats(h.getCdp(), h.currentIdeType, agentType);
   return { success: true, chats };
 }
 async function handleAgentStreamSwitchSession(h, args) {
   if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
+  const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
   const sessionId = args?.sessionId || args?.id;
   if (!agentType || !sessionId) return { success: false, error: "agentType and sessionId required" };
-  const ok = await h.agentStream.switchAgentSession(h.getCdp(), agentType, sessionId);
+  if (!h.currentIdeType) return { success: false, error: "ideType required" };
+  const ok = await h.agentStream.switchAgentSession(h.getCdp(), h.currentIdeType, agentType, sessionId);
   return { success: ok };
 }
 async function handleAgentStreamFocus(h, args) {
   if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
+  const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
   if (!agentType) return { success: false, error: "agentType required" };
   await h.agentStream.ensureAgentPanelOpen(agentType, h.currentIdeType);
-  const ok = await h.agentStream.focusAgentEditor(h.getCdp(), agentType);
+  if (!h.currentIdeType) return { success: false, error: "ideType required" };
+  const ok = await h.agentStream.focusAgentEditor(h.getCdp(), h.currentIdeType, agentType);
   return { success: ok };
 }
 function handlePtyInput(h, args) {
@@ -6021,7 +6092,7 @@ var DaemonCommandHandler = class {
     const key = ideType || this._currentIdeType;
     if (!key) return null;
     const resolved = this._ctx.instanceIdMap?.get(key) || key;
-    const m = findCdpManager(this._ctx.cdpManagers, resolved.toLowerCase());
+    const m = findCdpManager(this._ctx.cdpManagers, resolved);
     if (m?.isConnected) return m;
     return null;
   }
@@ -6062,11 +6133,11 @@ var DaemonCommandHandler = class {
     const cdp = this.getCdp();
     if (!cdp?.isConnected) return null;
     if (provider?.category === "extension") {
-      let sessionId = this.getExtensionSessionId(provider);
-      if (!sessionId && this._agentStream) {
-        await this._agentStream.switchActiveAgent(cdp, provider.type);
-        await this._agentStream.syncAgentSessions(cdp);
-        sessionId = this.getExtensionSessionId(provider);
+      let sessionId = this.getExtensionSessionId(provider, this._currentIdeType);
+      if (!sessionId && this._agentStream && this._currentIdeType) {
+        await this._agentStream.switchActiveAgent(cdp, this._currentIdeType, provider.type);
+        await this._agentStream.syncAgentSessions(cdp, this._currentIdeType);
+        sessionId = this.getExtensionSessionId(provider, this._currentIdeType);
       }
       if (!sessionId) return null;
       const result2 = await cdp.evaluateInSessionFrame(sessionId, script, timeout);
@@ -6092,15 +6163,39 @@ var DaemonCommandHandler = class {
     return null;
   }
   // ─── Private helpers ──────────────────────────────
-  getExtensionSessionId(provider) {
-    if (provider.category !== "extension" || !this._agentStream) return null;
-    const managed = this._agentStream.getManagedAgent(provider.type);
+  getExtensionSessionId(provider, scopeKey) {
+    if (provider.category !== "extension" || !this._agentStream || !scopeKey) return null;
+    const managed = this._agentStream.getManagedAgent(provider.type, scopeKey);
     return managed?.sessionId || null;
   }
+  resolveManagerKeyFromInstanceId(instanceId) {
+    const mapped = this._ctx.instanceIdMap?.get(instanceId);
+    if (mapped) return mapped;
+    const entries = this._ctx.instanceManager?.instances?.entries?.();
+    if (!entries) return void 0;
+    for (const [instanceKey, instance] of entries) {
+      if (typeof instanceKey !== "string" || !instanceKey.startsWith("ide:")) continue;
+      if (typeof instance?.getInstanceId === "function" && instance.getInstanceId() === instanceId) {
+        const managerKey = instanceKey.slice(4);
+        this._ctx.instanceIdMap?.set(instanceId, managerKey);
+        return managerKey;
+      }
+      if (typeof instance?.getExtensionInstances === "function") {
+        for (const ext of instance.getExtensionInstances() || []) {
+          if (typeof ext?.getInstanceId === "function" && ext.getInstanceId() === instanceId) {
+            const managerKey = instanceKey.slice(4);
+            this._ctx.instanceIdMap?.set(instanceId, managerKey);
+            return managerKey;
+          }
+        }
+      }
+    }
+    return void 0;
+  }
   /** Extract ideType from _targetInstance or explicit ideType */
   extractIdeType(args) {
     if (args?.ideType) {
-      const mappedKey = this._ctx.instanceIdMap?.get(args.ideType);
+      const mappedKey = this.resolveManagerKeyFromInstanceId(args.ideType);
       if (mappedKey) {
         return mappedKey;
       }
@@ -6122,8 +6217,9 @@ var DaemonCommandHandler = class {
       if (ideMatch) raw = ideMatch[1];
       else if (cliMatch) raw = cliMatch[1];
       else if (acpMatch) raw = acpMatch[1];
-      if (this._ctx.instanceIdMap?.has(raw)) {
-        return this._ctx.instanceIdMap.get(raw);
+      const mappedKey = this.resolveManagerKeyFromInstanceId(raw);
+      if (mappedKey) {
+        return mappedKey;
       }
       if (this._ctx.cdpManagers.has(raw)) {
         return raw;
@@ -10078,12 +10174,12 @@ var ProviderStreamAdapter = class {
 init_logger();
 var DaemonAgentStreamManager = class {
   allAdapters = [];
-  managed = /* @__PURE__ */ new Map();
+  managedByScope = /* @__PURE__ */ new Map();
   enabled = true;
   logFn;
-  lastDiscoveryTime = 0;
-  discoveryIntervalMs = 1e4;
-  _activeAgentType = null;
+  lastDiscoveryTimeByScope = /* @__PURE__ */ new Map();
+  discoveryIntervalMsByScope = /* @__PURE__ */ new Map();
+  activeAgentTypeByScope = /* @__PURE__ */ new Map();
   constructor(logFn, providerLoader) {
     this.logFn = logFn || LOG.forComponent("AgentStream").asLogFn();
     if (providerLoader) {
@@ -10103,46 +10199,69 @@ var DaemonAgentStreamManager = class {
   get isEnabled() {
     return this.enabled;
   }
-  get activeAgentType() {
-    return this._activeAgentType;
+  getActiveAgentType(scopeKey) {
+    return this.activeAgentTypeByScope.get(scopeKey) || null;
+  }
+  getManagedScope(scopeKey) {
+    let managed = this.managedByScope.get(scopeKey);
+    if (!managed) {
+      managed = /* @__PURE__ */ new Map();
+      this.managedByScope.set(scopeKey, managed);
+    }
+    return managed;
+  }
+  resetScope(scopeKey) {
+    this.managedByScope.delete(scopeKey);
+    this.activeAgentTypeByScope.delete(scopeKey);
+    this.lastDiscoveryTimeByScope.delete(scopeKey);
+    this.discoveryIntervalMsByScope.delete(scopeKey);
   }
   /** Panel focus based on provider.js focusPanel or extensionId (currently no-op) */
   async ensureAgentPanelOpen(agentType, targetIdeType) {
   }
-  async switchActiveAgent(cdp, agentType) {
-    if (this._activeAgentType === agentType) return;
-    if (this._activeAgentType) {
-      const prev = this.managed.get(this._activeAgentType);
+  async switchActiveAgent(cdp, scopeKey, agentType) {
+    const managed = this.getManagedScope(scopeKey);
+    const previousAgentType = this.getActiveAgentType(scopeKey);
+    if (previousAgentType === agentType) return;
+    if (previousAgentType) {
+      const prev = managed.get(previousAgentType);
       if (prev) {
         try {
           await cdp.detachAgent(prev.sessionId);
         } catch {
         }
-        this.managed.delete(this._activeAgentType);
-        this.logFn(`[AgentStream] Deactivated: ${prev.adapter.agentName}`);
+        managed.delete(previousAgentType);
+        this.logFn(`[AgentStream] Deactivated: ${prev.adapter.agentName} (${scopeKey})`);
       }
     }
-    this._activeAgentType = agentType;
-    this.lastDiscoveryTime = 0;
-    this.logFn(`[AgentStream] Active agent: ${agentType || "none"}`);
+    this.activeAgentTypeByScope.set(scopeKey, agentType);
+    this.lastDiscoveryTimeByScope.set(scopeKey, 0);
+    if (!agentType && managed.size === 0) {
+      this.managedByScope.delete(scopeKey);
+    }
+    this.logFn(`[AgentStream] Active agent (${scopeKey}): ${agentType || "none"}`);
   }
   /** Agent webview discovery + session connection */
-  async syncAgentSessions(cdp) {
-    if (!this.enabled || !this._activeAgentType) return;
+  async syncAgentSessions(cdp, scopeKey) {
+    const activeAgentType = this.getActiveAgentType(scopeKey);
+    if (!this.enabled || !activeAgentType) return;
     const now = Date.now();
-    if (this.managed.has(this._activeAgentType) && now - this.lastDiscoveryTime < this.discoveryIntervalMs) {
+    const managed = this.getManagedScope(scopeKey);
+    const lastDiscoveryTime = this.lastDiscoveryTimeByScope.get(scopeKey) || 0;
+    const discoveryIntervalMs = this.discoveryIntervalMsByScope.get(scopeKey) || 1e4;
+    if (managed.has(activeAgentType) && now - lastDiscoveryTime < discoveryIntervalMs) {
       return;
     }
-    this.lastDiscoveryTime = now;
+    this.lastDiscoveryTimeByScope.set(scopeKey, now);
     try {
       const targets = await cdp.discoverAgentWebviews();
-      const activeTarget = targets.find((t) => t.agentType === this._activeAgentType);
-      if (activeTarget && !this.managed.has(this._activeAgentType)) {
-        const adapter = this.allAdapters.find((a) => a.agentType === this._activeAgentType);
+      const activeTarget = targets.find((t) => t.agentType === activeAgentType);
+      if (activeTarget && !managed.has(activeAgentType)) {
+        const adapter = this.allAdapters.find((a) => a.agentType === activeAgentType);
         if (adapter) {
           const sessionId = await cdp.attachToAgent(activeTarget);
           if (sessionId) {
-            this.managed.set(this._activeAgentType, {
+            managed.set(activeAgentType, {
               adapter,
               sessionId,
               target: activeTarget,
@@ -10150,28 +10269,30 @@ var DaemonAgentStreamManager = class {
               lastError: null,
               lastHiddenCheckTime: 0
             });
-            this.logFn(`[AgentStream] Connected: ${adapter.agentName}`);
+            this.logFn(`[AgentStream] Connected: ${adapter.agentName} (${scopeKey})`);
           }
         }
       }
-      for (const [type, agent] of this.managed) {
-        if (type !== this._activeAgentType) {
+      for (const [type, agent] of managed) {
+        if (type !== activeAgentType) {
           await cdp.detachAgent(agent.sessionId);
-          this.managed.delete(type);
+          managed.delete(type);
         }
       }
-      this.discoveryIntervalMs = this.managed.has(this._activeAgentType) ? 3e4 : 1e4;
+      this.discoveryIntervalMsByScope.set(scopeKey, managed.has(activeAgentType) ? 3e4 : 1e4);
     } catch (e) {
-      this.logFn(`[AgentStream] sync error: ${e.message}`);
+      this.logFn(`[AgentStream] sync error (${scopeKey}): ${e.message}`);
     }
   }
   /** Collect active agent status */
-  async collectAgentStreams(cdp) {
+  async collectAgentStreams(cdp, scopeKey) {
     if (!this.enabled) return [];
     const results = [];
-    if (this._activeAgentType && this.managed.has(this._activeAgentType)) {
-      const agent = this.managed.get(this._activeAgentType);
-      const type = this._activeAgentType;
+    const activeAgentType = this.getActiveAgentType(scopeKey);
+    const managed = this.managedByScope.get(scopeKey);
+    if (activeAgentType && managed?.has(activeAgentType)) {
+      const agent = managed.get(activeAgentType);
+      const type = activeAgentType;
       const isHidden = agent.lastState?.status === "panel_hidden";
       const hiddenCacheFresh = isHidden && Date.now() - agent.lastHiddenCheckTime < 3e4;
       if (hiddenCacheFresh) {
@@ -10204,17 +10325,17 @@ var DaemonAgentStreamManager = class {
               await cdp.detachAgent(agent.sessionId);
             } catch {
             }
-            this.managed.delete(type);
-            this.lastDiscoveryTime = 0;
+            managed.delete(type);
+            this.lastDiscoveryTimeByScope.set(scopeKey, 0);
           }
         }
       }
     }
     return results;
   }
-  async sendToAgent(cdp, agentType, text, targetIdeType) {
+  async sendToAgent(cdp, scopeKey, agentType, text, targetIdeType) {
     await this.ensureAgentPanelOpen(agentType, targetIdeType);
-    const agent = this.managed.get(agentType);
+    const agent = this.getManagedAgent(agentType, scopeKey);
     if (!agent) return false;
     try {
       const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
@@ -10225,9 +10346,9 @@ var DaemonAgentStreamManager = class {
       return false;
     }
   }
-  async resolveAgentAction(cdp, agentType, action, targetIdeType) {
+  async resolveAgentAction(cdp, scopeKey, agentType, action, targetIdeType) {
     await this.ensureAgentPanelOpen(agentType, targetIdeType);
-    const agent = this.managed.get(agentType);
+    const agent = this.getManagedAgent(agentType, scopeKey);
     if (!agent) return false;
     try {
       const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
@@ -10237,9 +10358,9 @@ var DaemonAgentStreamManager = class {
       return false;
     }
   }
-  async newAgentSession(cdp, agentType, targetIdeType) {
+  async newAgentSession(cdp, scopeKey, agentType, targetIdeType) {
     await this.ensureAgentPanelOpen(agentType, targetIdeType);
-    const agent = this.managed.get(agentType);
+    const agent = this.getManagedAgent(agentType, scopeKey);
     if (!agent) return false;
     try {
       const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
@@ -10250,13 +10371,13 @@ var DaemonAgentStreamManager = class {
       return false;
     }
   }
-  async listAgentChats(cdp, agentType) {
-    let agent = this.managed.get(agentType);
+  async listAgentChats(cdp, scopeKey, agentType) {
+    let agent = this.getManagedAgent(agentType, scopeKey);
     if (!agent) {
-      this.logFn(`[AgentStream] listChats: ${agentType} not managed, trying on-demand activation`);
-      await this.switchActiveAgent(cdp, agentType);
-      await this.syncAgentSessions(cdp);
-      agent = this.managed.get(agentType);
+      this.logFn(`[AgentStream] listChats: ${agentType} not managed in ${scopeKey}, trying on-demand activation`);
+      await this.switchActiveAgent(cdp, scopeKey, agentType);
+      await this.syncAgentSessions(cdp, scopeKey);
+      agent = this.getManagedAgent(agentType, scopeKey);
     }
     if (!agent || typeof agent.adapter.listChats !== "function") return [];
     try {
@@ -10267,13 +10388,13 @@ var DaemonAgentStreamManager = class {
       return [];
     }
   }
-  async switchAgentSession(cdp, agentType, sessionId) {
-    let agent = this.managed.get(agentType);
+  async switchAgentSession(cdp, scopeKey, agentType, sessionId) {
+    let agent = this.getManagedAgent(agentType, scopeKey);
     if (!agent) {
-      this.logFn(`[AgentStream] switchSession: ${agentType} not managed, trying on-demand activation`);
-      await this.switchActiveAgent(cdp, agentType);
-      await this.syncAgentSessions(cdp);
-      agent = this.managed.get(agentType);
+      this.logFn(`[AgentStream] switchSession: ${agentType} not managed in ${scopeKey}, trying on-demand activation`);
+      await this.switchActiveAgent(cdp, scopeKey, agentType);
+      await this.syncAgentSessions(cdp, scopeKey);
+      agent = this.getManagedAgent(agentType, scopeKey);
     }
     if (!agent || typeof agent.adapter.switchSession !== "function") return false;
     try {
@@ -10284,8 +10405,8 @@ var DaemonAgentStreamManager = class {
       return false;
     }
   }
-  async focusAgentEditor(cdp, agentType) {
-    const agent = this.managed.get(agentType);
+  async focusAgentEditor(cdp, scopeKey, agentType) {
+    const agent = this.getManagedAgent(agentType, scopeKey);
     if (!agent || typeof agent.adapter.focusEditor !== "function") return false;
     try {
       const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
@@ -10296,20 +10417,28 @@ var DaemonAgentStreamManager = class {
       return false;
     }
   }
-  getConnectedAgents() {
-    return Array.from(this.managed.keys());
+  getConnectedAgents(scopeKey) {
+    if (scopeKey) return Array.from((this.managedByScope.get(scopeKey) || /* @__PURE__ */ new Map()).keys());
+    return Array.from(this.managedByScope.values()).flatMap((scope) => Array.from(scope.keys()));
   }
-  getManagedAgent(agentType) {
-    return this.managed.get(agentType);
+  getManagedAgent(agentType, scopeKey) {
+    return this.managedByScope.get(scopeKey)?.get(agentType);
   }
-  async dispose(cdp) {
-    for (const [, agent] of this.managed) {
-      try {
-        await cdp.detachAgent(agent.sessionId);
-      } catch {
+  async dispose(cdpManagers) {
+    for (const [scopeKey, managed] of this.managedByScope) {
+      const cdp = cdpManagers.get(scopeKey);
+      if (!cdp) continue;
+      for (const [, agent] of managed) {
+        try {
+          await cdp.detachAgent(agent.sessionId);
+        } catch {
+        }
       }
     }
-    this.managed.clear();
+    this.managedByScope.clear();
+    this.activeAgentTypeByScope.clear();
+    this.lastDiscoveryTimeByScope.clear();
+    this.discoveryIntervalMsByScope.clear();
   }
 };
 
@@ -10317,20 +10446,17 @@ var DaemonAgentStreamManager = class {
 init_logger();
 var AgentStreamPoller = class {
   deps;
-  _activeIdeType = null;
   timer = null;
   constructor(deps) {
     this.deps = deps;
   }
   /** Currently active IDE type for agent streaming */
   get activeIde() {
-    return this._activeIdeType;
+    return null;
   }
   /** Reset active IDE tracking (e.g., when IDE is stopped) */
   resetActiveIde(ideType) {
-    if (this._activeIdeType === ideType) {
-      this._activeIdeType = null;
-    }
+    this.deps.agentStreamManager.resetScope(ideType);
   }
   /** Start polling (idempotent — ignored if already started) */
   start(intervalMs = 5e3) {
@@ -10380,49 +10506,43 @@ var AgentStreamPoller = class {
           }
         }
       }
-      if (this._activeIdeType === ideType && agentStreamManager.activeAgentType) {
-        const activeType = agentStreamManager.activeAgentType;
+      const activeType = agentStreamManager.getActiveAgentType(ideType);
+      if (activeType) {
         const enabledExtTypes = new Set(
           providerLoader.getEnabledExtensionProviders(ideType).map((p) => p.type)
         );
         if (!enabledExtTypes.has(activeType)) {
           LOG.info("AgentStream", `Active agent ${activeType} was disabled for ${ideType} \u2014 detaching`);
-          await agentStreamManager.switchActiveAgent(cdp, null);
-          this._activeIdeType = null;
+          await agentStreamManager.switchActiveAgent(cdp, ideType, null);
           this.deps.onStreamsUpdated?.(ideType, []);
         }
       }
-    }
-    if (this._activeIdeType) {
-      const cdp = cdpManagers.get(this._activeIdeType);
-      if (cdp?.isConnected) {
-        try {
-          await agentStreamManager.syncAgentSessions(cdp);
-          const streams = await agentStreamManager.collectAgentStreams(cdp);
-          this.deps.onStreamsUpdated?.(this._activeIdeType, streams);
-        } catch {
+      if (!cdp.isConnected) {
+        if (activeType) {
+          agentStreamManager.resetScope(ideType);
+          this.deps.onStreamsUpdated?.(ideType, []);
         }
-        return;
+        continue;
       }
-      this._activeIdeType = null;
-    }
-    if (!agentStreamManager.activeAgentType) {
-      for (const [ideType, cdp] of cdpManagers) {
-        if (!cdp.isConnected) continue;
+      let resolvedActiveType = activeType;
+      if (!resolvedActiveType) {
         try {
           const discovered = await cdp.discoverAgentWebviews();
           if (discovered.length > 0) {
-            this._activeIdeType = ideType;
-            await agentStreamManager.switchActiveAgent(cdp, discovered[0].agentType);
-            LOG.info("AgentStream", `Auto-activated: ${discovered[0].agentType} (${ideType})`);
-            await agentStreamManager.syncAgentSessions(cdp);
-            const streams = await agentStreamManager.collectAgentStreams(cdp);
-            this.deps.onStreamsUpdated?.(ideType, streams);
-            return;
+            resolvedActiveType = discovered[0].agentType;
+            await agentStreamManager.switchActiveAgent(cdp, ideType, resolvedActiveType);
+            LOG.info("AgentStream", `Auto-activated: ${resolvedActiveType} (${ideType})`);
           }
         } catch {
         }
       }
+      if (!resolvedActiveType) continue;
+      try {
+        await agentStreamManager.syncAgentSessions(cdp, ideType);
+        const streams = await agentStreamManager.collectAgentStreams(cdp, ideType);
+        this.deps.onStreamsUpdated?.(ideType, streams);
+      } catch {
+      }
     }
   }
 };
@@ -14464,9 +14584,8 @@ async function shutdownDaemonComponents(components) {
   poller.stop();
   cdpInitializer.stop();
   try {
-    const anyCdp = [...cdpManagers.values()].find((m) => m.isConnected);
-    if (agentStreamManager && anyCdp) {
-      await agentStreamManager.dispose(anyCdp);
+    if (agentStreamManager) {
+      await agentStreamManager.dispose(cdpManagers);
     }
   } catch (e) {
     LOG.warn("Shutdown", `AgentStream dispose: ${e?.message}`);
@@ -14537,6 +14656,8 @@ async function shutdownDaemonComponents(components) {
   isCdpConnected,
   isExtensionInstalled,
   isIdeRunning,
+  isManagedStatusWaiting,
+  isManagedStatusWorking,
   isSetupComplete,
   killIdeProcess,
   launchIDE,
@@ -14544,6 +14665,8 @@ async function shutdownDaemonComponents(components) {
   loadConfig,
   logCommand,
   markSetupComplete,
+  normalizeActiveChatData,
+  normalizeManagedStatus,
   probeCdpPort,
   readChatHistory,
   registerExtensionProviders,