@adhdev/daemon-core 0.6.76 → 0.6.79

package/dist/status/normalize.d.mts

@@ -0,0 +1 @@
+export { x as ManagedStatus, N as isManagedStatusWaiting, O as isManagedStatusWorking, V as normalizeActiveChatData, X as normalizeManagedStatus } from '../normalize-igHDb198.mjs';

package/dist/status/normalize.d.ts

@@ -0,0 +1 @@
+export { x as ManagedStatus, N as isManagedStatusWaiting, O as isManagedStatusWorking, V as normalizeActiveChatData, X as normalizeManagedStatus } from '../normalize-igHDb198.js';

package/dist/status/normalize.js

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/status/normalize.ts
+var normalize_exports = {};
+__export(normalize_exports, {
+  isManagedStatusWaiting: () => isManagedStatusWaiting,
+  isManagedStatusWorking: () => isManagedStatusWorking,
+  normalizeActiveChatData: () => normalizeActiveChatData,
+  normalizeManagedStatus: () => normalizeManagedStatus
+});
+module.exports = __toCommonJS(normalize_exports);
+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 })
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isManagedStatusWaiting,
+  isManagedStatusWorking,
+  normalizeActiveChatData,
+  normalizeManagedStatus
+});
+//# sourceMappingURL=normalize.js.map

package/dist/status/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/status/normalize.ts"],"sourcesContent":["import type { ActiveChatData } from '../providers/provider-instance.js';\n\nexport type ManagedStatus =\n    | 'idle'\n    | 'generating'\n    | 'waiting_approval'\n    | 'error'\n    | 'stopped'\n    | 'starting'\n    | 'panel_hidden'\n    | 'not_monitored'\n    | 'disconnected';\n\nconst WORKING_STATUSES = new Set([\n    'generating',\n    'streaming',\n    'loading',\n    'loading_reference',\n    'thinking',\n    'active',\n]);\n\nfunction hasApprovalButtons(activeModal?: { buttons?: unknown[] | null } | null): boolean {\n    return (activeModal?.buttons?.length ?? 0) > 0;\n}\n\nexport function normalizeManagedStatus(\n    status?: string | null,\n    opts?: { activeModal?: { buttons?: unknown[] | null } | null },\n): ManagedStatus {\n    if (hasApprovalButtons(opts?.activeModal)) return 'waiting_approval';\n\n    const normalized = String(status || 'idle').trim().toLowerCase();\n    if (normalized === 'waiting_approval') return 'waiting_approval';\n    if (WORKING_STATUSES.has(normalized)) return 'generating';\n    if (normalized === 'error') return 'error';\n    if (normalized === 'stopped') return 'stopped';\n    if (normalized === 'starting') return 'starting';\n    if (normalized === 'panel_hidden') return 'panel_hidden';\n    if (normalized === 'not_monitored') return 'not_monitored';\n    if (normalized === 'disconnected') return 'disconnected';\n    return 'idle';\n}\n\nexport function isManagedStatusWorking(status?: string | null): boolean {\n    return normalizeManagedStatus(status) === 'generating';\n}\n\nexport function isManagedStatusWaiting(\n    status?: string | null,\n    opts?: { activeModal?: { buttons?: unknown[] | null } | null },\n): boolean {\n    return normalizeManagedStatus(status, opts) === 'waiting_approval';\n}\n\nexport function normalizeActiveChatData<T extends ActiveChatData | null | undefined>(\n    activeChat: T,\n): T {\n    if (!activeChat) return activeChat;\n    return {\n        ...activeChat,\n        status: normalizeManagedStatus(activeChat.status, { activeModal: activeChat.activeModal }),\n    } as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,IAAM,mBAAmB,oBAAI,IAAI;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,CAAC;AAED,SAAS,mBAAmB,aAA8D;AACtF,UAAQ,aAAa,SAAS,UAAU,KAAK;AACjD;AAEO,SAAS,uBACZ,QACA,MACa;AACb,MAAI,mBAAmB,MAAM,WAAW,EAAG,QAAO;AAElD,QAAM,aAAa,OAAO,UAAU,MAAM,EAAE,KAAK,EAAE,YAAY;AAC/D,MAAI,eAAe,mBAAoB,QAAO;AAC9C,MAAI,iBAAiB,IAAI,UAAU,EAAG,QAAO;AAC7C,MAAI,eAAe,QAAS,QAAO;AACnC,MAAI,eAAe,UAAW,QAAO;AACrC,MAAI,eAAe,WAAY,QAAO;AACtC,MAAI,eAAe,eAAgB,QAAO;AAC1C,MAAI,eAAe,gBAAiB,QAAO;AAC3C,MAAI,eAAe,eAAgB,QAAO;AAC1C,SAAO;AACX;AAEO,SAAS,uBAAuB,QAAiC;AACpE,SAAO,uBAAuB,MAAM,MAAM;AAC9C;AAEO,SAAS,uBACZ,QACA,MACO;AACP,SAAO,uBAAuB,QAAQ,IAAI,MAAM;AACpD;AAEO,SAAS,wBACZ,YACC;AACD,MAAI,CAAC,WAAY,QAAO;AACxB,SAAO;AAAA,IACH,GAAG;AAAA,IACH,QAAQ,uBAAuB,WAAW,QAAQ,EAAE,aAAa,WAAW,YAAY,CAAC;AAAA,EAC7F;AACJ;","names":[]}

package/dist/status/normalize.mjs

@@ -0,0 +1,45 @@
+// 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 })
+  };
+}
+export {
+  isManagedStatusWaiting,
+  isManagedStatusWorking,
+  normalizeActiveChatData,
+  normalizeManagedStatus
+};
+//# sourceMappingURL=normalize.mjs.map

