@adhdev/daemon-core 0.6.77 → 0.7.0

package/src/commands/handler.ts

@@ -5,7 +5,7 @@
  * the correct CDP manager or CLI adapter.
  *
  * Key concepts:
- *   - extractIdeType(): determines target IDE from _targetInstance
+ *   - extractIdeType(): determines target IDE from targetSessionId or ideType
  *   - getCdp(): returns the DaemonCdpManager for current command
  *   - getProvider(): returns the ProviderModule for current command
  *   - handle(): main entry point, sets context then dispatches
@@ -20,6 +20,7 @@ import type { ProviderModule } from '../providers/contracts.js';
 import type { DaemonAgentStreamManager } from '../agent-stream/index.js';
 import { loadConfig } from '../config/config.js';
 import { ChatHistoryWriter } from '../config/chat-history.js';
+import type { SessionRegistry, SessionRuntimeTarget } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
 
 // Sub-module imports
@@ -42,8 +43,7 @@ export interface CommandContext {
     providerLoader?: ProviderLoader;
     /** ProviderInstanceManager — for runtime settings propagation */
     instanceManager?: ProviderInstanceManager;
-    /** UUID instanceId → CDP manager key (ideType) mapping */
-    instanceIdMap?: Map<string, string>;
+    sessionRegistry?: SessionRegistry;
 }
 
 /**
@@ -56,8 +56,10 @@ export interface CommandHelpers {
     getProviderScript(scriptName: string, params?: Record<string, string>, ideType?: string): string | null;
     evaluateProviderScript(scriptName: string, params?: Record<string, string>, timeout?: number): Promise<{ result: any; category: string } | null>;
     getCliAdapter(type?: string): any | null;
+    readonly currentManagerKey: string | undefined;
     readonly currentIdeType: string | undefined;
     readonly currentProviderType: string | undefined;
+    readonly currentSession: SessionRuntimeTarget | undefined;
     readonly agentStream: DaemonAgentStreamManager | null;
     readonly ctx: CommandContext;
     readonly historyWriter: ChatHistoryWriter;
@@ -69,10 +71,12 @@ export class DaemonCommandHandler implements CommandHelpers {
     private domHandlers: CdpDomHandlers;
     private _historyWriter: ChatHistoryWriter;
 
-    /** Current IDE type extracted from command args (per-request) */
-    private _currentIdeType: string | undefined;
-    /** Current provider type — agentType priority, ideType use */
-    private _currentProviderType: string | undefined;
+    /** Current request route context */
+    private _currentRoute: {
+        session?: SessionRuntimeTarget;
+        managerKey?: string;
+        providerType?: string;
+    } = {};
 
     constructor(ctx: CommandContext) {
         this._ctx = ctx;
@@ -85,19 +89,18 @@ export class DaemonCommandHandler implements CommandHelpers {
     get ctx(): CommandContext { return this._ctx; }
     get agentStream(): DaemonAgentStreamManager | null { return this._agentStream; }
     get historyWriter(): ChatHistoryWriter { return this._historyWriter; }
-    get currentIdeType(): string | undefined { return this._currentIdeType; }
-    get currentProviderType(): string | undefined { return this._currentProviderType; }
+    get currentManagerKey(): string | undefined { return this._currentRoute.managerKey; }
+    get currentIdeType(): string | undefined { return this._currentRoute.managerKey; }
+    get currentProviderType(): string | undefined { return this._currentRoute.providerType; }
+    get currentSession(): SessionRuntimeTarget | undefined { return this._currentRoute.session; }
 
-    /** Get CDP manager for a specific ideType or managerKey.
-     * Supports exact match, multi-window prefix match, and instanceIdMap UUID lookup.
-     * Returns null if no match — never falls back to another IDE. */
+    /** Get CDP manager for a specific session or manager key. */
     getCdp(ideType?: string): DaemonCdpManager | null {
-        const key = ideType || this._currentIdeType;
-        if (!key) return null;
-        // 1. Try instanceIdMap (UUID → managerKey)
-        const resolved = this._ctx.instanceIdMap?.get(key) || key;
-        // 2. Use findCdpManager (exact + prefix match)
-        const m = findCdpManager(this._ctx.cdpManagers, resolved.toLowerCase());
+        const requested = ideType || this._currentRoute.session?.sessionId || this._currentRoute.managerKey;
+        if (!requested) return null;
+        const session = this._ctx.sessionRegistry?.get(requested);
+        const managerKey = session?.cdpManagerKey || requested;
+        const m = findCdpManager(this._ctx.cdpManagers, managerKey);
         if (m?.isConnected) return m;
         return null;
     }
@@ -106,7 +109,7 @@ export class DaemonCommandHandler implements CommandHelpers {
      * Get provider module — _currentProviderType (agentType priority) use.
      */
     getProvider(overrideType?: string): ProviderModule | undefined {
-        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 undefined;
         const result = this._ctx.providerLoader.resolve(key);
         if (result) return result;
@@ -148,14 +151,22 @@ export class DaemonCommandHandler implements CommandHelpers {
 
         // Extension: evaluateInSession
         if (provider?.category === 'extension') {
-            let sessionId = this.getExtensionSessionId(provider);
-            if (!sessionId && this._agentStream) {
-                await this._agentStream.switchActiveAgent(cdp, provider.type);
-                await this._agentStream.syncAgentSessions(cdp);
-                sessionId = this.getExtensionSessionId(provider);
+            let sessionId: string | null = 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 result = await cdp.evaluateInSessionFrame(sessionId, script, timeout);
+            const managed = this._agentStream?.getManagedSession(sessionId);
+            const cdpSessionId = managed?.cdpSessionId;
+            if (!cdpSessionId) return null;
+            const result = await cdp.evaluateInSessionFrame(cdpSessionId, script, timeout);
             return { result, category: 'extension' };
         }
 
@@ -166,49 +177,47 @@ export class DaemonCommandHandler implements CommandHelpers {
 
     /** CLI adapter search */
     getCliAdapter(type?: string): any | null {
-        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;
-        // Normalize composite transport IDs:
-        //   standalone_xxx:cli:<uuid> -> <uuid>
-        //   daemon:acp:<uuid>         -> <uuid>
-        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 as any).cliType === target
-                || (adapter as any).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 ──────────────────────────────
 
-    private getExtensionSessionId(provider: ProviderModule): string | null {
-        if (provider.category !== 'extension' || !this._agentStream) return null;
-        const managed = this._agentStream.getManagedAgent(provider.type);
-        return managed?.sessionId || null;
+    private inferProviderType(key: string | undefined): string | undefined {
+        if (!key) return undefined;
+        const session = this._ctx.sessionRegistry?.get(key);
+        if (session?.providerType) return session.providerType;
+        return key.split('_')[0];
+    }
+
+    private resolveRoute(args: any): { session?: SessionRuntimeTarget; managerKey?: string; providerType?: string } {
+        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 ideType from _targetInstance or explicit ideType */
+    /** Extract CDP scope key from target session or explicit ideType */
     private extractIdeType(args: any): string | undefined {
+        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;
+        }
+
         // Also accept explicit ideType from args (P2P input, agentType for extensions)
         if (args?.ideType) {
-            // UUID → managerKey via instanceIdMap (P2P sends UUID instance IDs)
-            const mappedKey = this._ctx.instanceIdMap?.get(args.ideType);
-            if (mappedKey) {
-                return mappedKey;
-            }
+            const target = this._ctx.sessionRegistry?.get(args.ideType);
+            if (target?.cdpManagerKey) return target.cdpManagerKey;
             // Exact match first
             if (this._ctx.cdpManagers.has(args.ideType)) {
                 return args.ideType;
@@ -223,45 +232,6 @@ export class DaemonCommandHandler implements CommandHelpers {
             }
         }
 
-        if (args?._targetInstance) {
-            let raw = args._targetInstance as string;
-            const ideMatch = raw.match(/:ide:(.+)$/);
-            const cliMatch = raw.match(/:cli:(.+)$/);
-            const acpMatch = raw.match(/:acp:(.+)$/);
-            if (ideMatch) raw = ideMatch[1];
-            else if (cliMatch) raw = cliMatch[1];
-            else if (acpMatch) raw = acpMatch[1];
-
-            if (this._ctx.instanceIdMap?.has(raw)) {
-                return this._ctx.instanceIdMap.get(raw)!;
-            }
-
-            // Direct CDP manager key match (e.g. "cursor", "cursor_remote_vs")
-            if (this._ctx.cdpManagers.has(raw)) {
-                return raw;
-            }
-
-            // Prefix match for multi-window keys
-            const found = findCdpManager(this._ctx.cdpManagers, raw);
-            if (found) {
-                for (const [k, m] of this._ctx.cdpManagers.entries()) {
-                    if (m === found) return k;
-                }
-            }
-
-            // Fallback removed: returning first-connected CDP was the root cause of
-            // input routing to wrong IDE (e.g. screenshot shows Cursor but input goes
-            // to Antigravity). If no match is found, return undefined so the caller
-            // gets an explicit error rather than silently routing to the wrong IDE.
-
-            // Legacy: strip trailing _N suffix (e.g. "cursor_1" → "cursor")
-            const lastUnderscore = raw.lastIndexOf('_');
-            if (lastUnderscore > 0) {
-                const stripped = raw.substring(0, lastUnderscore);
-                if (this._ctx.cdpManagers.has(stripped)) return stripped;
-            }
-            return raw;
-        }
         return undefined;
     }
 
@@ -272,15 +242,14 @@ export class DaemonCommandHandler implements CommandHelpers {
     // ─── Command Dispatcher ──────────────────────────
 
     async handle(cmd: string, args: any): Promise<CommandResult> {
-        // Per-request: extract target IDE/provider type from args
-        this._currentIdeType = this.extractIdeType(args);
-        this._currentProviderType = args?.agentType || args?.providerType || this._currentIdeType;
+        // Per-request: extract target session / CDP scope / provider type from args
+        this._currentRoute = this.resolveRoute(args);
 
         // Commands without ideType CDP silently fail (prevent P2P retry spam)
-        if (!this._currentIdeType && !this._currentProviderType) {
+        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 — cannot route command' };
+                return { success: false, error: 'No targetSessionId specified — cannot route command' };
             }
         }
 
@@ -351,14 +320,7 @@ export class DaemonCommandHandler implements CommandHelpers {
             case 'refresh_scripts': return this.handleRefreshScripts(args);
 
             // ─── Stream commands (stream-commands.ts) ───────────
-            case 'agent_stream_switch': return Stream.handleAgentStreamSwitch(this, args);
-            case 'agent_stream_read': return Stream.handleAgentStreamRead(this, args);
-            case 'agent_stream_send': return Stream.handleAgentStreamSend(this, args);
-            case 'agent_stream_resolve': return Stream.handleAgentStreamResolve(this, args);
-            case 'agent_stream_new': return Stream.handleAgentStreamNew(this, args);
-            case 'agent_stream_list_chats': return Stream.handleAgentStreamListChats(this, args);
-            case 'agent_stream_switch_session': return Stream.handleAgentStreamSwitchSession(this, args);
-            case 'agent_stream_focus': return Stream.handleAgentStreamFocus(this, args);
+            case 'focus_session': return Stream.handleFocusSession(this, args);
 
             // ─── PTY Raw I/O (stream-commands.ts) ─────────
             case 'pty_input': return Stream.handlePtyInput(this, args);

package/src/commands/router.ts

@@ -21,6 +21,7 @@ import { resolveIdeLaunchWorkspace } from '../config/workspaces.js';
 import { appendWorkspaceActivity } from '../config/workspace-activity.js';
 import { addCliHistory } from '../config/config.js';
 import { detectIDEs } from '../detection/ide-detector.js';
+import { SessionRegistry } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
 import { logCommand } from '../logging/command-log.js';
 import { getRecentLogs, LOG_PATH } from '../logging/logger.js';
@@ -36,8 +37,7 @@ export interface CommandRouterDeps {
     instanceManager: ProviderInstanceManager;
     /** Reference to detected IDEs array (mutable — router updates it) */
     detectedIdes: { value: any[] };
-    /** UUID instanceId → CDP manager key mapping */
-    instanceIdMap: Map<string, string>;
+    sessionRegistry: SessionRegistry;
     /** Callback for CDP manager creation after launch_ide */
     onCdpManagerCreated?: (ideType: string, manager: DaemonCdpManager) => void;
     /** Callback after IDE connected (e.g., startAgentStreamPolling) */
@@ -60,7 +60,7 @@ export interface CommandRouterResult {
 // Commands that trigger post-chat status updates
 const CHAT_COMMANDS = [
     'send_chat', 'new_chat', 'switch_chat', 'set_mode',
-    'change_model', 'agent_stream_send',
+    'change_model',
 ];
 
 export class DaemonCommandRouter {
@@ -344,6 +344,7 @@ export class DaemonCommandRouter {
             if (cdp) {
                 try { cdp.disconnect(); } catch { /* noop */ }
                 this.deps.cdpManagers.delete(key);
+                this.deps.sessionRegistry.unregisterByManagerKey(key);
                 LOG.info('StopIDE', `CDP disconnected: ${key}`);
             }
         }
@@ -358,15 +359,6 @@ export class DaemonCommandRouter {
         for (const instanceKey of keysToRemove) {
             const ideInstance = this.deps.instanceManager.getInstance(instanceKey) as any;
             if (ideInstance) {
-                // Remove IDE and child Extension UUIDs from instanceIdMap
-                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}`);
             }
@@ -376,14 +368,6 @@ export class DaemonCommandRouter {
             const instanceKey = `ide:${ideType}`;
             const ideInstance = this.deps.instanceManager.getInstance(instanceKey) as any;
             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}`);
             }

package/src/commands/stream-commands.ts

@@ -8,166 +8,41 @@ import type { ProviderLoader } from '../providers/provider-loader.js';
 import { loadConfig } from '../config/config.js';
 import { LOG } from '../logging/logger.js';
 
-// ─── Agent Stream commands ───────────────────────
-
-export async function handleAgentStreamSwitch(h: CommandHelpers, args: any): Promise<CommandResult> {
-    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
-    const agentType = args?.agentType || args?.agent || null;
-    await h.agentStream.switchActiveAgent(h.getCdp()!, agentType);
-    return { success: true, activeAgent: agentType };
-}
-
-export async function handleAgentStreamRead(h: CommandHelpers, args: any): Promise<CommandResult> {
-    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
-    const streams = await h.agentStream.collectAgentStreams(h.getCdp()!);
-    return { success: true, streams };
-}
-
-export async function handleAgentStreamSend(h: CommandHelpers, args: any): Promise<CommandResult> {
-    const agentType = args?.agentType || args?.agent;
-    const text = args?.text || args?.message;
-    if (!text) return { success: false, error: 'text required' };
-
-    // CLI adapter routing
-    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: any) {
-                    LOG.info('Command', `[agent_stream_send] CLI adapter failed: ${e.message}`);
-                    return { success: false, error: `CLI send failed: ${e.message}` };
-                }
-            }
-        }
-    }
-
-    // CDP-based IDE agent routing
-    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
-    const resolvedAgent = agentType || h.agentStream.activeAgentType;
-    if (!resolvedAgent) return { success: false, error: 'agentType required' };
-    const ok = await h.agentStream.sendToAgent(h.getCdp()!, resolvedAgent, text, h.currentIdeType);
-    return { success: ok };
-}
-
-export async function handleAgentStreamResolve(h: CommandHelpers, args: any): Promise<CommandResult> {
-    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
-    const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
-    const action = args?.action as 'approve' | 'reject' || 'approve';
-    if (!agentType) return { success: false, error: 'agentType required' };
-    const ok = await h.agentStream.resolveAgentAction(h.getCdp()!, agentType, action, h.currentIdeType);
-    return { success: ok };
-}
-
-export async function handleAgentStreamNew(h: CommandHelpers, args: any): Promise<CommandResult> {
-    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
-    const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
-    if (!agentType) return { success: false, error: 'agentType required' };
-    const ok = await h.agentStream.newAgentSession(h.getCdp()!, agentType, h.currentIdeType);
-    return { success: ok };
-}
-
-export async function handleAgentStreamListChats(h: CommandHelpers, args: any): Promise<CommandResult> {
-    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
-    const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
-    if (!agentType) return { success: false, error: 'agentType required' };
-    const chats = await h.agentStream.listAgentChats(h.getCdp()!, agentType);
-    return { success: true, chats };
-}
-
-export async function handleAgentStreamSwitchSession(h: CommandHelpers, args: any): Promise<CommandResult> {
+export async function handleFocusSession(h: CommandHelpers, args: any): Promise<CommandResult> {
     if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
-    const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
-    const sessionId = args?.sessionId || args?.id;
-    if (!agentType || !sessionId) return { success: false, error: 'agentType and sessionId required' };
-    const ok = await h.agentStream.switchAgentSession(h.getCdp()!, agentType, sessionId);
-    return { success: ok };
-}
-
-export async function handleAgentStreamFocus(h: CommandHelpers, args: any): Promise<CommandResult> {
-    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
-    const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
-    if (!agentType) return { success: false, error: 'agentType required' };
-    await h.agentStream.ensureAgentPanelOpen(agentType, h.currentIdeType);
-    const ok = await h.agentStream.focusAgentEditor(h.getCdp()!, agentType);
+    const sessionId = args?.targetSessionId || h.currentSession?.sessionId;
+    if (!sessionId) return { success: false, error: 'targetSessionId required' };
+    const ok = await h.agentStream.focusSession(h.getCdp()!, sessionId);
     return { success: ok };
 }
 
 // ─── PTY Raw I/O ──────────────────────────────────
 
 export function handlePtyInput(h: CommandHelpers, args: any): CommandResult {
-    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 };
 }
 
 export function handlePtyResize(h: CommandHelpers, args: any): CommandResult {
-    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 };
 }
 
 // ─── Provider Settings ────────────────────────
@@ -210,7 +85,7 @@ export function handleSetProviderSetting(h: CommandHelpers, args: any): CommandR
 
 export async function handleExtensionScript(h: CommandHelpers, args: any, scriptName: string): Promise<CommandResult> {
     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;
@@ -240,7 +115,9 @@ export async function handleExtensionScript(h: CommandHelpers, args: any, script
     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'}` };
@@ -249,14 +126,15 @@ export async function handleExtensionScript(h: CommandHelpers, args: any, script
         let result: unknown;
 
         if (provider.category === 'extension') {
-            const sessions = cdp.getAgentSessions();
-            let targetSessionId: string | null = 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;
 
             // IDE-level scripts (model/mode) — try session frame first, fallback to main page
             const IDE_LEVEL_SCRIPTS = ['listModes', 'setMode', 'listModels', 'setModel'];
@@ -338,7 +216,7 @@ export function handleGetIdeExtensions(h: CommandHelpers, args: any): CommandRes
             enabled: config.ideSettings?.[ide]?.extensions?.[p.type]?.enabled === true,
         }));
     }
-    return { success: true, ides: result };
+    return { success: true, ideExtensions: result };
 }
 
 export function handleSetIdeExtension(h: CommandHelpers, args: any): CommandResult {

package/src/daemon-core.ts

@@ -6,7 +6,7 @@
  */
 
 import type { StatusResponse, CommandResult, DaemonEvent } from './types.js';
-import type { ManagedIdeEntry, ManagedCliEntry, ManagedAcpEntry } from './shared-types.js';
+import type { SessionEntry } from './shared-types.js';
 
 export interface DaemonCoreOptions {
  /** Data directory for config, logs */
@@ -40,12 +40,6 @@ export interface IDaemonCore {
  /** Execute a command (send_chat, new_session, etc.) */
   executeCommand(type: string, payload: any, target?: string): Promise<CommandResult>;
 
- /** Get currently detected/managed IDEs */
-  getManagedIdes(): ManagedIdeEntry[];
-
- /** Get currently detected/managed CLIs */
-  getManagedClis(): ManagedCliEntry[];
-
- /** Get currently detected/managed ACP agents */
-  getManagedAcps(): ManagedAcpEntry[];
+  /** Get current canonical runtime sessions */
+  getSessions(): SessionEntry[];
 }

package/src/index.ts

@@ -20,10 +20,11 @@ export type {
 
 // ── Shared Types (cross-package) ──
 export type {
-  ManagedIdeEntry,
-  ManagedCliEntry,
-  ManagedAcpEntry,
-  ManagedAgentStream,
+  SessionEntry,
+  SessionTransport,
+  SessionKind,
+  SessionCapability,
+  AgentSessionStream,
   AvailableProviderInfo,
   AcpConfigOption,
   AcpMode,
@@ -74,8 +75,10 @@ export type { CommandRouterDeps, CommandRouterResult } from './commands/router.j
 
 // ── Status ──
 export { DaemonStatusReporter } from './status/reporter.js';
-export { buildManagedIdes, buildManagedClis, buildManagedAcps, buildAllManagedEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
+export { buildSessionEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
 export { buildStatusSnapshot } from './status/snapshot.js';
+export { normalizeManagedStatus, isManagedStatusWorking, isManagedStatusWaiting, normalizeActiveChatData } from './status/normalize.js';
+export type { ManagedStatus } from './status/normalize.js';
 export type { StatusSnapshotOptions, StatusSnapshot } from './status/snapshot.js';
 
 // ── Logger ──

package/src/logging/command-log.ts

@@ -50,7 +50,7 @@ function maskArgs(args: any): Record<string, unknown> | undefined {
                 ? `[${value.length} chars]`
                 : '[masked]';
         } else if (key.startsWith('_')) {
- // internal fields: keep as-is (e.g. _targetType, _targetInstance)
+ // internal fields: keep as-is (e.g. targetSessionId)
             masked[key] = value;
         } else if (typeof value === 'object' && value !== null) {
  // Don't recurse deeply — just note the type