@adhdev/daemon-core 0.9.34 → 0.9.36

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

@@ -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>;
     /**

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

@@ -78,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';
@@ -163,6 +163,8 @@ export interface ProviderInstance {
     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.34",
+  "version": "0.9.36",
   "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.34",
+  "version": "0.9.36",
   "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;
@@ -339,7 +369,17 @@ export class ProviderCliAdapter implements CliAdapter {
         return baseMessages.slice(-ProviderCliAdapter.PARSE_MESSAGE_TAIL_LIMIT);
     }
 
+    private messagesShareStableIdentity(left: any, right: any): boolean {
+        if (left === right) return true;
+        if (!left || !right) return false;
+        if ((left.role || '') !== (right.role || '')) return false;
+        if (left.id && right.id && String(left.id) === String(right.id)) return true;
+        if (typeof left.index === 'number' && typeof right.index === 'number' && left.index === right.index) return true;
+        return false;
+    }
+
     private messagesComparable(left: any, right: any): boolean {
+        if (this.messagesShareStableIdentity(left, right)) return true;
         if (!left || !right) return false;
         if ((left.role || '') !== (right.role || '')) return false;
         const leftText = normalizeComparableTranscriptText(left.content);
@@ -519,10 +559,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 };
     }
@@ -1685,6 +1733,82 @@ export class ProviderCliAdapter implements CliAdapter {
         this.syncMessageViews();
     }
 
+    private getSharedCommittedPrefixLength(parsedMessages: any[]): number {
+        const committedMessages = this.committedMessages;
+        const max = Math.min(parsedMessages.length, committedMessages.length);
+        let index = 0;
+        while (index < max && this.messagesShareStableIdentity(parsedMessages[index], committedMessages[index])) {
+            index += 1;
+        }
+        return index;
+    }
+
+    private hydrateCommittedPrefixForParsedStatus(parsedMessages: any[]): any[] | null {
+        const sharedPrefixLength = this.getSharedCommittedPrefixLength(parsedMessages);
+        if (sharedPrefixLength !== this.committedMessages.length) return null;
+
+        const committedHydratedMessages = this.committedMessages.map((message, index) => {
+            const timestamp = typeof message.timestamp === 'number' && Number.isFinite(message.timestamp)
+                ? message.timestamp
+                : (this.lastOutputAt || this.currentTurnScope?.startedAt || Date.now());
+            const contentValue = message.content;
+            return {
+                role: message.role,
+                content: typeof contentValue === 'string' ? contentValue : String(contentValue || ''),
+                timestamp,
+                receivedAt: typeof message.receivedAt === 'number' && Number.isFinite(message.receivedAt)
+                    ? message.receivedAt
+                    : timestamp,
+                kind: message.kind,
+                id: message.id || `msg_${index}`,
+                index: typeof message.index === 'number' ? message.index : index,
+                meta: message.meta,
+                senderName: message.senderName,
+            };
+        });
+        const extraMessages = parsedMessages.slice(sharedPrefixLength);
+        if (extraMessages.length === 0) return committedHydratedMessages;
+
+        const extraHydratedMessages = hydrateCliParsedMessages(extraMessages, {
+            committedMessages: [],
+            scope: this.currentTurnScope,
+            lastOutputAt: this.lastOutputAt,
+        }).map((message, offset) => ({
+            ...message,
+            id: message.id || `msg_${sharedPrefixLength + offset}`,
+            index: typeof message.index === 'number' ? message.index : sharedPrefixLength + offset,
+        }));
+        return [...committedHydratedMessages, ...extraHydratedMessages];
+    }
+
+    private hydrateParsedMessagesForStatus(parsedMessages: any[]): any[] {
+        return this.hydrateCommittedPrefixForParsedStatus(parsedMessages)
+            || hydrateCliParsedMessages(parsedMessages, {
+                committedMessages: this.committedMessages,
+                scope: this.currentTurnScope,
+                lastOutputAt: this.lastOutputAt,
+            });
+    }
+
+    private buildCommittedChatMessages(): any[] {
+        return this.committedMessages.map((message, index) => {
+            const contentValue = message.content;
+            return buildChatMessage({
+                role: message.role,
+                content: typeof contentValue === 'string' ? contentValue : String(contentValue || ''),
+                timestamp: message.timestamp,
+                kind: message.kind,
+                meta: message.meta,
+                senderName: message.senderName,
+                id: message.id || `msg_${index}`,
+                index: typeof message.index === 'number' ? message.index : index,
+                receivedAt: typeof message.receivedAt === 'number'
+                    ? message.receivedAt
+                    : message.timestamp,
+            });
+        });
+    }
+
     /**
      * Script-based full parse — returns ReadChatResult.
      * Called by command handler / dashboard for rich content rendering.
@@ -1727,7 +1851,7 @@ export class ProviderCliAdapter implements CliAdapter {
                 this.onStatusChange?.();
             }
         }
-        if (parsed && Array.isArray(parsed.messages)) {
+        if (parsed && Array.isArray(parsed.messages) && this.provider.allowInputDuringGeneration === true) {
             const hydratedForCommit = normalizeCliParsedMessages(parsed.messages, {
                 committedMessages: this.committedMessages,
                 scope: this.currentTurnScope,
@@ -1749,25 +1873,13 @@ export class ProviderCliAdapter implements CliAdapter {
             && this.currentStatus === 'idle';
         let result: any;
         if (parsed && Array.isArray(parsed.messages)) {
-            const parsedHydratedMessages = hydrateCliParsedMessages(parsed.messages, {
-                committedMessages: this.committedMessages,
-                scope: this.currentTurnScope,
-                lastOutputAt: this.lastOutputAt,
-            });
-            const committedHydratedMessages = this.committedMessages.map((message, index) => buildChatMessage({
-                ...message,
-                id: message.id || `msg_${index}`,
-                index: typeof message.index === 'number' ? message.index : index,
-                receivedAt: typeof message.receivedAt === 'number'
-                    ? message.receivedAt
-                    : message.timestamp,
-            }));
+            const parsedHydratedMessages = this.hydrateParsedMessagesForStatus(parsed.messages);
             const parsedLastAssistant = [...parsedHydratedMessages].reverse().find((message) => message.role === 'assistant' && typeof message.content === 'string' && message.content.trim());
             const shouldAdoptParsedIdleReplay =
                 !this.currentTurnScope
                 && !this.activeModal
                 && !!parsedLastAssistant
-                && parsedTranscriptIsRicherThanCommitted(parsedHydratedMessages, committedHydratedMessages)
+                && parsedTranscriptIsRicherThanCommitted(parsedHydratedMessages, this.committedMessages)
                 && (
                     this.currentStatus === 'idle'
                     || (
@@ -1778,11 +1890,23 @@ export class ProviderCliAdapter implements CliAdapter {
                     )
                 );
             if (shouldAdoptParsedIdleReplay) {
-                this.committedMessages = normalizeCliParsedMessages(parsed.messages, {
-                    committedMessages: this.committedMessages,
-                    scope: this.currentTurnScope,
-                    lastOutputAt: this.lastOutputAt,
-                });
+                this.committedMessages = this.getSharedCommittedPrefixLength(parsed.messages) === this.committedMessages.length
+                    ? parsedHydratedMessages.map((message) => ({
+                        role: message.role,
+                        content: typeof message.content === 'string' ? message.content : String(message.content || ''),
+                        timestamp: message.timestamp,
+                        receivedAt: message.receivedAt,
+                        kind: message.kind,
+                        id: message.id,
+                        index: message.index,
+                        meta: message.meta,
+                        senderName: message.senderName,
+                    }))
+                    : normalizeCliParsedMessages(parsed.messages, {
+                        committedMessages: this.committedMessages,
+                        scope: this.currentTurnScope,
+                        lastOutputAt: this.lastOutputAt,
+                    });
                 this.syncMessageViews();
                 if (this.currentStatus !== 'idle' || this.isWaitingForResponse) {
                     this.responseBuffer = '';
@@ -1797,25 +1921,15 @@ export class ProviderCliAdapter implements CliAdapter {
                     this.onStatusChange?.();
                 }
             }
-            const effectiveCommittedHydratedMessages = shouldAdoptParsedIdleReplay
-                ? this.committedMessages.map((message, index) => buildChatMessage({
-                    ...message,
-                    id: message.id || `msg_${index}`,
-                    index: typeof message.index === 'number' ? message.index : index,
-                    receivedAt: typeof message.receivedAt === 'number'
-                        ? message.receivedAt
-                        : message.timestamp,
-                }))
-                : committedHydratedMessages;
             const shouldPreferCommittedHistoryReplay =
                 !this.currentTurnScope
                 && !this.activeModal
-                && effectiveCommittedHydratedMessages.length > parsedHydratedMessages.length;
+                && this.committedMessages.length > parsedHydratedMessages.length;
             const shouldPreferCommittedIdleReplay =
                 shouldPreferCommittedMessages
                 && !shouldAdoptParsedIdleReplay;
             const hydratedMessages = (shouldPreferCommittedIdleReplay || shouldPreferCommittedHistoryReplay)
-                ? effectiveCommittedHydratedMessages
+                ? this.buildCommittedChatMessages()
                 : parsedHydratedMessages;
             result = {
                 id: parsed.id || 'cli_session',

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/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

@@ -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> {
@@ -492,9 +498,13 @@ export class CliProviderInstance implements ProviderInstance {
         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,

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

@@ -15,6 +15,9 @@ function projectHotChatSessionStatesFromProviderState(state: ProviderState): Hot
     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,
@@ -258,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

@@ -197,6 +197,9 @@ export interface ProviderInstance {
  /** 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;
 }