package/dist/status/normalize.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/status/normalize.ts"],"sourcesContent":["import type { ActiveChatData } from '../providers/provider-instance.js';\n\nexport type ManagedStatus =\n    | 'idle'\n    | 'generating'\n    | 'waiting_approval'\n    | 'error'\n    | 'stopped'\n    | 'starting'\n    | 'panel_hidden'\n    | 'not_monitored'\n    | 'disconnected';\n\nconst WORKING_STATUSES = new Set([\n    'generating',\n    'streaming',\n    'loading',\n    'loading_reference',\n    'thinking',\n    'active',\n]);\n\nfunction hasApprovalButtons(activeModal?: { buttons?: unknown[] | null } | null): boolean {\n    return (activeModal?.buttons?.length ?? 0) > 0;\n}\n\nexport function normalizeManagedStatus(\n    status?: string | null,\n    opts?: { activeModal?: { buttons?: unknown[] | null } | null },\n): ManagedStatus {\n    if (hasApprovalButtons(opts?.activeModal)) return 'waiting_approval';\n\n    const normalized = String(status || 'idle').trim().toLowerCase();\n    if (normalized === 'waiting_approval') return 'waiting_approval';\n    if (WORKING_STATUSES.has(normalized)) return 'generating';\n    if (normalized === 'error') return 'error';\n    if (normalized === 'stopped') return 'stopped';\n    if (normalized === 'starting') return 'starting';\n    if (normalized === 'panel_hidden') return 'panel_hidden';\n    if (normalized === 'not_monitored') return 'not_monitored';\n    if (normalized === 'disconnected') return 'disconnected';\n    return 'idle';\n}\n\nexport function isManagedStatusWorking(status?: string | null): boolean {\n    return normalizeManagedStatus(status) === 'generating';\n}\n\nexport function isManagedStatusWaiting(\n    status?: string | null,\n    opts?: { activeModal?: { buttons?: unknown[] | null } | null },\n): boolean {\n    return normalizeManagedStatus(status, opts) === 'waiting_approval';\n}\n\nexport function normalizeActiveChatData<T extends ActiveChatData | null | undefined>(\n    activeChat: T,\n): T {\n    if (!activeChat) return activeChat;\n    return {\n        ...activeChat,\n        status: normalizeManagedStatus(activeChat.status, { activeModal: activeChat.activeModal }),\n    } as T;\n}\n"],"mappings":";AAaA,IAAM,mBAAmB,oBAAI,IAAI;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,CAAC;AAED,SAAS,mBAAmB,aAA8D;AACtF,UAAQ,aAAa,SAAS,UAAU,KAAK;AACjD;AAEO,SAAS,uBACZ,QACA,MACa;AACb,MAAI,mBAAmB,MAAM,WAAW,EAAG,QAAO;AAElD,QAAM,aAAa,OAAO,UAAU,MAAM,EAAE,KAAK,EAAE,YAAY;AAC/D,MAAI,eAAe,mBAAoB,QAAO;AAC9C,MAAI,iBAAiB,IAAI,UAAU,EAAG,QAAO;AAC7C,MAAI,eAAe,QAAS,QAAO;AACnC,MAAI,eAAe,UAAW,QAAO;AACrC,MAAI,eAAe,WAAY,QAAO;AACtC,MAAI,eAAe,eAAgB,QAAO;AAC1C,MAAI,eAAe,gBAAiB,QAAO;AAC3C,MAAI,eAAe,eAAgB,QAAO;AAC1C,SAAO;AACX;AAEO,SAAS,uBAAuB,QAAiC;AACpE,SAAO,uBAAuB,MAAM,MAAM;AAC9C;AAEO,SAAS,uBACZ,QACA,MACO;AACP,SAAO,uBAAuB,QAAQ,IAAI,MAAM;AACpD;AAEO,SAAS,wBACZ,YACC;AACD,MAAI,CAAC,WAAY,QAAO;AACxB,SAAO;AAAA,IACH,GAAG;AAAA,IACH,QAAQ,uBAAuB,WAAW,QAAQ,EAAE,aAAa,WAAW,YAAY,CAAC;AAAA,EAC7F;AACJ;","names":[]}

