@adhdev/daemon-core 0.6.79 → 0.7.0

package/src/agent-stream/manager.ts

@@ -11,6 +11,7 @@
 import { DaemonCdpManager, AgentWebviewTarget } from '../cdp/manager.js';
 import { ProviderLoader } from '../providers/provider-loader.js';
 import { ProviderStreamAdapter } from './provider-adapter.js';
+import { SessionRegistry } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
 import type {
     IAgentStreamAdapter,
@@ -21,7 +22,9 @@ import type {
 
 export interface ManagedAgent {
     adapter: IAgentStreamAdapter;
-    sessionId: string;
+    runtimeSessionId: string;
+    parentSessionId: string;
+    cdpSessionId: string;
     target: AgentWebviewTarget;
     lastState: AgentStreamState | null;
     lastError: string | null;
@@ -29,15 +32,19 @@ export interface ManagedAgent {
 }
 
 export class DaemonAgentStreamManager {
-    private allAdapters: IAgentStreamAdapter[] = [];
-    private managedByScope = new Map<string, Map<string, ManagedAgent>>();
+    private adaptersByType = new Map<string, IAgentStreamAdapter>();
+    private managedBySessionId = new Map<string, ManagedAgent>();
     private enabled = true;
     private logFn: (msg: string) => void;
-    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) {
+    private lastDiscoveryTimeByParent = new Map<string, number>();
+    private discoveryIntervalMsByParent = new Map<string, number>();
+    private activeSessionIdByParent = new Map<string, string | null>();
+
+    constructor(
+        logFn?: (msg: string) => void,
+        providerLoader?: ProviderLoader,
+        private readonly sessionRegistry?: SessionRegistry,
+    ) {
         this.logFn = logFn || LOG.forComponent('AgentStream').asLogFn();
 
  // Create adapter for all extension providers
@@ -48,7 +55,7 @@ export class DaemonAgentStreamManager {
                 const resolved = providerLoader.resolve(p.type);
                 if (!resolved) continue;
                 const adapter = new ProviderStreamAdapter(resolved);
-                this.allAdapters.push(adapter);
+                this.adaptersByType.set(p.type, adapter);
                 this.logFn(`[AgentStream] Adapter created: ${p.type} (${p.name}) scripts=${Object.keys(resolved.scripts || {}).join(',') || 'none'}`);
             }
         }
@@ -56,274 +63,290 @@ export class DaemonAgentStreamManager {
 
     setEnabled(enabled: boolean) { this.enabled = enabled; }
     get isEnabled() { return this.enabled; }
-    getActiveAgentType(scopeKey: string): string | null {
-        return this.activeAgentTypeByScope.get(scopeKey) || null;
+    getActiveSessionId(parentSessionId: string): string | null {
+        return this.activeSessionIdByParent.get(parentSessionId) || 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;
+    private getSessionTarget(sessionId: string) {
+        return this.sessionRegistry?.get(sessionId);
     }
 
-    resetScope(scopeKey: string): void {
-        this.managedByScope.delete(scopeKey);
-        this.activeAgentTypeByScope.delete(scopeKey);
-        this.lastDiscoveryTimeByScope.delete(scopeKey);
-        this.discoveryIntervalMsByScope.delete(scopeKey);
+    resetParentSession(parentSessionId: string): void {
+        const activeSessionId = this.activeSessionIdByParent.get(parentSessionId);
+        if (activeSessionId) this.managedBySessionId.delete(activeSessionId);
+        for (const child of this.sessionRegistry?.listChildren(parentSessionId) || []) {
+            this.managedBySessionId.delete(child.sessionId);
+        }
+        this.activeSessionIdByParent.delete(parentSessionId);
+        this.lastDiscoveryTimeByParent.delete(parentSessionId);
+        this.discoveryIntervalMsByParent.delete(parentSessionId);
     }
 
  /** Panel focus based on provider.js focusPanel or extensionId (currently no-op) */
-    async ensureAgentPanelOpen(agentType: string, targetIdeType?: string): Promise<void> {
+    async ensureSessionPanelOpen(_sessionId: string): Promise<void> {
  // Extension was removed, so localServer-based panel focus no longer works
  // Can be replaced with CDP-based focus (future implementation)
     }
 
-    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;
+    async setActiveSession(cdp: DaemonCdpManager, parentSessionId: string, sessionId: string | null): Promise<void> {
+        const previousSessionId = this.getActiveSessionId(parentSessionId);
+        if (previousSessionId === sessionId) return;
 
-        if (previousAgentType) {
-            const prev = managed.get(previousAgentType);
+        if (previousSessionId) {
+            const prev = this.managedBySessionId.get(previousSessionId);
             if (prev) {
-                try { await cdp.detachAgent(prev.sessionId); } catch { }
-                managed.delete(previousAgentType);
-                this.logFn(`[AgentStream] Deactivated: ${prev.adapter.agentName} (${scopeKey})`);
+                try { await cdp.detachAgent(prev.cdpSessionId); } catch { }
+                this.managedBySessionId.delete(previousSessionId);
+                this.logFn(`[AgentStream] Deactivated: ${prev.adapter.agentName} (${parentSessionId})`);
             }
         }
 
-        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'}`);
+        this.activeSessionIdByParent.set(parentSessionId, sessionId);
+        this.lastDiscoveryTimeByParent.set(parentSessionId, 0);
+        this.logFn(`[AgentStream] Active session (${parentSessionId}): ${sessionId || 'none'}`);
+    }
+
+    private resolveSessionIdForTarget(parentSessionId: string, agentType: string): string | null {
+        const child = (this.sessionRegistry?.listChildren(parentSessionId) || [])
+            .find((entry) => entry.providerCategory === 'extension' && entry.providerType === agentType);
+        return child?.sessionId || null;
+    }
+
+    private async connectManagedSession(
+        cdp: DaemonCdpManager,
+        parentSessionId: string,
+        runtimeSessionId: string,
+    ): Promise<ManagedAgent | null> {
+        const target = this.getSessionTarget(runtimeSessionId);
+        if (!target || target.providerCategory !== 'extension') return null;
+        const adapter = this.adaptersByType.get(target.providerType);
+        if (!adapter) return null;
+        const targets = await cdp.discoverAgentWebviews();
+        const activeTarget = targets.find((entry) => entry.agentType === target.providerType);
+        if (!activeTarget) return null;
+        const cdpSessionId = await cdp.attachToAgent(activeTarget);
+        if (!cdpSessionId) return null;
+        const managed: ManagedAgent = {
+            adapter,
+            runtimeSessionId,
+            parentSessionId,
+            cdpSessionId,
+            target: activeTarget,
+            lastState: null,
+            lastError: null,
+            lastHiddenCheckTime: 0,
+        };
+        this.managedBySessionId.set(runtimeSessionId, managed);
+        this.logFn(`[AgentStream] Connected: ${adapter.agentName} (${parentSessionId})`);
+        return managed;
     }
 
- /** Agent webview discovery + session connection */
-    async syncAgentSessions(cdp: DaemonCdpManager, scopeKey: string): Promise<void> {
-        const activeAgentType = this.getActiveAgentType(scopeKey);
-        if (!this.enabled || !activeAgentType) return;
+    /** Agent webview discovery + session connection */
+    async syncActiveSession(cdp: DaemonCdpManager, parentSessionId: string): Promise<void> {
+        const activeSessionId = this.getActiveSessionId(parentSessionId);
+        if (!this.enabled || !activeSessionId) return;
 
         const now = Date.now();
-        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) {
+        const managed = this.managedBySessionId.get(activeSessionId);
+        const lastDiscoveryTime = this.lastDiscoveryTimeByParent.get(parentSessionId) || 0;
+        const discoveryIntervalMs = this.discoveryIntervalMsByParent.get(parentSessionId) || 10_000;
+        if (managed && (now - lastDiscoveryTime) < discoveryIntervalMs) {
             return;
         }
-        this.lastDiscoveryTimeByScope.set(scopeKey, now);
+        this.lastDiscoveryTimeByParent.set(parentSessionId, now);
 
         try {
-            const targets = await cdp.discoverAgentWebviews();
-            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) {
-                        managed.set(activeAgentType, {
-                            adapter,
-                            sessionId,
-                            target: activeTarget,
-                            lastState: null,
-                            lastError: null,
-                            lastHiddenCheckTime: 0,
-                        });
-                        this.logFn(`[AgentStream] Connected: ${adapter.agentName} (${scopeKey})`);
-                    }
-                }
-            }
-
- // Cleanup inactive agents
-            for (const [type, agent] of managed) {
-                if (type !== activeAgentType) {
-                    await cdp.detachAgent(agent.sessionId);
-                    managed.delete(type);
-                }
+            if (!managed) {
+                await this.connectManagedSession(cdp, parentSessionId, activeSessionId);
             }
-
-            this.discoveryIntervalMsByScope.set(scopeKey, managed.has(activeAgentType) ? 30_000 : 10_000);
+            this.discoveryIntervalMsByParent.set(parentSessionId, this.managedBySessionId.has(activeSessionId) ? 30_000 : 10_000);
         } catch (e) {
-            this.logFn(`[AgentStream] sync error (${scopeKey}): ${(e as Error).message}`);
+            this.logFn(`[AgentStream] sync error (${parentSessionId}): ${(e as Error).message}`);
         }
     }
 
- /** Collect active agent status */
-    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 (activeAgentType && managed?.has(activeAgentType)) {
-            const agent = managed.get(activeAgentType)!;
-            const type = activeAgentType;
+    /** Collect active extension session state */
+    async collectActiveSession(cdp: DaemonCdpManager, parentSessionId: string): Promise<AgentStreamState | null> {
+        if (!this.enabled) return null;
+        const activeSessionId = this.getActiveSessionId(parentSessionId);
+        if (!activeSessionId) return null;
+        let agent = this.managedBySessionId.get(activeSessionId);
+        if (!agent) {
+            agent = await this.connectManagedSession(cdp, parentSessionId, activeSessionId) || undefined;
+        }
+        if (!agent) return null;
+        const type = agent.adapter.agentType;
+        const isHidden = agent.lastState?.status === 'panel_hidden';
+        const hiddenCacheFresh = isHidden && (Date.now() - agent.lastHiddenCheckTime < 30000);
 
-            const isHidden = agent.lastState?.status === 'panel_hidden';
-            const hiddenCacheFresh = isHidden && (Date.now() - agent.lastHiddenCheckTime < 30000);
+        if (hiddenCacheFresh) return agent.lastState!;
 
-            if (hiddenCacheFresh) {
-                results.push(agent.lastState!);
-            } else {
-                try {
-                    const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                        cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
-                    const state = await agent.adapter.readChat(evaluate);
-                    LOG.debug('AgentStream', `[AgentStream] readChat(${type}) result: status=${state.status} msgs=${state.messages?.length || 0} model=${state.model || ''}${state.status === 'error' ? ' error=' + JSON.stringify((state as any).error || (state as any)._error || 'unknown') : ''}`);
-                    agent.lastState = state;
-                    agent.lastError = null;
-                    if (state.status === 'panel_hidden') {
-                        agent.lastHiddenCheckTime = Date.now();
-                    }
-                    results.push(state);
-                } catch (e) {
-                    const errorMsg = (e as Error)?.message || String(e);
-                    this.logFn(`[AgentStream] readChat(${type}) error: ${errorMsg.slice(0, 200)}`);
-                    agent.lastError = errorMsg;
-                    results.push({
-                        agentType: type,
-                        agentName: agent.adapter.agentName,
-                        extensionId: agent.adapter.extensionId,
-                        status: 'disconnected',
-                        messages: agent.lastState?.messages || [],
-                        inputContent: '',
-                    });
-                    if (errorMsg.includes('timeout') || errorMsg.includes('not connected') || errorMsg.includes('Session')) {
-                        try { await cdp.detachAgent(agent.sessionId); } catch { }
-                        managed.delete(type);
-                        this.lastDiscoveryTimeByScope.set(scopeKey, 0);
-                    }
-                }
+        try {
+            const evaluate: AgentEvaluateFn = (expr, timeout) =>
+                cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
+            const state = await agent.adapter.readChat(evaluate);
+            LOG.debug('AgentStream', `[AgentStream] readChat(${type}) result: status=${state.status} msgs=${state.messages?.length || 0} model=${state.model || ''}${state.status === 'error' ? ' error=' + JSON.stringify((state as any).error || (state as any)._error || 'unknown') : ''}`);
+            agent.lastState = state;
+            agent.lastError = null;
+            if (state.status === 'panel_hidden') {
+                agent.lastHiddenCheckTime = Date.now();
             }
+            return state;
+        } catch (e) {
+            const errorMsg = (e as Error)?.message || String(e);
+            this.logFn(`[AgentStream] readChat(${type}) error: ${errorMsg.slice(0, 200)}`);
+            agent.lastError = errorMsg;
+            if (errorMsg.includes('timeout') || errorMsg.includes('not connected') || errorMsg.includes('Session')) {
+                try { await cdp.detachAgent(agent.cdpSessionId); } catch { }
+                this.managedBySessionId.delete(activeSessionId);
+                this.lastDiscoveryTimeByParent.set(parentSessionId, 0);
+            }
+            return {
+                agentType: type,
+                agentName: agent.adapter.agentName,
+                extensionId: agent.adapter.extensionId,
+                status: 'disconnected',
+                messages: agent.lastState?.messages || [],
+                inputContent: '',
+            };
         }
-
-        return results;
     }
 
-    async sendToAgent(cdp: DaemonCdpManager, scopeKey: string, agentType: string, text: string, targetIdeType?: string): Promise<boolean> {
-        await this.ensureAgentPanelOpen(agentType, targetIdeType);
-        const agent = this.getManagedAgent(agentType, scopeKey);
+    async sendToSession(cdp: DaemonCdpManager, sessionId: string, text: string): Promise<boolean> {
+        await this.ensureSessionPanelOpen(sessionId);
+        const target = this.getSessionTarget(sessionId);
+        if (!target?.parentSessionId) return false;
+        await this.setActiveSession(cdp, target.parentSessionId, sessionId);
+        await this.syncActiveSession(cdp, target.parentSessionId);
+        const agent = this.managedBySessionId.get(sessionId);
         if (!agent) return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
+                cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
             await agent.adapter.sendMessage(evaluate, text);
             return true;
         } catch (e) {
-            this.logFn(`[AgentStream] sendToAgent(${agentType}) error: ${(e as Error).message}`);
+            this.logFn(`[AgentStream] sendToSession(${sessionId}) error: ${(e as Error).message}`);
             return false;
         }
     }
 
-    async resolveAgentAction(cdp: DaemonCdpManager, scopeKey: string, agentType: string, action: 'approve' | 'reject', targetIdeType?: string): Promise<boolean> {
-        await this.ensureAgentPanelOpen(agentType, targetIdeType);
-        const agent = this.getManagedAgent(agentType, scopeKey);
+    async resolveSessionAction(cdp: DaemonCdpManager, sessionId: string, action: 'approve' | 'reject'): Promise<boolean> {
+        await this.ensureSessionPanelOpen(sessionId);
+        const target = this.getSessionTarget(sessionId);
+        if (!target?.parentSessionId) return false;
+        await this.setActiveSession(cdp, target.parentSessionId, sessionId);
+        await this.syncActiveSession(cdp, target.parentSessionId);
+        const agent = this.managedBySessionId.get(sessionId);
         if (!agent) return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
+                cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
             return await agent.adapter.resolveAction(evaluate, action);
         } catch (e) {
-            this.logFn(`[AgentStream] resolveAction(${agentType}) error: ${(e as Error).message}`);
+            this.logFn(`[AgentStream] resolveAction(${sessionId}) error: ${(e as Error).message}`);
             return false;
         }
     }
 
-    async newAgentSession(cdp: DaemonCdpManager, scopeKey: string, agentType: string, targetIdeType?: string): Promise<boolean> {
-        await this.ensureAgentPanelOpen(agentType, targetIdeType);
-        const agent = this.getManagedAgent(agentType, scopeKey);
+    async newSession(cdp: DaemonCdpManager, sessionId: string): Promise<boolean> {
+        await this.ensureSessionPanelOpen(sessionId);
+        const target = this.getSessionTarget(sessionId);
+        if (!target?.parentSessionId) return false;
+        await this.setActiveSession(cdp, target.parentSessionId, sessionId);
+        await this.syncActiveSession(cdp, target.parentSessionId);
+        const agent = this.managedBySessionId.get(sessionId);
         if (!agent) return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
+                cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
             await agent.adapter.newSession(evaluate);
             return true;
         } catch (e) {
-            this.logFn(`[AgentStream] newSession(${agentType}) error: ${(e as Error).message}`);
+            this.logFn(`[AgentStream] newSession(${sessionId}) error: ${(e as Error).message}`);
             return false;
         }
     }
 
-    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 in ${scopeKey}, trying on-demand activation`);
-            await this.switchActiveAgent(cdp, scopeKey, agentType);
-            await this.syncAgentSessions(cdp, scopeKey);
-            agent = this.getManagedAgent(agentType, scopeKey);
-        }
+    async listSessionChats(cdp: DaemonCdpManager, sessionId: string): Promise<AgentChatListItem[]> {
+        const target = this.getSessionTarget(sessionId);
+        if (!target?.parentSessionId) return [];
+        await this.setActiveSession(cdp, target.parentSessionId, sessionId);
+        await this.syncActiveSession(cdp, target.parentSessionId);
+        const agent = this.managedBySessionId.get(sessionId);
         if (!agent || typeof agent.adapter.listChats !== 'function') return [];
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                cdp.evaluateInSessionFrame(agent!.sessionId, expr, timeout);
+                cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
             return await agent.adapter.listChats(evaluate);
         } catch (e) {
-            this.logFn(`[AgentStream] listChats(${agentType}) error: ${(e as Error).message}`);
+            this.logFn(`[AgentStream] listChats(${sessionId}) error: ${(e as Error).message}`);
             return [];
         }
     }
 
-    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 in ${scopeKey}, trying on-demand activation`);
-            await this.switchActiveAgent(cdp, scopeKey, agentType);
-            await this.syncAgentSessions(cdp, scopeKey);
-            agent = this.getManagedAgent(agentType, scopeKey);
-        }
+    async switchConversation(cdp: DaemonCdpManager, sessionId: string, conversationId: string): Promise<boolean> {
+        const target = this.getSessionTarget(sessionId);
+        if (!target?.parentSessionId) return false;
+        await this.setActiveSession(cdp, target.parentSessionId, sessionId);
+        await this.syncActiveSession(cdp, target.parentSessionId);
+        const agent = this.managedBySessionId.get(sessionId);
         if (!agent || typeof agent.adapter.switchSession !== 'function') return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                cdp.evaluateInSessionFrame(agent!.sessionId, expr, timeout);
-            return await agent.adapter.switchSession(evaluate, sessionId);
+                cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
+            return await agent.adapter.switchSession(evaluate, conversationId);
         } catch (e) {
-            this.logFn(`[AgentStream] switchSession(${agentType}) error: ${(e as Error).message}`);
+            this.logFn(`[AgentStream] switchSession(${sessionId}) error: ${(e as Error).message}`);
             return false;
         }
     }
 
-    async focusAgentEditor(cdp: DaemonCdpManager, scopeKey: string, agentType: string): Promise<boolean> {
-        const agent = this.getManagedAgent(agentType, scopeKey);
+    async focusSession(cdp: DaemonCdpManager, sessionId: string): Promise<boolean> {
+        const target = this.getSessionTarget(sessionId);
+        if (!target?.parentSessionId) return false;
+        await this.setActiveSession(cdp, target.parentSessionId, sessionId);
+        await this.syncActiveSession(cdp, target.parentSessionId);
+        const agent = this.managedBySessionId.get(sessionId);
         if (!agent || typeof agent.adapter.focusEditor !== 'function') return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
+                cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
             await agent.adapter.focusEditor(evaluate);
             return true;
         } catch (e) {
-            this.logFn(`[AgentStream] focusEditor(${agentType}) error: ${(e as Error).message}`);
+            this.logFn(`[AgentStream] focusEditor(${sessionId}) error: ${(e as Error).message}`);
             return false;
         }
     }
 
-    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()));
+    getConnectedSessions(parentSessionId?: string): string[] {
+        if (parentSessionId) {
+            return [...this.managedBySessionId.values()]
+                .filter((entry) => entry.parentSessionId === parentSessionId)
+                .map((entry) => entry.runtimeSessionId);
+        }
+        return [...this.managedBySessionId.keys()];
     }
 
-    getManagedAgent(agentType: string, scopeKey: string): ManagedAgent | undefined {
-        return this.managedByScope.get(scopeKey)?.get(agentType);
+    getManagedSession(sessionId: string): ManagedAgent | undefined {
+        return this.managedBySessionId.get(sessionId);
     }
 
     async dispose(cdpManagers: Map<string, DaemonCdpManager>): Promise<void> {
-        for (const [scopeKey, managed] of this.managedByScope) {
-            const cdp = cdpManagers.get(scopeKey);
+        for (const managed of this.managedBySessionId.values()) {
+            const managerKey = this.getSessionTarget(managed.runtimeSessionId)?.cdpManagerKey;
+            const cdp = managerKey ? cdpManagers.get(managerKey) : null;
             if (!cdp) continue;
-            for (const [, agent] of managed) {
-                try { await cdp.detachAgent(agent.sessionId); } catch { }
-            }
+            try { await cdp.detachAgent(managed.cdpSessionId); } catch { }
         }
-        this.managedByScope.clear();
-        this.activeAgentTypeByScope.clear();
-        this.lastDiscoveryTimeByScope.clear();
-        this.discoveryIntervalMsByScope.clear();
+        this.managedBySessionId.clear();
+        this.activeSessionIdByParent.clear();
+        this.lastDiscoveryTimeByParent.clear();
+        this.discoveryIntervalMsByParent.clear();
+    }
+
+    resolveSessionForAgent(parentSessionId: string, agentType: string): string | null {
+        return this.resolveSessionIdForTarget(parentSessionId, agentType);
     }
 }