@adhdev/daemon-core 0.8.24 → 0.8.27

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/agent-stream/provider-adapter.ts

@@ -41,6 +41,15 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
         return typeof (this.provider.scripts as any)?.[name] === 'function';
     }
 
+    private parseMaybeJson(raw: unknown): any {
+        if (typeof raw !== 'string') return raw;
+        try {
+            return JSON.parse(raw);
+        } catch {
+            return raw;
+        }
+    }
+
     private summarizeRaw(raw: unknown): string {
         try {
             if (typeof raw === 'string') return raw.replace(/\s+/g, ' ').trim().slice(0, 240);
@@ -111,12 +120,32 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
     }
 
     async sendMessage(evaluate: AgentEvaluateFn, text: string): Promise<void> {
-        const script = this.callScript('sendMessage', text);
+        const params = { message: text };
+        const script = this.callScript('sendMessage', params) || this.callScript('sendMessage', text);
         if (!script) throw new Error(`[${this.agentName}] sendMessage script not available`);
         const result = await evaluate(script) as string;
         if (result && typeof result === 'string' && result.startsWith('error:')) {
             throw new Error(`[${this.agentName}] sendMessage failed: ${result}`);
         }
+
+        const parsed = this.parseMaybeJson(result);
+        if (parsed === true) return;
+        if (typeof parsed === 'string') {
+            const normalized = parsed.trim().toLowerCase();
+            if (normalized === 'ok' || normalized === 'sent' || normalized === 'success' || normalized === 'true') {
+                return;
+            }
+        }
+        if (parsed && typeof parsed === 'object') {
+            if (parsed.sent === true || parsed.success === true || parsed.ok === true || parsed.submitted === true || parsed.dispatched === true) {
+                return;
+            }
+            if (typeof parsed.error === 'string' && parsed.error.trim()) {
+                throw new Error(`[${this.agentName}] sendMessage failed: ${parsed.error}`);
+            }
+        }
+
+        throw new Error(`[${this.agentName}] sendMessage was not confirmed`);
     }
 
     async resolveAction(evaluate: AgentEvaluateFn, action: string, button?: string): Promise<boolean> {

package/src/boot/daemon-lifecycle.ts

@@ -12,6 +12,7 @@ import { DaemonCdpInitializer, type CdpInitializerConfig } from '../cdp/initiali
 import { setupIdeInstance, type CdpSetupContext } from '../cdp/setup.js';
 import { DaemonCommandHandler } from '../commands/handler.js';
 import { DaemonCommandRouter, type CommandRouterDeps } from '../commands/router.js';
+import type { SessionHostControlPlane } from '../commands/router.js';
 import {
     DaemonCliManager,
     type CliTransportFactoryParams,
@@ -51,6 +52,7 @@ export interface DaemonInitConfig {
     /** Router transport-specific callbacks */
     onStatusChange?: () => void;
     onPostChatCommand?: () => void;
+    sessionHostControl?: SessionHostControlPlane | null;
     getCdpLogFn?: (ideType: string) => (msg: string) => void;
 
     /** Additional callback after CDP manager created (transport-specific extras) */
@@ -245,6 +247,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         onIdeConnected: () => poller?.start(),
         onStatusChange: config.onStatusChange,
         onPostChatCommand: config.onPostChatCommand,
+        sessionHostControl: config.sessionHostControl,
         getCdpLogFn: config.getCdpLogFn || ((ideType: string) => LOG.forComponent(`CDP:${ideType}`).asLogFn()),
     });
 

package/src/cli-adapters/pty-transport.ts

@@ -42,6 +42,9 @@ export interface PtyRuntimeMetadata {
   workspaceLabel?: string;
   writeOwner?: PtyRuntimeWriteOwner | null;
   attachedClients?: PtyRuntimeClientInfo[];
+  restoredFromStorage?: boolean;
+  recoveryState?: string | null;
+  recoveryError?: string | null;
 }
 
 export interface PtyRuntimeTransport {

package/src/cli-adapters/session-host-transport.ts

@@ -305,6 +305,7 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
     }
 
     private handleEvent(event: SessionHostEvent): void {
+        if (!('sessionId' in event)) return;
         if (event.sessionId !== this.options.runtimeId) return;
         if ((event.type === 'session_started' || event.type === 'session_resumed') && typeof event.pid === 'number') {
             this.currentPid = event.pid;
@@ -383,6 +384,13 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
                 type: client.type,
                 readOnly: client.readOnly,
             })),
+            restoredFromStorage: record.meta?.restoredFromStorage === true,
+            recoveryState: typeof record.meta?.runtimeRecoveryState === 'string'
+                ? String(record.meta.runtimeRecoveryState)
+                : null,
+            recoveryError: typeof record.meta?.runtimeRecoveryError === 'string'
+                ? String(record.meta.runtimeRecoveryError)
+                : null,
         };
     }
 

