@adhdev/daemon-core 0.9.5 → 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);

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

@@ -161,6 +161,16 @@ export class CliProviderInstance implements ProviderInstance {
     private runtimeMessages: Array<{ key: string; message: ChatMessage }> = [];
     private lastPersistedHistoryMessages: PersistableCliHistoryMessage[] = [];
     private lastCanonicalHermesSyncMtimeMs = 0;
+    private lastCanonicalHermesExistCheckAt = 0;
+    private lastCanonicalHermesWatchPath: string | undefined = undefined;
+    private lastCanonicalClaudeRebuildMtimeMs = 0;
+    private lastCanonicalClaudeCheckAt = 0;
+    private cachedSqliteDb: {
+        prepare(sql: string): { get(...values: Array<string | number>): unknown };
+        close(): void;
+    } | null = null;
+    private cachedSqliteDbPath: string | null = null;
+    private cachedSqliteDbMissingUntil = 0;
     readonly instanceId: string;
     private suppressIdleHistoryReplay = false;
     private errorMessage: string | undefined = undefined;
@@ -281,7 +291,13 @@ export class CliProviderInstance implements ProviderInstance {
         timestampFormat?: 'unix_ms' | 'unix_s' | 'iso';
     }): string | null {
         const resolvedDbPath = probe.dbPath.replace(/^~/, os.homedir());
-        if (!fs.existsSync(resolvedDbPath)) return null;
+        // Skip existsSync if we already confirmed DB is missing (cache for 10s)
+        const now = Date.now();
+        if (this.cachedSqliteDbMissingUntil > now) return null;
+        if (!fs.existsSync(resolvedDbPath)) {
+            this.cachedSqliteDbMissingUntil = now + 10_000;
+            return null;
+        }
 
         const directories = this.getProbeDirectories();
         const minCreatedAt = Math.max(0, this.startedAt - 60_000);
@@ -486,6 +502,9 @@ export class CliProviderInstance implements ProviderInstance {
         this.adapter.shutdown();
         this.monitor.reset();
         this.appliedEffectKeys.clear();
+        try { this.cachedSqliteDb?.close(); } catch { /* noop */ }
+        this.cachedSqliteDb = null;
+        this.cachedSqliteDbPath = null;
     }
 
     private completedDebounceTimer: NodeJS.Timeout | null = null;
@@ -944,13 +963,38 @@ export class CliProviderInstance implements ProviderInstance {
                 const watchPath = canonicalHistory.watchPath
                     .replace(/^~/, os.homedir())
                     .replace('{{sessionId}}', this.providerSessionId);
-                if (!fs.existsSync(watchPath)) return false;
+                // Throttle existsSync: check file existence at most once per 2s
+                const now = Date.now();
+                if (watchPath !== this.lastCanonicalHermesWatchPath || now - this.lastCanonicalHermesExistCheckAt >= 2_000) {
+                    this.lastCanonicalHermesWatchPath = watchPath;
+                    this.lastCanonicalHermesExistCheckAt = now;
+                    if (!fs.existsSync(watchPath)) return false;
+                } else if (this.lastCanonicalHermesSyncMtimeMs === 0) {
+                    // First check: file existence not yet confirmed, must verify
+                    if (!fs.existsSync(watchPath)) return false;
+                }
                 const stat = fs.statSync(watchPath);
                 if (stat.mtimeMs <= this.lastCanonicalHermesSyncMtimeMs) return true;
                 rebuilt = rebuildHermesSavedHistoryFromCanonicalSession(this.providerSessionId);
                 if (rebuilt) this.lastCanonicalHermesSyncMtimeMs = stat.mtimeMs;
             } else if (canonicalHistory.format === 'claude-jsonl') {
+                // Throttle: only check for changes at most once per 2s
+                const now = Date.now();
+                if (now - this.lastCanonicalClaudeCheckAt < 2_000 && this.lastCanonicalClaudeRebuildMtimeMs !== 0) {
+                    return true;
+                }
+                this.lastCanonicalClaudeCheckAt = now;
+                // Only rebuild if the transcript file has changed since last rebuild
+                const claudeProjectsDir = path.join(os.homedir(), '.claude', 'projects');
+                const workspaceSegment = typeof this.workingDir === 'string'
+                    ? this.workingDir.replace(/[\\/]/g, '-').replace(/^-+/, '')
+                    : '';
+                const transcriptFile = path.join(claudeProjectsDir, workspaceSegment, `${this.providerSessionId}.jsonl`);
+                let transcriptMtime = 0;
+                try { transcriptMtime = fs.statSync(transcriptFile).mtimeMs; } catch { /* not found yet */ }
+                if (transcriptMtime > 0 && transcriptMtime <= this.lastCanonicalClaudeRebuildMtimeMs) return true;
                 rebuilt = rebuildClaudeSavedHistoryFromNativeProject(this.providerSessionId, this.workingDir);
+                if (rebuilt) this.lastCanonicalClaudeRebuildMtimeMs = transcriptMtime || Date.now();
             }
             if (!rebuilt) return false;
             const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
@@ -1023,24 +1067,24 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     private querySqliteText(dbPath: string, query: string, params: Array<string | number>): string | null {
-        let db: {
-            prepare(sql: string): { get(...values: Array<string | number>): unknown };
-            close(): void;
-        } | null = null;
         try {
-            const DatabaseSync = getDatabaseSync();
-            db = new DatabaseSync(dbPath, { readOnly: true });
-            const row = db.prepare(query).get(...params) as { id?: unknown } | undefined;
+            if (this.cachedSqliteDb === null || this.cachedSqliteDbPath !== dbPath) {
+                try { this.cachedSqliteDb?.close(); } catch { /* noop */ }
+                this.cachedSqliteDb = null;
+                this.cachedSqliteDbPath = null;
+                const DatabaseSync = getDatabaseSync();
+                this.cachedSqliteDb = new DatabaseSync(dbPath, { readOnly: true });
+                this.cachedSqliteDbPath = dbPath;
+            }
+            const row = this.cachedSqliteDb!.prepare(query).get(...params) as { id?: unknown } | undefined;
             const sessionId = typeof row?.id === 'string' ? row.id.trim() : '';
             return sessionId || null;
         } catch {
+            // Close cached connection on error so we retry fresh next tick
+            try { this.cachedSqliteDb?.close(); } catch { /* noop */ }
+            this.cachedSqliteDb = null;
+            this.cachedSqliteDbPath = null;
             return null;
-        } finally {
-            try {
-                db?.close();
-            } catch {
-                // noop
-            }
         }
     }
 }

package/src/providers/provider-schema.ts

@@ -37,6 +37,7 @@ const KNOWN_PROVIDER_FIELDS = new Set<string>([
   'canonicalHistory',
   'autoFixProfile',
   'ideLevelScripts',
+  'allowInputDuringGeneration',
   'scripts',
   'vscodeCommands',
   'inputMethod',