@adhdev/daemon-core 0.9.36 → 0.9.38

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

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.9.36",
+  "version": "0.9.38",
   "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.36",
+  "version": "0.9.38",
   "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

@@ -1675,11 +1675,12 @@ export class ProviderCliAdapter implements CliAdapter {
 
  // ─── Public API (CliAdapter) ───────────────────
 
-    getStatus(): CliSessionStatus {
-        const startupModal = this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
+    getStatus(options: { allowParse?: boolean } = {}): CliSessionStatus {
+        const allowParse = options.allowParse !== false;
+        const startupModal = allowParse && this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
         let effectiveStatus = this.projectEffectiveStatus(startupModal);
         let effectiveModal = startupModal || this.activeModal;
-        if (!startupModal && !effectiveModal && typeof this.cliScripts?.parseOutput === 'function') {
+        if (allowParse && !startupModal && !effectiveModal && typeof this.cliScripts?.parseOutput === 'function') {
             let parsed = this.getFreshParsedStatusCache();
             if (!parsed && effectiveStatus !== 'idle') {
                 const now = Date.now();

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

@@ -31,37 +31,115 @@ export function hydrateCliParsedMessages(
 ): any[] {
     const { committedMessages, scope, lastOutputAt } = options;
     const referenceMessages = [...committedMessages];
-    const referenceComparables = referenceMessages.map((message) => normalizeComparableMessageContent(message?.content || ''));
+    const referenceComparables: Array<string | undefined> = new Array(referenceMessages.length);
     const usedReferenceIndexes = new Set<number>();
     const now = options.now ?? Date.now();
+    let exactReferenceIndexesByKey: Map<string, number[]> | null = null;
+    const exactReferenceCursorByKey = new Map<string, number>();
+
+    const hasFiniteTimestamp = (message: any): message is { timestamp: number } => (
+        typeof message?.timestamp === 'number' && Number.isFinite(message.timestamp)
+    );
+
+    const getReferenceComparable = (index: number): string => {
+        if (typeof referenceComparables[index] === 'string') return referenceComparables[index] || '';
+        const comparable = normalizeComparableMessageContent(referenceMessages[index]?.content || '');
+        referenceComparables[index] = comparable;
+        return comparable;
+    };
+
+    const messagesShareStableIdentity = (parsed: any, reference: any): boolean => {
+        if (!parsed || !reference) return false;
+        const parsedId = typeof parsed.id === 'string' ? parsed.id.trim() : '';
+        const referenceId = typeof reference.id === 'string' ? reference.id.trim() : '';
+        if (parsedId && referenceId && parsedId === referenceId) return true;
+        return typeof parsed.index === 'number'
+            && Number.isFinite(parsed.index)
+            && typeof reference.index === 'number'
+            && Number.isFinite(reference.index)
+            && parsed.index === reference.index;
+    };
+
+    const exactReferenceKey = (role: 'user' | 'assistant', comparable: string): string => `${role}\u0000${comparable}`;
+
+    const ensureExactReferenceIndex = (): Map<string, number[]> => {
+        if (exactReferenceIndexesByKey) return exactReferenceIndexesByKey;
+        const byKey = new Map<string, number[]>();
+        for (let i = 0; i < referenceMessages.length; i++) {
+            const candidate = referenceMessages[i];
+            if (!candidate || (candidate.role !== 'user' && candidate.role !== 'assistant') || !hasFiniteTimestamp(candidate)) continue;
+            const comparable = getReferenceComparable(i);
+            if (!comparable) continue;
+            const key = exactReferenceKey(candidate.role, comparable);
+            const indexes = byKey.get(key);
+            if (indexes) {
+                indexes.push(i);
+            } else {
+                byKey.set(key, [i]);
+            }
+        }
+        exactReferenceIndexesByKey = byKey;
+        return byKey;
+    };
+
+    const takeExactReferenceTimestamp = (role: 'user' | 'assistant', normalizedContent: string): number | undefined => {
+        const key = exactReferenceKey(role, normalizedContent);
+        const indexes = ensureExactReferenceIndex().get(key);
+        if (!indexes) return undefined;
+        let cursor = exactReferenceCursorByKey.get(key) || 0;
+        while (cursor < indexes.length) {
+            const candidateIndex = indexes[cursor];
+            cursor += 1;
+            if (usedReferenceIndexes.has(candidateIndex)) continue;
+            const candidate = referenceMessages[candidateIndex];
+            if (!candidate || candidate.role !== role || !hasFiniteTimestamp(candidate)) continue;
+            usedReferenceIndexes.add(candidateIndex);
+            exactReferenceCursorByKey.set(key, cursor);
+            return candidate.timestamp;
+        }
+        exactReferenceCursorByKey.set(key, cursor);
+        return undefined;
+    };
+
+    const findReferenceTimestamp = (message: any, role: 'user' | 'assistant', content: string, parsedIndex: number): number | undefined => {
+        const sameIndex = referenceMessages[parsedIndex];
+        if (
+            sameIndex
+            && !usedReferenceIndexes.has(parsedIndex)
+            && sameIndex.role === role
+            && hasFiniteTimestamp(sameIndex)
+            && messagesShareStableIdentity(message, sameIndex)
+        ) {
+            usedReferenceIndexes.add(parsedIndex);
+            return sameIndex.timestamp;
+        }
 
-    const findReferenceTimestamp = (role: 'user' | 'assistant', content: string, parsedIndex: number): number | undefined => {
         const normalizedContent = normalizeComparableMessageContent(content);
         if (!normalizedContent) return undefined;
 
-        const sameIndex = referenceMessages[parsedIndex];
         if (
             sameIndex
             && !usedReferenceIndexes.has(parsedIndex)
             && sameIndex.role === role
-            && referenceComparables[parsedIndex] === normalizedContent
-            && typeof sameIndex.timestamp === 'number'
-            && Number.isFinite(sameIndex.timestamp)
+            && getReferenceComparable(parsedIndex) === normalizedContent
+            && hasFiniteTimestamp(sameIndex)
         ) {
             usedReferenceIndexes.add(parsedIndex);
             return sameIndex.timestamp;
         }
 
+        const exactTimestamp = takeExactReferenceTimestamp(role, normalizedContent);
+        if (typeof exactTimestamp === 'number') return exactTimestamp;
+
         for (let i = 0; i < referenceMessages.length; i++) {
             if (usedReferenceIndexes.has(i)) continue;
             const candidate = referenceMessages[i];
             if (!candidate || candidate.role !== role) continue;
-            const candidateContent = referenceComparables[i];
+            const candidateContent = getReferenceComparable(i);
             if (!candidateContent) continue;
-            const exactMatch = candidateContent === normalizedContent;
             const fuzzyMatch = candidateContent.includes(normalizedContent) || normalizedContent.includes(candidateContent);
-            if (!exactMatch && !fuzzyMatch) continue;
-            if (typeof candidate.timestamp === 'number' && Number.isFinite(candidate.timestamp)) {
+            if (!fuzzyMatch) continue;
+            if (hasFiniteTimestamp(candidate)) {
                 usedReferenceIndexes.add(i);
                 return candidate.timestamp;
             }
@@ -78,7 +156,7 @@ export function hydrateCliParsedMessages(
             const parsedTimestamp = typeof message.timestamp === 'number' && Number.isFinite(message.timestamp)
                 ? message.timestamp
                 : undefined;
-            const referenceTimestamp = parsedTimestamp ?? findReferenceTimestamp(role, content, index);
+            const referenceTimestamp = parsedTimestamp ?? findReferenceTimestamp(message, role, content, index);
             const fallbackTimestamp = role === 'user'
                 ? (scope?.startedAt || now)
                 : (lastOutputAt || scope?.startedAt || now);

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

@@ -48,6 +48,13 @@ function buildPersistableCliHistorySignature(message: PersistableCliHistoryMessa
     ].join('|');
 }
 
+function hasSamePersistableCliHistoryIdentity(a: PersistableCliHistoryMessage, b: PersistableCliHistoryMessage): boolean {
+    return String(a?.role || '') === String(b?.role || '')
+        && String(a?.kind || '') === String(b?.kind || '')
+        && String(a?.senderName || '') === String(b?.senderName || '')
+        && String(a?.content || '') === String(b?.content || '');
+}
+
 export function buildIncrementalHistoryAppendMessages(
     previousMessages: PersistableCliHistoryMessage[],
     currentMessages: PersistableCliHistoryMessage[],
@@ -55,20 +62,32 @@ export function buildIncrementalHistoryAppendMessages(
     if (!Array.isArray(currentMessages) || currentMessages.length === 0) return [];
     if (!Array.isArray(previousMessages) || previousMessages.length === 0) return currentMessages;
 
-    const previousSignatures = previousMessages.map(buildPersistableCliHistorySignature);
-    const currentSignatures = currentMessages.map(buildPersistableCliHistorySignature);
-
+    const comparableLength = Math.min(previousMessages.length, currentMessages.length);
     let sharedPrefixLength = 0;
     while (
-        sharedPrefixLength < previousSignatures.length
-        && sharedPrefixLength < currentSignatures.length
-        && previousSignatures[sharedPrefixLength] === currentSignatures[sharedPrefixLength]
+        sharedPrefixLength < comparableLength
+        && hasSamePersistableCliHistoryIdentity(previousMessages[sharedPrefixLength], currentMessages[sharedPrefixLength])
+    ) {
+        sharedPrefixLength += 1;
+    }
+
+    if (sharedPrefixLength === currentMessages.length) return [];
+    if (sharedPrefixLength === previousMessages.length) return currentMessages.slice(sharedPrefixLength);
+
+    // Rare fallback: preserve the older whitespace-normalized behavior only when
+    // the cheap identity check detects a changed prefix. Recomputing normalized
+    // signatures for the full transcript on every idle status poll was a CPU
+    // hot path for long CLI sessions.
+    while (
+        sharedPrefixLength < comparableLength
+        && buildPersistableCliHistorySignature(previousMessages[sharedPrefixLength])
+            === buildPersistableCliHistorySignature(currentMessages[sharedPrefixLength])
     ) {
         sharedPrefixLength += 1;
     }
 
-    if (sharedPrefixLength === currentSignatures.length) return [];
-    if (sharedPrefixLength === previousSignatures.length) return currentMessages.slice(sharedPrefixLength);
+    if (sharedPrefixLength === currentMessages.length) return [];
+    if (sharedPrefixLength === previousMessages.length) return currentMessages.slice(sharedPrefixLength);
     return currentMessages;
 }
 
@@ -418,13 +437,15 @@ export class CliProviderInstance implements ProviderInstance {
             }));
             if (!canonicalBackedHistory && !shouldSkipReplayPersist && normalizedMessagesToSave.length > 0) {
                 const incrementalMessages = buildIncrementalHistoryAppendMessages(this.lastPersistedHistoryMessages, normalizedMessagesToSave);
-                this.historyWriter.appendNewMessages(
-                    this.type,
-                    incrementalMessages,
-                    parsedStatus?.title || dirName,
-                    this.instanceId,
-                    this.providerSessionId,
-                );
+                if (incrementalMessages.length > 0) {
+                    this.historyWriter.appendNewMessages(
+                        this.type,
+                        incrementalMessages,
+                        parsedStatus?.title || dirName,
+                        this.instanceId,
+                        this.providerSessionId,
+                    );
+                }
             }
             if (!canonicalBackedHistory) {
                 this.lastPersistedHistoryMessages = normalizedMessagesToSave;
@@ -494,7 +515,7 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     getHotChatSessionState(): HotChatSessionState {
-        const adapterStatus = this.adapter.getStatus();
+        const adapterStatus = this.adapter.getStatus({ allowParse: false });
         const autoApproveActive = adapterStatus.status === 'waiting_approval' && this.shouldAutoApprove();
         const visibleStatus = autoApproveActive ? 'generating' : adapterStatus.status;
         const runtime = this.adapter.getRuntimeMetadata();