@adhdev/daemon-core 0.9.33 → 0.9.35

package/dist/providers/cli-provider-instance.d.ts

@@ -5,7 +5,7 @@
  * collectCliData() + status transition logic from daemon-status.ts moved here.
  */
 import { type ProviderModule } from './contracts.js';
-import type { ProviderInstance, ProviderState, InstanceContext } from './provider-instance.js';
+import type { ProviderInstance, ProviderState, InstanceContext, HotChatSessionState } from './provider-instance.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 type PersistableCliHistoryMessage = {
@@ -79,6 +79,7 @@ export declare class CliProviderInstance implements ProviderInstance {
             previousProviderSessionId?: string;
         }) => void;
     });
+    refreshProviderDefinition(provider: ProviderModule): void;
     init(context: InstanceContext): Promise<void>;
     onTick(): Promise<void>;
     /**
@@ -89,6 +90,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     getState(): ProviderState;
     setPresentationMode(mode: 'terminal' | 'chat'): void;
     getPresentationMode(): 'terminal' | 'chat';
+    getHotChatSessionState(): HotChatSessionState;
     updateSettings(newSettings: Record<string, any>): void;
     onEvent(event: string, data?: any): void;
     dispose(): void;

package/dist/providers/provider-instance-manager.d.ts

@@ -7,7 +7,7 @@
  * 3. Collect overall state
  * 4. Event collection and propagation
  */
