@adhdev/daemon-core 0.9.6 → 0.9.7

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

@@ -94,6 +94,51 @@ export function hydrateCliParsedMessages(
         });
 }
 
+function chooseMoreComparableCliMessage(left: CliChatMessage, right: CliChatMessage): CliChatMessage {
+    const leftComparable = normalizeComparableMessageContent(left.content || '');
+    const rightComparable = normalizeComparableMessageContent(right.content || '');
+
+    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;
+        return rightNewlines < leftNewlines ? right : left;
+    }
+
+    return rightComparable.length > leftComparable.length ? right : left;
+}
+
+function dedupeConsecutiveComparableCliMessages(messages: CliChatMessage[]): CliChatMessage[] {
+    const deduped: CliChatMessage[] = [];
+
+    for (const message of messages) {
+        const current = {
+            ...message,
+            content: typeof message.content === 'string' ? message.content : String(message.content || ''),
+        } as CliChatMessage;
+        const previous = deduped[deduped.length - 1];
+        if (!previous) {
+            deduped.push(current);
+            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;
+
+        if (sameRole && sameKind && sameSender && comparableMatch) {
+            deduped[deduped.length - 1] = chooseMoreComparableCliMessage(previous, current);
+            continue;
+        }
+
+        deduped.push(current);
+    }
+
+    return deduped;
+}
+
 export function normalizeCliParsedMessages(
     parsedMessages: any[],
     options: {
@@ -103,7 +148,7 @@ export function normalizeCliParsedMessages(
         now?: number;
     },
 ): CliChatMessage[] {
-    return hydrateCliParsedMessages(parsedMessages, options).map((message) => ({
+    return dedupeConsecutiveComparableCliMessages(hydrateCliParsedMessages(parsedMessages, options).map((message) => ({
         role: message.role,
         content: message.content,
         timestamp: message.timestamp,
@@ -113,7 +158,7 @@ export function normalizeCliParsedMessages(
         index: message.index,
         meta: message.meta,
         senderName: message.senderName,
-    }));
+    })));
 }
 
 export function buildCliParseInput(options: {

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

@@ -373,8 +373,58 @@ export function normalizeScreenSnapshot(text: string): string {
         .trim();
 }
 
+const COMMON_COMPARABLE_WRAP_WORDS = new Set([
+    'a', 'an', 'and', 'as', 'at', 'but', 'by', 'for', 'from', 'in', 'into', 'is', 'it', 'of', 'on', 'or', 'that', 'the', 'their', 'then', 'this', 'to', 'was', 'with',
+]);
+
+function shouldReflowComparableMessageLines(lines: string[]): boolean {
+    return Array.isArray(lines)
+        && lines.length > 1
+        && lines.slice(0, -1).every((line) => String(line || '').trim().length >= 48)
+        && !lines.some((line) => /^```/.test(line))
+        && !lines.some((line) => /^\|/.test(line))
+        && !lines.some((line) => /^\s*(?:[-*+] |\d+\.\s)/.test(line));
+}
+
+function joinComparableMessageLines(lines: string[]): string {
+    return lines.reduce((acc, line) => {
+        const next = String(line || '').trim();
+        if (!next) return acc;
+        if (!acc) return next;
+
+        if (/[,\d]$/.test(acc) && /^\d/.test(next)) {
+            return `${acc}${next}`;
+        }
+
+        if (/[A-Za-z]$/.test(acc) && /^\d/.test(next)) {
+            return `${acc}${next}`;
+        }
+
+        const fragmentMatch = acc.match(/([A-Za-z]{1,4})$/);
+        const fragment = fragmentMatch ? fragmentMatch[1].toLowerCase() : '';
+        if (/^[a-z]/.test(next) && fragment && !COMMON_COMPARABLE_WRAP_WORDS.has(fragment)) {
+            return `${acc}${next}`;
+        }
+
+        return `${acc} ${next}`;
+    }, '')
+        .replace(/\s+([,.;:!?])/g, '$1')
+        .replace(/(\d)\s+,/g, '$1,')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
 export function normalizeComparableMessageContent(text: string): string {
-    return String(text || '')
+    const lines = String(text || '')
+        .split(/\r\n|\n|\r/g)
+        .map((line) => line.trim())
+        .filter(Boolean);
+
+    if (lines.length === 0) return '';
+    if (shouldReflowComparableMessageLines(lines)) {
+        return joinComparableMessageLines(lines);
+    }
+    return lines.join(' ')
         .replace(/\s+/g, ' ')
         .trim();
 }
@@ -414,10 +464,6 @@ export function getLastUserPromptText(messages: Array<{ role?: string; content?:
     return '';
 }
 
-export function looksLikeConfirmOnlyLabel(label: string): boolean {
-    return /^(?:continue|confirm|ok|yes|trust|proceed|enter)$/i.test(String(label || '').trim());
-}
-
 function parsePatternEntry(x: unknown): RegExp | null {
     if (x instanceof RegExp) return x;
     if (x && typeof x === 'object' && typeof (x as { source?: string }).source === 'string') {

package/src/commands/chat-commands.ts

@@ -1255,26 +1255,24 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
             ? 'waiting_approval'
             : status?.status;
         LOG.info('Command', `[resolveAction] CLI PTY gate target=${String(args?.targetSessionId || '')} rawStatus=${String(status?.status || '')} effectiveStatus=${String(effectiveStatus || '')} statusModal=${statusModal ? 'yes' : 'no'} surfacedModal=${surfacedModal ? 'yes' : 'no'} instance=${targetInstance ? 'yes' : 'no'}`);
-        if (effectiveStatus !== 'waiting_approval' && !effectiveModal) {
+        if (!effectiveModal) {
             return { success: false, error: 'Not in approval state' };
         }
-        const buttons: string[] = effectiveModal?.buttons || ['Allow once', 'Always allow', 'Deny'];
-        // Resolve button index: explicit buttonIndex arg → button text match → action fallback
+        const buttons: string[] = Array.isArray(effectiveModal.buttons) ? effectiveModal.buttons : [];
+        // Resolve button index: explicit buttonIndex arg → exact text match → explicit action mapping
         let buttonIndex = typeof args?.buttonIndex === 'number' ? args.buttonIndex : -1;
-        if (buttonIndex < 0) {
+        if (buttonIndex < 0 && button) {
             const btnLower = button.toLowerCase();
             buttonIndex = buttons.findIndex(b => b.toLowerCase().includes(btnLower));
         }
+        if (buttonIndex < 0 && (action === 'reject' || action === 'deny')) {
+            buttonIndex = buttons.findIndex(b => /deny|reject|no/i.test(b));
+        }
+        if (buttonIndex < 0 && (action === 'always' || /always/i.test(button))) {
+            buttonIndex = buttons.findIndex(b => /always/i.test(b));
+        }
         if (buttonIndex < 0) {
-            if (action === 'reject' || action === 'deny') {
-                buttonIndex = buttons.findIndex(b => /deny|reject|no/i.test(b));
-                if (buttonIndex < 0) buttonIndex = buttons.length - 1;
-            } else if (action === 'always' || /always/i.test(button)) {
-                buttonIndex = buttons.findIndex(b => /always/i.test(b));
-                if (buttonIndex < 0) buttonIndex = 1;
-            } else {
-                buttonIndex = 0; // approve → first option (default selected)
-            }
+            return { success: false, error: 'Approval action did not match any visible button' };
         }
         if (typeof adapter.resolveModal === 'function') {
             adapter.resolveModal(buttonIndex);