package/package.json

@@ -1,14 +1,21 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.6.76",
+  "version": "0.6.79",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
       "require": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./status/normalize": {
+      "types": "./dist/status/normalize.d.ts",
+      "import": "./dist/status/normalize.mjs",
+      "require": "./dist/status/normalize.js",
+      "default": "./dist/status/normalize.js"
     }
   },
   "scripts": {

package/src/agent-stream/manager.ts

@@ -30,14 +30,12 @@ export interface ManagedAgent {
 
 export class DaemonAgentStreamManager {
     private allAdapters: IAgentStreamAdapter[] = [];
-    private managed = new Map<string, ManagedAgent>();
+    private managedByScope = new Map<string, Map<string, ManagedAgent>>();
     private enabled = true;
     private logFn: (msg: string) => void;
-    private lastDiscoveryTime = 0;
-    private discoveryIntervalMs = 10_000;
-
-
-    private _activeAgentType: string | null = null;
+    private lastDiscoveryTimeByScope = new Map<string, number>();
+    private discoveryIntervalMsByScope = new Map<string, number>();
+    private activeAgentTypeByScope = new Map<string, string | null>();
 
     constructor(logFn?: (msg: string) => void, providerLoader?: ProviderLoader) {
         this.logFn = logFn || LOG.forComponent('AgentStream').asLogFn();
@@ -58,7 +56,25 @@ export class DaemonAgentStreamManager {
 
     setEnabled(enabled: boolean) { this.enabled = enabled; }
     get isEnabled() { return this.enabled; }
-    get activeAgentType(): string | null { return this._activeAgentType; }
+    getActiveAgentType(scopeKey: string): string | null {
+        return this.activeAgentTypeByScope.get(scopeKey) || null;
+    }
+
+    private getManagedScope(scopeKey: string): Map<string, ManagedAgent> {
+        let managed = this.managedByScope.get(scopeKey);
+        if (!managed) {
+            managed = new Map<string, ManagedAgent>();
+            this.managedByScope.set(scopeKey, managed);
+        }
+        return managed;
+    }
+
+    resetScope(scopeKey: string): void {
+        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: string, targetIdeType?: string): Promise<void> {
@@ -66,43 +82,52 @@ export class DaemonAgentStreamManager {
  // Can be replaced with CDP-based focus (future implementation)
     }
 
-    async switchActiveAgent(cdp: DaemonCdpManager, agentType: string | null): Promise<void> {
-        if (this._activeAgentType === agentType) return;
+    async switchActiveAgent(cdp: DaemonCdpManager, scopeKey: string, agentType: string | null): Promise<void> {
+        const managed = this.getManagedScope(scopeKey);
+        const previousAgentType = this.getActiveAgentType(scopeKey);
+        if (previousAgentType === agentType) return;
 
-        if (this._activeAgentType) {
-            const prev = this.managed.get(this._activeAgentType);
+        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: DaemonCdpManager): Promise<void> {
-        if (!this.enabled || !this._activeAgentType) return;
+    async syncAgentSessions(cdp: DaemonCdpManager, scopeKey: string): Promise<void> {
+        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) || 10_000;
+        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);
+            const activeTarget = targets.find(t => t.agentType === activeAgentType);
 
-            if (activeTarget && !this.managed.has(this._activeAgentType)) {
-                const adapter = this.allAdapters.find(a => a.agentType === this._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,
@@ -110,34 +135,36 @@ export class DaemonAgentStreamManager {
                             lastError: null,
                             lastHiddenCheckTime: 0,
                         });
-                        this.logFn(`[AgentStream] Connected: ${adapter.agentName}`);
+                        this.logFn(`[AgentStream] Connected: ${adapter.agentName} (${scopeKey})`);
                     }
                 }
             }
 
  // Cleanup inactive agents
-            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) ? 30_000 : 10_000;
+            this.discoveryIntervalMsByScope.set(scopeKey, managed.has(activeAgentType) ? 30_000 : 10_000);
         } catch (e) {
-            this.logFn(`[AgentStream] sync error: ${(e as Error).message}`);
+            this.logFn(`[AgentStream] sync error (${scopeKey}): ${(e as Error).message}`);
         }
     }
 
  /** Collect active agent status */
-    async collectAgentStreams(cdp: DaemonCdpManager): Promise<AgentStreamState[]> {
+    async collectAgentStreams(cdp: DaemonCdpManager, scopeKey: string): Promise<AgentStreamState[]> {
         if (!this.enabled) return [];
 
         const results: AgentStreamState[] = [];
+        const activeAgentType = this.getActiveAgentType(scopeKey);
+        const managed = this.managedByScope.get(scopeKey);
 
-        if (this._activeAgentType && this.managed.has(this._activeAgentType)) {
-            const agent = this.managed.get(this._activeAgentType)!;
-            const type = this._activeAgentType;
+        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 < 30000);
@@ -170,8 +197,8 @@ export class DaemonAgentStreamManager {
                     });
                     if (errorMsg.includes('timeout') || errorMsg.includes('not connected') || errorMsg.includes('Session')) {
                         try { await cdp.detachAgent(agent.sessionId); } catch { }
-                        this.managed.delete(type);
-                        this.lastDiscoveryTime = 0;
+                        managed.delete(type);
+                        this.lastDiscoveryTimeByScope.set(scopeKey, 0);
                     }
                 }
             }
@@ -180,9 +207,9 @@ export class DaemonAgentStreamManager {
         return results;
     }
 
-    async sendToAgent(cdp: DaemonCdpManager, agentType: string, text: string, targetIdeType?: string): Promise<boolean> {
+    async sendToAgent(cdp: DaemonCdpManager, scopeKey: string, agentType: string, text: string, targetIdeType?: string): Promise<boolean> {
         await this.ensureAgentPanelOpen(agentType, targetIdeType);
-        const agent = this.managed.get(agentType);
+        const agent = this.getManagedAgent(agentType, scopeKey);
         if (!agent) return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
@@ -195,9 +222,9 @@ export class DaemonAgentStreamManager {
         }
     }
 
-    async resolveAgentAction(cdp: DaemonCdpManager, agentType: string, action: 'approve' | 'reject', targetIdeType?: string): Promise<boolean> {
+    async resolveAgentAction(cdp: DaemonCdpManager, scopeKey: string, agentType: string, action: 'approve' | 'reject', targetIdeType?: string): Promise<boolean> {
         await this.ensureAgentPanelOpen(agentType, targetIdeType);
-        const agent = this.managed.get(agentType);
+        const agent = this.getManagedAgent(agentType, scopeKey);
         if (!agent) return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
@@ -209,9 +236,9 @@ export class DaemonAgentStreamManager {
         }
     }
 
-    async newAgentSession(cdp: DaemonCdpManager, agentType: string, targetIdeType?: string): Promise<boolean> {
+    async newAgentSession(cdp: DaemonCdpManager, scopeKey: string, agentType: string, targetIdeType?: string): Promise<boolean> {
         await this.ensureAgentPanelOpen(agentType, targetIdeType);
-        const agent = this.managed.get(agentType);
+        const agent = this.getManagedAgent(agentType, scopeKey);
         if (!agent) return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
@@ -224,14 +251,14 @@ export class DaemonAgentStreamManager {
         }
     }
 
-    async listAgentChats(cdp: DaemonCdpManager, agentType: string): Promise<AgentChatListItem[]> {
-        let agent = this.managed.get(agentType);
+    async listAgentChats(cdp: DaemonCdpManager, scopeKey: string, agentType: string): Promise<AgentChatListItem[]> {
+        let agent = this.getManagedAgent(agentType, scopeKey);
  // on-demand: try activate+sync if not in managed list
         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 {
@@ -244,13 +271,13 @@ export class DaemonAgentStreamManager {
         }
     }
 
-    async switchAgentSession(cdp: DaemonCdpManager, agentType: string, sessionId: string): Promise<boolean> {
-        let agent = this.managed.get(agentType);
+    async switchAgentSession(cdp: DaemonCdpManager, scopeKey: string, agentType: string, sessionId: string): Promise<boolean> {
+        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 {
@@ -263,8 +290,8 @@ export class DaemonAgentStreamManager {
         }
     }
 
-    async focusAgentEditor(cdp: DaemonCdpManager, agentType: string): Promise<boolean> {
-        const agent = this.managed.get(agentType);
+    async focusAgentEditor(cdp: DaemonCdpManager, scopeKey: string, agentType: string): Promise<boolean> {
+        const agent = this.getManagedAgent(agentType, scopeKey);
         if (!agent || typeof agent.adapter.focusEditor !== 'function') return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
@@ -277,13 +304,26 @@ export class DaemonAgentStreamManager {
         }
     }
 
-    getConnectedAgents(): string[] { return Array.from(this.managed.keys()); }
-    getManagedAgent(agentType: string): ManagedAgent | undefined { return this.managed.get(agentType); }
+    getConnectedAgents(scopeKey?: string): string[] {
+        if (scopeKey) return Array.from((this.managedByScope.get(scopeKey) || new Map()).keys());
+        return Array.from(this.managedByScope.values()).flatMap(scope => Array.from(scope.keys()));
+    }
+
+    getManagedAgent(agentType: string, scopeKey: string): ManagedAgent | undefined {
+        return this.managedByScope.get(scopeKey)?.get(agentType);
+    }
 
-    async dispose(cdp: DaemonCdpManager): Promise<void> {
-        for (const [, agent] of this.managed) {
-            try { await cdp.detachAgent(agent.sessionId); } catch { }
+    async dispose(cdpManagers: Map<string, DaemonCdpManager>): Promise<void> {
+        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();
     }
 }

package/src/agent-stream/poller.ts

@@ -31,7 +31,6 @@ export interface AgentStreamPollerDeps {
 
 export class AgentStreamPoller {
     private deps: AgentStreamPollerDeps;
-    private _activeIdeType: string | null = null;
     private timer: NodeJS.Timeout | null = null;
 
     constructor(deps: AgentStreamPollerDeps) {
@@ -40,14 +39,12 @@ export class AgentStreamPoller {
 
     /** Currently active IDE type for agent streaming */
     get activeIde(): string | null {
-        return this._activeIdeType;
+        return null;
     }
 
     /** Reset active IDE tracking (e.g., when IDE is stopped) */
     resetActiveIde(ideType: string): void {
-        if (this._activeIdeType === ideType) {
-            this._activeIdeType = null;
-        }
+        this.deps.agentStreamManager.resetScope(ideType);
     }
 
     /** Start polling (idempotent — ignored if already started) */
@@ -113,56 +110,48 @@ export class AgentStreamPoller {
             }
 
             // 1c. If the active agent stream belongs to a now-disabled extension, detach it
-            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: any) => p.type)
                 );
                 if (!enabledExtTypes.has(activeType)) {
                     LOG.info('AgentStream', `Active agent ${activeType} was disabled for ${ideType} — detaching`);
-                    await agentStreamManager.switchActiveAgent(cdp, null);
-                    this._activeIdeType = null;
+                    await agentStreamManager.switchActiveAgent(cdp, ideType, null);
                     // Report empty streams so dashboard removes the tab
                     this.deps.onStreamsUpdated?.(ideType, []);
                 }
             }
-        }
-
-        // ─── Phase 2: Agent session sync + collect ───
-
-        // If agent already connected to a specific IDE, only operate on that CDP
-        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 { }
-                return;
+            if (!cdp.isConnected) {
+                if (activeType) {
+                    agentStreamManager.resetScope(ideType);
+                    this.deps.onStreamsUpdated?.(ideType, []);
+                }
+                continue;
             }
-            // CDP lost — reset
-            this._activeIdeType = null;
-        }
 
-        // ─── Phase 3: Auto-discover agents ───
-        if (!agentStreamManager.activeAgentType) {
-            for (const [ideType, cdp] of cdpManagers) {
-                if (!cdp.isConnected) continue;
+            // ─── Phase 2: Agent session sync + collect ───
+            let resolvedActiveType = activeType;
+
+            // ─── Phase 3: Auto-discover agents ───
+            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})`);
-                        // sync+collect immediately
-                        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 { }
         }
     }
 }

package/src/boot/daemon-lifecycle.ts

@@ -288,9 +288,8 @@ export async function shutdownDaemonComponents(components: DaemonComponents): Pr
 
     // 2. Dispose agent stream
     try {
-        const anyCdp = [...cdpManagers.values()].find(m => m.isConnected);
-        if (agentStreamManager && anyCdp) {
-            await agentStreamManager.dispose(anyCdp);
+        if (agentStreamManager) {
+            await agentStreamManager.dispose(cdpManagers);
         }
     } catch (e: any) { LOG.warn('Shutdown', `AgentStream dispose: ${e?.message}`); }
 

package/src/cdp/manager.ts

@@ -660,9 +660,12 @@ export class DaemonCdpManager {
         try {
  // 1. Find webview iframe targets
             const { targetInfos } = await sendWs('Target.getTargets');
-            const webviewIframes = (targetInfos || []).filter(
-                (t: any) => t.type === 'iframe' && (t.url || '').includes('vscode-webview')
-            );
+            const pageWebviewUrls = await this.getCurrentPageWebviewUrls();
+            const webviewIframes = (targetInfos || []).filter((t: any) => {
+                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');
@@ -766,6 +769,8 @@ export class DaemonCdpManager {
                 allTargets = result?.targetInfos || [];
             }
 
+            const pageWebviewUrls = await this.getCurrentPageWebviewUrls();
+
             const iframes = allTargets.filter((t: any) => t.type === 'iframe');
             const typeMap = new Map<string, number>();
             for (const t of allTargets) {
@@ -794,6 +799,7 @@ export class DaemonCdpManager {
                 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)) {
@@ -963,6 +969,23 @@ export class DaemonCdpManager {
         return this.agentSessions;
     }
 
+    private async getCurrentPageWebviewUrls(): Promise<Set<string>> {
+        if (!this.isConnected) return 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')))`,
+                5000,
+            );
+            const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+            if (!Array.isArray(parsed)) return new Set();
+            return new Set(parsed.filter((src: unknown): src is string => typeof src === 'string' && src.length > 0));
+        } catch {
+            return new Set();
+        }
+    }
+
  // ─── Screenshot ──────────────────────────────────────────
 
     async captureScreenshot(opts?: { quality?: number }): Promise<Buffer | null> {