-import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
+import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext, HotChatSessionState } from './provider-instance.js';
 export declare class ProviderInstanceManager {
     private instances;
     private tickTimer;
@@ -45,6 +45,7 @@ export declare class ProviderInstanceManager {
     * + Propagate pending events to event listeners
     */
     collectAllStates(): ProviderState[];
+    collectHotChatSessionStates(): HotChatSessionState[];
     /**
     * Per-category status collect
     */
@@ -77,6 +78,7 @@ export declare class ProviderInstanceManager {
      * Called when user changes settings from dashboard.
      */
     updateInstanceSettings(providerType: string, settings: Record<string, any>): number;
+    refreshProviderDefinitions(resolveProvider: (providerType: string) => unknown): number;
     /**
     * All terminate
     */

package/dist/providers/provider-instance.d.ts

@@ -7,7 +7,7 @@
  * Daemon only collects via ProviderInstance.getState(),
  * Each Instance manages its own status.
  */
-import type { ProviderResumeCapability } from './contracts.js';
+import type { ProviderModule, ProviderResumeCapability } from './contracts.js';
 import type { AcpConfigOption, AcpMode, ProviderControlSchema, ProviderSummaryMetadata, SessionCapability } from '../shared-types.js';
 import type { ChatMessage } from '../types.js';
 export type ProviderStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
@@ -112,6 +112,17 @@ export interface ProviderEvent {
     timestamp: number;
     [key: string]: any;
 }
+export interface HotChatSessionState {
+    id: string;
+    status?: unknown;
+    unread?: unknown;
+    inboxBucket?: unknown;
+    lastMessageAt?: unknown;
+    runtimeLifecycle?: unknown;
+    runtimeSurfaceKind?: unknown;
+    runtimeRestoredFromStorage?: unknown;
+    runtimeRecoveryState?: unknown;
+}
 export interface InstanceContext {
     /** CDP connection (IDE/Extension) */
     cdp?: {
@@ -142,10 +153,18 @@ export interface ProviderInstance {
     onTick(): Promise<void>;
     /** Return current status */
     getState(): ProviderState;
+    /**
+     * Return the cheap session metadata needed to decide whether chat-tail
+     * subscriptions should be flushed. Implementations must avoid rich transcript
+     * parsing here; callers use this on P2P hot flush paths.
+     */
+    getHotChatSessionState?(): HotChatSessionState | HotChatSessionState[] | null;
     /** Receive event (external → Instance) */
     onEvent(event: string, data?: any): void;
     /** Update settings at runtime (called when user changes settings from dashboard) */
     updateSettings?(newSettings: Record<string, any>): void;
+    /** Refresh static provider definition/scripts without restarting the live runtime. */
+    refreshProviderDefinition?(provider: ProviderModule): void;
     /** cleanup */
     dispose(): void;
 }

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

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

package/src/cli-adapter-types.ts

@@ -51,6 +51,7 @@ export interface CliAdapter {
     isReady(): boolean;
     setOnStatusChange(callback: () => void): void;
     updateRuntimeSettings?(settings: Record<string, unknown>): void;
+    setCliScripts?(scripts: Record<string, unknown>): void;
     setServerConn?(serverConn: unknown): void;
     clearHistory?(): void;
     resolveAction?(data: unknown): Promise<void>;

package/src/cli-adapters/provider-cli-adapter.ts

@@ -32,6 +32,7 @@ import {
     extractPromptRetrySnippet,
     getLastUserPromptText,
     listCliScriptNames,
+    normalizeComparableMessageContent,
     normalizePromptText,
     normalizeScreenSnapshot,
     promptLikelyVisible,
@@ -183,6 +184,8 @@ export class ProviderCliAdapter implements CliAdapter {
     private messages: CliChatMessage[] = [];
     private committedMessages: CliChatMessage[] = [];
     private structuredMessages: CliChatMessage[] = [];
+    private committedMessagesActivitySignature = '';
+    private committedMessagesChangedAt = 0;
     private currentStatus: CliSessionStatus['status'] = 'starting';
     private onStatusChange: (() => void) | null = null;
 
@@ -288,11 +291,38 @@ export class ProviderCliAdapter implements CliAdapter {
     private static readonly FINISH_RETRY_DELAY_MS = 300;
     private static readonly MAX_FINISH_RETRIES = 2;
 
+    private buildCommittedMessagesActivitySignature(): string {
+        const last = this.committedMessages[this.committedMessages.length - 1];
+        return [
+            String(this.committedMessages.length),
+            String(last?.role || ''),
+            String(last?.kind || ''),
+            String(last?.senderName || ''),
+            String(last?.timestamp || ''),
+            String(last?.receivedAt || ''),
+            normalizeComparableMessageContent(last?.content || '').slice(-240),
+        ].join('|');
+    }
+
     private syncMessageViews(): void {
+        const signature = this.buildCommittedMessagesActivitySignature();
+        if (signature !== this.committedMessagesActivitySignature) {
+            this.committedMessagesActivitySignature = signature;
+            this.committedMessagesChangedAt = Date.now();
+        }
         this.messages = [...this.committedMessages];
         this.structuredMessages = [...this.committedMessages];
     }
 
+    getLastCommittedMessageActivityAt(): number {
+        const last = this.committedMessages[this.committedMessages.length - 1];
+        const messageTime = Math.max(
+            typeof last?.receivedAt === 'number' && Number.isFinite(last.receivedAt) ? last.receivedAt : 0,
+            typeof last?.timestamp === 'number' && Number.isFinite(last.timestamp) ? last.timestamp : 0,
+        );
+        return Math.max(messageTime, this.committedMessagesChangedAt || 0);
+    }
+
     private readTerminalScreenText(now = Date.now()): string {
         const screenText = this.terminalScreen.getText() || '';
         this.lastScreenText = screenText;
@@ -519,10 +549,18 @@ export class ProviderCliAdapter implements CliAdapter {
     /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
     setCliScripts(scripts: CliScripts): void {
         this.cliScripts = scripts;
+        this.parsedStatusCache = null;
+        this.parseErrorMessage = null;
         const scriptNames = listCliScriptNames(scripts);
         LOG.info('CLI', `[${this.cliType}] CLI scripts injected: [${scriptNames.join(', ')}]`);
     }
 
+    /** Refresh provider scripts/config used by this adapter without restarting the PTY runtime. */
+    refreshProviderDefinition(provider: CliProviderModule): void {
+        this.provider = provider;
+        this.setCliScripts(provider.scripts || {});
+    }
+
     updateRuntimeSettings(settings: Record<string, any>): void {
         this.runtimeSettings = { ...settings };
     }
@@ -1067,7 +1105,7 @@ export class ProviderCliAdapter implements CliAdapter {
         }
 
         if (this.currentTurnScope && !lastParsedAssistant) {
-            LOG.info(
+            LOG.debug(
                 'CLI',
                 `[${this.cliType}] Settled without assistant: prompt=${JSON.stringify(this.currentTurnScope.prompt).slice(0, 140)} responseBuffer=${JSON.stringify(summarizeCliTraceText(this.responseBuffer, 220)).slice(0, 260)} screen=${JSON.stringify(summarizeCliTraceText(screenText, 220)).slice(0, 260)} providerDir=${this.providerResolutionMeta.providerDir || '-'} scriptDir=${this.providerResolutionMeta.scriptDir || '-'}`
             );
@@ -2013,9 +2051,52 @@ export class ProviderCliAdapter implements CliAdapter {
 
     private armResponseTimeout(): void {
         if (this.responseTimeout) clearTimeout(this.responseTimeout);
+        const timeoutMs = this.timeouts.maxResponse;
+        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+            this.responseTimeout = null;
+            return;
+        }
         this.responseTimeout = setTimeout(() => {
-            if (this.isWaitingForResponse) this.finishResponse();
-        }, this.timeouts.maxResponse);
+            this.responseTimeout = null;
+            if (!this.isWaitingForResponse) return;
+
+            const detectedStatusBeforeEval = this.runDetectStatus(this.recentOutputBuffer);
+            this.recordTrace('response_timeout_check', {
+                timeoutMs,
+                detectedStatus: detectedStatusBeforeEval,
+                currentStatus: this.currentStatus,
+                isWaitingForResponse: this.isWaitingForResponse,
+                hasActionableApproval: this.hasActionableApproval(),
+                ...buildCliTraceParseSnapshot({
+                    accumulatedBuffer: this.accumulatedBuffer,
+                    accumulatedRawBuffer: this.accumulatedRawBuffer,
+                    responseBuffer: this.responseBuffer,
+                    partialResponse: this.responseBuffer,
+                    scope: this.currentTurnScope,
+                }),
+            });
+
+            // maxResponse is a watchdog/checkpoint, not a completion signal. The old
+            // behavior called finishResponse() unconditionally at the default 300s,
+            // which fabricated idle transitions and downstream generating_completed
+            // notifications while long-running CLIs were still generating. Re-run the
+            // normal settled parser instead and keep the turn open unless the provider
+            // actually reports an idle, commit-ready state.
+            this.settledBuffer = this.recentOutputBuffer;
+            this.evaluateSettled();
+
+            if (this.isWaitingForResponse && !this.hasActionableApproval()) {
+                const detectedStatusAfterEval = this.runDetectStatus(this.recentOutputBuffer);
+                this.recordTrace('response_timeout_kept_open', {
+                    timeoutMs,
+                    detectedStatusBeforeEval,
+                    detectedStatusAfterEval,
+                    currentStatus: this.currentStatus,
+                    isWaitingForResponse: this.isWaitingForResponse,
+                });
+                this.armResponseTimeout();
+            }
+        }, timeoutMs);
     }
 
     private writeSubmitKeyForRetry(mode: string): void {

package/src/cli-adapters/provider-cli-parse.ts

@@ -31,6 +31,7 @@ export function hydrateCliParsedMessages(
 ): any[] {
     const { committedMessages, scope, lastOutputAt } = options;
     const referenceMessages = [...committedMessages];
+    const referenceComparables = referenceMessages.map((message) => normalizeComparableMessageContent(message?.content || ''));
     const usedReferenceIndexes = new Set<number>();
     const now = options.now ?? Date.now();
 
@@ -43,7 +44,7 @@ export function hydrateCliParsedMessages(
             sameIndex
             && !usedReferenceIndexes.has(parsedIndex)
             && sameIndex.role === role
-            && normalizeComparableMessageContent(sameIndex.content) === normalizedContent
+            && referenceComparables[parsedIndex] === normalizedContent
             && typeof sameIndex.timestamp === 'number'
             && Number.isFinite(sameIndex.timestamp)
         ) {
@@ -55,7 +56,7 @@ export function hydrateCliParsedMessages(
             if (usedReferenceIndexes.has(i)) continue;
             const candidate = referenceMessages[i];
             if (!candidate || candidate.role !== role) continue;
-            const candidateContent = normalizeComparableMessageContent(candidate.content);
+            const candidateContent = referenceComparables[i];
             if (!candidateContent) continue;
             const exactMatch = candidateContent === normalizedContent;
             const fuzzyMatch = candidateContent.includes(normalizedContent) || normalizedContent.includes(candidateContent);

package/src/commands/handler.ts

@@ -507,7 +507,16 @@ export class DaemonCommandHandler implements CommandHelpers {
         if (this._ctx.providerLoader) {
             await this._ctx.providerLoader.fetchLatest().catch(() => {});
             this._ctx.providerLoader.reload();
-            return { success: true };
+            this._ctx.providerLoader.registerToDetector();
+            const refreshedInstances = this._ctx.instanceManager
+                ? this._ctx.instanceManager.refreshProviderDefinitions((providerType) => this._ctx.providerLoader!.resolve(providerType))
+                : 0;
+            const providers = this._ctx.providerLoader.getAll().map((provider) => ({
+                type: provider.type,
+                name: provider.name,
+                category: provider.category,
+            }));
+            return { success: true, refreshedInstances, providers };
         }
         return { success: false, error: 'ProviderLoader not initialized' };
     }

package/src/commands/upgrade-helper.ts

@@ -161,6 +161,52 @@ function killPid(pid: number): boolean {
   }
 }
 
+function getWindowsProcessCommandLine(pid: number): string | null {
+  const pidFilter = `ProcessId=${pid}`;
+  try {
+    const psOut = execFileSync('powershell.exe', [
+      '-NoProfile',
+      '-NonInteractive',
+      '-ExecutionPolicy', 'Bypass',
+      '-Command',
+      `(Get-CimInstance Win32_Process -Filter "${pidFilter}").CommandLine`,
+    ], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    if (psOut) return psOut;
+  } catch {
+    // fall through to wmic fallback
+  }
+
+  try {
+    const wmicOut = execFileSync('wmic', [
+      'process', 'where', pidFilter, 'get', 'CommandLine',
+    ], { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    if (wmicOut) return wmicOut;
+  } catch {
+    // noop
+  }
+  return null;
+}
+
+function getProcessCommandLine(pid: number): string | null {
+  if (!Number.isFinite(pid) || pid <= 0) return null;
+  if (process.platform === 'win32') return getWindowsProcessCommandLine(pid);
+  try {
+    const text = execFileSync('ps', ['-o', 'command=', '-p', String(pid)], {
+      encoding: 'utf8',
+      timeout: 3000,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    return text || null;
+  } catch {
+    return null;
+  }
+}
+
+function isManagedSessionHostPid(pid: number): boolean {
+  const commandLine = getProcessCommandLine(pid);
+  return !!commandLine && /session-host-daemon/i.test(commandLine);
+}
+
 async function waitForPidExit(pid: number, timeoutMs: number): Promise<void> {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
@@ -173,12 +219,12 @@ async function waitForPidExit(pid: number, timeoutMs: number): Promise<void> {
   }
 }
 
-function stopSessionHostProcesses(appName: string): void {
+export function stopSessionHostProcesses(appName: string): void {
   const pidFile = path.join(os.homedir(), '.adhdev', `${appName}-session-host.pid`);
   try {
     if (fs.existsSync(pidFile)) {
       const pid = Number.parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
-      if (Number.isFinite(pid)) {
+      if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
         killPid(pid);
       }
     }
@@ -191,20 +237,6 @@ function stopSessionHostProcesses(appName: string): void {
       // noop
     }
   }
-
-  if (process.platform !== 'win32') {
-    try {
-      const raw = execFileSync('pgrep', ['-f', 'session-host-daemon'], { encoding: 'utf8' }).trim();
-      for (const line of raw.split('\n')) {
-        const pid = Number.parseInt(line.trim(), 10);
-        if (Number.isFinite(pid)) {
-          killPid(pid);
-        }
-      }
-    } catch {
-      // noop
-    }
-  }
 }
 
 function removeDaemonPidFile(): void {

package/src/daemon/dev-server.ts

@@ -507,20 +507,9 @@ export class DevServer implements DevServerContext {
   private async handleReload(_req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     try {
       this.providerLoader.reload();
-      let refreshedInstances = 0;
-      if (this.instanceManager) {
-        for (const id of this.instanceManager.listInstanceIds()) {
-          const instance = this.instanceManager.getInstance(id) as any;
-          const providerType = typeof instance?.type === 'string' ? instance.type : '';
-          if (!providerType) continue;
-          const resolved = this.providerLoader.resolve(providerType);
-          if (!resolved) continue;
-          if (instance && typeof instance === 'object' && 'provider' in instance) {
-            instance.provider = resolved;
-            refreshedInstances += 1;
-          }
-        }
-      }
+      const refreshedInstances = this.instanceManager
+        ? this.instanceManager.refreshProviderDefinitions((providerType) => this.providerLoader.resolve(providerType))
+        : 0;
       const providers = this.providerLoader.getAll().map(p => ({
         type: p.type, name: p.name, category: p.category,
       }));

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

@@ -12,7 +12,7 @@ import * as fs from 'fs';
 import { createRequire } from 'node:module';
 import { normalizeInputEnvelope, type ProviderModule, flattenContent } from './contracts.js';
 import { assertTextOnlyInput } from './provider-input-support.js';
-import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext, ProviderErrorReason } from './provider-instance.js';
+import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext, ProviderErrorReason, HotChatSessionState } 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 { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pty-transport.js';
@@ -219,6 +219,12 @@ export class CliProviderInstance implements ProviderInstance {
         this.historyWriter = new ChatHistoryWriter();
     }
 
+    refreshProviderDefinition(provider: ProviderModule): void {
+        if (provider.type !== this.type || provider.category !== 'cli') return;
+        this.provider = provider;
+        this.adapter.refreshProviderDefinition(provider as CliProviderModule);
+    }
+
  // ─── Lifecycle ─────────────────────────────────
 
     async init(context: InstanceContext): Promise<void> {
@@ -487,6 +493,25 @@ export class CliProviderInstance implements ProviderInstance {
         return this.presentationMode;
     }
 
+    getHotChatSessionState(): HotChatSessionState {
+        const adapterStatus = this.adapter.getStatus();
+        const autoApproveActive = adapterStatus.status === 'waiting_approval' && this.shouldAutoApprove();
+        const visibleStatus = autoApproveActive ? 'generating' : adapterStatus.status;
+        const runtime = this.adapter.getRuntimeMetadata();
+        const lastCommittedMessageActivityAt = typeof this.adapter.getLastCommittedMessageActivityAt === 'function'
+            ? this.adapter.getLastCommittedMessageActivityAt()
+            : 0;
+        return {
+            id: this.instanceId,
+            status: visibleStatus,
+            lastMessageAt: lastCommittedMessageActivityAt || undefined,
+            runtimeLifecycle: runtime?.lifecycle ?? null,
+            runtimeSurfaceKind: runtime?.surfaceKind,
+            runtimeRestoredFromStorage: runtime?.restoredFromStorage === true,
+            runtimeRecoveryState: runtime?.recoveryState ?? null,
+        };
+    }
+
     updateSettings(newSettings: Record<string, any>): void {
         this.settings = { ...newSettings };
         this.adapter.updateRuntimeSettings?.(this.settings);
@@ -650,6 +675,15 @@ export class CliProviderInstance implements ProviderInstance {
                     this.completedDebouncePending = { chatTitle, duration, timestamp: now };
                     this.completedDebounceTimer = setTimeout(() => {
                         if (this.completedDebouncePending) {
+                            const latestStatus = this.adapter.getStatus();
+                            const latestAutoApproveActive = latestStatus.status === 'waiting_approval' && this.shouldAutoApprove();
+                            const latestVisibleStatus = latestAutoApproveActive ? 'generating' : latestStatus.status;
+                            if (latestVisibleStatus !== 'idle') {
+                                LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
+                                this.completedDebouncePending = null;
+                                this.completedDebounceTimer = null;
+                                return;
+                            }
                             LOG.info('CLI', `[${this.type}] completed in ${this.completedDebouncePending.duration}s`);
                             this.pushEvent({ event: 'agent:generating_completed', ...this.completedDebouncePending });
                             this.completedDebouncePending = null;

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

@@ -8,9 +8,28 @@
  * 4. Event collection and propagation
  */
 
-import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
+import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext, HotChatSessionState } from './provider-instance.js';
 import { LOG } from '../logging/logger.js';
 
+function projectHotChatSessionStatesFromProviderState(state: ProviderState): HotChatSessionState[] {
+    const project = (item: ProviderState): HotChatSessionState => ({
+        id: item.instanceId,
+        status: item.activeChat?.status || item.status,
+        unread: (item as any).unread,
+        inboxBucket: (item as any).inboxBucket,
+        lastMessageAt: (item as any).lastMessageAt ?? (item.activeChat as any)?.lastMessageAt,
+        runtimeLifecycle: item.runtime?.lifecycle ?? null,
+        runtimeSurfaceKind: item.runtime?.surfaceKind,
+        runtimeRestoredFromStorage: item.runtime?.restoredFromStorage === true,
+        runtimeRecoveryState: item.runtime?.recoveryState ?? null,
+    });
+
+    if (state.category === 'ide') {
+        return [project(state), ...state.extensions.map(project)];
+    }
+    return [project(state)];
+}
+
 export class ProviderInstanceManager {
     private instances = new Map<string, ProviderInstance>();
     private tickTimer: NodeJS.Timeout | null = null;
@@ -120,6 +139,32 @@ export class ProviderInstanceManager {
         return states;
     }
 
+    collectHotChatSessionStates(): HotChatSessionState[] {
+        const sessions: HotChatSessionState[] = [];
+        for (const [id, instance] of this.instances) {
+            try {
+                const projected = instance.getHotChatSessionState?.();
+                if (Array.isArray(projected)) {
+                    sessions.push(...projected.filter((session): session is HotChatSessionState => !!session?.id));
+                    continue;
+                }
+                if (projected?.id) {
+                    sessions.push(projected);
+                    continue;
+                }
+
+                // Fallback for provider types that have not implemented the cheap
+                // projection yet. CLI implements getHotChatSessionState() because
+                // its full getState() may run rich transcript parsing.
+                const state = instance.getState();
+                sessions.push(...projectHotChatSessionStatesFromProviderState(state));
+            } catch (e) {
+                LOG.warn('InstanceMgr', `[InstanceManager] Failed to collect hot chat metadata from ${id}: ${(e as Error).message}`);
+            }
+        }
+        return sessions;
+    }
+
  /**
  * Per-category status collect
  */
@@ -216,6 +261,18 @@ export class ProviderInstanceManager {
         return updated;
     }
 
+    refreshProviderDefinitions(resolveProvider: (providerType: string) => unknown): number {
+        let refreshed = 0;
+        for (const instance of this.instances.values()) {
+            if (typeof instance.refreshProviderDefinition !== 'function') continue;
+            const provider = resolveProvider(instance.type);
+            if (!provider || typeof provider !== 'object') continue;
+            instance.refreshProviderDefinition(provider as any);
+            refreshed += 1;
+        }
+        return refreshed;
+    }
+
  // ─── cleanup ──────────────────────────────────────
 
  /**

package/src/providers/provider-instance.ts

@@ -135,6 +135,18 @@ export interface ProviderEvent {
     [key: string]: any;
 }
 
+export interface HotChatSessionState {
+    id: string;
+    status?: unknown;
+    unread?: unknown;
+    inboxBucket?: unknown;
+    lastMessageAt?: unknown;
+    runtimeLifecycle?: unknown;
+    runtimeSurfaceKind?: unknown;
+    runtimeRestoredFromStorage?: unknown;
+    runtimeRecoveryState?: unknown;
+}
+
 // ─── ProviderInstance interface ─────────────────
 
 export interface InstanceContext {
@@ -172,12 +184,22 @@ export interface ProviderInstance {
  /** Return current status */
     getState(): ProviderState;
 
+    /**
+     * Return the cheap session metadata needed to decide whether chat-tail
+     * subscriptions should be flushed. Implementations must avoid rich transcript
+     * parsing here; callers use this on P2P hot flush paths.
+     */
+    getHotChatSessionState?(): HotChatSessionState | HotChatSessionState[] | null;
+
  /** Receive event (external → Instance) */
     onEvent(event: string, data?: any): void;
 
  /** Update settings at runtime (called when user changes settings from dashboard) */
     updateSettings?(newSettings: Record<string, any>): void;
 
+    /** Refresh static provider definition/scripts without restarting the live runtime. */
+    refreshProviderDefinition?(provider: ProviderModule): void;
+
  /** cleanup */
     dispose(): void;
 }