@adhdev/daemon-core 0.8.24 → 0.8.25

package/dist/sessions/reconcile.d.ts

@@ -0,0 +1,22 @@
+import type { SessionRegistry } from './registry.js';
+interface IdeLikeInstance {
+    category?: string;
+    type?: string;
+    getInstanceId?: () => string;
+    getExtensionInstances?: () => Array<{
+        type?: string;
+        getInstanceId?: () => string;
+    }>;
+}
+interface InstanceManagerLike {
+    listInstanceIds(): string[];
+    getInstance(id: string): IdeLikeInstance | undefined;
+}
+/**
+ * Rebuild missing IDE/runtime session registry entries from live ProviderInstance objects.
+ *
+ * This is a defensive repair path for cases where an IDE extension instance still exists
+ * in InstanceManager/status, but its runtime session entry has been dropped from SessionRegistry.
+ */
+export declare function reconcileIdeRuntimeSessions(instanceManager: InstanceManagerLike | undefined, sessionRegistry: SessionRegistry | undefined): void;
+export {};

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

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.24",
+  "version": "0.8.25",
   "description": "ADHDev local session host core — 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.24",
+  "version": "0.8.25",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/agent-stream/poller.ts

@@ -16,6 +16,7 @@ import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { registerExtensionProviders } from '../cdp/setup.js';
 import type { SessionRegistry } from '../sessions/registry.js';
+import { reconcileIdeRuntimeSessions } from '../sessions/reconcile.js';
 import { LOG } from '../logging/logger.js';
 import type { AgentStreamState } from './types.js';
 
