@adhdev/daemon-core 0.6.76 → 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 {
+      }
     }
   }
 };
@@ -13525,14 +13645,16 @@ var DevServer = class _DevServer {
     lines.push("| Status | When to use | How to detect |");
     lines.push("|---|---|---|");
     lines.push("| `idle` | AI is NOT generating, no approval needed | Default state. No stop button, no spinners, no approval pills/buttons |");
-    lines.push("| `generating` | AI is actively streaming/thinking | ANY of: (1) Stop/Cancel button visible, (2) CSS animation (animate-spin/pulse/bounce), (3) floating state text like Thinking/Generating/Sailing, (4) streaming indicator class |");
+    lines.push('| `generating` | AI is actively streaming/thinking | ANY of: (1) Submit button icon SVG changes (e.g. arrow\u2192stop square, fill="none"\u2192fill="currentColor"), (2) Stop/Cancel button visible, (3) CSS animation, (4) Structural markers (aria-labels that only appear during generation) |');
     lines.push("| `waiting_approval` | AI stopped and needs user action | Actionable buttons like Run/Skip/Accept/Reject are visible AND clickable |");
     lines.push("");
     lines.push("### \u26A0\uFE0F Status Detection Gotchas (MUST READ!)");
-    lines.push('1. **FALSE POSITIVES from old messages**: Chat history may contain text like "Command Awaiting Approval" from PAST turns. If you search the entire chat panel for this text, you will get false matches from parent divs whose innerText includes ALL child text. ONLY match small leaf elements (under 80 chars) or use explicit button/pill selectors.');
-    lines.push('2. **Awaiting Approval pill without actions**: Some IDEs show a floating pill/banner saying "Awaiting Approval" that is just a scroll-to indicator (not an actual approval dialog). If this pill exists but NO actionable buttons (Run/Skip/Accept/Reject) exist anywhere in the panel, the status should be `idle`, NOT `waiting_approval`.');
-    lines.push("3. **generating detection must be multi-signal**: Do NOT rely on just one indicator. Check ALL of: stop buttons, CSS animations, floating state labels, streaming classes. IDEs differ widely.");
-    lines.push("4. **activeModal must include actions**: When `status` is `waiting_approval`, the `activeModal` object MUST include a non-empty `actions` array listing the button labels. If you cannot find any action buttons, the status is NOT `waiting_approval`.");
+    lines.push(`1. **DO NOT rely on button text/labels in the user's language.** OS locale may be Korean, Japanese, etc. Button text like "Cancel" or "Stop" will be localized. Instead, detect STRUCTURAL indicators: SVG icon changes, CSS classes, aria-labels from the extension's own React/Radix UI (which stay in English regardless of OS locale).`);
+    lines.push('2. **Use sendMessage to CREATE a generating state, then CAPTURE the DOM.** Send a LONG prompt (e.g. "Write an extremely detailed 5000-word essay...") so the AI takes 10+ seconds. Then periodically capture the DOM during generation to find which elements appear/change. Compare idle vs generating DOM snapshots to find reliable structural markers.');
+    lines.push("3. **Look for SVG icon changes in the submit button.** Many IDEs change the submit button icon from an arrow (send) to a square (stop) during generation. Check the SVG `fill` attribute or path data.");
+    lines.push('4. **FALSE POSITIVES from old messages**: Chat history may contain text like "Command Awaiting Approval" from PAST turns. ONLY match small leaf elements (under 80 chars) or use explicit button/pill selectors.');
+    lines.push("5. **Awaiting Approval pill without actions**: Some IDEs show a floating pill/banner that is just a scroll-to indicator. If NO actionable buttons exist, the status should be `idle`, NOT `waiting_approval`.");
+    lines.push("6. **activeModal must include actions**: When `status` is `waiting_approval`, the `activeModal` object MUST include a non-empty `actions` array.");
     lines.push("");
     lines.push("## Action");
     lines.push("1. Edit the script files to implement working code");
@@ -13590,10 +13712,10 @@ var DevServer = class _DevServer {
     lines.push(`echo "$RESULT" | python3 -c "import sys,json; d=json.load(sys.stdin); r=d.get('result',d); r=json.loads(r) if isinstance(r,str) else r; assert r.get('status')=='idle', f'Expected idle, got {r.get(chr(34)+chr(115)+chr(116)+chr(97)+chr(116)+chr(117)+chr(115)+chr(34))}'; print('Step 1 PASS: status=idle')"`);
     lines.push("```");
     lines.push("");
-    lines.push("### Step 2: Send a message that triggers generation");
+    lines.push("### Step 2: Send a LONG message that triggers extended generation (10+ seconds)");
     lines.push("```bash");
-    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "sendMessage", "type": "${type}", "ideType": "${type}", "args": {"message": "Say hello in one word"}}'`);
-    lines.push("sleep 2");
+    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "sendMessage", "type": "${type}", "ideType": "${type}", "args": {"message": "Write an extremely detailed 5000-word essay about the history of artificial intelligence from Alan Turing to 2025. Be very thorough and verbose."}}'`);
+    lines.push("sleep 3");
     lines.push("```");
     lines.push("");
     lines.push("### Step 3: Check generating OR completed");
@@ -14462,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}`);
@@ -14535,6 +14656,8 @@ async function shutdownDaemonComponents(components) {
   isCdpConnected,
   isExtensionInstalled,
   isIdeRunning,
+  isManagedStatusWaiting,
+  isManagedStatusWorking,
   isSetupComplete,
   killIdeProcess,
   launchIDE,
@@ -14542,6 +14665,8 @@ async function shutdownDaemonComponents(components) {
   loadConfig,
   logCommand,
   markSetupComplete,
+  normalizeActiveChatData,
+  normalizeManagedStatus,
   probeCdpPort,
   readChatHistory,
   registerExtensionProviders,