@adhdev/daemon-core 0.9.31 → 0.9.33

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

@@ -85,6 +85,7 @@ export declare class ProviderLoader {
         probeStarts?: string[];
     });
     private log;
+    private debugLog;
     /**
      * User override root (~/.adhdev/providers by default).
      */
@@ -220,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/dist/status/chat-tail-hot-sessions.d.ts

@@ -15,6 +15,7 @@ export declare function classifyHotChatSessionsForSubscriptionFlush(sessions: Ho
     now?: number;
     recentMessageGraceMs?: number;
     activeStatuses?: ReadonlySet<string>;
+    activeSessionIds?: ReadonlySet<string>;
 }): {
     active: Set<string>;
     finalizing: Set<string>;

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

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.9.31",
+  "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.31",
+  "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/cli-adapters/provider-cli-adapter.ts

@@ -282,6 +282,7 @@ export class ProviderCliAdapter implements CliAdapter {
     private static readonly STATUS_HOT_PATH_PARSE_MIN_INTERVAL_MS = 1000;
     private static readonly SCREEN_SNAPSHOT_MIN_INTERVAL_MS = 250;
     private static readonly MAX_TRACE_ENTRIES = 250;
+    private static readonly PARSE_MESSAGE_TAIL_LIMIT = 100;
 
     private readonly providerResolutionMeta: ProviderResolutionMeta;
     private static readonly FINISH_RETRY_DELAY_MS = 300;
@@ -333,6 +334,42 @@ export class ProviderCliAdapter implements CliAdapter {
         return null;
     }
 
+    private selectParseBaseMessages(baseMessages: CliChatMessage[]): CliChatMessage[] {
+        if (baseMessages.length <= ProviderCliAdapter.PARSE_MESSAGE_TAIL_LIMIT) return baseMessages;
+        return baseMessages.slice(-ProviderCliAdapter.PARSE_MESSAGE_TAIL_LIMIT);
+    }
+
+    private messagesComparable(left: any, right: any): boolean {
+        if (!left || !right) return false;
+        if ((left.role || '') !== (right.role || '')) return false;
+        const leftText = normalizeComparableTranscriptText(left.content);
+        const rightText = normalizeComparableTranscriptText(right.content);
+        return !!leftText && leftText === rightText;
+    }
+
+    private stitchParsedMessagesWithCommittedBase(
+        parsedMessages: any[],
+        fullBaseMessages: CliChatMessage[],
+        parseBaseMessages: CliChatMessage[],
+    ): any[] {
+        if (!Array.isArray(parsedMessages) || parsedMessages.length === 0) return parsedMessages;
+        if (fullBaseMessages.length <= parseBaseMessages.length) return parsedMessages;
+
+        const parsedFirst = parsedMessages[0];
+        const fullFirst = fullBaseMessages[0];
+        if (parsedMessages.length >= fullBaseMessages.length && this.messagesComparable(parsedFirst, fullFirst)) {
+            return parsedMessages;
+        }
+
+        const tailFirst = parseBaseMessages[0];
+        if (tailFirst && this.messagesComparable(parsedFirst, tailFirst)) {
+            const prefixLength = fullBaseMessages.length - parseBaseMessages.length;
+            return [...fullBaseMessages.slice(0, prefixLength), ...parsedMessages];
+        }
+
+        return [...fullBaseMessages, ...parsedMessages];
+    }
+
     private getIdleFinishConfirmMs(): number {
         return this.timeouts.idleFinishConfirm;
     }
@@ -1044,7 +1081,7 @@ export class ProviderCliAdapter implements CliAdapter {
         if (!this.applyPendingScriptStatusDebounce(ctx)) return;
 
         const recentInteractiveActivity = this.hasRecentInteractiveActivity(now);
-        LOG.info(
+        LOG.debug(
             'CLI',
             `[${this.cliType}] settled diagnostics prompt=${JSON.stringify(this.currentTurnScope?.prompt || '').slice(0, 140)} status=${String(status || '')} parsedStatus=${String(parsedStatus || '')} parsedMsgCount=${parsedMessages.length} lastParsedAssistant=${JSON.stringify(summarizeCliTraceText(lastParsedAssistant?.content || '', 120)).slice(0, 160)} responseBuffer=${JSON.stringify(summarizeCliTraceText(this.responseBuffer, 160)).slice(0, 220)} screen=${JSON.stringify(summarizeCliTraceText(screenText, 160)).slice(0, 220)}`
         );
@@ -1439,18 +1476,26 @@ export class ProviderCliAdapter implements CliAdapter {
             try {
                 const screenText = this.terminalScreen.getText();
                 const tail = this.recentOutputBuffer.slice(-500);
+                const parseBaseMessages = this.selectParseBaseMessages(this.committedMessages);
                 const input = buildCliParseInput({
                     accumulatedBuffer: this.accumulatedBuffer,
                     accumulatedRawBuffer: this.accumulatedRawBuffer,
                     recentOutputBuffer: this.recentOutputBuffer,
                     terminalScreenText: screenText,
-                    baseMessages: this.committedMessages,
+                    baseMessages: parseBaseMessages,
                     partialResponse: this.responseBuffer,
                     isWaitingForResponse: this.isWaitingForResponse,
                     scope: this.currentTurnScope,
                     runtimeSettings: this.runtimeSettings,
                 });
                 const session = this.cliScripts.parseSession({ ...input, tail, tailScreen: buildCliScreenSnapshot(tail) });
+                if (session && typeof session === 'object' && Array.isArray(session.messages)) {
+                    session.messages = this.stitchParsedMessagesWithCommittedBase(
+                        session.messages,
+                        this.committedMessages,
+                        parseBaseMessages,
+                    );
+                }
                 this.parseErrorMessage = null;
                 return session && typeof session === 'object' ? session : null;
             } catch (e: any) {
@@ -1871,12 +1916,13 @@ export class ProviderCliAdapter implements CliAdapter {
         }
         try {
             const screenText = typeof screenTextOverride === 'string' ? screenTextOverride : this.terminalScreen.getText();
+            const parseBaseMessages = this.selectParseBaseMessages(baseMessages);
             const input = buildCliParseInput({
                 accumulatedBuffer: this.accumulatedBuffer,
                 accumulatedRawBuffer: this.accumulatedRawBuffer,
                 recentOutputBuffer: this.recentOutputBuffer,
                 terminalScreenText: screenText,
-                baseMessages,
+                baseMessages: parseBaseMessages,
                 partialResponse,
                 isWaitingForResponse: this.isWaitingForResponse,
                 scope,
@@ -1888,6 +1934,11 @@ export class ProviderCliAdapter implements CliAdapter {
             }
             const normalizedParsed = this.suppressStaleParsedApproval(parsed, input.recentBuffer, input.screenText);
             if (normalizedParsed && Array.isArray(normalizedParsed.messages)) {
+                normalizedParsed.messages = this.stitchParsedMessagesWithCommittedBase(
+                    normalizedParsed.messages,
+                    baseMessages,
+                    parseBaseMessages,
+                );
                 this.trimLastAssistantEcho(normalizedParsed.messages, scope?.prompt || getLastUserPromptText(baseMessages));
             }
             this.parseErrorMessage = null;

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/logging/logger.ts

@@ -175,19 +175,18 @@ export function daemonLog(category: string, msg: string, level: LogLevel = 'info
     const label = LEVEL_LABEL[level];
     const line = `[${ts()}] [${label}] [${category}] ${msg}`;
 
- // Always record to file (including DEBUG)
+ // Apply the active log level consistently to console, file, and the remote ring buffer.
+ // Debug hot paths are useful when explicitly enabled, but should not inflate normal-mode logs.
+    if (!shouldOutput) return;
+
     writeToFile(line);
 
- // Always save to ring buffer (for remote transmission)
     ringBuffer.push({ ts: Date.now(), level, category, message: msg });
     if (ringBuffer.length > RING_BUFFER_SIZE) {
         ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
     }
 
- // Apply filter to console output
-    if (shouldOutput) {
-        origConsoleLog(line);
-    }
+    origConsoleLog(line);
 }
 
 // ─── Convenience API ────────────────────────────────

package/src/providers/provider-loader.ts

@@ -199,6 +199,10 @@ export class ProviderLoader {
     this.logFn(`[ProviderLoader] ${msg}`);
   }
 
+  private debugLog(msg: string): void {
+    LOG.debug('Provider', `[ProviderLoader] ${msg}`);
+  }
+
  // ─── Public API ────────────────────────────────
 
   /**
@@ -649,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';
   }
@@ -788,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 {
@@ -892,7 +912,7 @@ export class ProviderLoader {
             const loaded = this.loadScriptsFromDir(type, entry.scriptDir);
             if (loaded) {
               resolved.scripts = loaded;
-              this.log(`  [compatibility] ${type} v${currentVersion} → ${entry.scriptDir}`);
+              this.debugLog(`  [compatibility] ${type} v${currentVersion} → ${entry.scriptDir}`);
               resolved._resolvedScriptDir = entry.scriptDir;
               resolved._resolvedScriptsSource = `compatibility:${entry.ideVersion}`;
               if (providerDir) {
@@ -912,7 +932,7 @@ export class ProviderLoader {
           const loaded = this.loadScriptsFromDir(type, base.defaultScriptDir);
           if (loaded) {
             resolved.scripts = loaded;
-            this.log(`  [compatibility] ${type} v${currentVersion} → default: ${base.defaultScriptDir}`);
+            this.debugLog(`  [compatibility] ${type} v${currentVersion} → default: ${base.defaultScriptDir}`);
             resolved._resolvedScriptDir = base.defaultScriptDir;
             resolved._resolvedScriptsSource = 'defaultScriptDir:version_miss';
             if (providerDir) {
@@ -955,7 +975,7 @@ export class ProviderLoader {
       const loaded = this.loadScriptsFromDir(type, base.defaultScriptDir);
       if (loaded) {
         resolved.scripts = loaded;
-        this.log(`  [compatibility] ${type} no version detected → default: ${base.defaultScriptDir}`);
+        this.debugLog(`  [compatibility] ${type} no version detected → default: ${base.defaultScriptDir}`);
         resolved._resolvedScriptDir = base.defaultScriptDir;
         resolved._resolvedScriptsSource = 'defaultScriptDir:no_version';
         if (providerDir) {

package/src/status/chat-tail-hot-sessions.ts

@@ -59,6 +59,7 @@ export function classifyHotChatSessionsForSubscriptionFlush(
     now?: number;
     recentMessageGraceMs?: number;
     activeStatuses?: ReadonlySet<string>;
+    activeSessionIds?: ReadonlySet<string>;
   } = {},
 ): { active: Set<string>; finalizing: Set<string> } {
   const now = options.now ?? Date.now();
@@ -69,6 +70,7 @@ export function classifyHotChatSessionsForSubscriptionFlush(
       : DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS,
   );
   const activeStatuses = options.activeStatuses ?? DEFAULT_ACTIVE_CHAT_POLL_STATUSES;
+  const activeSessionIds = options.activeSessionIds ?? new Set<string>();
   const active = new Set<string>();
   const excluded = new Set<string>();
 
@@ -79,6 +81,10 @@ export function classifyHotChatSessionsForSubscriptionFlush(
       excluded.add(sessionId);
       continue;
     }
+    if (activeSessionIds.has(sessionId)) {
+      active.add(sessionId);
+      continue;
+    }
 
     const status = String(session?.status || '').toLowerCase();
     const unread = session?.unread === true;