@adhdev/daemon-core 0.6.77 → 0.7.0

package/dist/index.js

@@ -1788,10 +1788,7 @@ __export(index_exports, {
   ProviderLoader: () => ProviderLoader,
   VersionArchive: () => VersionArchive,
   addCliHistory: () => addCliHistory,
-  buildAllManagedEntries: () => buildAllManagedEntries,
-  buildManagedAcps: () => buildManagedAcps,
-  buildManagedClis: () => buildManagedClis,
-  buildManagedIdes: () => buildManagedIdes,
+  buildSessionEntries: () => buildSessionEntries,
   buildStatusSnapshot: () => buildStatusSnapshot,
   connectCdpManager: () => connectCdpManager,
   detectAllVersions: () => detectAllVersions,
@@ -1814,6 +1811,8 @@ __export(index_exports, {
   isCdpConnected: () => isCdpConnected,
   isExtensionInstalled: () => isExtensionInstalled,
   isIdeRunning: () => isIdeRunning,
+  isManagedStatusWaiting: () => isManagedStatusWaiting,
+  isManagedStatusWorking: () => isManagedStatusWorking,
   isSetupComplete: () => isSetupComplete,
   killIdeProcess: () => killIdeProcess,
   launchIDE: () => launchIDE,
@@ -1821,6 +1820,8 @@ __export(index_exports, {
   loadConfig: () => loadConfig,
   logCommand: () => logCommand,
   markSetupComplete: () => markSetupComplete,
+  normalizeActiveChatData: () => normalizeActiveChatData,
+  normalizeManagedStatus: () => normalizeManagedStatus,
   probeCdpPort: () => probeCdpPort,
   readChatHistory: () => readChatHistory,
   registerExtensionProviders: () => registerExtensionProviders,
@@ -2711,9 +2712,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 +2804,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 +2830,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({
@@ -2850,7 +2856,11 @@ var DaemonCdpManager = class {
   async attachToAgent(target) {
     if (!this.isConnected) return null;
     for (const [sid, t] of this.agentSessions) {
-      if (t.agentType === target.agentType) return sid;
+      if (t.targetId === target.targetId) return sid;
+      if (t.agentType === target.agentType && t.targetId !== target.targetId) {
+        await this.detachAgent(sid).catch(() => {
+        });
+      }
     }
     try {
       const sendFn = this._browserConnected ? this.sendBrowser.bind(this) : this.sendInternal.bind(this);
@@ -2972,6 +2982,36 @@ var DaemonCdpManager = class {
   getAgentSessions() {
     return this.agentSessions;
   }
+  async getCurrentPageWebviewUrls() {
+    if (!this.isConnected) return /* @__PURE__ */ new Set();
+    try {
+      const urls = /* @__PURE__ */ new Set();
+      const { frameTree } = await this.sendInternal("Page.getFrameTree", {}, 5e3);
+      const visit = (node) => {
+        const url = node?.frame?.url;
+        if (typeof url === "string" && url.includes("vscode-webview")) {
+          urls.add(url);
+        }
+        for (const child of node?.childFrames || []) visit(child);
+      };
+      if (frameTree) visit(frameTree);
+      if (urls.size > 0) return urls;
+    } catch {
+    }
+    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;
@@ -4109,7 +4149,7 @@ function registerExtensionProviders(providerLoader, manager, ideType) {
   manager.setExtensionProviders(enabledExtProviders);
 }
 async function setupIdeInstance(ctx, opts) {
-  const { providerLoader, instanceManager, instanceIdMap } = ctx;
+  const { providerLoader, instanceManager, sessionRegistry } = ctx;
   const { ideType, manager, settings } = opts;
   const managerKey = opts.managerKey || ideType;
   registerExtensionProviders(providerLoader, manager, ideType);
@@ -4125,14 +4165,30 @@ async function setupIdeInstance(ctx, opts) {
     serverConn: ctx.serverConn,
     settings: resolvedSettings
   });
-  instanceIdMap.set(ideInstance.getInstanceId(), managerKey);
+  sessionRegistry.register({
+    sessionId: ideInstance.getInstanceId(),
+    parentSessionId: null,
+    providerType: ideType,
+    providerCategory: "ide",
+    transport: "cdp-page",
+    cdpManagerKey: managerKey,
+    instanceKey: `ide:${managerKey}`
+  });
   const extensionProviders = providerLoader.getEnabledByCategory("extension", ideType);
   for (const extProvider of extensionProviders) {
     const extSettings = providerLoader.getSettings(extProvider.type);
     await ideInstance.addExtension(extProvider, extSettings);
-    for (const ext of ideInstance.getExtensionInstances()) {
-      instanceIdMap.set(ext.getInstanceId(), managerKey);
-    }
+  }
+  for (const ext of ideInstance.getExtensionInstances()) {
+    sessionRegistry.register({
+      sessionId: ext.getInstanceId(),
+      parentSessionId: ideInstance.getInstanceId(),
+      providerType: ext.type,
+      providerCategory: "extension",
+      transport: "cdp-webview",
+      cdpManagerKey: managerKey,
+      instanceKey: `ide:${managerKey}`
+    });
   }
   return ideInstance;
 }
@@ -4349,6 +4405,7 @@ var DaemonCdpInitializer = class {
   async connectIdePort(port, ide) {
     const { providerLoader, cdpManagers } = this.config;
     const targets = await DaemonCdpManager.listAllTargets(port);
+    await this.pruneStaleManagers(port, ide, targets);
     if (targets.length === 0) {
       if (cdpManagers.has(ide)) return;
       if (!await probeCdpPort(port)) return;
@@ -4401,6 +4458,34 @@ var DaemonCdpInitializer = class {
       }
     }
   }
+  async pruneStaleManagers(port, ide, targets) {
+    const trackedTargetIds = new Set(targets.map((target) => target.id));
+    const removals = [];
+    for (const [key, manager] of this.config.cdpManagers.entries()) {
+      if (!(key === ide || key.startsWith(`${ide}_`))) continue;
+      if (manager.getPort() !== port) continue;
+      if (targets.length === 0) {
+        removals.push({ key, manager, reason: "ide_closed" });
+        continue;
+      }
+      if (manager.targetId && !trackedTargetIds.has(manager.targetId)) {
+        removals.push({ key, manager, reason: "target_closed" });
+        continue;
+      }
+      if (key === ide && !manager.targetId && targets.length > 1) {
+        removals.push({ key, manager, reason: "target_rekeyed" });
+      }
+    }
+    for (const { key, manager, reason } of removals) {
+      try {
+        manager.disconnect();
+      } catch {
+      }
+      this.config.cdpManagers.delete(key);
+      LOG.info("CDP", `Removed stale manager: ${key} (${reason})`);
+      await this.config.onDisconnected?.(ide, manager, key, reason);
+    }
+  }
   // ─── Periodic scanning ───
   /**
    * Start periodic scanning for newly opened IDEs.
@@ -4443,6 +4528,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);
@@ -4465,95 +4589,152 @@ function isCdpConnected(cdpManagers, key) {
   const m = findCdpManager(cdpManagers, key);
   return m?.isConnected ?? false;
 }
-function buildManagedIdes(ideStates, cdpManagers, opts) {
-  const result = [];
-  for (const state of ideStates) {
-    const cdpConnected = state.cdpConnected ?? isCdpConnected(cdpManagers, state.type);
-    result.push({
-      ideType: state.type,
-      ideVersion: "",
-      instanceId: state.instanceId || state.type,
-      workspace: state.workspace || null,
-      terminals: 0,
-      aiAgents: [],
-      activeChat: state.activeChat,
-      chats: [],
-      agentStreams: state.extensions.map((ext) => ({
-        agentType: ext.type,
-        agentName: ext.name,
-        extensionId: ext.type,
-        status: ext.status || "idle",
-        messages: ext.activeChat?.messages || [],
-        inputContent: ext.activeChat?.inputContent || "",
-        activeModal: ext.activeChat?.activeModal || null
-      })),
-      cdpConnected,
-      currentModel: state.currentModel,
-      currentPlan: state.currentPlan,
-      currentAutoApprove: state.currentAutoApprove
-    });
-  }
-  if (opts?.detectedIdes) {
-    const coveredTypes = new Set(ideStates.map((s) => s.type));
-    for (const ide of opts.detectedIdes) {
-      if (!ide.installed || coveredTypes.has(ide.id)) continue;
-      if (!isCdpConnected(cdpManagers, ide.id)) continue;
-      result.push({
-        ideType: ide.id,
-        ideVersion: "",
-        instanceId: ide.id,
-        workspace: null,
-        terminals: 0,
-        aiAgents: [],
-        activeChat: null,
-        chats: [],
-        agentStreams: [],
-        cdpConnected: true,
-        currentModel: void 0,
-        currentPlan: void 0
-      });
-    }
-  }
-  return result;
+var IDE_SESSION_CAPABILITIES = [
+  "read_chat",
+  "send_message",
+  "new_session",
+  "list_sessions",
+  "switch_session",
+  "resolve_action",
+  "change_model",
+  "set_mode",
+  "set_thought_level"
+];
+var EXTENSION_SESSION_CAPABILITIES = [
+  "read_chat",
+  "send_message",
+  "new_session",
+  "list_sessions",
+  "switch_session",
+  "resolve_action",
+  "change_model",
+  "set_mode"
+];
+var PTY_SESSION_CAPABILITIES = [
+  "read_chat",
+  "send_message",
+  "resolve_action",
+  "terminal_io",
+  "resize_terminal"
+];
+var ACP_SESSION_CAPABILITIES = [
+  "read_chat",
+  "send_message",
+  "new_session",
+  "resolve_action",
+  "change_model",
+  "set_mode",
+  "set_thought_level"
+];
+function buildIdeWorkspaceSession(state, cdpManagers) {
+  const activeChat = normalizeActiveChatData(state.activeChat);
+  const title = activeChat?.title || state.name;
+  return {
+    id: state.instanceId || state.type,
+    parentId: null,
+    providerType: state.type,
+    providerName: state.name,
+    kind: "workspace",
+    transport: "cdp-page",
+    status: normalizeManagedStatus(activeChat?.status || state.status, {
+      activeModal: activeChat?.activeModal || null
+    }),
+    title,
+    workspace: state.workspace || null,
+    activeChat,
+    capabilities: IDE_SESSION_CAPABILITIES,
+    cdpConnected: state.cdpConnected ?? isCdpConnected(cdpManagers, state.type),
+    currentModel: state.currentModel,
+    currentPlan: state.currentPlan,
+    currentAutoApprove: state.currentAutoApprove,
+    errorMessage: state.errorMessage,
+    errorReason: state.errorReason
+  };
 }
-function buildManagedClis(cliStates) {
-  return cliStates.map((s) => ({
-    id: s.instanceId,
-    instanceId: s.instanceId,
-    cliType: s.type,
-    cliName: s.name,
-    status: s.status,
-    mode: "terminal",
-    workspace: s.workspace || "",
-    activeChat: s.activeChat
-  }));
+function buildExtensionAgentSession(parent, ext) {
+  const activeChat = normalizeActiveChatData(ext.activeChat);
+  return {
+    id: ext.instanceId || `${parent.instanceId}:${ext.type}`,
+    parentId: parent.instanceId || parent.type,
+    providerType: ext.type,
+    providerName: ext.name,
+    kind: "agent",
+    transport: "cdp-webview",
+    status: normalizeManagedStatus(activeChat?.status || ext.status, {
+      activeModal: activeChat?.activeModal || null
+    }),
+    title: activeChat?.title || ext.name,
+    workspace: parent.workspace || null,
+    activeChat,
+    capabilities: EXTENSION_SESSION_CAPABILITIES,
+    currentModel: ext.currentModel,
+    currentPlan: ext.currentPlan,
+    errorMessage: ext.errorMessage,
+    errorReason: ext.errorReason
+  };
 }
-function buildManagedAcps(acpStates) {
-  return acpStates.map((s) => ({
-    id: s.instanceId,
-    acpType: s.type,
-    acpName: s.name,
-    status: s.status,
-    mode: "chat",
-    workspace: s.workspace || "",
-    activeChat: s.activeChat,
-    currentModel: s.currentModel,
-    currentPlan: s.currentPlan,
-    acpConfigOptions: s.acpConfigOptions,
-    acpModes: s.acpModes,
-    errorMessage: s.errorMessage,
-    errorReason: s.errorReason
-  }));
+function buildCliSession(state) {
+  const activeChat = normalizeActiveChatData(state.activeChat);
+  return {
+    id: state.instanceId,
+    parentId: null,
+    providerType: state.type,
+    providerName: state.name,
+    kind: "agent",
+    transport: "pty",
+    status: normalizeManagedStatus(activeChat?.status || state.status, {
+      activeModal: activeChat?.activeModal || null
+    }),
+    title: activeChat?.title || state.name,
+    workspace: state.workspace || null,
+    activeChat,
+    capabilities: PTY_SESSION_CAPABILITIES,
+    errorMessage: state.errorMessage,
+    errorReason: state.errorReason
+  };
+}
+function buildAcpSession(state) {
+  const activeChat = normalizeActiveChatData(state.activeChat);
+  return {
+    id: state.instanceId,
+    parentId: null,
+    providerType: state.type,
+    providerName: state.name,
+    kind: "agent",
+    transport: "acp",
+    status: normalizeManagedStatus(activeChat?.status || state.status, {
+      activeModal: activeChat?.activeModal || null
+    }),
+    title: activeChat?.title || state.name,
+    workspace: state.workspace || null,
+    activeChat,
+    capabilities: ACP_SESSION_CAPABILITIES,
+    currentModel: state.currentModel,
+    currentPlan: state.currentPlan,
+    acpConfigOptions: state.acpConfigOptions,
+    acpModes: state.acpModes,
+    errorMessage: state.errorMessage,
+    errorReason: state.errorReason
+  };
 }
-function buildAllManagedEntries(allStates, cdpManagers, opts) {
+function buildSessionEntries(allStates, cdpManagers) {
+  const sessions = [];
   const ideStates = allStates.filter((s) => s.category === "ide");
   const cliStates = allStates.filter((s) => s.category === "cli");
   const acpStates = allStates.filter((s) => s.category === "acp");
-  return {
-    managedIdes: buildManagedIdes(ideStates, cdpManagers, opts),
-    managedClis: buildManagedClis(cliStates),
-    managedAcps: buildManagedAcps(acpStates)
-  };
+  for (const state of ideStates) {
+    sessions.push(buildIdeWorkspaceSession(state, cdpManagers));
+    for (const ext of state.extensions) {
+      sessions.push(buildExtensionAgentSession(state, ext));
+    }
+  }
+  for (const state of cliStates) {
+    sessions.push(buildCliSession(state));
+  }
+  for (const state of acpStates) {
+    sessions.push(buildAcpSession(state));
+  }
+  return sessions;
 }
 
 // src/commands/handler.ts
@@ -4562,14 +4743,37 @@ init_logger();
 
 // src/commands/chat-commands.ts
 init_logger();
+var RECENT_SEND_WINDOW_MS = 1200;
+var recentSendByTarget = /* @__PURE__ */ new Map();
+function getCurrentProviderType(h, fallback = "") {
+  return h.currentSession?.providerType || h.currentProviderType || fallback;
+}
+function getCurrentManagerKey(h) {
+  return h.currentSession?.cdpManagerKey || h.currentManagerKey || "";
+}
 function getTargetedCliAdapter(h, args, providerType) {
-  return h.getCliAdapter(args?._targetInstance || h.currentIdeType || providerType);
+  return h.getCliAdapter(args?.targetSessionId || providerType || h.currentSession?.providerType || h.currentManagerKey);
+}
+function buildRecentSendKey(h, args, provider, text) {
+  const target = args?.targetSessionId || args?.agentType || h.currentSession?.providerType || h.currentProviderType || h.currentManagerKey || "unknown";
+  return `${provider?.category || "unknown"}:${target}:${text.trim()}`;
+}
+function isRecentDuplicateSend(key) {
+  const now = Date.now();
+  for (const [candidate, ts2] of recentSendByTarget.entries()) {
+    if (now - ts2 > RECENT_SEND_WINDOW_MS) recentSendByTarget.delete(candidate);
+  }
+  const previous = recentSendByTarget.get(key);
+  if (previous && now - previous <= RECENT_SEND_WINDOW_MS) return true;
+  recentSendByTarget.set(key, now);
+  return false;
 }
 async function handleChatHistory(h, args) {
-  const { agentType, offset, limit, instanceId } = args;
+  const { agentType, offset, limit } = args;
+  const instanceId = args?.targetSessionId;
   try {
     const provider = h.getProvider(agentType);
-    const agentStr = provider?.type || agentType || h.currentIdeType || "";
+    const agentStr = provider?.type || agentType || getCurrentProviderType(h);
     const result = readChatHistory(agentStr, offset || 0, limit || 30, instanceId);
     return { success: true, ...result, agent: agentStr };
   } catch (e) {
@@ -4613,7 +4817,7 @@ async function handleReadChat(h, args) {
             provider.type || "unknown_extension",
             parsed.messages || [],
             parsed.title,
-            args?.instanceId
+            args?.targetSessionId
           );
           return { success: true, ...parsed };
         }
@@ -4623,15 +4827,18 @@ async function handleReadChat(h, args) {
     }
     if (h.agentStream) {
       const cdp2 = h.getCdp();
-      if (cdp2) {
-        const streams = await h.agentStream.collectAgentStreams(cdp2);
-        const stream = streams.find((s) => s.agentType === provider.type);
+      const parentSessionId = h.currentSession?.parentSessionId;
+      if (cdp2 && parentSessionId) {
+        const stream = await h.agentStream.collectActiveSession(cdp2, parentSessionId);
+        if (stream?.agentType !== provider.type) {
+          return { success: true, messages: [], status: "idle" };
+        }
         if (stream) {
           h.historyWriter.appendNewMessages(
             stream.agentType,
             stream.messages || [],
             void 0,
-            args?.instanceId
+            args?.targetSessionId
           );
           return { success: true, messages: stream.messages || [], status: stream.status, agentType: stream.agentType };
         }
@@ -4658,10 +4865,10 @@ async function handleReadChat(h, args) {
         if (parsed && typeof parsed === "object") {
           _log(`Webview OK: ${parsed.messages?.length || 0} msgs`);
           h.historyWriter.appendNewMessages(
-            provider?.type || h.currentIdeType || "unknown_webview",
+            provider?.type || getCurrentProviderType(h, "unknown_webview"),
             parsed.messages || [],
             parsed.title,
-            args?.instanceId
+            args?.targetSessionId
           );
           return { success: true, ...parsed };
         }
@@ -4685,10 +4892,10 @@ async function handleReadChat(h, args) {
       if (parsed && typeof parsed === "object" && parsed.messages?.length > 0) {
         _log(`OK: ${parsed.messages?.length} msgs`);
         h.historyWriter.appendNewMessages(
-          provider?.type || h.currentIdeType || "unknown_ide",
+          provider?.type || getCurrentProviderType(h, "unknown_ide"),
           parsed.messages || [],
           parsed.title,
-          args?.instanceId
+          args?.targetSessionId
         );
         return { success: true, ...parsed };
       }
@@ -4703,16 +4910,21 @@ async function handleSendChat(h, args) {
   if (!text) return { success: false, error: "text required" };
   const _log = (msg) => LOG.debug("Command", `[send_chat] ${msg}`);
   const provider = h.getProvider(args?.agentType);
+  const dedupeKey = buildRecentSendKey(h, args, provider, text);
   const _logSendSuccess = (method, targetAgent) => {
     h.historyWriter.appendNewMessages(
-      targetAgent || provider?.type || h.currentIdeType || "unknown_agent",
+      targetAgent || provider?.type || getCurrentProviderType(h, "unknown_agent"),
       [{ role: "user", content: text, receivedAt: Date.now() }],
       void 0,
       // title
-      args?.instanceId
+      args?.targetSessionId
     );
     return { success: true, sent: true, method, targetAgent };
   };
+  if (isRecentDuplicateSend(dedupeKey)) {
+    _log(`Suppressed duplicate send for ${dedupeKey}`);
+    return { success: true, sent: false, deduplicated: true };
+  }
   if (provider?.category === "cli" || provider?.category === "acp") {
     const adapter = getTargetedCliAdapter(h, args, provider.type);
     if (adapter) {
@@ -4748,8 +4960,9 @@ 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);
+    const extensionSessionId = h.currentSession?.sessionId;
+    if (h.agentStream && h.getCdp() && extensionSessionId) {
+      const ok = await h.agentStream.sendToSession(h.getCdp(), extensionSessionId, text);
       if (ok) {
         _log(`AgentStreamManager sent OK`);
         return _logSendSuccess("agent-stream");
@@ -4759,45 +4972,11 @@ async function handleSendChat(h, args) {
   }
   const targetCdp = h.getCdp();
   if (!targetCdp?.isConnected) {
-    _log(`No CDP for ${h.currentIdeType}`);
-    return { success: false, error: `CDP for ${h.currentIdeType || "unknown"} not connected` };
-  }
-  _log(`Targeting IDE: ${h.currentIdeType}`);
-  if (provider?.webviewMatchText && provider?.scripts?.webviewSendMessage) {
-    try {
-      const webviewScript = provider.scripts.webviewSendMessage(text);
-      if (webviewScript && targetCdp.evaluateInWebviewFrame) {
-        const matchText = provider.webviewMatchText;
-        const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
-        const wvResult = await targetCdp.evaluateInWebviewFrame(webviewScript, matchFn);
-        let wvParsed = wvResult;
-        if (typeof wvResult === "string") {
-          try {
-            wvParsed = JSON.parse(wvResult);
-          } catch {
-          }
-        }
-        if (wvParsed?.sent) {
-          _log(`webviewSendMessage (priority) OK`);
-          return _logSendSuccess("webview-script-priority");
-        }
-        _log(`webviewSendMessage (priority) did not confirm sent, falling through`);
-      }
-    } catch (e) {
-      _log(`webviewSendMessage (priority) failed: ${e.message}, falling through`);
-    }
-  }
-  if (provider?.inputMethod === "cdp-type-and-send" && provider.inputSelector) {
-    try {
-      const sent = await targetCdp.typeAndSend(provider.inputSelector, text);
-      if (sent) {
-        _log(`typeAndSend(provider.inputSelector=${provider.inputSelector}) success`);
-        return _logSendSuccess("typeAndSend-provider");
-      }
-    } catch (e) {
-      _log(`typeAndSend(provider) failed: ${e.message}`);
-    }
+    const managerKey = getCurrentManagerKey(h);
+    _log(`No CDP for ${managerKey}`);
+    return { success: false, error: `CDP for ${managerKey || "unknown"} not connected` };
   }
+  _log(`Targeting IDE: ${getCurrentManagerKey(h)}`);
   const sendScript = h.getProviderScript("sendMessage", { MESSAGE: text });
   if (sendScript) {
     try {
@@ -4824,7 +5003,30 @@ async function handleSendChat(h, args) {
           _log(`typeAndSend(script.selector) failed: ${e.message}`);
         }
       }
-      if (parsed?.needsTypeAndSend && provider?.scripts?.webviewSendMessage) {
+      if (parsed?.needsTypeAndSend && parsed?.clickCoords) {
+        try {
+          const { x, y } = parsed.clickCoords;
+          const sent = await targetCdp.typeAndSendAt(x, y, text);
+          if (sent) {
+            _log(`typeAndSendAt(${x},${y}) success`);
+            return _logSendSuccess("typeAndSendAt-script");
+          }
+        } catch (e) {
+          _log(`typeAndSendAt failed: ${e.message}`);
+        }
+      }
+      if (parsed?.needsTypeAndSend && provider?.inputMethod === "cdp-type-and-send" && provider.inputSelector) {
+        try {
+          const sent = await targetCdp.typeAndSend(provider.inputSelector, text);
+          if (sent) {
+            _log(`typeAndSend(provider.inputSelector=${provider.inputSelector}) success`);
+            return _logSendSuccess("typeAndSend-provider");
+          }
+        } catch (e) {
+          _log(`typeAndSend(provider) failed: ${e.message}`);
+        }
+      }
+      if (parsed?.needsTypeAndSend && provider?.webviewMatchText && provider?.scripts?.webviewSendMessage) {
         try {
           const webviewScript = provider.scripts.webviewSendMessage(text);
           if (webviewScript && targetCdp.evaluateInWebviewFrame) {
@@ -4847,20 +5049,44 @@ async function handleSendChat(h, args) {
           _log(`webviewSendMessage failed: ${e.message}`);
         }
       }
-      if (parsed?.needsTypeAndSend && parsed?.clickCoords) {
-        try {
-          const { x, y } = parsed.clickCoords;
-          const sent = await targetCdp.typeAndSendAt(x, y, text);
-          if (sent) {
-            _log(`typeAndSendAt(${x},${y}) success`);
-            return _logSendSuccess("typeAndSendAt-script");
+      return { success: false, error: parsed?.error || "Provider sendMessage did not confirm send" };
+    } catch (e) {
+      _log(`sendMessage script failed: ${e.message}`);
+      return { success: false, error: `Provider sendMessage failed: ${e.message}` };
+    }
+  }
+  if (provider?.webviewMatchText && provider?.scripts?.webviewSendMessage) {
+    try {
+      const webviewScript = provider.scripts.webviewSendMessage(text);
+      if (webviewScript && targetCdp.evaluateInWebviewFrame) {
+        const matchText = provider.webviewMatchText;
+        const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
+        const wvResult = await targetCdp.evaluateInWebviewFrame(webviewScript, matchFn);
+        let wvParsed = wvResult;
+        if (typeof wvResult === "string") {
+          try {
+            wvParsed = JSON.parse(wvResult);
+          } catch {
           }
-        } catch (e) {
-          _log(`typeAndSendAt failed: ${e.message}`);
+        }
+        if (wvParsed?.sent) {
+          _log(`webviewSendMessage OK`);
+          return _logSendSuccess("webview-script");
         }
       }
     } catch (e) {
-      _log(`sendMessage script failed: ${e.message}`);
+      _log(`webviewSendMessage failed: ${e.message}`);
+    }
+  }
+  if (provider?.inputMethod === "cdp-type-and-send" && provider.inputSelector) {
+    try {
+      const sent = await targetCdp.typeAndSend(provider.inputSelector, text);
+      if (sent) {
+        _log(`typeAndSend(provider.inputSelector=${provider.inputSelector}) success`);
+        return _logSendSuccess("typeAndSend-provider");
+      }
+    } catch (e) {
+      _log(`typeAndSend(provider) failed: ${e.message}`);
     }
   }
   _log("All methods failed");
@@ -4868,9 +5094,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.currentSession?.sessionId) {
     try {
-      const chats = await h.agentStream.listAgentChats(h.getCdp(), provider.type);
+      const chats = await h.agentStream.listSessionChats(h.getCdp(), h.currentSession.sessionId);
       LOG.info("Command", `[list_chats] Extension: ${chats.length} chats`);
       return { success: true, chats };
     } catch (e) {
@@ -4929,8 +5155,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.currentSession?.sessionId) {
+    const ok = await h.agentStream.newSession(h.getCdp(), h.currentSession.sessionId);
     return { success: ok };
   }
   try {
@@ -4954,15 +5180,15 @@ async function handleNewChat(h, args) {
 }
 async function handleSwitchChat(h, args) {
   const provider = h.getProvider(args?.agentType);
-  const ideType = h.currentIdeType;
+  const managerKey = getCurrentManagerKey(h);
   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);
+  LOG.info("Command", `[switch_chat] sessionId=${sessionId}, manager=${managerKey}`);
+  if (provider?.category === "extension" && h.agentStream && h.getCdp() && h.currentSession?.sessionId) {
+    const ok = await h.agentStream.switchConversation(h.getCdp(), h.currentSession.sessionId, sessionId);
     return { success: ok, result: ok ? "switched" : "failed" };
   }
-  const cdp = h.getCdp(ideType);
+  const cdp = h.getCdp(managerKey);
   if (!cdp?.isConnected) return { success: false, error: "CDP not connected" };
   try {
     const webviewScript = h.getProviderScript("webviewSwitchSession", { SESSION_ID: JSON.stringify(sessionId) });
@@ -5104,7 +5330,7 @@ async function handleSetMode(h, args) {
 async function handleChangeModel(h, args) {
   const provider = h.getProvider(args?.agentType);
   const model = args?.model;
-  LOG.info("Command", `[change_model] model=${model} provider=${provider?.type} category=${provider?.category} ideType=${h.currentIdeType} providerType=${h.currentProviderType}`);
+  LOG.info("Command", `[change_model] model=${model} provider=${provider?.type} category=${provider?.category} manager=${getCurrentManagerKey(h)} providerType=${getCurrentProviderType(h)}`);
   if (provider?.category === "acp") {
     const adapter = getTargetedCliAdapter(h, args, provider.type);
     LOG.info("Command", `[change_model] ACP adapter found: ${!!adapter}, type=${adapter?.cliType}, hasAcpInstance=${!!adapter?._acpInstance}`);
@@ -5225,13 +5451,8 @@ 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()) {
-    const ok = await h.agentStream.resolveAgentAction(
-      h.getCdp(),
-      provider.type,
-      action,
-      h.currentIdeType
-    );
+  if (provider?.category === "extension" && h.agentStream && h.getCdp() && h.currentSession?.sessionId) {
+    const ok = await h.agentStream.resolveSessionAction(h.getCdp(), h.currentSession.sessionId, action);
     return { success: ok };
   }
   if (provider?.scripts?.webviewResolveAction || provider?.scripts?.webview_resolve_action) {
@@ -5591,151 +5812,37 @@ async function handleFileListBrowse(h, args) {
 // src/commands/stream-commands.ts
 init_config();
 init_logger();
-async function handleAgentStreamSwitch(h, args) {
-  if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const agentType = args?.agentType || args?.agent || null;
-  await h.agentStream.switchActiveAgent(h.getCdp(), agentType);
-  return { success: true, activeAgent: agentType };
-}
-async function handleAgentStreamRead(h, args) {
+async function handleFocusSession(h, args) {
   if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const streams = await h.agentStream.collectAgentStreams(h.getCdp());
-  return { success: true, streams };
-}
-async function handleAgentStreamSend(h, args) {
-  const agentType = args?.agentType || args?.agent;
-  const text = args?.text || args?.message;
-  if (!text) return { success: false, error: "text required" };
-  if (agentType && h.ctx.adapters) {
-    for (const [key, adapter] of h.ctx.adapters.entries()) {
-      if (adapter.cliType === agentType || key.includes(agentType)) {
-        LOG.info("Command", `[agent_stream_send] Routing to CLI adapter: ${adapter.cliType}`);
-        try {
-          await adapter.sendMessage(text);
-          return { success: true, sent: true, targetAgent: adapter.cliType };
-        } catch (e) {
-          LOG.info("Command", `[agent_stream_send] CLI adapter failed: ${e.message}`);
-          return { success: false, error: `CLI send failed: ${e.message}` };
-        }
-      }
-    }
-  }
-  if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const resolvedAgent = agentType || h.agentStream.activeAgentType;
-  if (!resolvedAgent) return { success: false, error: "agentType required" };
-  const ok = await h.agentStream.sendToAgent(h.getCdp(), 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 action = args?.action || "approve";
-  if (!agentType) return { success: false, error: "agentType required" };
-  const ok = await h.agentStream.resolveAgentAction(h.getCdp(), 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;
-  if (!agentType) return { success: false, error: "agentType required" };
-  const ok = await h.agentStream.newAgentSession(h.getCdp(), 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;
-  if (!agentType) return { success: false, error: "agentType required" };
-  const chats = await h.agentStream.listAgentChats(h.getCdp(), 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 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);
-  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;
-  if (!agentType) return { success: false, error: "agentType required" };
-  await h.agentStream.ensureAgentPanelOpen(agentType, h.currentIdeType);
-  const ok = await h.agentStream.focusAgentEditor(h.getCdp(), agentType);
+  const sessionId = args?.targetSessionId || h.currentSession?.sessionId;
+  if (!sessionId) return { success: false, error: "targetSessionId required" };
+  const ok = await h.agentStream.focusSession(h.getCdp(), sessionId);
   return { success: ok };
 }
 function handlePtyInput(h, args) {
-  const { cliType, data } = args || {};
+  const { cliType, data, targetSessionId } = args || {};
   if (!data) return { success: false, error: "data required" };
-  if (h.ctx.adapters) {
-    const targetCli = cliType || "";
-    if (!targetCli && h.ctx.adapters.size > 0) {
-      const first = h.ctx.adapters.values().next().value;
-      if (first && typeof first.writeRaw === "function") {
-        first.writeRaw(data);
-        return { success: true };
-      }
-    }
-    const directAdapter = h.ctx.adapters.get(targetCli);
-    if (directAdapter && typeof directAdapter.writeRaw === "function") {
-      directAdapter.writeRaw(data);
-      return { success: true };
-    }
-    for (const [, adapter] of h.ctx.adapters) {
-      if (adapter.cliType === targetCli && typeof adapter.writeRaw === "function") {
-        adapter.writeRaw(data);
-        return { success: true };
-      }
-    }
-    for (const [key, adapter] of h.ctx.adapters) {
-      if ((key.startsWith(targetCli) || targetCli.startsWith(adapter.cliType)) && typeof adapter.writeRaw === "function") {
-        adapter.writeRaw(data);
-        return { success: true };
-      }
-    }
+  const adapter = h.getCliAdapter(targetSessionId || cliType);
+  if (!adapter || typeof adapter.writeRaw !== "function") {
+    return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || "unknown"}` };
   }
-  return { success: false, error: `CLI adapter not found: ${cliType}` };
+  adapter.writeRaw(data);
+  return { success: true };
 }
 function handlePtyResize(h, args) {
-  const { cliType, cols, rows, force } = args || {};
+  const { cliType, cols, rows, force, targetSessionId } = args || {};
   if (!cols || !rows) return { success: false, error: "cols and rows required" };
-  if (h.ctx.adapters) {
-    const targetCli = cliType || "";
-    if (!targetCli && h.ctx.adapters.size > 0) {
-      const first = h.ctx.adapters.values().next().value;
-      if (first && typeof first.resize === "function") {
-        if (force) {
-          first.resize(cols - 1, rows);
-          setTimeout(() => first.resize(cols, rows), 50);
-        } else {
-          first.resize(cols, rows);
-        }
-        return { success: true };
-      }
-    }
-    const directAdapter = h.ctx.adapters.get(targetCli);
-    if (directAdapter && typeof directAdapter.resize === "function") {
-      if (force) {
-        directAdapter.resize(cols - 1, rows);
-        setTimeout(() => directAdapter.resize(cols, rows), 50);
-      } else {
-        directAdapter.resize(cols, rows);
-      }
-      return { success: true };
-    }
-    for (const [key, adapter] of h.ctx.adapters) {
-      if ((adapter.cliType === targetCli || key.startsWith(targetCli) || targetCli.startsWith(adapter.cliType)) && typeof adapter.resize === "function") {
-        if (force) {
-          adapter.resize(cols - 1, rows);
-          setTimeout(() => adapter.resize(cols, rows), 50);
-        } else {
-          adapter.resize(cols, rows);
-        }
-        return { success: true };
-      }
-    }
+  const adapter = h.getCliAdapter(targetSessionId || cliType);
+  if (!adapter || typeof adapter.resize !== "function") {
+    return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || "unknown"}` };
   }
-  return { success: false, error: `CLI adapter not found: ${cliType}` };
+  if (force) {
+    adapter.resize(cols - 1, rows);
+    setTimeout(() => adapter.resize(cols, rows), 50);
+  } else {
+    adapter.resize(cols, rows);
+  }
+  return { success: true };
 }
 function handleGetProviderSettings(h, args) {
   const loader = h.ctx.providerLoader;
@@ -5771,7 +5878,7 @@ function handleSetProviderSetting(h, args) {
 }
 async function handleExtensionScript(h, args, scriptName) {
   const { agentType, ideType } = args || {};
-  LOG.info("Command", `[ExtScript] ${scriptName} agentType=${agentType} ideType=${ideType} _currentIdeType=${h.currentIdeType}`);
+  LOG.info("Command", `[ExtScript] ${scriptName} agentType=${agentType} ideType=${ideType} session=${h.currentSession?.sessionId || ""}`);
   if (!agentType) return { success: false, error: "agentType is required" };
   const loader = h.ctx.providerLoader;
   if (!loader) return { success: false, error: "ProviderLoader not initialized" };
@@ -5792,21 +5899,22 @@ async function handleExtensionScript(h, args, scriptName) {
   }
   const scriptCode = scriptFn(normalizedArgs);
   if (!scriptCode) return { success: false, error: `Script '${actualScriptName}' returned null` };
-  const cdpKey = provider.category === "ide" ? h.currentIdeType || agentType : h.currentIdeType || ideType;
+  const cdpKey = provider.category === "ide" ? h.currentSession?.cdpManagerKey || h.currentManagerKey || agentType : h.currentSession?.cdpManagerKey || h.currentManagerKey || ideType;
   LOG.info("Command", `[ExtScript] provider=${provider.type} category=${provider.category} cdpKey=${cdpKey}`);
   const cdp = h.getCdp(cdpKey);
   if (!cdp?.isConnected) return { success: false, error: `No CDP connection for ${cdpKey || "any"}` };
   try {
     let result;
     if (provider.category === "extension") {
-      const sessions = cdp.getAgentSessions();
-      let targetSessionId = null;
-      for (const [sessionId, target] of sessions) {
-        if (target.agentType === agentType) {
-          targetSessionId = sessionId;
-          break;
-        }
-      }
+      const runtimeSessionId = h.currentSession?.sessionId || args?.targetSessionId;
+      if (!runtimeSessionId) return { success: false, error: `No target session found for ${agentType}` };
+      const parentSessionId = h.currentSession?.parentSessionId;
+      if (parentSessionId) {
+        await h.agentStream?.setActiveSession(cdp, parentSessionId, runtimeSessionId);
+        await h.agentStream?.syncActiveSession(cdp, parentSessionId);
+      }
+      const managed = runtimeSessionId ? h.agentStream?.getManagedSession(runtimeSessionId) : null;
+      const targetSessionId = managed?.cdpSessionId || null;
       const IDE_LEVEL_SCRIPTS = ["listModes", "setMode", "listModels", "setModel"];
       if (IDE_LEVEL_SCRIPTS.includes(scriptName)) {
         if (targetSessionId) {
@@ -5877,7 +5985,7 @@ function handleGetIdeExtensions(h, args) {
       enabled: config.ideSettings?.[ide]?.extensions?.[p.type]?.enabled === true
     }));
   }
-  return { success: true, ides: result };
+  return { success: true, ideExtensions: result };
 }
 function handleSetIdeExtension(h, args) {
   const { ideType, extensionType, enabled } = args || {};
@@ -5989,10 +6097,8 @@ var DaemonCommandHandler = class {
   _agentStream = null;
   domHandlers;
   _historyWriter;
-  /** Current IDE type extracted from command args (per-request) */
-  _currentIdeType;
-  /** Current provider type — agentType priority, ideType use */
-  _currentProviderType;
+  /** Current request route context */
+  _currentRoute = {};
   constructor(ctx) {
     this._ctx = ctx;
     this.domHandlers = new CdpDomHandlers((ideType) => this.getCdp(ideType));
@@ -6008,20 +6114,25 @@ var DaemonCommandHandler = class {
   get historyWriter() {
     return this._historyWriter;
   }
+  get currentManagerKey() {
+    return this._currentRoute.managerKey;
+  }
   get currentIdeType() {
-    return this._currentIdeType;
+    return this._currentRoute.managerKey;
   }
   get currentProviderType() {
-    return this._currentProviderType;
+    return this._currentRoute.providerType;
+  }
+  get currentSession() {
+    return this._currentRoute.session;
   }
-  /** Get CDP manager for a specific ideType or managerKey.
-   * Supports exact match, multi-window prefix match, and instanceIdMap UUID lookup.
-   * Returns null if no match — never falls back to another IDE. */
+  /** Get CDP manager for a specific session or manager key. */
   getCdp(ideType) {
-    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 requested = ideType || this._currentRoute.session?.sessionId || this._currentRoute.managerKey;
+    if (!requested) return null;
+    const session = this._ctx.sessionRegistry?.get(requested);
+    const managerKey = session?.cdpManagerKey || requested;
+    const m = findCdpManager(this._ctx.cdpManagers, managerKey);
     if (m?.isConnected) return m;
     return null;
   }
@@ -6029,7 +6140,7 @@ var DaemonCommandHandler = class {
    * Get provider module — _currentProviderType (agentType priority) use.
    */
   getProvider(overrideType) {
-    const key = overrideType || this._currentProviderType || this._currentIdeType;
+    const key = overrideType || this._currentRoute.providerType || this._currentRoute.session?.providerType || this._currentRoute.managerKey;
     if (!key || !this._ctx.providerLoader) return void 0;
     const result = this._ctx.providerLoader.resolve(key);
     if (result) return result;
@@ -6062,14 +6173,22 @@ 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._currentRoute.session?.sessionId || null;
+      if (!sessionId && this._currentRoute.session?.parentSessionId) {
+        sessionId = this._agentStream?.resolveSessionForAgent(this._currentRoute.session.parentSessionId, provider.type) || null;
+      }
+      if (sessionId && this._agentStream) {
+        const target = this._ctx.sessionRegistry?.get(sessionId);
+        if (target?.parentSessionId) {
+          await this._agentStream.setActiveSession(cdp, target.parentSessionId, sessionId);
+          await this._agentStream.syncActiveSession(cdp, target.parentSessionId);
+        }
       }
       if (!sessionId) return null;
-      const result2 = await cdp.evaluateInSessionFrame(sessionId, script, timeout);
+      const managed = this._agentStream?.getManagedSession(sessionId);
+      const cdpSessionId = managed?.cdpSessionId;
+      if (!cdpSessionId) return null;
+      const result2 = await cdp.evaluateInSessionFrame(cdpSessionId, script, timeout);
       return { result: result2, category: "extension" };
     }
     const result = await cdp.evaluate(script, timeout);
@@ -6077,33 +6196,37 @@ var DaemonCommandHandler = class {
   }
   /** CLI adapter search */
   getCliAdapter(type) {
-    const target = type || this._currentIdeType;
+    const target = type || this._currentRoute.session?.sessionId || this._currentRoute.providerType || this._currentRoute.managerKey;
     if (!target || !this._ctx.adapters) return null;
-    let normalizedTarget = target;
-    const colonIdx = normalizedTarget.lastIndexOf(":");
-    if (colonIdx >= 0) normalizedTarget = normalizedTarget.substring(colonIdx + 1);
-    const direct = this._ctx.adapters.get(normalizedTarget);
-    if (direct) return direct;
-    for (const [key, adapter] of this._ctx.adapters.entries()) {
-      if (adapter.cliType === target || adapter.cliType === normalizedTarget || key === normalizedTarget || key.startsWith(target) || key.startsWith(normalizedTarget)) {
-        return adapter;
-      }
+    const session = this._ctx.sessionRegistry?.get(target);
+    if (session?.adapterKey) {
+      return this._ctx.adapters.get(session.adapterKey) || null;
     }
-    return null;
+    return this._ctx.adapters.get(target) || null;
   }
   // ─── Private helpers ──────────────────────────────
-  getExtensionSessionId(provider) {
-    if (provider.category !== "extension" || !this._agentStream) return null;
-    const managed = this._agentStream.getManagedAgent(provider.type);
-    return managed?.sessionId || null;
-  }
-  /** Extract ideType from _targetInstance or explicit ideType */
+  inferProviderType(key) {
+    if (!key) return void 0;
+    const session = this._ctx.sessionRegistry?.get(key);
+    if (session?.providerType) return session.providerType;
+    return key.split("_")[0];
+  }
+  resolveRoute(args) {
+    const session = this._ctx.sessionRegistry?.get(args?.targetSessionId);
+    const managerKey = this.extractIdeType(args);
+    const providerType = args?.agentType || args?.providerType || session?.providerType || this.inferProviderType(managerKey);
+    return { session, managerKey, providerType };
+  }
+  /** Extract CDP scope key from target session or explicit ideType */
   extractIdeType(args) {
+    if (args?.targetSessionId) {
+      const target = this._ctx.sessionRegistry?.get(args.targetSessionId);
+      if (target?.cdpManagerKey) return target.cdpManagerKey;
+      if (this._ctx.cdpManagers.has(args.targetSessionId)) return args.targetSessionId;
+    }
     if (args?.ideType) {
-      const mappedKey = this._ctx.instanceIdMap?.get(args.ideType);
-      if (mappedKey) {
-        return mappedKey;
-      }
+      const target = this._ctx.sessionRegistry?.get(args.ideType);
+      if (target?.cdpManagerKey) return target.cdpManagerKey;
       if (this._ctx.cdpManagers.has(args.ideType)) {
         return args.ideType;
       }
@@ -6114,33 +6237,6 @@ var DaemonCommandHandler = class {
         }
       }
     }
-    if (args?._targetInstance) {
-      let raw = args._targetInstance;
-      const ideMatch = raw.match(/:ide:(.+)$/);
-      const cliMatch = raw.match(/:cli:(.+)$/);
-      const acpMatch = raw.match(/:acp:(.+)$/);
-      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);
-      }
-      if (this._ctx.cdpManagers.has(raw)) {
-        return raw;
-      }
-      const found = findCdpManager(this._ctx.cdpManagers, raw);
-      if (found) {
-        for (const [k, m] of this._ctx.cdpManagers.entries()) {
-          if (m === found) return k;
-        }
-      }
-      const lastUnderscore = raw.lastIndexOf("_");
-      if (lastUnderscore > 0) {
-        const stripped = raw.substring(0, lastUnderscore);
-        if (this._ctx.cdpManagers.has(stripped)) return stripped;
-      }
-      return raw;
-    }
     return void 0;
   }
   setAgentStreamManager(manager) {
@@ -6148,12 +6244,11 @@ var DaemonCommandHandler = class {
   }
   // ─── Command Dispatcher ──────────────────────────
   async handle(cmd, args) {
-    this._currentIdeType = this.extractIdeType(args);
-    this._currentProviderType = args?.agentType || args?.providerType || this._currentIdeType;
-    if (!this._currentIdeType && !this._currentProviderType) {
+    this._currentRoute = this.resolveRoute(args);
+    if (!this._currentRoute.session && !this._currentRoute.managerKey && !this._currentRoute.providerType) {
       const cdpCommands = ["send_chat", "read_chat", "list_chats", "new_chat", "switch_chat", "set_mode", "change_model", "set_thought_level", "resolve_action"];
       if (cdpCommands.includes(cmd)) {
-        return { success: false, error: "No ideType specified \u2014 cannot route command" };
+        return { success: false, error: "No targetSessionId specified \u2014 cannot route command" };
       }
     }
     try {
@@ -6244,22 +6339,8 @@ var DaemonCommandHandler = class {
       case "refresh_scripts":
         return this.handleRefreshScripts(args);
       // ─── Stream commands (stream-commands.ts) ───────────
-      case "agent_stream_switch":
-        return handleAgentStreamSwitch(this, args);
-      case "agent_stream_read":
-        return handleAgentStreamRead(this, args);
-      case "agent_stream_send":
-        return handleAgentStreamSend(this, args);
-      case "agent_stream_resolve":
-        return handleAgentStreamResolve(this, args);
-      case "agent_stream_new":
-        return handleAgentStreamNew(this, args);
-      case "agent_stream_list_chats":
-        return handleAgentStreamListChats(this, args);
-      case "agent_stream_switch_session":
-        return handleAgentStreamSwitchSession(this, args);
-      case "agent_stream_focus":
-        return handleAgentStreamFocus(this, args);
+      case "focus_session":
+        return handleFocusSession(this, args);
       // ─── PTY Raw I/O (stream-commands.ts) ─────────
       case "pty_input":
         return handlePtyInput(this, args);
@@ -7907,8 +7988,7 @@ var CHAT_COMMANDS = [
   "new_chat",
   "switch_chat",
   "set_mode",
-  "change_model",
-  "agent_stream_send"
+  "change_model"
 ];
 var DaemonCommandRouter = class {
   deps;
@@ -8146,6 +8226,7 @@ var DaemonCommandRouter = class {
         } catch {
         }
         this.deps.cdpManagers.delete(key);
+        this.deps.sessionRegistry.unregisterByManagerKey(key);
         LOG.info("StopIDE", `CDP disconnected: ${key}`);
       }
     }
@@ -8158,14 +8239,6 @@ var DaemonCommandRouter = class {
     for (const instanceKey of keysToRemove) {
       const ideInstance = this.deps.instanceManager.getInstance(instanceKey);
       if (ideInstance) {
-        if (ideInstance.getInstanceId) {
-          this.deps.instanceIdMap.delete(ideInstance.getInstanceId());
-        }
-        if (ideInstance.getExtensionInstances) {
-          for (const ext of ideInstance.getExtensionInstances()) {
-            if (ext.getInstanceId) this.deps.instanceIdMap.delete(ext.getInstanceId());
-          }
-        }
         this.deps.instanceManager.removeInstance(instanceKey);
         LOG.info("StopIDE", `Instance removed: ${instanceKey}`);
       }
@@ -8174,14 +8247,6 @@ var DaemonCommandRouter = class {
       const instanceKey = `ide:${ideType}`;
       const ideInstance = this.deps.instanceManager.getInstance(instanceKey);
       if (ideInstance) {
-        if (ideInstance.getInstanceId) {
-          this.deps.instanceIdMap.delete(ideInstance.getInstanceId());
-        }
-        if (ideInstance.getExtensionInstances) {
-          for (const ext of ideInstance.getExtensionInstances()) {
-            if (ext.getInstanceId) this.deps.instanceIdMap.delete(ext.getInstanceId());
-          }
-        }
         this.deps.instanceManager.removeInstance(instanceKey);
         LOG.info("StopIDE", `Instance removed: ${instanceKey}`);
       }
@@ -8234,15 +8299,9 @@ function buildStatusSnapshot(options) {
   const cfg = loadConfig();
   const wsState = getWorkspaceState(cfg);
   const memSnap = getHostMemorySnapshot();
-  const { managedIdes, managedClis, managedAcps } = buildAllManagedEntries(
+  const sessions = buildSessionEntries(
     options.allStates,
-    options.cdpManagers,
-    {
-      detectedIdes: options.detectedIdes.map((ide) => ({
-        id: ide.id,
-        installed: ide.installed !== false
-      }))
-    }
+    options.cdpManagers
   );
   return {
     instanceId: options.instanceId,
@@ -8264,9 +8323,7 @@ function buildStatusSnapshot(options) {
     timestamp: options.timestamp ?? Date.now(),
     detectedIdes: buildDetectedIdeInfos(options.detectedIdes, options.cdpManagers),
     ...options.p2p ? { p2p: options.p2p } : {},
-    managedIdes,
-    managedClis,
-    managedAcps,
+    sessions,
     workspaces: wsState.workspaces,
     defaultWorkspaceId: wsState.defaultWorkspaceId,
     defaultWorkspacePath: wsState.defaultWorkspacePath,
@@ -8378,7 +8435,7 @@ var DaemonStatusReporter = class {
         LOG.info("StatusReport", `\u2192${target} ${baseSummary}`);
       }
     }
-    const { managedIdes, managedClis, managedAcps } = buildAllManagedEntries(
+    const sessions = buildSessionEntries(
       allStates,
       this.deps.cdpManagers
     );
@@ -8409,23 +8466,20 @@ var DaemonStatusReporter = class {
     if (opts?.p2pOnly) return;
     const wsPayload = {
       daemonMode: true,
-      // managedIdes: server only saves id, type, cdpConnected
-      managedIdes: managedIdes.map((ide) => ({
-        ideType: ide.ideType,
-        instanceId: ide.instanceId,
-        cdpConnected: ide.cdpConnected
-      })),
-      // managedClis: server only saves id, type, name
-      managedClis: managedClis.map((c) => ({
-        id: c.id,
-        cliType: c.cliType,
-        cliName: c.cliName
-      })),
-      // managedAcps: server only saves id, type, name
-      managedAcps: managedAcps?.map((a) => ({
-        id: a.id,
-        acpType: a.acpType,
-        acpName: a.acpName
+      sessions: sessions.map((session) => ({
+        id: session.id,
+        parentId: session.parentId,
+        providerType: session.providerType,
+        providerName: session.providerName,
+        kind: session.kind,
+        transport: session.transport,
+        status: session.status,
+        workspace: session.workspace,
+        title: session.title,
+        cdpConnected: session.cdpConnected,
+        currentModel: session.currentModel,
+        currentPlan: session.currentPlan,
+        currentAutoApprove: session.currentAutoApprove
       })),
       p2p: payload.p2p,
       timestamp: now
@@ -8856,6 +8910,9 @@ var AcpProviderInstance = class {
       );
     }
   }
+  getInstanceId() {
+    return this.instanceId;
+  }
   // ─── ACP Config Options & Modes ─────────────────────
   parseConfigOptions(raw) {
     if (!Array.isArray(raw)) return;
@@ -9635,6 +9692,7 @@ var DaemonCliManager = class {
     const normalizedType = this.providerLoader.resolveAlias(cliType);
     const provider = this.providerLoader.getByAlias(cliType);
     const key = crypto4.randomUUID();
+    const sessionRegistry = this.deps.getSessionRegistry?.() || null;
     if (provider && provider.category === "acp") {
       const instanceManager2 = this.deps.getInstanceManager();
       if (!instanceManager2) throw new Error("InstanceManager not available");
@@ -9658,6 +9716,16 @@ ${installInfo}`
       await instanceManager2.addInstance(key, acpInstance, {
         settings: this.providerLoader.getSettings(normalizedType)
       });
+      const sessionId = acpInstance.getInstanceId();
+      sessionRegistry?.register({
+        sessionId,
+        parentSessionId: null,
+        providerType: normalizedType,
+        providerCategory: "acp",
+        transport: "acp",
+        adapterKey: key,
+        instanceKey: key
+      });
       this.adapters.set(key, {
         cliType: normalizedType,
         workingDir: resolvedDir,
@@ -9715,9 +9783,18 @@ ${installInfo}`
           serverConn: this.deps.getServerConn(),
           settings: {},
           onPtyData: (data) => {
-            this.deps.getP2p()?.broadcastPtyOutput(key, data);
+            this.deps.getP2p()?.broadcastPtyOutput(cliInstance.instanceId, data);
           }
         });
+        sessionRegistry?.register({
+          sessionId: cliInstance.instanceId,
+          parentSessionId: null,
+          providerType: normalizedType,
+          providerCategory: "cli",
+          transport: "pty",
+          adapterKey: key,
+          instanceKey: key
+        });
       } catch (spawnErr) {
         LOG.error("CLI", `[${cliType}] Spawn failed: ${spawnErr?.message}`);
         instanceManager.removeInstance(key);
@@ -9739,6 +9816,7 @@ ${installInfo}`
               if (this.adapters.has(key)) {
                 this.adapters.delete(key);
                 this.deps.removeAgentTracking(key);
+                sessionRegistry?.unregisterByInstanceKey(key);
                 instanceManager.removeInstance(key);
                 LOG.info("CLI", `\u{1F9F9} Auto-cleaned ${status.status} CLI: ${cliType}`);
                 this.deps.onStatusChange();
@@ -9799,12 +9877,14 @@ ${installInfo}`
       }
       this.adapters.delete(key);
       this.deps.removeAgentTracking(key);
+      this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
       this.deps.getInstanceManager()?.removeInstance(key);
       LOG.info("CLI", `\u{1F6D1} Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`);
       this.deps.onStatusChange();
     } else {
       const im = this.deps.getInstanceManager();
       if (im) {
+        this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
         im.removeInstance(key);
         this.deps.removeAgentTracking(key);
         LOG.warn("CLI", `\u{1F9F9} Force-removed orphan entry: ${key}`);
@@ -9819,7 +9899,7 @@ ${installInfo}`
   // ─── Adapter search ─────────────────────────────
   /**
   * Search for CLI adapter. Priority order:
-  * 0. instanceKey (UUID direct match) — extracted from _targetInstance / composite ID
+  * 0. sessionId (UUID direct match)
   * 1. agentType + dir (iteration match)
   * 2. agentType fuzzy match (⚠ returns first match when multiple sessions exist)
   */
@@ -9887,7 +9967,7 @@ ${installInfo}`
         const cliType = args?.cliType;
         const dir = args?.dir || "";
         if (!cliType) throw new Error("cliType required");
-        const found = this.findAdapter(cliType, { instanceKey: args?._targetInstance, dir });
+        const found = this.findAdapter(cliType, { instanceKey: args?.targetSessionId, dir });
         if (found) {
           await this.stopSession(found.key);
         } else {
@@ -9919,7 +9999,7 @@ ${installInfo}`
         }
         const dir = rdir.path;
         if (!cliType) throw new Error("cliType required");
-        const found = this.findAdapter(cliType, { instanceKey: args?._targetInstance, dir });
+        const found = this.findAdapter(cliType, { instanceKey: args?.targetSessionId, dir });
         if (found) await this.stopSession(found.key);
         await this.startSession(cliType, dir);
         this.persistRecentDir(cliType, dir);
@@ -9931,7 +10011,7 @@ ${installInfo}`
         if (!agentType || !action) throw new Error("agentType and action required");
         const found = this.findAdapter(agentType, {
           dir: args?.dir,
-          instanceKey: args?._targetInstance
+          instanceKey: args?.targetSessionId
         });
         if (!found) throw new Error(`CLI agent not running: ${agentType}`);
         const { adapter, key } = found;
@@ -10077,14 +10157,8 @@ var ProviderStreamAdapter = class {
 // src/agent-stream/manager.ts
 init_logger();
 var DaemonAgentStreamManager = class {
-  allAdapters = [];
-  managed = /* @__PURE__ */ new Map();
-  enabled = true;
-  logFn;
-  lastDiscoveryTime = 0;
-  discoveryIntervalMs = 1e4;
-  _activeAgentType = null;
-  constructor(logFn, providerLoader) {
+  constructor(logFn, providerLoader, sessionRegistry) {
+    this.sessionRegistry = sessionRegistry;
     this.logFn = logFn || LOG.forComponent("AgentStream").asLogFn();
     if (providerLoader) {
       const allExtProviders = providerLoader.getByCategory("extension");
@@ -10092,224 +10166,278 @@ var DaemonAgentStreamManager = class {
         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"}`);
       }
     }
   }
+  adaptersByType = /* @__PURE__ */ new Map();
+  managedBySessionId = /* @__PURE__ */ new Map();
+  enabled = true;
+  logFn;
+  lastDiscoveryTimeByParent = /* @__PURE__ */ new Map();
+  discoveryIntervalMsByParent = /* @__PURE__ */ new Map();
+  activeSessionIdByParent = /* @__PURE__ */ new Map();
   setEnabled(enabled) {
     this.enabled = enabled;
   }
   get isEnabled() {
     return this.enabled;
   }
-  get activeAgentType() {
-    return this._activeAgentType;
+  getActiveSessionId(parentSessionId) {
+    return this.activeSessionIdByParent.get(parentSessionId) || null;
+  }
+  getSessionTarget(sessionId) {
+    return this.sessionRegistry?.get(sessionId);
+  }
+  resetParentSession(parentSessionId) {
+    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, targetIdeType) {
+  async ensureSessionPanelOpen(_sessionId) {
   }
-  async switchActiveAgent(cdp, agentType) {
-    if (this._activeAgentType === agentType) return;
-    if (this._activeAgentType) {
-      const prev = this.managed.get(this._activeAgentType);
+  async setActiveSession(cdp, parentSessionId, sessionId) {
+    const previousSessionId = this.getActiveSessionId(parentSessionId);
+    if (previousSessionId === sessionId) return;
+    if (previousSessionId) {
+      const prev = this.managedBySessionId.get(previousSessionId);
       if (prev) {
         try {
-          await cdp.detachAgent(prev.sessionId);
+          await cdp.detachAgent(prev.cdpSessionId);
         } catch {
         }
-        this.managed.delete(this._activeAgentType);
-        this.logFn(`[AgentStream] Deactivated: ${prev.adapter.agentName}`);
-      }
-    }
-    this._activeAgentType = agentType;
-    this.lastDiscoveryTime = 0;
-    this.logFn(`[AgentStream] Active agent: ${agentType || "none"}`);
+        this.managedBySessionId.delete(previousSessionId);
+        this.logFn(`[AgentStream] Deactivated: ${prev.adapter.agentName} (${parentSessionId})`);
+      }
+    }
+    this.activeSessionIdByParent.set(parentSessionId, sessionId);
+    this.lastDiscoveryTimeByParent.set(parentSessionId, 0);
+    this.logFn(`[AgentStream] Active session (${parentSessionId}): ${sessionId || "none"}`);
+  }
+  resolveSessionIdForTarget(parentSessionId, agentType) {
+    const child = (this.sessionRegistry?.listChildren(parentSessionId) || []).find((entry) => entry.providerCategory === "extension" && entry.providerType === agentType);
+    return child?.sessionId || null;
+  }
+  async connectManagedSession(cdp, parentSessionId, runtimeSessionId) {
+    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 = {
+      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) {
-    if (!this.enabled || !this._activeAgentType) return;
+  async syncActiveSession(cdp, parentSessionId) {
+    const activeSessionId = this.getActiveSessionId(parentSessionId);
+    if (!this.enabled || !activeSessionId) return;
     const now = Date.now();
-    if (this.managed.has(this._activeAgentType) && now - this.lastDiscoveryTime < this.discoveryIntervalMs) {
+    const managed = this.managedBySessionId.get(activeSessionId);
+    const lastDiscoveryTime = this.lastDiscoveryTimeByParent.get(parentSessionId) || 0;
+    const discoveryIntervalMs = this.discoveryIntervalMsByParent.get(parentSessionId) || 1e4;
+    if (managed && now - lastDiscoveryTime < discoveryIntervalMs) {
       return;
     }
-    this.lastDiscoveryTime = now;
+    this.lastDiscoveryTimeByParent.set(parentSessionId, 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);
-        if (adapter) {
-          const sessionId = await cdp.attachToAgent(activeTarget);
-          if (sessionId) {
-            this.managed.set(this._activeAgentType, {
-              adapter,
-              sessionId,
-              target: activeTarget,
-              lastState: null,
-              lastError: null,
-              lastHiddenCheckTime: 0
-            });
-            this.logFn(`[AgentStream] Connected: ${adapter.agentName}`);
-          }
-        }
+      if (!managed) {
+        await this.connectManagedSession(cdp, parentSessionId, activeSessionId);
       }
-      for (const [type, agent] of this.managed) {
-        if (type !== this._activeAgentType) {
-          await cdp.detachAgent(agent.sessionId);
-          this.managed.delete(type);
-        }
+      this.discoveryIntervalMsByParent.set(parentSessionId, this.managedBySessionId.has(activeSessionId) ? 3e4 : 1e4);
+    } catch (e) {
+      this.logFn(`[AgentStream] sync error (${parentSessionId}): ${e.message}`);
+    }
+  }
+  /** Collect active extension session state */
+  async collectActiveSession(cdp, parentSessionId) {
+    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) || void 0;
+    }
+    if (!agent) return null;
+    const type = agent.adapter.agentType;
+    const isHidden = agent.lastState?.status === "panel_hidden";
+    const hiddenCacheFresh = isHidden && Date.now() - agent.lastHiddenCheckTime < 3e4;
+    if (hiddenCacheFresh) return agent.lastState;
+    try {
+      const evaluate = (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.error || state._error || "unknown") : ""}`);
+      agent.lastState = state;
+      agent.lastError = null;
+      if (state.status === "panel_hidden") {
+        agent.lastHiddenCheckTime = Date.now();
       }
-      this.discoveryIntervalMs = this.managed.has(this._activeAgentType) ? 3e4 : 1e4;
+      return state;
     } catch (e) {
-      this.logFn(`[AgentStream] sync error: ${e.message}`);
-    }
-  }
-  /** Collect active agent status */
-  async collectAgentStreams(cdp) {
-    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 isHidden = agent.lastState?.status === "panel_hidden";
-      const hiddenCacheFresh = isHidden && Date.now() - agent.lastHiddenCheckTime < 3e4;
-      if (hiddenCacheFresh) {
-        results.push(agent.lastState);
-      } else {
+      const errorMsg = e?.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 {
-          const evaluate = (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.error || state._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?.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 {
-            }
-            this.managed.delete(type);
-            this.lastDiscoveryTime = 0;
-          }
+          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, agentType, text, targetIdeType) {
-    await this.ensureAgentPanelOpen(agentType, targetIdeType);
-    const agent = this.managed.get(agentType);
+  async sendToSession(cdp, sessionId, text) {
+    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 = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
+      const evaluate = (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.message}`);
+      this.logFn(`[AgentStream] sendToSession(${sessionId}) error: ${e.message}`);
       return false;
     }
   }
-  async resolveAgentAction(cdp, agentType, action, targetIdeType) {
-    await this.ensureAgentPanelOpen(agentType, targetIdeType);
-    const agent = this.managed.get(agentType);
+  async resolveSessionAction(cdp, sessionId, action) {
+    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 = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
+      const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
       return await agent.adapter.resolveAction(evaluate, action);
     } catch (e) {
-      this.logFn(`[AgentStream] resolveAction(${agentType}) error: ${e.message}`);
+      this.logFn(`[AgentStream] resolveAction(${sessionId}) error: ${e.message}`);
       return false;
     }
   }
-  async newAgentSession(cdp, agentType, targetIdeType) {
-    await this.ensureAgentPanelOpen(agentType, targetIdeType);
-    const agent = this.managed.get(agentType);
+  async newSession(cdp, sessionId) {
+    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 = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
+      const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
       await agent.adapter.newSession(evaluate);
       return true;
     } catch (e) {
-      this.logFn(`[AgentStream] newSession(${agentType}) error: ${e.message}`);
+      this.logFn(`[AgentStream] newSession(${sessionId}) error: ${e.message}`);
       return false;
     }
   }
-  async listAgentChats(cdp, agentType) {
-    let agent = this.managed.get(agentType);
-    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);
-    }
+  async listSessionChats(cdp, sessionId) {
+    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 = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
+      const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
       return await agent.adapter.listChats(evaluate);
     } catch (e) {
-      this.logFn(`[AgentStream] listChats(${agentType}) error: ${e.message}`);
+      this.logFn(`[AgentStream] listChats(${sessionId}) error: ${e.message}`);
       return [];
     }
   }
-  async switchAgentSession(cdp, agentType, sessionId) {
-    let agent = this.managed.get(agentType);
-    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);
-    }
+  async switchConversation(cdp, sessionId, conversationId) {
+    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 = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
-      return await agent.adapter.switchSession(evaluate, sessionId);
+      const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
+      return await agent.adapter.switchSession(evaluate, conversationId);
     } catch (e) {
-      this.logFn(`[AgentStream] switchSession(${agentType}) error: ${e.message}`);
+      this.logFn(`[AgentStream] switchSession(${sessionId}) error: ${e.message}`);
       return false;
     }
   }
-  async focusAgentEditor(cdp, agentType) {
-    const agent = this.managed.get(agentType);
+  async focusSession(cdp, 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 || typeof agent.adapter.focusEditor !== "function") return false;
     try {
-      const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
+      const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
       await agent.adapter.focusEditor(evaluate);
       return true;
     } catch (e) {
-      this.logFn(`[AgentStream] focusEditor(${agentType}) error: ${e.message}`);
+      this.logFn(`[AgentStream] focusEditor(${sessionId}) error: ${e.message}`);
       return false;
     }
   }
-  getConnectedAgents() {
-    return Array.from(this.managed.keys());
+  getConnectedSessions(parentSessionId) {
+    if (parentSessionId) {
+      return [...this.managedBySessionId.values()].filter((entry) => entry.parentSessionId === parentSessionId).map((entry) => entry.runtimeSessionId);
+    }
+    return [...this.managedBySessionId.keys()];
   }
-  getManagedAgent(agentType) {
-    return this.managed.get(agentType);
+  getManagedSession(sessionId) {
+    return this.managedBySessionId.get(sessionId);
   }
-  async dispose(cdp) {
-    for (const [, agent] of this.managed) {
+  async dispose(cdpManagers) {
+    for (const managed of this.managedBySessionId.values()) {
+      const managerKey = this.getSessionTarget(managed.runtimeSessionId)?.cdpManagerKey;
+      const cdp = managerKey ? cdpManagers.get(managerKey) : null;
+      if (!cdp) continue;
       try {
-        await cdp.detachAgent(agent.sessionId);
+        await cdp.detachAgent(managed.cdpSessionId);
       } catch {
       }
     }
-    this.managed.clear();
+    this.managedBySessionId.clear();
+    this.activeSessionIdByParent.clear();
+    this.lastDiscoveryTimeByParent.clear();
+    this.discoveryIntervalMsByParent.clear();
+  }
+  resolveSessionForAgent(parentSessionId, agentType) {
+    return this.resolveSessionIdForTarget(parentSessionId, agentType);
   }
 };
 
@@ -10317,20 +10445,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;
-    }
+  resetActiveIde(parentSessionId) {
+    this.deps.agentStreamManager.resetParentSession(parentSessionId);
   }
   /** Start polling (idempotent — ignored if already started) */
   start(intervalMs = 5e3) {
@@ -10352,12 +10477,14 @@ var AgentStreamPoller = class {
       agentStreamManager,
       providerLoader,
       instanceManager,
-      cdpManagers
+      cdpManagers,
+      sessionRegistry
     } = this.deps;
     if (!agentStreamManager || cdpManagers.size === 0) return;
     for (const [ideType, cdp] of cdpManagers) {
       registerExtensionProviders(providerLoader, cdp, ideType);
       const ideInstance = instanceManager.getInstance(`ide:${ideType}`);
+      const parentSessionId = ideInstance?.getInstanceId?.();
       if (ideInstance?.getExtensionTypes && ideInstance?.addExtension && ideInstance?.removeExtension) {
         const currentExtTypes = new Set(ideInstance.getExtensionTypes());
         const enabledExtTypes = new Set(
@@ -10365,6 +10492,10 @@ var AgentStreamPoller = class {
         );
         for (const extType of currentExtTypes) {
           if (!enabledExtTypes.has(extType)) {
+            const extInstance = ideInstance.getExtension?.(extType);
+            if (extInstance?.getInstanceId) {
+              sessionRegistry.unregister(extInstance.getInstanceId());
+            }
             ideInstance.removeExtension(extType);
             LOG.info("AgentStream", `Extension removed: ${extType} (disabled for ${ideType})`);
           }
@@ -10375,54 +10506,63 @@ var AgentStreamPoller = class {
             if (extProvider) {
               const extSettings = providerLoader.getSettings(extType);
               ideInstance.addExtension(extProvider, extSettings);
+              const extInstance = ideInstance.getExtension?.(extType);
+              if (parentSessionId && extInstance?.getInstanceId) {
+                sessionRegistry.register({
+                  sessionId: extInstance.getInstanceId(),
+                  parentSessionId,
+                  providerType: extType,
+                  providerCategory: "extension",
+                  transport: "cdp-webview",
+                  cdpManagerKey: ideType,
+                  instanceKey: `ide:${ideType}`
+                });
+              }
               LOG.info("AgentStream", `Extension added: ${extType} (enabled for ${ideType})`);
             }
           }
         }
       }
-      if (this._activeIdeType === ideType && agentStreamManager.activeAgentType) {
-        const activeType = agentStreamManager.activeAgentType;
-        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;
+      const activeSessionId = parentSessionId ? agentStreamManager.getActiveSessionId(parentSessionId) : null;
+      if (activeSessionId) {
+        const activeTarget = sessionRegistry.get(activeSessionId);
+        const enabledExtTypes = new Set(providerLoader.getEnabledExtensionProviders(ideType).map((p) => p.type));
+        if (!activeTarget || !enabledExtTypes.has(activeTarget.providerType)) {
+          LOG.info("AgentStream", `Active agent ${activeTarget?.providerType || activeSessionId} was disabled for ${ideType} \u2014 detaching`);
+          await agentStreamManager.setActiveSession(cdp, parentSessionId, 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 (parentSessionId && activeSessionId) {
+          agentStreamManager.resetParentSession(parentSessionId);
+          this.deps.onStreamsUpdated?.(ideType, []);
         }
-        return;
+        continue;
       }
-      this._activeIdeType = null;
-    }
-    if (!agentStreamManager.activeAgentType) {
-      for (const [ideType, cdp] of cdpManagers) {
-        if (!cdp.isConnected) continue;
+      let resolvedActiveSessionId = activeSessionId;
+      if (!resolvedActiveSessionId && parentSessionId) {
         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;
+          for (const target of discovered) {
+            const sessionId = agentStreamManager.resolveSessionForAgent(parentSessionId, target.agentType);
+            if (sessionId) {
+              resolvedActiveSessionId = sessionId;
+              await agentStreamManager.setActiveSession(cdp, parentSessionId, sessionId);
+              LOG.info("AgentStream", `Auto-activated: ${target.agentType} (${ideType})`);
+              break;
+            }
           }
         } catch {
         }
       }
+      if (!resolvedActiveSessionId || !parentSessionId) continue;
+      try {
+        await agentStreamManager.syncActiveSession(cdp, parentSessionId);
+        const stream = await agentStreamManager.collectActiveSession(cdp, parentSessionId);
+        this.deps.onStreamsUpdated?.(ideType, stream ? [stream] : []);
+      } catch {
+      }
     }
   }
 };
@@ -10509,6 +10649,7 @@ var ProviderInstanceManager = class {
               ...event,
               providerType: instance.type,
               instanceId: state.instanceId,
+              targetSessionId: state.instanceId,
               providerCategory: state.category
             });
           }
@@ -14319,6 +14460,63 @@ function launchIDE(ide, workspacePath) {
   }
 }
 
+// src/sessions/registry.ts
+var SessionRegistry = class {
+  bySessionId = /* @__PURE__ */ new Map();
+  byManagerKey = /* @__PURE__ */ new Map();
+  byInstanceKey = /* @__PURE__ */ new Map();
+  byParentSessionId = /* @__PURE__ */ new Map();
+  register(target) {
+    this.unregister(target.sessionId);
+    this.bySessionId.set(target.sessionId, target);
+    if (target.cdpManagerKey) this.addIndex(this.byManagerKey, target.cdpManagerKey, target.sessionId);
+    if (target.instanceKey) this.addIndex(this.byInstanceKey, target.instanceKey, target.sessionId);
+    if (target.parentSessionId) this.addIndex(this.byParentSessionId, target.parentSessionId, target.sessionId);
+  }
+  get(sessionId) {
+    if (!sessionId) return void 0;
+    return this.bySessionId.get(sessionId);
+  }
+  unregister(sessionId) {
+    if (!sessionId) return;
+    const target = this.bySessionId.get(sessionId);
+    if (!target) return;
+    this.bySessionId.delete(sessionId);
+    if (target.cdpManagerKey) this.removeIndex(this.byManagerKey, target.cdpManagerKey, sessionId);
+    if (target.instanceKey) this.removeIndex(this.byInstanceKey, target.instanceKey, sessionId);
+    if (target.parentSessionId) this.removeIndex(this.byParentSessionId, target.parentSessionId, sessionId);
+  }
+  unregisterByManagerKey(managerKey) {
+    for (const sessionId of [...this.byManagerKey.get(managerKey) || []]) {
+      this.unregister(sessionId);
+    }
+  }
+  unregisterByInstanceKey(instanceKey) {
+    for (const sessionId of [...this.byInstanceKey.get(instanceKey) || []]) {
+      this.unregister(sessionId);
+    }
+  }
+  listChildren(parentSessionId) {
+    const ids = this.byParentSessionId.get(parentSessionId);
+    if (!ids) return [];
+    return [...ids].map((id) => this.bySessionId.get(id)).filter(Boolean);
+  }
+  addIndex(index, key, sessionId) {
+    let set = index.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      index.set(key, set);
+    }
+    set.add(sessionId);
+  }
+  removeIndex(index, key, sessionId) {
+    const set = index.get(key);
+    if (!set) return;
+    set.delete(sessionId);
+    if (set.size === 0) index.delete(key);
+  }
+};
+
 // src/boot/daemon-lifecycle.ts
 init_logger();
 init_config();
@@ -14358,11 +14556,14 @@ async function initDaemonComponents(config) {
   });
   const instanceManager = new ProviderInstanceManager();
   const cdpManagers = /* @__PURE__ */ new Map();
-  const instanceIdMap = /* @__PURE__ */ new Map();
+  const sessionRegistry = new SessionRegistry();
   const detectedIdesRef = { value: [] };
+  let agentStreamManager = null;
+  let poller = null;
   const cliManager = new DaemonCliManager({
     ...config.cliManagerDeps,
-    getInstanceManager: () => instanceManager
+    getInstanceManager: () => instanceManager,
+    getSessionRegistry: () => sessionRegistry
   }, providerLoader);
   LOG.info("Init", "Detecting IDEs...");
   detectedIdesRef.value = await detectIDEs();
@@ -14372,7 +14573,7 @@ async function initDaemonComponents(config) {
     providerLoader,
     instanceManager,
     cdpManagers,
-    instanceIdMap
+    sessionRegistry
   };
   const cdpInitializer = new DaemonCdpInitializer({
     providerLoader,
@@ -14381,6 +14582,19 @@ async function initDaemonComponents(config) {
     onConnected: async (ideType, manager, managerKey) => {
       await setupIdeInstance(cdpSetupContext, { ideType, manager, managerKey });
       await config.onCdpManagerSetup?.(ideType, manager, managerKey);
+    },
+    onDisconnected: async (_ideType, _manager, managerKey) => {
+      sessionRegistry.unregisterByManagerKey(managerKey);
+      const instanceKey = `ide:${managerKey}`;
+      const ideInstance = instanceManager.getInstance(instanceKey);
+      if (ideInstance) {
+        instanceManager.removeInstance(instanceKey);
+        LOG.info("CDP", `Instance removed after disconnect: ${instanceKey}`);
+      }
+      if (ideInstance?.getInstanceId) {
+        agentStreamManager?.resetParentSession(ideInstance.getInstanceId());
+      }
+      config.onStatusChange?.();
     }
   });
   await cdpInitializer.connectAll(detectedIdesRef.value);
@@ -14392,14 +14606,14 @@ async function initDaemonComponents(config) {
     adapters: cliManager.adapters,
     providerLoader,
     instanceManager,
-    instanceIdMap
+    sessionRegistry
   });
-  const agentStreamManager = new DaemonAgentStreamManager(
+  agentStreamManager = new DaemonAgentStreamManager(
     LOG.forComponent("AgentStream").asLogFn(),
-    providerLoader
+    providerLoader,
+    sessionRegistry
   );
   commandHandler.setAgentStreamManager(agentStreamManager);
-  let poller;
   const router = new DaemonCommandRouter({
     commandHandler,
     cliManager,
@@ -14407,7 +14621,7 @@ async function initDaemonComponents(config) {
     providerLoader,
     instanceManager,
     detectedIdes: detectedIdesRef,
-    instanceIdMap,
+    sessionRegistry,
     onCdpManagerCreated: async (ideType, manager) => {
       await setupIdeInstance(cdpSetupContext, { ideType, manager });
       await config.onCdpManagerSetup?.(ideType, manager, ideType);
@@ -14422,6 +14636,7 @@ async function initDaemonComponents(config) {
     providerLoader,
     instanceManager,
     cdpManagers,
+    sessionRegistry,
     onStreamsUpdated: config.onStreamsUpdated
   });
   poller.start();
@@ -14436,7 +14651,7 @@ async function initDaemonComponents(config) {
     poller,
     cdpInitializer,
     cdpManagers,
-    instanceIdMap,
+    sessionRegistry,
     detectedIdes: detectedIdesRef
   };
 }
@@ -14464,9 +14679,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}`);
@@ -14511,10 +14725,7 @@ async function shutdownDaemonComponents(components) {
   ProviderLoader,
   VersionArchive,
   addCliHistory,
-  buildAllManagedEntries,
-  buildManagedAcps,
-  buildManagedClis,
-  buildManagedIdes,
+  buildSessionEntries,
   buildStatusSnapshot,
   connectCdpManager,
   detectAllVersions,
@@ -14537,6 +14748,8 @@ async function shutdownDaemonComponents(components) {
   isCdpConnected,
   isExtensionInstalled,
   isIdeRunning,
+  isManagedStatusWaiting,
+  isManagedStatusWorking,
   isSetupComplete,
   killIdeProcess,
   launchIDE,
@@ -14544,6 +14757,8 @@ async function shutdownDaemonComponents(components) {
   loadConfig,
   logCommand,
   markSetupComplete,
+  normalizeActiveChatData,
+  normalizeManagedStatus,
   probeCdpPort,
   readChatHistory,
   registerExtensionProviders,