adhdev 0.6.79 → 0.7.1

package/dist/index.js

@@ -1657,7 +1657,11 @@ var init_manager = __esm({
       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);
@@ -1781,6 +1785,20 @@ var init_manager = __esm({
       }
       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 url2 = node?.frame?.url;
+            if (typeof url2 === "string" && url2.includes("vscode-webview")) {
+              urls.add(url2);
+            }
+            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'))
@@ -2966,7 +2984,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);
@@ -2982,14 +3000,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;
 }
@@ -3075,6 +3109,7 @@ var init_initializer = __esm({
       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;
@@ -3127,6 +3162,34 @@ var init_initializer = __esm({
           }
         }
       }
+      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.
@@ -3224,112 +3287,191 @@ 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: normalizeActiveChatData(state.activeChat),
-      chats: [],
-      agentStreams: state.extensions.map((ext) => ({
-        agentType: ext.type,
-        agentName: ext.name,
-        extensionId: ext.type,
-        status: normalizeManagedStatus(ext.status, { activeModal: ext.activeChat?.activeModal || null }),
-        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((s15) => s15.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;
+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((s15) => ({
-    id: s15.instanceId,
-    instanceId: s15.instanceId,
-    cliType: s15.type,
-    cliName: s15.name,
-    status: normalizeManagedStatus(s15.status, { activeModal: s15.activeChat?.activeModal || null }),
-    mode: "terminal",
-    workspace: s15.workspace || "",
-    activeChat: normalizeActiveChatData(s15.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((s15) => ({
-    id: s15.instanceId,
-    acpType: s15.type,
-    acpName: s15.name,
-    status: normalizeManagedStatus(s15.status, { activeModal: s15.activeChat?.activeModal || null }),
-    mode: "chat",
-    workspace: s15.workspace || "",
-    activeChat: normalizeActiveChatData(s15.activeChat),
-    currentModel: s15.currentModel,
-    currentPlan: s15.currentPlan,
-    acpConfigOptions: s15.acpConfigOptions,
-    acpModes: s15.acpModes,
-    errorMessage: s15.errorMessage,
-    errorReason: s15.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 buildAllManagedEntries(allStates, cdpManagers, opts) {
+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 buildSessionEntries(allStates, cdpManagers) {
+  const sessions = [];
   const ideStates = allStates.filter((s15) => s15.category === "ide");
   const cliStates = allStates.filter((s15) => s15.category === "cli");
   const acpStates = allStates.filter((s15) => s15.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;
 }
+var IDE_SESSION_CAPABILITIES, EXTENSION_SESSION_CAPABILITIES, PTY_SESSION_CAPABILITIES, ACP_SESSION_CAPABILITIES;
 var init_builders = __esm({
   "../../oss/packages/daemon-core/src/status/builders.ts"() {
     "use strict";
     init_normalize();
+    IDE_SESSION_CAPABILITIES = [
+      "read_chat",
+      "send_message",
+      "new_session",
+      "list_sessions",
+      "switch_session",
+      "resolve_action",
+      "change_model",
+      "set_mode",
+      "set_thought_level"
+    ];
+    EXTENSION_SESSION_CAPABILITIES = [
+      "read_chat",
+      "send_message",
+      "new_session",
+      "list_sessions",
+      "switch_session",
+      "resolve_action",
+      "change_model",
+      "set_mode"
+    ];
+    PTY_SESSION_CAPABILITIES = [
+      "read_chat",
+      "send_message",
+      "resolve_action",
+      "terminal_io",
+      "resize_terminal"
+    ];
+    ACP_SESSION_CAPABILITIES = [
+      "read_chat",
+      "send_message",
+      "new_session",
+      "resolve_action",
+      "change_model",
+      "set_mode",
+      "set_thought_level"
+    ];
   }
 });
 
 // ../../oss/packages/daemon-core/src/commands/chat-commands.ts
+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, ts3] of recentSendByTarget.entries()) {
+    if (now - ts3 > 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) {
@@ -3373,7 +3515,7 @@ async function handleReadChat(h, args) {
             provider.type || "unknown_extension",
             parsed.messages || [],
             parsed.title,
-            args?.instanceId
+            args?.targetSessionId
           );
           return { success: true, ...parsed };
         }
@@ -3383,15 +3525,18 @@ async function handleReadChat(h, args) {
     }
     if (h.agentStream) {
       const cdp2 = h.getCdp();
-      if (cdp2 && h.currentIdeType) {
-        const streams = await h.agentStream.collectAgentStreams(cdp2, h.currentIdeType);
-        const stream = streams.find((s15) => s15.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 };
         }
@@ -3418,10 +3563,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 };
         }
@@ -3445,10 +3590,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 };
       }
@@ -3463,16 +3608,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) {
@@ -3508,8 +3658,9 @@ async function handleSendChat(h, args) {
     } catch (e) {
       _log(`Extension script error: ${e.message}`);
     }
-    if (h.agentStream && h.getCdp() && h.currentIdeType) {
-      const ok = await h.agentStream.sendToAgent(h.getCdp(), h.currentIdeType, 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");
@@ -3519,45 +3670,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 {
@@ -3584,7 +3701,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) {
@@ -3607,20 +3747,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");
@@ -3628,9 +3792,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() && h.currentIdeType) {
+  if (provider?.category === "extension" && h.agentStream && h.getCdp() && h.currentSession?.sessionId) {
     try {
-      const chats = await h.agentStream.listAgentChats(h.getCdp(), h.currentIdeType, 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) {
@@ -3689,8 +3853,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() && h.currentIdeType) {
-    const ok = await h.agentStream.newAgentSession(h.getCdp(), h.currentIdeType, 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 {
@@ -3714,15 +3878,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() && h.currentIdeType) {
-    const ok = await h.agentStream.switchAgentSession(h.getCdp(), h.currentIdeType, 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) });
@@ -3864,7 +4028,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}`);
@@ -3985,14 +4149,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() && h.currentIdeType) {
-    const ok = await h.agentStream.resolveAgentAction(
-      h.getCdp(),
-      h.currentIdeType,
-      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) {
@@ -4070,11 +4228,14 @@ async function handleResolveAction(h, args) {
   }
   return { success: false, error: "resolveAction script not available for this provider" };
 }
+var RECENT_SEND_WINDOW_MS, recentSendByTarget;
 var init_chat_commands = __esm({
   "../../oss/packages/daemon-core/src/commands/chat-commands.ts"() {
     "use strict";
     init_chat_history();
     init_logger();
+    RECENT_SEND_WINDOW_MS = 1200;
+    recentSendByTarget = /* @__PURE__ */ new Map();
   }
 });
 
@@ -4363,157 +4524,37 @@ var init_cdp_commands = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/commands/stream-commands.ts
-async function handleAgentStreamSwitch(h, args) {
-  if (!h.agentStream || !h.getCdp() || !h.currentIdeType) return { success: false, error: "AgentStream or CDP not available" };
-  const agentType = args?.agentType || args?.agent || null;
-  await h.agentStream.switchActiveAgent(h.getCdp(), h.currentIdeType, agentType);
-  return { success: true, activeAgent: agentType };
-}
-async function handleAgentStreamRead(h, args) {
-  if (!h.agentStream || !h.getCdp() || !h.currentIdeType) return { success: false, error: "AgentStream or CDP not available" };
-  const streams = await h.agentStream.collectAgentStreams(h.getCdp(), h.currentIdeType);
-  return { success: true, streams };
-}
-async function handleAgentStreamSend(h, args) {
-  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.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
-  if (!resolvedAgent) return { success: false, error: "agentType required" };
-  if (!h.currentIdeType) return { success: false, error: "ideType required" };
-  const ok = await h.agentStream.sendToAgent(h.getCdp(), h.currentIdeType, resolvedAgent, text, h.currentIdeType);
-  return { success: ok };
-}
-async function handleAgentStreamResolve(h, args) {
-  if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
-  const action = args?.action || "approve";
-  if (!agentType) return { success: false, error: "agentType required" };
-  if (!h.currentIdeType) return { success: false, error: "ideType required" };
-  const ok = await h.agentStream.resolveAgentAction(h.getCdp(), h.currentIdeType, agentType, action, h.currentIdeType);
-  return { success: ok };
-}
-async function handleAgentStreamNew(h, args) {
-  if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
-  if (!agentType) return { success: false, error: "agentType required" };
-  if (!h.currentIdeType) return { success: false, error: "ideType required" };
-  const ok = await h.agentStream.newAgentSession(h.getCdp(), h.currentIdeType, agentType, h.currentIdeType);
-  return { success: ok };
-}
-async function handleAgentStreamListChats(h, args) {
-  if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
-  if (!agentType) return { success: false, error: "agentType required" };
-  if (!h.currentIdeType) return { success: false, error: "ideType required" };
-  const chats = await h.agentStream.listAgentChats(h.getCdp(), h.currentIdeType, agentType);
-  return { success: true, chats };
-}
-async function handleAgentStreamSwitchSession(h, args) {
-  if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
-  const sessionId = args?.sessionId || args?.id;
-  if (!agentType || !sessionId) return { success: false, error: "agentType and sessionId required" };
-  if (!h.currentIdeType) return { success: false, error: "ideType required" };
-  const ok = await h.agentStream.switchAgentSession(h.getCdp(), h.currentIdeType, agentType, sessionId);
-  return { success: ok };
-}
-async function handleAgentStreamFocus(h, args) {
+async function handleFocusSession(h, args) {
   if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
-  const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
-  if (!agentType) return { success: false, error: "agentType required" };
-  await h.agentStream.ensureAgentPanelOpen(agentType, h.currentIdeType);
-  if (!h.currentIdeType) return { success: false, error: "ideType required" };
-  const ok = await h.agentStream.focusAgentEditor(h.getCdp(), h.currentIdeType, 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"}` };
+  }
+  if (force) {
+    adapter.resize(cols - 1, rows);
+    setTimeout(() => adapter.resize(cols, rows), 50);
+  } else {
+    adapter.resize(cols, rows);
   }
-  return { success: false, error: `CLI adapter not found: ${cliType}` };
+  return { success: true };
 }
 function handleGetProviderSettings(h, args) {
   const loader = h.ctx.providerLoader;
@@ -4549,7 +4590,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" };
@@ -4570,21 +4611,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) {
@@ -4655,7 +4697,7 @@ function handleGetIdeExtensions(h, args) {
       enabled: config2.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 || {};
@@ -4794,10 +4836,8 @@ var init_handler = __esm({
       _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));
@@ -4813,20 +4853,25 @@ var init_handler = __esm({
       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 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 currentSession() {
+        return this._currentRoute.session;
+      }
+      /** 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);
+        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;
       }
@@ -4834,7 +4879,7 @@ var init_handler = __esm({
        * 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;
@@ -4867,14 +4912,22 @@ var init_handler = __esm({
         const cdp = this.getCdp();
         if (!cdp?.isConnected) return null;
         if (provider?.category === "extension") {
-          let sessionId = this.getExtensionSessionId(provider, this._currentIdeType);
-          if (!sessionId && this._agentStream && this._currentIdeType) {
-            await this._agentStream.switchActiveAgent(cdp, this._currentIdeType, provider.type);
-            await this._agentStream.syncAgentSessions(cdp, this._currentIdeType);
-            sessionId = this.getExtensionSessionId(provider, this._currentIdeType);
+          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);
@@ -4882,57 +4935,37 @@ var init_handler = __esm({
       }
       /** 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, scopeKey) {
-        if (provider.category !== "extension" || !this._agentStream || !scopeKey) return null;
-        const managed = this._agentStream.getManagedAgent(provider.type, scopeKey);
-        return managed?.sessionId || null;
-      }
-      resolveManagerKeyFromInstanceId(instanceId) {
-        const mapped = this._ctx.instanceIdMap?.get(instanceId);
-        if (mapped) return mapped;
-        const entries = this._ctx.instanceManager?.instances?.entries?.();
-        if (!entries) return void 0;
-        for (const [instanceKey, instance] of entries) {
-          if (typeof instanceKey !== "string" || !instanceKey.startsWith("ide:")) continue;
-          if (typeof instance?.getInstanceId === "function" && instance.getInstanceId() === instanceId) {
-            const managerKey = instanceKey.slice(4);
-            this._ctx.instanceIdMap?.set(instanceId, managerKey);
-            return managerKey;
-          }
-          if (typeof instance?.getExtensionInstances === "function") {
-            for (const ext of instance.getExtensionInstances() || []) {
-              if (typeof ext?.getInstanceId === "function" && ext.getInstanceId() === instanceId) {
-                const managerKey = instanceKey.slice(4);
-                this._ctx.instanceIdMap?.set(instanceId, managerKey);
-                return managerKey;
-              }
-            }
-          }
-        }
-        return void 0;
-      }
-      /** Extract ideType from _targetInstance or explicit ideType */
+      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.resolveManagerKeyFromInstanceId(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;
           }
@@ -4943,34 +4976,6 @@ var init_handler = __esm({
             }
           }
         }
-        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];
-          const mappedKey = this.resolveManagerKeyFromInstanceId(raw);
-          if (mappedKey) {
-            return mappedKey;
-          }
-          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) {
@@ -4978,12 +4983,11 @@ var init_handler = __esm({
       }
       // ─── 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 {
@@ -5074,22 +5078,8 @@ var init_handler = __esm({
           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);
@@ -8487,8 +8477,7 @@ var init_router = __esm({
       "new_chat",
       "switch_chat",
       "set_mode",
-      "change_model",
-      "agent_stream_send"
+      "change_model"
     ];
     DaemonCommandRouter = class {
       deps;
@@ -8726,6 +8715,7 @@ var init_router = __esm({
             } catch {
             }
             this.deps.cdpManagers.delete(key);
+            this.deps.sessionRegistry.unregisterByManagerKey(key);
             LOG.info("StopIDE", `CDP disconnected: ${key}`);
           }
         }
@@ -8738,14 +8728,6 @@ var init_router = __esm({
         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}`);
           }
@@ -8754,14 +8736,6 @@ var init_router = __esm({
           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}`);
           }
@@ -8810,15 +8784,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,
@@ -8840,9 +8808,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,
@@ -8973,7 +8939,7 @@ var init_reporter = __esm({
             LOG.info("StatusReport", `\u2192${target} ${baseSummary}`);
           }
         }
-        const { managedIdes, managedClis, managedAcps } = buildAllManagedEntries(
+        const sessions = buildSessionEntries(
           allStates,
           this.deps.cdpManagers
         );
@@ -9004,23 +8970,20 @@ var init_reporter = __esm({
         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
@@ -36001,6 +35964,9 @@ var init_acp_provider_instance = __esm({
           );
         }
       }
+      getInstanceId() {
+        return this.instanceId;
+      }
       // ─── ACP Config Options & Modes ─────────────────────
       parseConfigOptions(raw) {
         if (!Array.isArray(raw)) return;
@@ -36797,6 +36763,7 @@ var init_cli_manager = __esm({
         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");
@@ -36820,6 +36787,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,
@@ -36877,9 +36854,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);
@@ -36901,6 +36887,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();
@@ -36961,12 +36948,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}`);
@@ -36981,7 +36970,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)
       */
@@ -37049,7 +37038,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 {
@@ -37081,7 +37070,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);
@@ -37093,7 +37082,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;
@@ -37257,14 +37246,8 @@ var init_manager2 = __esm({
     init_provider_adapter();
     init_logger();
     DaemonAgentStreamManager = class {
-      allAdapters = [];
-      managedByScope = /* @__PURE__ */ new Map();
-      enabled = true;
-      logFn;
-      lastDiscoveryTimeByScope = /* @__PURE__ */ new Map();
-      discoveryIntervalMsByScope = /* @__PURE__ */ new Map();
-      activeAgentTypeByScope = /* @__PURE__ */ new Map();
-      constructor(logFn, providerLoader) {
+      constructor(logFn, providerLoader, sessionRegistry) {
+        this.sessionRegistry = sessionRegistry;
         this.logFn = logFn || LOG.forComponent("AgentStream").asLogFn();
         if (providerLoader) {
           const allExtProviders = providerLoader.getByCategory("extension");
@@ -37272,257 +37255,278 @@ var init_manager2 = __esm({
             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;
       }
-      getActiveAgentType(scopeKey) {
-        return this.activeAgentTypeByScope.get(scopeKey) || null;
+      getActiveSessionId(parentSessionId) {
+        return this.activeSessionIdByParent.get(parentSessionId) || null;
       }
-      getManagedScope(scopeKey) {
-        let managed = this.managedByScope.get(scopeKey);
-        if (!managed) {
-          managed = /* @__PURE__ */ new Map();
-          this.managedByScope.set(scopeKey, managed);
-        }
-        return managed;
+      getSessionTarget(sessionId) {
+        return this.sessionRegistry?.get(sessionId);
       }
-      resetScope(scopeKey) {
-        this.managedByScope.delete(scopeKey);
-        this.activeAgentTypeByScope.delete(scopeKey);
-        this.lastDiscoveryTimeByScope.delete(scopeKey);
-        this.discoveryIntervalMsByScope.delete(scopeKey);
+      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 switchActiveAgent(cdp, scopeKey, agentType) {
-        const managed = this.getManagedScope(scopeKey);
-        const previousAgentType = this.getActiveAgentType(scopeKey);
-        if (previousAgentType === agentType) return;
-        if (previousAgentType) {
-          const prev = managed.get(previousAgentType);
+      async ensureSessionPanelOpen(_sessionId) {
+      }
+      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 {
             }
-            managed.delete(previousAgentType);
-            this.logFn(`[AgentStream] Deactivated: ${prev.adapter.agentName} (${scopeKey})`);
-          }
-        }
-        this.activeAgentTypeByScope.set(scopeKey, agentType);
-        this.lastDiscoveryTimeByScope.set(scopeKey, 0);
-        if (!agentType && managed.size === 0) {
-          this.managedByScope.delete(scopeKey);
-        }
-        this.logFn(`[AgentStream] Active agent (${scopeKey}): ${agentType || "none"}`);
+            this.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, scopeKey) {
-        const activeAgentType = this.getActiveAgentType(scopeKey);
-        if (!this.enabled || !activeAgentType) return;
+      async syncActiveSession(cdp, parentSessionId) {
+        const activeSessionId = this.getActiveSessionId(parentSessionId);
+        if (!this.enabled || !activeSessionId) return;
         const now = Date.now();
-        const managed = this.getManagedScope(scopeKey);
-        const lastDiscoveryTime = this.lastDiscoveryTimeByScope.get(scopeKey) || 0;
-        const discoveryIntervalMs = this.discoveryIntervalMsByScope.get(scopeKey) || 1e4;
-        if (managed.has(activeAgentType) && now - lastDiscoveryTime < discoveryIntervalMs) {
+        const managed = this.managedBySessionId.get(activeSessionId);
+        const lastDiscoveryTime = this.lastDiscoveryTimeByParent.get(parentSessionId) || 0;
+        const discoveryIntervalMs = this.discoveryIntervalMsByParent.get(parentSessionId) || 1e4;
+        if (managed && now - lastDiscoveryTime < discoveryIntervalMs) {
           return;
         }
-        this.lastDiscoveryTimeByScope.set(scopeKey, now);
+        this.lastDiscoveryTimeByParent.set(parentSessionId, now);
         try {
-          const targets = await cdp.discoverAgentWebviews();
-          const activeTarget = targets.find((t) => t.agentType === activeAgentType);
-          if (activeTarget && !managed.has(activeAgentType)) {
-            const adapter = this.allAdapters.find((a) => a.agentType === activeAgentType);
-            if (adapter) {
-              const sessionId = await cdp.attachToAgent(activeTarget);
-              if (sessionId) {
-                managed.set(activeAgentType, {
-                  adapter,
-                  sessionId,
-                  target: activeTarget,
-                  lastState: null,
-                  lastError: null,
-                  lastHiddenCheckTime: 0
-                });
-                this.logFn(`[AgentStream] Connected: ${adapter.agentName} (${scopeKey})`);
-              }
-            }
-          }
-          for (const [type, agent] of managed) {
-            if (type !== activeAgentType) {
-              await cdp.detachAgent(agent.sessionId);
-              managed.delete(type);
-            }
+          if (!managed) {
+            await this.connectManagedSession(cdp, parentSessionId, activeSessionId);
           }
-          this.discoveryIntervalMsByScope.set(scopeKey, managed.has(activeAgentType) ? 3e4 : 1e4);
+          this.discoveryIntervalMsByParent.set(parentSessionId, this.managedBySessionId.has(activeSessionId) ? 3e4 : 1e4);
         } catch (e) {
-          this.logFn(`[AgentStream] sync error (${scopeKey}): ${e.message}`);
+          this.logFn(`[AgentStream] sync error (${parentSessionId}): ${e.message}`);
         }
       }
-      /** Collect active agent status */
-      async collectAgentStreams(cdp, scopeKey) {
-        if (!this.enabled) return [];
-        const results = [];
-        const activeAgentType = this.getActiveAgentType(scopeKey);
-        const managed = this.managedByScope.get(scopeKey);
-        if (activeAgentType && managed?.has(activeAgentType)) {
-          const agent = managed.get(activeAgentType);
-          const type = activeAgentType;
-          const isHidden = agent.lastState?.status === "panel_hidden";
-          const hiddenCacheFresh = isHidden && Date.now() - agent.lastHiddenCheckTime < 3e4;
-          if (hiddenCacheFresh) {
-            results.push(agent.lastState);
-          } else {
+      /** 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();
+          }
+          return state;
+        } catch (e) {
+          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 {
-                }
-                managed.delete(type);
-                this.lastDiscoveryTimeByScope.set(scopeKey, 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, scopeKey, agentType, text, targetIdeType) {
-        await this.ensureAgentPanelOpen(agentType, targetIdeType);
-        const agent = this.getManagedAgent(agentType, scopeKey);
+      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, scopeKey, agentType, action, targetIdeType) {
-        await this.ensureAgentPanelOpen(agentType, targetIdeType);
-        const agent = this.getManagedAgent(agentType, scopeKey);
+      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, scopeKey, agentType, targetIdeType) {
-        await this.ensureAgentPanelOpen(agentType, targetIdeType);
-        const agent = this.getManagedAgent(agentType, scopeKey);
+      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, scopeKey, agentType) {
-        let agent = this.getManagedAgent(agentType, scopeKey);
-        if (!agent) {
-          this.logFn(`[AgentStream] listChats: ${agentType} not managed in ${scopeKey}, trying on-demand activation`);
-          await this.switchActiveAgent(cdp, scopeKey, agentType);
-          await this.syncAgentSessions(cdp, scopeKey);
-          agent = this.getManagedAgent(agentType, scopeKey);
-        }
+      async listSessionChats(cdp, 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, scopeKey, agentType, sessionId) {
-        let agent = this.getManagedAgent(agentType, scopeKey);
-        if (!agent) {
-          this.logFn(`[AgentStream] switchSession: ${agentType} not managed in ${scopeKey}, trying on-demand activation`);
-          await this.switchActiveAgent(cdp, scopeKey, agentType);
-          await this.syncAgentSessions(cdp, scopeKey);
-          agent = this.getManagedAgent(agentType, scopeKey);
-        }
+      async switchConversation(cdp, 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, scopeKey, agentType) {
-        const agent = this.getManagedAgent(agentType, scopeKey);
+      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(scopeKey) {
-        if (scopeKey) return Array.from((this.managedByScope.get(scopeKey) || /* @__PURE__ */ new Map()).keys());
-        return Array.from(this.managedByScope.values()).flatMap((scope) => Array.from(scope.keys()));
+      getConnectedSessions(parentSessionId) {
+        if (parentSessionId) {
+          return [...this.managedBySessionId.values()].filter((entry) => entry.parentSessionId === parentSessionId).map((entry) => entry.runtimeSessionId);
+        }
+        return [...this.managedBySessionId.keys()];
       }
-      getManagedAgent(agentType, scopeKey) {
-        return this.managedByScope.get(scopeKey)?.get(agentType);
+      getManagedSession(sessionId) {
+        return this.managedBySessionId.get(sessionId);
       }
       async dispose(cdpManagers) {
-        for (const [scopeKey, managed] of this.managedByScope) {
-          const cdp = cdpManagers.get(scopeKey);
+        for (const managed of this.managedBySessionId.values()) {
+          const managerKey = this.getSessionTarget(managed.runtimeSessionId)?.cdpManagerKey;
+          const cdp = managerKey ? cdpManagers.get(managerKey) : null;
           if (!cdp) continue;
-          for (const [, agent] of managed) {
-            try {
-              await cdp.detachAgent(agent.sessionId);
-            } catch {
-            }
+          try {
+            await cdp.detachAgent(managed.cdpSessionId);
+          } catch {
           }
         }
-        this.managedByScope.clear();
-        this.activeAgentTypeByScope.clear();
-        this.lastDiscoveryTimeByScope.clear();
-        this.discoveryIntervalMsByScope.clear();
+        this.managedBySessionId.clear();
+        this.activeSessionIdByParent.clear();
+        this.lastDiscoveryTimeByParent.clear();
+        this.discoveryIntervalMsByParent.clear();
+      }
+      resolveSessionForAgent(parentSessionId, agentType) {
+        return this.resolveSessionIdForTarget(parentSessionId, agentType);
       }
     };
   }
@@ -37553,8 +37557,8 @@ var init_poller = __esm({
         return null;
       }
       /** Reset active IDE tracking (e.g., when IDE is stopped) */
-      resetActiveIde(ideType) {
-        this.deps.agentStreamManager.resetScope(ideType);
+      resetActiveIde(parentSessionId) {
+        this.deps.agentStreamManager.resetParentSession(parentSessionId);
       }
       /** Start polling (idempotent — ignored if already started) */
       start(intervalMs = 5e3) {
@@ -37576,12 +37580,14 @@ var init_poller = __esm({
           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(
@@ -37589,6 +37595,10 @@ var init_poller = __esm({
             );
             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})`);
               }
@@ -37599,46 +37609,61 @@ var init_poller = __esm({
                 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})`);
                 }
               }
             }
           }
-          const activeType = agentStreamManager.getActiveAgentType(ideType);
-          if (activeType) {
-            const enabledExtTypes = new Set(
-              providerLoader.getEnabledExtensionProviders(ideType).map((p) => p.type)
-            );
-            if (!enabledExtTypes.has(activeType)) {
-              LOG.info("AgentStream", `Active agent ${activeType} was disabled for ${ideType} \u2014 detaching`);
-              await agentStreamManager.switchActiveAgent(cdp, ideType, 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 (!cdp.isConnected) {
-            if (activeType) {
-              agentStreamManager.resetScope(ideType);
+            if (parentSessionId && activeSessionId) {
+              agentStreamManager.resetParentSession(parentSessionId);
               this.deps.onStreamsUpdated?.(ideType, []);
             }
             continue;
           }
-          let resolvedActiveType = activeType;
-          if (!resolvedActiveType) {
+          let resolvedActiveSessionId = activeSessionId;
+          if (!resolvedActiveSessionId && parentSessionId) {
             try {
               const discovered = await cdp.discoverAgentWebviews();
-              if (discovered.length > 0) {
-                resolvedActiveType = discovered[0].agentType;
-                await agentStreamManager.switchActiveAgent(cdp, ideType, resolvedActiveType);
-                LOG.info("AgentStream", `Auto-activated: ${resolvedActiveType} (${ideType})`);
+              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 (!resolvedActiveType) continue;
+          if (!resolvedActiveSessionId || !parentSessionId) continue;
           try {
-            await agentStreamManager.syncAgentSessions(cdp, ideType);
-            const streams = await agentStreamManager.collectAgentStreams(cdp, ideType);
-            this.deps.onStreamsUpdated?.(ideType, streams);
+            await agentStreamManager.syncActiveSession(cdp, parentSessionId);
+            const stream = await agentStreamManager.collectActiveSession(cdp, parentSessionId);
+            this.deps.onStreamsUpdated?.(ideType, stream ? [stream] : []);
           } catch {
           }
         }
@@ -37749,6 +37774,7 @@ var init_provider_instance_manager = __esm({
                   ...event,
                   providerType: instance.type,
                   instanceId: state.instanceId,
+                  targetSessionId: state.instanceId,
                   providerCategory: state.category
                 });
               }
@@ -41403,6 +41429,69 @@ var init_installer = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/src/sessions/registry.ts
+var SessionRegistry;
+var init_registry = __esm({
+  "../../oss/packages/daemon-core/src/sessions/registry.ts"() {
+    "use strict";
+    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 set2 = index.get(key);
+        if (!set2) {
+          set2 = /* @__PURE__ */ new Set();
+          index.set(key, set2);
+        }
+        set2.add(sessionId);
+      }
+      removeIndex(index, key, sessionId) {
+        const set2 = index.get(key);
+        if (!set2) return;
+        set2.delete(sessionId);
+        if (set2.size === 0) index.delete(key);
+      }
+    };
+  }
+});
+
 // ../../oss/packages/daemon-core/src/boot/daemon-lifecycle.ts
 async function initDaemonComponents(config2) {
   installGlobalInterceptor();
@@ -41440,11 +41529,14 @@ async function initDaemonComponents(config2) {
   });
   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({
     ...config2.cliManagerDeps,
-    getInstanceManager: () => instanceManager
+    getInstanceManager: () => instanceManager,
+    getSessionRegistry: () => sessionRegistry
   }, providerLoader);
   LOG.info("Init", "Detecting IDEs...");
   detectedIdesRef.value = await detectIDEs();
@@ -41454,7 +41546,7 @@ async function initDaemonComponents(config2) {
     providerLoader,
     instanceManager,
     cdpManagers,
-    instanceIdMap
+    sessionRegistry
   };
   const cdpInitializer = new DaemonCdpInitializer({
     providerLoader,
@@ -41463,6 +41555,19 @@ async function initDaemonComponents(config2) {
     onConnected: async (ideType, manager, managerKey) => {
       await setupIdeInstance(cdpSetupContext, { ideType, manager, managerKey });
       await config2.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());
+      }
+      config2.onStatusChange?.();
     }
   });
   await cdpInitializer.connectAll(detectedIdesRef.value);
@@ -41474,14 +41579,14 @@ async function initDaemonComponents(config2) {
     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,
@@ -41489,7 +41594,7 @@ async function initDaemonComponents(config2) {
     providerLoader,
     instanceManager,
     detectedIdes: detectedIdesRef,
-    instanceIdMap,
+    sessionRegistry,
     onCdpManagerCreated: async (ideType, manager) => {
       await setupIdeInstance(cdpSetupContext, { ideType, manager });
       await config2.onCdpManagerSetup?.(ideType, manager, ideType);
@@ -41504,6 +41609,7 @@ async function initDaemonComponents(config2) {
     providerLoader,
     instanceManager,
     cdpManagers,
+    sessionRegistry,
     onStreamsUpdated: config2.onStreamsUpdated
   });
   poller.start();
@@ -41518,7 +41624,7 @@ async function initDaemonComponents(config2) {
     poller,
     cdpInitializer,
     cdpManagers,
-    instanceIdMap,
+    sessionRegistry,
     detectedIdes: detectedIdesRef
   };
 }
@@ -41571,6 +41677,7 @@ var init_daemon_lifecycle = __esm({
     init_provider_instance_manager();
     init_dev_server();
     init_ide_detector();
+    init_registry();
     init_logger();
     init_config();
   }
@@ -42926,7 +43033,7 @@ var init_adhdev_daemon = __esm({
     fs12 = __toESM(require("fs"));
     path14 = __toESM(require("path"));
     import_chalk2 = __toESM(require("chalk"));
-    pkgVersion = "0.6.79";
+    pkgVersion = "0.7.1";
     if (pkgVersion === "unknown") {
       try {
         const possiblePaths = [
@@ -43204,7 +43311,7 @@ ${err?.stack || ""}`);
         });
       }
       async handleCommand(msg, cmd, args) {
-        LOG.info("Command", `${cmd}${args?._targetInstance ? ` \u2192 ${args._targetType}:${args._targetInstance.split("_")[0]}` : ""}`);
+        LOG.info("Command", `${cmd}${args?.targetSessionId ? ` \u2192 session:${String(args.targetSessionId).split("_")[0]}` : ""}`);
         const cmdStart = Date.now();
         const source = msg.ipcWs ? "ext" : "ws";
         try {
@@ -43320,24 +43427,13 @@ ${err?.stack || ""}`);
       // ─── CDP helpers ─────────────────────────────
       /** Return CDP manager for specific IDE.
        *  Lookup order:
-       *  1. instanceIdMap (UUID → managerKey) — for multi-window UUID instance IDs
-       *  2. Exact match on cdpManagers (key = "cursor", "antigravity")
-       *  3. Prefix match (multi-window: "antigravity_WorkspaceName")
+       *  1. Exact match on cdpManagers (full manager key)
+       *  2. Prefix match on cdpManagers (ideType_workspace)
        */
       getCdpFor(ideType) {
         if (!this.components) return null;
         const key = ideType.toLowerCase();
-        const mappedKey = this.components.instanceIdMap.get(ideType) || this.components.instanceIdMap.get(key);
-        if (mappedKey) {
-          const mapped = this.components.cdpManagers.get(mappedKey);
-          if (mapped?.isConnected) return mapped;
-        }
-        const exact = this.components.cdpManagers.get(key);
-        if (exact) return exact;
-        for (const [k, m] of this.components.cdpManagers.entries()) {
-          if (k.startsWith(key + "_") && m.isConnected) return m;
-        }
-        return null;
+        return findCdpManager(this.components.cdpManagers, key);
       }
     };
   }