@@ -78,6 +79,9 @@ export class AgentStreamPoller {
 
         if (!agentStreamManager || cdpManagers.size === 0) return;
 
+        // Defensive repair: keep SessionRegistry aligned with live IDE/extension instances.
+        reconcileIdeRuntimeSessions(instanceManager as any, sessionRegistry);
+
         // ─── Phase 1: Refresh extension providers + IDE instance extensions ───
         for (const [ideType, cdp] of cdpManagers) {
             // 1a. Refresh CDP manager's extension providers from config

package/src/commands/handler.ts

@@ -21,6 +21,7 @@ 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 { reconcileIdeRuntimeSessions } from '../sessions/reconcile.js';
 import { LOG } from '../logging/logger.js';
 
 // Sub-module imports
@@ -165,6 +166,7 @@ export class DaemonCommandHandler implements CommandHelpers {
         session?: SessionRuntimeTarget;
         managerKey?: string;
         providerType?: string;
+        sessionLookupFailed?: boolean;
     } = {};
 
     constructor(ctx: CommandContext) {
@@ -284,23 +286,36 @@ export class DaemonCommandHandler implements CommandHelpers {
         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 };
+    private resolveRoute(args: any): { session?: SessionRuntimeTarget; managerKey?: string; providerType?: string; sessionLookupFailed?: boolean } {
+        const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
+        let session = targetSessionId ? this._ctx.sessionRegistry?.get(targetSessionId) : undefined;
+        if (targetSessionId && !session) {
+            reconcileIdeRuntimeSessions(this._ctx.instanceManager as any, this._ctx.sessionRegistry);
+            session = this._ctx.sessionRegistry?.get(targetSessionId);
+        }
+        const sessionLookupFailed = !!targetSessionId && !session;
+
+        const managerKey = this.extractIdeType(args, sessionLookupFailed);
+        let providerType: string | undefined;
+
+        if (!sessionLookupFailed) {
+            providerType =
+                session?.providerType
+                || args?.agentType
+                || args?.providerType
+                || this.inferProviderType(managerKey);
+        }
+
+        return { session, managerKey, providerType, sessionLookupFailed };
     }
 
     /** Extract CDP scope key from target session or explicit ideType */
-    private extractIdeType(args: any): string | undefined {
+    private extractIdeType(args: any, sessionLookupFailed = false): 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;
+            if (sessionLookupFailed) return undefined;
         }
 
         // Also accept explicit ideType from args (P2P input, agentType for extensions)
@@ -360,6 +375,35 @@ export class DaemonCommandHandler implements CommandHelpers {
         const startedAt = Date.now();
         this.logCommandStart(cmd, args);
 
+        const sessionScopedCommands = new Set([
+            'read_chat',
+            'send_chat',
+            'list_chats',
+            'new_chat',
+            'switch_chat',
+            'set_mode',
+            'change_model',
+            'set_thought_level',
+            'resolve_action',
+            'focus_session',
+            'pty_input',
+            'pty_resize',
+            'invoke_provider_script',
+            'list_extension_models',
+            'set_extension_model',
+            'list_extension_modes',
+            'set_extension_mode',
+        ]);
+
+        if (this._currentRoute.sessionLookupFailed && sessionScopedCommands.has(cmd)) {
+            const result = {
+                success: false,
+                error: `Live session not found for targetSessionId: ${String(args?.targetSessionId || '').trim() || 'unknown'}`,
+            };
+            this.logCommandEnd(cmd, result, startedAt);
+            return result;
+        }
+
         // Commands without ideType CDP silently fail (prevent P2P retry spam)
         let result: CommandResult;
         if (!this._currentRoute.session && !this._currentRoute.managerKey && !this._currentRoute.providerType) {

package/src/sessions/reconcile.ts

@@ -0,0 +1,85 @@
+import type { SessionRegistry, SessionRuntimeTarget } from './registry.js';
+
+interface IdeLikeInstance {
+    category?: string;
+    type?: string;
+    getInstanceId?: () => string;
+    getExtensionInstances?: () => Array<{
+        type?: string;
+        getInstanceId?: () => string;
+    }>;
+}
+
+interface InstanceManagerLike {
+    listInstanceIds(): string[];
+    getInstance(id: string): IdeLikeInstance | undefined;
+}
+
+function upsertSessionTarget(sessionRegistry: SessionRegistry, target: SessionRuntimeTarget): void {
+    const existing = sessionRegistry.get(target.sessionId);
+    if (
+        existing
+        && existing.parentSessionId === target.parentSessionId
+        && existing.providerType === target.providerType
+        && existing.transport === target.transport
+        && existing.cdpManagerKey === target.cdpManagerKey
+        && existing.instanceKey === target.instanceKey
+    ) {
+        return;
+    }
+    sessionRegistry.register(target);
+}
+
+/**
+ * Rebuild missing IDE/runtime session registry entries from live ProviderInstance objects.
+ *
+ * This is a defensive repair path for cases where an IDE extension instance still exists
+ * in InstanceManager/status, but its runtime session entry has been dropped from SessionRegistry.
+ */
+export function reconcileIdeRuntimeSessions(
+    instanceManager: InstanceManagerLike | undefined,
+    sessionRegistry: SessionRegistry | undefined,
+): void {
+    if (!instanceManager || !sessionRegistry) return;
+
+    for (const instanceKey of instanceManager.listInstanceIds()) {
+        if (!instanceKey.startsWith('ide:')) continue;
+
+        const ideInstance = instanceManager.getInstance(instanceKey);
+        if (!ideInstance || ideInstance.category !== 'ide' || typeof ideInstance.getInstanceId !== 'function') {
+            continue;
+        }
+
+        const managerKey = instanceKey.slice(4);
+        const ideType = typeof ideInstance.type === 'string' && ideInstance.type.trim()
+            ? ideInstance.type.trim()
+            : managerKey.split('_')[0];
+        const parentSessionId = ideInstance.getInstanceId();
+        if (!parentSessionId) continue;
+
+        upsertSessionTarget(sessionRegistry, {
+            sessionId: parentSessionId,
+            parentSessionId: null,
+            providerType: ideType,
+            transport: 'cdp-page',
+            cdpManagerKey: managerKey,
+            instanceKey,
+        });
+
+        const extensions = ideInstance.getExtensionInstances?.() || [];
+        for (const ext of extensions) {
+            const extType = typeof ext?.type === 'string' ? ext.type.trim() : '';
+            const extSessionId = ext?.getInstanceId?.();
+            if (!extType || !extSessionId) continue;
+
+            upsertSessionTarget(sessionRegistry, {
+                sessionId: extSessionId,
+                parentSessionId,
+                providerType: extType,
+                transport: 'cdp-webview',
+                cdpManagerKey: managerKey,
+                instanceKey,
+            });
+        }
+    }
+}