@adhdev/daemon-core 0.9.39 → 0.9.40

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

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.9.39",
+  "version": "0.9.40",
   "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.39",
+  "version": "0.9.40",
   "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-parse.ts

@@ -173,10 +173,12 @@ export function hydrateCliParsedMessages(
         });
 }
 
-function chooseMoreComparableCliMessage(left: CliChatMessage, right: CliChatMessage): CliChatMessage {
-    const leftComparable = normalizeComparableMessageContent(left.content || '');
-    const rightComparable = normalizeComparableMessageContent(right.content || '');
-
+function chooseMoreComparableCliMessage(
+    left: CliChatMessage,
+    right: CliChatMessage,
+    leftComparable = normalizeComparableMessageContent(left.content || ''),
+    rightComparable = normalizeComparableMessageContent(right.content || ''),
+): CliChatMessage {
     if (leftComparable && leftComparable === rightComparable) {
         const leftNewlines = String(left.content || '').split(/\r\n|\n|\r/g).length - 1;
         const rightNewlines = String(right.content || '').split(/\r\n|\n|\r/g).length - 1;
@@ -187,35 +189,43 @@ function chooseMoreComparableCliMessage(left: CliChatMessage, right: CliChatMess
 }
 
 function dedupeConsecutiveComparableCliMessages(messages: CliChatMessage[]): CliChatMessage[] {
-    const deduped: CliChatMessage[] = [];
+    const deduped: Array<{ message: CliChatMessage; comparable: string }> = [];
 
     for (const message of messages) {
         const current = {
             ...message,
             content: typeof message.content === 'string' ? message.content : String(message.content || ''),
         } as CliChatMessage;
+        const currentComparable = normalizeComparableMessageContent(current.content || '');
         const previous = deduped[deduped.length - 1];
         if (!previous) {
-            deduped.push(current);
+            deduped.push({ message: current, comparable: currentComparable });
             continue;
         }
 
-        const previousComparable = normalizeComparableMessageContent(previous.content || '');
-        const currentComparable = normalizeComparableMessageContent(current.content || '');
-        const sameRole = previous.role === current.role;
-        const sameKind = (previous.kind || 'standard') === (current.kind || 'standard');
-        const sameSender = (previous.senderName || '') === (current.senderName || '');
-        const comparableMatch = previousComparable && previousComparable === currentComparable;
+        const sameRole = previous.message.role === current.role;
+        const sameKind = (previous.message.kind || 'standard') === (current.kind || 'standard');
+        const sameSender = (previous.message.senderName || '') === (current.senderName || '');
+        const comparableMatch = previous.comparable && previous.comparable === currentComparable;
 
         if (sameRole && sameKind && sameSender && comparableMatch) {
-            deduped[deduped.length - 1] = chooseMoreComparableCliMessage(previous, current);
+            const selected = chooseMoreComparableCliMessage(
+                previous.message,
+                current,
+                previous.comparable,
+                currentComparable,
+            );
+            deduped[deduped.length - 1] = {
+                message: selected,
+                comparable: selected === current ? currentComparable : previous.comparable,
+            };
             continue;
         }
 
-        deduped.push(current);
+        deduped.push({ message: current, comparable: currentComparable });
     }
 
-    return deduped;
+    return deduped.map((entry) => entry.message);
 }
 
 export function normalizeCliParsedMessages(

package/src/commands/chat-commands.ts

@@ -178,85 +178,90 @@ function normalizeReadChatMessages(payload: Record<string, any>): ChatMessage[]
     return normalizeChatMessages(messages);
 }
 
-function buildReadChatReplayCollapseSignature(message: ChatMessage | null | undefined): string {
-    if (!message) return '';
-    const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
-    const kind = typeof message.kind === 'string' ? message.kind.trim().toLowerCase() : 'standard';
-    const senderName = typeof message.senderName === 'string' ? message.senderName.trim().toLowerCase() : '';
-    const content = flattenContent(message.content || '').replace(/\s+/g, ' ').trim();
-    return `${role}:${kind}:${senderName}:${content}`;
-}
-
-function shouldCollapseReadChatReplayDuplicate(message: ChatMessage | null | undefined): boolean {
-    if (!message) return false;
-    const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
-    return role === 'assistant' || role === 'system';
+interface ReadChatReplayCollapseInfo {
+    role: string;
+    kind: string;
+    senderName: string;
+    content: string;
+    signature: string;
+    collapsible: boolean;
 }
 
-function normalizeReadChatReplayText(message: ChatMessage | null | undefined): string {
-    return flattenContent(message?.content || '').replace(/\s+/g, ' ').trim();
+function normalizeReadChatReplayTextContent(content: ChatMessage['content'] | undefined): string {
+    return flattenContent(content || '').replace(/\s+/g, ' ').trim();
 }
 
-function isStableReadChatAssistantAnswer(message: ChatMessage | null | undefined): boolean {
-    if (!message) return false;
+function getReadChatReplayCollapseInfo(message: ChatMessage | null | undefined): ReadChatReplayCollapseInfo | null {
+    if (!message) return null;
     const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
     const kind = typeof message.kind === 'string' ? message.kind.trim().toLowerCase() : 'standard';
-    if (role !== 'assistant') return false;
-    if (kind && kind !== 'standard') return false;
-    const content = normalizeReadChatReplayText(message);
-    if (content.length < 160) return false;
+    const senderName = typeof message.senderName === 'string' ? message.senderName.trim().toLowerCase() : '';
+    const collapsible = role === 'assistant' || role === 'system';
+    if (!collapsible) return { role, kind, senderName, content: '', signature: '', collapsible };
+    const content = normalizeReadChatReplayTextContent(message.content);
+    return {
+        role,
+        kind,
+        senderName,
+        content,
+        signature: `${role}:${kind}:${senderName}:${content}`,
+        collapsible,
+    };
+}
+
+function isStableReadChatAssistantAnswerInfo(info: ReadChatReplayCollapseInfo | null): boolean {
+    if (!info) return false;
+    if (info.role !== 'assistant') return false;
+    if (info.kind && info.kind !== 'standard') return false;
+    if (info.content.length < 160) return false;
 
     // A provider may surface expanded command output as a standard assistant bubble
     // (for example Claude Code's "Bash command ..." block). That is live work output,
     // not a stable final answer. Treating it as a terminal answer would hide the
     // real final response and violate read_chat fidelity.
-    if (/^(bash|shell|terminal) command\b/i.test(content)) return false;
+    if (/^(bash|shell|terminal) command\b/i.test(info.content)) return false;
     return true;
 }
 
-function isReplayedAssistantAnswerAfterStableAnswer(
-    message: ChatMessage | null | undefined,
-    stableAnswer: ChatMessage | null,
+function isReplayedAssistantAnswerAfterStableAnswerInfo(
+    info: ReadChatReplayCollapseInfo | null,
+    stableContent: string,
 ): boolean {
-    if (!message || !stableAnswer) return false;
-    const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
-    const kind = typeof message.kind === 'string' ? message.kind.trim().toLowerCase() : 'standard';
-    if (role !== 'assistant') return false;
-    if (kind && kind !== 'standard') return false;
-    const content = normalizeReadChatReplayText(message);
-    const stableContent = normalizeReadChatReplayText(stableAnswer);
+    if (!info || !stableContent) return false;
+    if (info.role !== 'assistant') return false;
+    if (info.kind && info.kind !== 'standard') return false;
+    const content = info.content;
     if (content.length < 80 || stableContent.length < 80) return false;
     return content === stableContent || content.startsWith(stableContent) || stableContent.startsWith(content);
 }
 
-function collapseReplayDuplicatesFromReadChat(messages: ChatMessage[]): ChatMessage[] {
+export function collapseReplayDuplicatesFromReadChat(messages: ChatMessage[]): ChatMessage[] {
     const collapsed: ChatMessage[] = [];
     const replaySignaturesInCurrentTurn = new Set<string>();
-    let stableAssistantAnswerInCurrentTurn: ChatMessage | null = null;
+    let stableAssistantAnswerContentInCurrentTurn = '';
+    let previousReplaySignature = '';
 
     for (const message of messages) {
-        const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
-        if (role === 'user') {
+        const info = getReadChatReplayCollapseInfo(message);
+        if (info?.role === 'user') {
             replaySignaturesInCurrentTurn.clear();
-            stableAssistantAnswerInCurrentTurn = null;
+            stableAssistantAnswerContentInCurrentTurn = '';
+            previousReplaySignature = '';
         }
 
-        const signature = buildReadChatReplayCollapseSignature(message);
-        const previous = collapsed[collapsed.length - 1];
-        const previousSignature = buildReadChatReplayCollapseSignature(previous);
-
-        if (shouldCollapseReadChatReplayDuplicate(message) && signature) {
-            if (previousSignature === signature) continue;
-            if (replaySignaturesInCurrentTurn.has(signature)) continue;
-            if (isReplayedAssistantAnswerAfterStableAnswer(message, stableAssistantAnswerInCurrentTurn)) continue;
+        if (info?.collapsible && info.signature) {
+            if (previousReplaySignature === info.signature) continue;
+            if (replaySignaturesInCurrentTurn.has(info.signature)) continue;
+            if (isReplayedAssistantAnswerAfterStableAnswerInfo(info, stableAssistantAnswerContentInCurrentTurn)) continue;
         }
 
         collapsed.push(message);
-        if (shouldCollapseReadChatReplayDuplicate(message) && signature) {
-            replaySignaturesInCurrentTurn.add(signature);
+        previousReplaySignature = info?.collapsible ? info.signature : '';
+        if (info?.collapsible && info.signature) {
+            replaySignaturesInCurrentTurn.add(info.signature);
         }
-        if (isStableReadChatAssistantAnswer(message)) {
-            stableAssistantAnswerInCurrentTurn = message;
+        if (isStableReadChatAssistantAnswerInfo(info)) {
+            stableAssistantAnswerContentInCurrentTurn = info?.content || '';
         }
     }
 
@@ -369,13 +374,17 @@ function computeReadChatSync(messages: ChatMessage[], cursor: Required<ReadChatC
     }
 
     if (cursor.tailLimit > 0 && knownSignature === lastMessageSignature) {
-        return {
-            syncMode: 'noop',
-            replaceFrom: totalMessages,
-            messages: [],
-            totalMessages,
-            lastMessageSignature,
-        };
+        const requestedTailCount = Math.min(totalMessages, cursor.tailLimit);
+        if (knownMessageCount >= requestedTailCount) {
+            return {
+                syncMode: 'noop',
+                replaceFrom: totalMessages,
+                messages: [],
+                totalMessages,
+                lastMessageSignature,
+            };
+        }
+        return buildBoundedTailSync(messages, cursor);
     }
 
     if (knownMessageCount < totalMessages) {