package/src/commands/chat-commands.ts

@@ -303,7 +303,7 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
         _log(`Extension: ${provider?.type || 'unknown_extension'}`);
         // Method 1: provider sendMessage script via evaluateInSession
         try {
-            const evalResult = await h.evaluateProviderScript('sendMessage', { MESSAGE: text }, 30000);
+            const evalResult = await h.evaluateProviderScript('sendMessage', { message: text }, 30000);
             if (evalResult?.result) {
                 const parsed = parseMaybeJson(evalResult.result);
                 if (didProviderConfirmSend(parsed)) {
@@ -338,7 +338,7 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
     }
 
     _log(`Targeting IDE: ${getCurrentManagerKey(h)}`);
-    const sendScript = h.getProviderScript('sendMessage', { MESSAGE: text });
+    const sendScript = h.getProviderScript('sendMessage', { message: text });
     if (sendScript) {
         try {
             const result = await targetCdp.evaluate(sendScript, 30000);

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) {
@@ -213,9 +215,31 @@ export class DaemonCommandHandler implements CommandHelpers {
         if (provider?.scripts) {
             const fn = (provider.scripts as any)[scriptName];
             if (typeof fn === 'function') {
-                const firstVal = params ? Object.values(params)[0] : undefined;
-                const script = firstVal ? fn(firstVal) : fn();
-                if (script) return script;
+                if (params && Object.keys(params).length > 0) {
+                    const firstVal = Object.values(params)[0];
+                    if (scriptName === 'sendMessage' && typeof firstVal === 'string') {
+                        const legacyScript = fn(firstVal);
+                        if (legacyScript) return legacyScript;
+                    }
+                    const script = fn(params);
+                    if (script) {
+                        const likelyLegacyObjectLeak =
+                            typeof script === 'string'
+                            && script.includes('[object Object]')
+                            && typeof firstVal === 'string';
+                        if (!likelyLegacyObjectLeak) return script;
+                    }
+
+                    if (firstVal !== undefined) {
+                        const legacyScript = fn(firstVal);
+                        if (legacyScript) return legacyScript;
+                    }
+
+                    if (script) return script;
+                } else {
+                    const script = fn();
+                    if (script) return script;
+                }
             }
         }
         return null;
@@ -284,23 +308,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 +397,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/commands/router.ts

@@ -14,6 +14,7 @@ import { registerExtensionProviders } from '../cdp/setup.js';
 import { DaemonCommandHandler } from './handler.js';
 import { DaemonCliManager } from './cli-manager.js';
 import { supportsExplicitSessionResume } from './cli-manager.js';
+import type { HostedCliRuntimeDescriptor } from './cli-manager.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { launchWithCdp, killIdeProcess, isIdeRunning } from '../launch.js';
@@ -35,6 +36,18 @@ import * as fs from 'fs';
 
 // ─── Types ───
 
+export interface SessionHostControlPlane {
+    getDiagnostics(payload?: { includeSessions?: boolean; limit?: number }): Promise<any>;
+    listSessions(): Promise<any[]>;
+    stopSession(sessionId: string): Promise<any>;
+    resumeSession(sessionId: string): Promise<any>;
+    restartSession(sessionId: string): Promise<any>;
+    sendSignal(sessionId: string, signal: string): Promise<any>;
+    forceDetachClient(sessionId: string, clientId: string): Promise<any>;
+    acquireWrite(payload: { sessionId: string; clientId: string; ownerType: 'agent' | 'user'; force?: boolean }): Promise<any>;
+    releaseWrite(payload: { sessionId: string; clientId: string }): Promise<any>;
+}
+
 export interface CommandRouterDeps {
     commandHandler: DaemonCommandHandler;
     cliManager: DaemonCliManager;
@@ -56,6 +69,8 @@ export interface CommandRouterDeps {
     getCdpLogFn?: (ideType: string) => (msg: string) => void;
     /** Package name for upgrade detection ('adhdev' or '@adhdev/daemon-standalone') */
     packageName?: string;
+    /** Session host control plane */
+    sessionHostControl?: SessionHostControlPlane | null;
 }
 
 export interface CommandRouterResult {
@@ -70,6 +85,30 @@ const CHAT_COMMANDS = [
 ];
 const READ_DEBUG_ENABLED = process.argv.includes('--dev') || process.env.ADHDEV_READ_DEBUG === '1';
 
+function toHostedCliRuntimeDescriptor(record: any): HostedCliRuntimeDescriptor | null {
+    if (!record || typeof record !== 'object') return null;
+    const runtimeId = typeof record.sessionId === 'string' ? record.sessionId : '';
+    const cliType = typeof record.providerType === 'string' ? record.providerType : '';
+    const workspace = typeof record.workspace === 'string' ? record.workspace : '';
+    if (!runtimeId || !cliType || !workspace) return null;
+    return {
+        runtimeId,
+        runtimeKey: typeof record.runtimeKey === 'string' ? record.runtimeKey : undefined,
+        displayName: typeof record.displayName === 'string' ? record.displayName : undefined,
+        workspaceLabel: typeof record.workspaceLabel === 'string' ? record.workspaceLabel : undefined,
+        lifecycle: typeof record.lifecycle === 'string' ? record.lifecycle as HostedCliRuntimeDescriptor['lifecycle'] : undefined,
+        recoveryState: typeof record.meta?.runtimeRecoveryState === 'string'
+            ? String(record.meta.runtimeRecoveryState)
+            : null,
+        cliType,
+        workspace,
+        cliArgs: Array.isArray(record.meta?.cliArgs) ? record.meta.cliArgs as string[] : [],
+        providerSessionId: typeof record.meta?.providerSessionId === 'string'
+            ? String(record.meta.providerSessionId)
+            : undefined,
+    };
+}
+
 export class DaemonCommandRouter {
     private deps: CommandRouterDeps;
 
@@ -159,6 +198,99 @@ export class DaemonCommandRouter {
                 }
             }
 
+            case 'session_host_get_diagnostics': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const diagnostics = await this.deps.sessionHostControl.getDiagnostics({
+                    includeSessions: args?.includeSessions !== false,
+                    limit: Number(args?.limit) || undefined,
+                });
+                return { success: true, diagnostics };
+            }
+
+            case 'session_host_list_sessions': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessions = await this.deps.sessionHostControl.listSessions();
+                return { success: true, sessions };
+            }
+
+            case 'session_host_stop_session': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                const record = await this.deps.sessionHostControl.stopSession(sessionId);
+                return { success: true, record };
+            }
+
+            case 'session_host_resume_session': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                const record = await this.deps.sessionHostControl.resumeSession(sessionId);
+                const hosted = toHostedCliRuntimeDescriptor(record);
+                if (hosted) {
+                    await this.deps.cliManager.restoreHostedSessions([hosted]);
+                }
+                return { success: true, record };
+            }
+
+            case 'session_host_restart_session': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                const record = await this.deps.sessionHostControl.restartSession(sessionId);
+                const hosted = toHostedCliRuntimeDescriptor(record);
+                if (hosted) {
+                    await this.deps.cliManager.restoreHostedSessions([hosted]);
+                }
+                return { success: true, record };
+            }
+
+            case 'session_host_send_signal': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                const signal = typeof args?.signal === 'string' ? args.signal : '';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                if (!signal) return { success: false, error: 'signal required' };
+                const record = await this.deps.sessionHostControl.sendSignal(sessionId, signal);
+                return { success: true, record };
+            }
+
+            case 'session_host_force_detach_client': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                const clientId = typeof args?.clientId === 'string' ? args.clientId : '';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                if (!clientId) return { success: false, error: 'clientId required' };
+                const record = await this.deps.sessionHostControl.forceDetachClient(sessionId, clientId);
+                return { success: true, record };
+            }
+
+            case 'session_host_acquire_write': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                const clientId = typeof args?.clientId === 'string' ? args.clientId : '';
+                const ownerType = args?.ownerType === 'agent' ? 'agent' : 'user';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                if (!clientId) return { success: false, error: 'clientId required' };
+                const record = await this.deps.sessionHostControl.acquireWrite({
+                    sessionId,
+                    clientId,
+                    ownerType,
+                    force: args?.force !== false,
+                });
+                return { success: true, record };
+            }
+
+            case 'session_host_release_write': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                const clientId = typeof args?.clientId === 'string' ? args.clientId : '';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                if (!clientId) return { success: false, error: 'clientId required' };
+                const record = await this.deps.sessionHostControl.releaseWrite({ sessionId, clientId });
+                return { success: true, record };
+            }
+
             case 'list_saved_sessions': {
                 const providerType = typeof args?.providerType === 'string'
                     ? args.providerType.trim()

package/src/providers/cli-provider-instance.ts

@@ -14,7 +14,7 @@ import type { ProviderModule } from './contracts.js';
 import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
-import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
+import type { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
 import { ChatHistoryWriter, readChatHistory } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
@@ -133,6 +133,7 @@ export class CliProviderInstance implements ProviderInstance {
 
  // PTY spawn
         await this.adapter.spawn();
+        this.maybeAppendRuntimeRecoveryMessage(this.adapter.getRuntimeMetadata());
         if (this.providerSessionId) {
             const restoredHistory = readChatHistory(this.type, 0, 200, this.providerSessionId);
             if (restoredHistory.messages.length > 0) {
@@ -246,6 +247,7 @@ export class CliProviderInstance implements ProviderInstance {
             this.promoteProviderSessionId(parsedProviderSessionId);
         }
         const runtime = this.adapter.getRuntimeMetadata();
+        this.maybeAppendRuntimeRecoveryMessage(runtime);
         const parsedMessages = Array.isArray(parsedStatus?.messages) ? parsedStatus.messages : [];
         const controlValues = extractProviderControlValues(this.provider.controls, parsedStatus);
         if (controlValues) {
@@ -603,6 +605,32 @@ export class CliProviderInstance implements ProviderInstance {
         return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
     }
 
+    private maybeAppendRuntimeRecoveryMessage(runtime: PtyRuntimeMetadata | null): void {
+        if (!runtime?.restoredFromStorage || !runtime.runtimeId) return;
+
+        const recoveryState = String(runtime.recoveryState || '').trim();
+        if (!recoveryState) return;
+
+        let content = '';
+        if (recoveryState === 'auto_resumed') {
+            content = 'Session host restored this CLI after restart and reattached it from a saved snapshot.';
+        } else if (recoveryState === 'resume_failed') {
+            const errorSuffix = runtime.recoveryError ? ` Resume failed: ${runtime.recoveryError}` : '';
+            content = `Session host found this CLI after restart, but automatic resume failed.${errorSuffix}`;
+        } else if (recoveryState === 'host_restart_interrupted') {
+            content = 'Session host found this CLI in interrupted state after restart and is attempting to resume it.';
+        } else if (recoveryState === 'orphan_snapshot') {
+            content = 'Session host restored the last snapshot for this CLI, but the original runtime was not resumed automatically.';
+        } else {
+            content = `Session host restored this CLI after restart (${recoveryState}).`;
+        }
+
+        this.appendRuntimeSystemMessage(
+            content,
+            `runtime_recovery:${runtime.runtimeId}:${recoveryState}`,
+        );
+    }
+
     private appendRuntimeSystemMessage(content: string, dedupKey: string, receivedAt = Date.now()): void {
         const normalizedContent = String(content || '').trim();
         if (!normalizedContent) return;

package/src/providers/extension-provider-instance.ts

@@ -25,6 +25,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
     private currentStatus: string = 'idle';
     private agentStreams: any[] = [];
     private messages: any[] = [];
+    private prevMessageHashes = new Map<string, number>();
     private activeModal: any = null;
     private currentModel: string = '';
     private currentMode: string = '';
@@ -104,7 +105,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
         if (event === 'stream_update') {
  // Reflect data collected from agent-stream-manager
             if (data?.streams) this.agentStreams = data.streams;
-            if (data?.messages) this.messages = data.messages;
+            if (data?.messages) this.messages = this.assignReceivedAt(data.messages);
             if (data?.activeModal !== undefined) this.activeModal = data.activeModal;
             if (data?.model) this.currentModel = data.model;
             if (data?.mode) this.currentMode = data.mode;
@@ -132,6 +133,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
     dispose(): void {
         this.agentStreams = [];
         this.messages = [];
+        this.prevMessageHashes.clear();
         this.monitor.reset();
         this.appliedEffectKeys.clear();
         this.runtimeMessages = [];
@@ -315,6 +317,26 @@ export class ExtensionProviderInstance implements ProviderInstance {
         );
     }
 
+    /**
+     * Assign stable receivedAt to extension messages.
+     * Same pattern as IdeProviderInstance.readChat() prevByHash —
+     * preserves first-seen timestamp across polling cycles.
+     */
+    private assignReceivedAt(messages: any[]): any[] {
+        const now = Date.now();
+        const nextHashes = new Map<string, number>();
+
+        for (const msg of messages) {
+            const hash = `${msg.role}:${(msg.content || '').slice(0, 100)}`;
+            const prevTime = this.prevMessageHashes.get(hash);
+            msg.receivedAt = prevTime || now;
+            nextHashes.set(hash, msg.receivedAt);
+        }
+
+        this.prevMessageHashes = nextHashes;
+        return messages;
+    }
+
     private mergeConversationMessages(messages: any[]): ChatMessage[] {
         if (this.runtimeMessages.length === 0) return messages;
         return [...messages, ...this.runtimeMessages.map((entry) => entry.message)]
@@ -382,6 +404,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
         }
         this.agentStreams = [];
         this.messages = [];
+        this.prevMessageHashes.clear();
         this.activeModal = null;
         this.currentModel = '';
         this.currentMode = '';

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,
+            });
+        }
+    }
+}