@adhdev/daemon-core 0.9.32 → 0.9.33

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

@@ -221,6 +221,7 @@ export declare class ProviderLoader {
     getMachineProviderConfig(type: string): MachineProviderConfig;
     setMachineProviderConfig(type: string, patch: Partial<MachineProviderConfig>): boolean;
     setMachineProviderEnabled(type: string, enabled: boolean): boolean;
+    private getEffectiveProviderAvailability;
     getMachineProviderStatus(type: string): ProviderMachineStatus;
     getSpawnArgs(type: string, fallback?: string[]): string[];
     private parseArgsSetting;

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

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

package/src/commands/chat-commands.ts

@@ -297,6 +297,36 @@ function toHistoryPersistedMessages(messages: ChatMessage[]): Array<{
     }));
 }
 
+function findLastMessageIndexBySignature(messages: ChatMessage[], signature: string): number {
+    if (!signature) return -1;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        if (getChatMessageSignature(messages[index]) === signature) {
+            return index;
+        }
+    }
+    return -1;
+}
+
+function buildBoundedTailSync(messages: ChatMessage[], cursor: Required<ReadChatCursor>): {
+    syncMode: ReadChatSyncMode;
+    replaceFrom: number;
+    messages: ChatMessage[];
+    totalMessages: number;
+    lastMessageSignature: string;
+} {
+    const totalMessages = messages.length;
+    const tailMessages = cursor.tailLimit > 0 && totalMessages > cursor.tailLimit
+        ? messages.slice(-cursor.tailLimit)
+        : messages;
+    return {
+        syncMode: 'full',
+        replaceFrom: 0,
+        messages: tailMessages,
+        totalMessages,
+        lastMessageSignature: getChatMessageSignature(messages[totalMessages - 1]),
+    };
+}
+
 function computeReadChatSync(messages: ChatMessage[], cursor: Required<ReadChatCursor>): {
     syncMode: ReadChatSyncMode;
     replaceFrom: number;
@@ -338,6 +368,16 @@ function computeReadChatSync(messages: ChatMessage[], cursor: Required<ReadChatC
         };
     }
 
+    if (cursor.tailLimit > 0 && knownSignature === lastMessageSignature) {
+        return {
+            syncMode: 'noop',
+            replaceFrom: totalMessages,
+            messages: [],
+            totalMessages,
+            lastMessageSignature,
+        };
+    }
+
     if (knownMessageCount < totalMessages) {
         const anchorSignature = getChatMessageSignature(messages[knownMessageCount - 1]);
         if (anchorSignature === knownSignature) {
@@ -349,6 +389,20 @@ function computeReadChatSync(messages: ChatMessage[], cursor: Required<ReadChatC
                 lastMessageSignature,
             };
         }
+
+        if (cursor.tailLimit > 0) {
+            const signatureIndex = findLastMessageIndexBySignature(messages, knownSignature);
+            if (signatureIndex >= 0) {
+                return {
+                    syncMode: 'append',
+                    replaceFrom: knownMessageCount,
+                    messages: messages.slice(signatureIndex + 1),
+                    totalMessages,
+                    lastMessageSignature,
+                };
+            }
+            return buildBoundedTailSync(messages, cursor);
+        }
     }
 
     const replaceFrom = Math.max(0, Math.min(knownMessageCount - 1, totalMessages));

package/src/providers/provider-loader.ts

@@ -653,10 +653,26 @@ export class ProviderLoader {
     return this.setMachineProviderConfig(type, { enabled });
   }
 
+  private getEffectiveProviderAvailability(type: string): ProviderAvailabilityState | undefined {
+    const providerType = this.resolveAlias(type);
+    const availability = this.providerAvailability.get(providerType);
+    if (availability) return availability;
+
+    const machineConfig = this.getMachineProviderConfig(providerType);
+    const lastDetection = machineConfig.lastDetection;
+    if (!lastDetection) return undefined;
+    return {
+      installed: lastDetection.ok === true,
+      detectedPath: typeof lastDetection.path === 'string' && lastDetection.path.trim()
+        ? lastDetection.path.trim()
+        : null,
+    };
+  }
+
   getMachineProviderStatus(type: string): ProviderMachineStatus {
     const providerType = this.resolveAlias(type);
     if (!this.isMachineProviderEnabled(providerType)) return 'disabled';
-    const availability = this.providerAvailability.get(providerType);
+    const availability = this.getEffectiveProviderAvailability(providerType);
     if (!availability) return 'enabled_unchecked';
     return availability.installed ? 'detected' : 'not_detected';
   }
@@ -792,7 +808,7 @@ export class ProviderLoader {
 
   getAvailableProviderInfos(): Array<ProviderModule & { installed?: boolean; detectedPath?: string | null; enabled: boolean; machineStatus: ProviderMachineStatus; lastDetection?: MachineProviderCheckResult; lastVerification?: MachineProviderCheckResult }> {
     return this.getAll().map((provider) => {
-      const availability = this.providerAvailability.get(provider.type);
+      const availability = this.getEffectiveProviderAvailability(provider.type);
       const enabled = this.isMachineProviderEnabled(provider.type);
       const machineConfig = this.getMachineProviderConfig(provider.type);
       return {