@adhdev/daemon-core 0.8.75 → 0.8.76

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.75",
+  "version": "0.8.76",
   "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.8.75",
+  "version": "0.8.76",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/agent-stream/manager.ts

@@ -181,10 +181,17 @@ export class DaemonAgentStreamManager {
     }
 
     /** Collect active extension session state */
-    async collectActiveSession(cdp: DaemonCdpManager, parentSessionId: string): Promise<AgentStreamState | null> {
+    async collectActiveSession(
+        cdp: DaemonCdpManager,
+        parentSessionId: string,
+        attemptedSessionIds: Set<string> = new Set(),
+        originSessionId?: string,
+    ): Promise<AgentStreamState | null> {
         if (!this.enabled) return null;
         const activeSessionId = this.getActiveSessionId(parentSessionId);
         if (!activeSessionId) return null;
+        const resolvedOriginSessionId = originSessionId || activeSessionId;
+        attemptedSessionIds.add(activeSessionId);
         let agent = this.managedBySessionId.get(activeSessionId);
         if (!agent) {
             agent = await this.connectManagedSession(cdp, parentSessionId, activeSessionId) || undefined;
@@ -200,18 +207,50 @@ export class DaemonAgentStreamManager {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
                 cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
             const state = await agent.adapter.readChat(evaluate);
-            const stateError = this.getStateError(state);
-            const selectedModelValue = typeof state.controlValues?.model === 'string' ? state.controlValues.model : '';
-            LOG.debug('AgentStream', `[AgentStream] readChat(${type}) result: status=${state.status} msgs=${state.messages?.length || 0} model=${selectedModelValue}${state.status === 'error' ? ' error=' + JSON.stringify(stateError) : ''}`);
-            if (state.status === 'error' && this.isRecoverableSessionError(stateError)) {
+            const resolvedProviderSessionId = typeof state.providerSessionId === 'string' && state.providerSessionId.trim()
+                ? state.providerSessionId.trim()
+                : (typeof state.sessionId === 'string' && state.sessionId.trim() && state.sessionId !== agent.runtimeSessionId
+                    ? state.sessionId.trim()
+                    : undefined);
+            const normalizedState: AgentStreamState = {
+                ...state,
+                sessionId: agent.runtimeSessionId,
+                ...(resolvedProviderSessionId ? { providerSessionId: resolvedProviderSessionId } : {}),
+            };
+            const stateError = this.getStateError(normalizedState);
+            const selectedModelValue = typeof normalizedState.controlValues?.model === 'string' ? normalizedState.controlValues.model : '';
+            LOG.debug('AgentStream', `[AgentStream] readChat(${type}) result: status=${normalizedState.status} msgs=${normalizedState.messages?.length || 0} model=${selectedModelValue}${normalizedState.status === 'error' ? ' error=' + JSON.stringify(stateError) : ''}`);
+            if (normalizedState.status === 'error' && this.isRecoverableSessionError(stateError)) {
                 throw new Error(stateError);
             }
-            agent.lastState = state;
+            agent.lastState = normalizedState;
             agent.lastError = null;
-            if (state.status === 'panel_hidden') {
+            if (normalizedState.status === 'panel_hidden') {
+                const discovered = await cdp.discoverAgentWebviews().catch(() => [] as AgentWebviewTarget[]);
+                const fallbackTarget = discovered.find((entry) => {
+                    if (entry.agentType === type) return false;
+                    const fallbackSessionId = this.resolveSessionIdForTarget(parentSessionId, entry.agentType);
+                    return !!fallbackSessionId
+                        && fallbackSessionId !== activeSessionId
+                        && !attemptedSessionIds.has(fallbackSessionId);
+                });
+                if (fallbackTarget) {
+                    const fallbackSessionId = this.resolveSessionIdForTarget(parentSessionId, fallbackTarget.agentType);
+                    if (fallbackSessionId && fallbackSessionId !== activeSessionId && !attemptedSessionIds.has(fallbackSessionId)) {
+                        this.logFn(`[AgentStream] Active session ${type} is hidden; switching to visible agent ${fallbackTarget.agentType} (${parentSessionId})`);
+                        await this.setActiveSession(cdp, parentSessionId, fallbackSessionId);
+                        await this.syncActiveSession(cdp, parentSessionId);
+                        const fallbackState = await this.collectActiveSession(cdp, parentSessionId, attemptedSessionIds, resolvedOriginSessionId);
+                        if (fallbackState?.status === 'panel_hidden' && resolvedOriginSessionId !== fallbackSessionId) {
+                            await this.setActiveSession(cdp, parentSessionId, resolvedOriginSessionId);
+                            await this.syncActiveSession(cdp, parentSessionId);
+                        }
+                        return fallbackState;
+                    }
+                }
                 agent.lastHiddenCheckTime = Date.now();
             }
-            return state;
+            return normalizedState;
         } catch (e) {
             const errorMsg = (e as Error)?.message || String(e);
             this.logFn(`[AgentStream] readChat(${type}) error: ${errorMsg.slice(0, 200)}`);

package/src/agent-stream/poller.ts

@@ -206,6 +206,7 @@ export class AgentStreamPoller {
             try {
                 await agentStreamManager.syncActiveSession(cdp, parentSessionId);
                 let stream = await agentStreamManager.collectActiveSession(cdp, parentSessionId);
+                resolvedActiveSessionId = stream?.sessionId || agentStreamManager.getActiveSessionId(parentSessionId) || resolvedActiveSessionId;
                 if (stream?.status === 'waiting_approval') {
                     const autoApprove = providerLoader.getSettings(stream.agentType).autoApprove !== false;
                     if (autoApprove && resolvedActiveSessionId) {

package/src/cdp/manager.ts

@@ -16,7 +16,7 @@ import * as fs from 'fs';
 import { LOG } from '../logging/logger.js';
 import type { CdpTargetFilter } from '../providers/contracts.js';
 
-interface CdpTarget {
+export interface CdpTarget {
     id: string;
     type: string;
     title: string;
@@ -24,6 +24,44 @@ interface CdpTarget {
     webSocketDebuggerUrl: string;
 }
 
+function normalizeTitle(value: string | null | undefined): string {
+    return String(value || '').trim().replace(/\s+/g, ' ').toLowerCase();
+}
+
+function titlesMatch(lhs: string | null | undefined, rhs: string | null | undefined): boolean {
+    const a = normalizeTitle(lhs);
+    const b = normalizeTitle(rhs);
+    if (!a || !b) return false;
+    return a === b || a.includes(b) || b.includes(a);
+}
+
+export function resolveCdpPageTarget(params: {
+    pages: CdpTarget[];
+    pinnedTargetId?: string | null;
+    previousPageTitle?: string | null;
+}): { target: CdpTarget | null; retargeted: boolean } {
+    const { pages, pinnedTargetId, previousPageTitle } = params;
+    if (pages.length === 0) return { target: null, retargeted: false };
+
+    if (!pinnedTargetId) {
+        return { target: pages[0] || null, retargeted: false };
+    }
+
+    const exact = pages.find((page) => page.id === pinnedTargetId);
+    if (exact) return { target: exact, retargeted: false };
+
+    const titleMatchesList = pages.filter((page) => titlesMatch(page.title, previousPageTitle));
+    if (titleMatchesList.length === 1) {
+        return { target: titleMatchesList[0], retargeted: true };
+    }
+
+    if (pages.length === 1) {
+        return { target: pages[0], retargeted: true };
+    }
+
+    return { target: null, retargeted: false };
+}
+
 export interface AgentWebviewTarget {
     targetId: string;
     extensionId: string;
@@ -204,22 +242,36 @@ export class DaemonCdpManager {
                             return;
                         }
 
- // Exclude non-main tabs
-                        const mainPages = pages.filter(t => !this.isNonMainTitle(t.title || ''));
-                        const list = mainPages.length > 0 ? mainPages : pages;
+                        // Keep reconnect target selection aligned with initial scan rules:
+                        // prefer visible workbench pages that satisfy provider URL filters,
+                        // then fall back to title-filtered pages only when nothing else matches.
+                        const titleFilteredPages = pages.filter(t => !this.isNonMainTitle(t.title || ''));
+                        const mainPages = titleFilteredPages.filter(t => this.isMainPageUrl(t.url));
+                        const list = mainPages.length > 0
+                            ? mainPages
+                            : (titleFilteredPages.length > 0 ? titleFilteredPages : pages);
 
                         this.log(`[CDP] pages(${list.length}): ${list.map(t => `"${t.title}"`).join(', ')}`);
 
- // If targetId is specified, select only matching page
-                        if (this._targetId) {
-                            const specific = list.find(t => t.id === this._targetId);
-                            if (specific) {
-                                this._pageTitle = specific.title || '';
-                                resolve(specific);
-                            } else {
-                                this.log(`[CDP] Target ${this._targetId} not found in page list`);
-                                resolve(null);
+                        const previousTargetId = this._targetId;
+                        const selected = resolveCdpPageTarget({
+                            pages: list,
+                            pinnedTargetId: previousTargetId,
+                            previousPageTitle: this._pageTitle,
+                        });
+                        if (selected.target) {
+                            if (selected.retargeted && previousTargetId && previousTargetId !== selected.target.id) {
+                                this.log(`[CDP] Target ${previousTargetId} rekeyed to ${selected.target.id}`);
+                                this._targetId = selected.target.id;
                             }
+                            this._pageTitle = selected.target.title || '';
+                            resolve(selected.target);
+                            return;
+                        }
+
+                        if (previousTargetId) {
+                            this.log(`[CDP] Target ${previousTargetId} not found in page list`);
+                            resolve(null);
                             return;
                         }
 

package/src/chat/async-batch.ts

@@ -0,0 +1,26 @@
+export interface AsyncBatchOptions {
+  concurrency?: number;
+}
+
+export async function runAsyncBatch<T>(
+  items: Iterable<T>,
+  worker: (item: T, index: number) => Promise<void>,
+  options: AsyncBatchOptions = {},
+): Promise<void> {
+  const list = Array.from(items);
+  if (list.length === 0) return;
+
+  const concurrency = Math.max(1, Math.min(list.length, Math.floor(options.concurrency || 1)));
+  let nextIndex = 0;
+
+  const runners = Array.from({ length: concurrency }, async () => {
+    while (true) {
+      const currentIndex = nextIndex;
+      nextIndex += 1;
+      if (currentIndex >= list.length) return;
+      await worker(list[currentIndex], currentIndex);
+    }
+  });
+
+  await Promise.all(runners);
+}

package/src/commands/stream-commands.ts

@@ -301,8 +301,11 @@ function applyProviderPatch(h: CommandHelpers, args: any, payload: any): void {
 }
 
 async function executeProviderScript(h: CommandHelpers, args: any, scriptName: string): Promise<CommandResult> {
+    const explicitTargetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
+    const targetSession = explicitTargetSessionId ? h.ctx.sessionRegistry?.get(explicitTargetSessionId) : undefined;
     const resolvedProviderType =
-        h.currentSession?.providerType
+        targetSession?.providerType
+        || h.currentSession?.providerType
         || h.currentProviderType
         || args?.agentType
         || args?.providerType;
@@ -358,8 +361,8 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
     if (!scriptCode) return { success: false, error: `Script '${actualScriptName}' returned null` };
 
     const cdpKey = provider.category === 'ide'
-        ? (h.currentSession?.cdpManagerKey || h.currentManagerKey || resolvedProviderType)
-        : (h.currentSession?.cdpManagerKey || h.currentManagerKey);
+        ? (targetSession?.cdpManagerKey || h.currentSession?.cdpManagerKey || h.currentManagerKey || resolvedProviderType)
+        : (targetSession?.cdpManagerKey || h.currentSession?.cdpManagerKey || h.currentManagerKey);
     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'}` };
@@ -368,9 +371,9 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
         let result: unknown;
 
         if (provider.category === 'extension') {
-            const runtimeSessionId = h.currentSession?.sessionId || args?.targetSessionId;
+            const runtimeSessionId = explicitTargetSessionId || h.currentSession?.sessionId;
             if (!runtimeSessionId) return { success: false, error: `No target session found for ${resolvedProviderType}` };
-            const parentSessionId = h.currentSession?.parentSessionId;
+            const parentSessionId = targetSession?.parentSessionId || h.currentSession?.parentSessionId;
             if (parentSessionId) {
                 await h.agentStream?.setActiveSession(cdp, parentSessionId, runtimeSessionId);
                 await h.agentStream?.syncActiveSession(cdp, parentSessionId);