@adhdev/daemon-core 0.8.28 → 0.8.30

package/src/config/chat-history.ts

@@ -29,6 +29,93 @@ interface HistoryMessage {
     sessionTitle?: string;
 }
 
+const CODEX_STARTER_PROMPT_RE = /^(?:[›❯]\s*)?(?:Find and fix a bug in @filename|Improve documentation in @filename|Write tests for @filename|Explain this codebase|Summarize recent commits|Implement \{feature\}|Use \/skills(?: to list available skills)?|Run \/review on my current changes)$/i;
+
+function normalizeHistoryComparable(text: string): string {
+    return String(text || '').replace(/\s+/g, ' ').trim();
+}
+
+function cleanupHistoryContent(agentType: string, role: HistoryMessage['role'], content: string): string {
+    let value = String(content || '').replace(/\r\n/g, '\n').trim();
+    if (!value) return '';
+
+    if (agentType === 'codex-cli' && role === 'assistant') {
+        const filtered = value
+            .split('\n')
+            .filter((line) => !CODEX_STARTER_PROMPT_RE.test(line.trim()))
+            .join('\n')
+            .replace(/\n{3,}/g, '\n\n')
+            .trim();
+        value = filtered;
+    }
+
+    return value;
+}
+
+function buildHistoryMessageHash(
+    agentType: string,
+    message: Pick<HistoryMessage, 'role' | 'content' | 'receivedAt' | 'kind'> & { historyDedupKey?: string },
+): string {
+    if (message.historyDedupKey) return message.historyDedupKey;
+    const cleaned = cleanupHistoryContent(agentType, message.role, message.content);
+    return `${message.kind || 'standard'}:${message.role}:${message.receivedAt || 0}:${normalizeHistoryComparable(cleaned)}`;
+}
+
+function buildHistoryMessageSignature(
+    agentType: string,
+    message: Pick<HistoryMessage, 'role' | 'content' | 'kind'>,
+): string {
+    const cleaned = cleanupHistoryContent(agentType, message.role, message.content);
+    return `${message.kind || 'standard'}:${message.role}:${normalizeHistoryComparable(cleaned)}`;
+}
+
+function isAdjacentHistoryDuplicate(
+    agentType: string,
+    previous: Pick<HistoryMessage, 'role' | 'content' | 'kind'> | null | undefined,
+    next: Pick<HistoryMessage, 'role' | 'content' | 'kind'> | null | undefined,
+): boolean {
+    if (!previous || !next) return false;
+    return buildHistoryMessageSignature(agentType, previous) === buildHistoryMessageSignature(agentType, next);
+}
+
+function collapseReplayAssistantTurns(agentType: string, messages: HistoryMessage[]): HistoryMessage[] {
+    if (agentType !== 'codex-cli') return messages;
+
+    const collapsed: HistoryMessage[] = [];
+    let sawAssistantSinceLastUser = false;
+
+    for (const message of messages) {
+        if (message.role === 'user') {
+            sawAssistantSinceLastUser = false;
+            collapsed.push(message);
+            continue;
+        }
+
+        if (message.role === 'assistant') {
+            if (sawAssistantSinceLastUser) continue;
+            sawAssistantSinceLastUser = true;
+            collapsed.push(message);
+            continue;
+        }
+
+        collapsed.push(message);
+    }
+
+    return collapsed;
+}
+
+function sanitizeHistoryMessage(agentType: string, message: HistoryMessage): HistoryMessage | null {
+    if (!message || (message.role !== 'user' && message.role !== 'assistant' && message.role !== 'system')) {
+        return null;
+    }
+    const content = cleanupHistoryContent(agentType, message.role, message.content);
+    if (!content) return null;
+    return {
+        ...message,
+        content,
+    };
+}
+
 export interface SavedHistorySessionSummary {
     historySessionId: string;
     sessionTitle?: string;
@@ -43,6 +130,10 @@ export class ChatHistoryWriter {
     private lastSeenCounts = new Map<string, number>();
 /** Last seen message hash per agent (deduplication) */
     private lastSeenHashes = new Map<string, Set<string>>();
+/** Last appended normalized message signature per agent/session */
+    private lastSeenSignatures = new Map<string, string>();
+/** Last appended normalized non-system turn signature per agent/session */
+    private lastSeenTurnSignatures = new Map<string, string>();
     private rotated = false;
 
  /**
@@ -75,14 +166,36 @@ export class ChatHistoryWriter {
  // Filter new messages
             const newMessages: HistoryMessage[] = [];
             for (const msg of messages) {
-                const hash = msg.historyDedupKey || `${msg.kind || 'standard'}:${msg.role}:${(msg.content || '').slice(0, 50)}`;
+                const role = msg.role as 'user' | 'assistant' | 'system';
+                if (role !== 'user' && role !== 'assistant' && role !== 'system') continue;
+                const content = cleanupHistoryContent(agentType, role, msg.content || '');
+                if (!content) continue;
+                const receivedAt = msg.receivedAt || Date.now();
+                const hash = buildHistoryMessageHash(agentType, {
+                    role,
+                    content,
+                    receivedAt,
+                    kind: typeof msg.kind === 'string' ? msg.kind : undefined,
+                    historyDedupKey: msg.historyDedupKey,
+                });
+                const signature = buildHistoryMessageSignature(agentType, {
+                    role,
+                    content,
+                    kind: typeof msg.kind === 'string' ? msg.kind : undefined,
+                });
                 if (seenHashes.has(hash)) continue;
+                if (this.lastSeenSignatures.get(dedupKey) === signature) continue;
+                if (role !== 'system' && this.lastSeenTurnSignatures.get(dedupKey) === signature) continue;
                 seenHashes.add(hash);
+                this.lastSeenSignatures.set(dedupKey, signature);
+                if (role !== 'system') {
+                    this.lastSeenTurnSignatures.set(dedupKey, signature);
+                }
                 newMessages.push({
-                    ts: new Date(msg.receivedAt || Date.now()).toISOString(),
-                    receivedAt: msg.receivedAt || Date.now(),
-                    role: msg.role as 'user' | 'assistant' | 'system',
-                    content: msg.content || '',
+                    ts: new Date(receivedAt).toISOString(),
+                    receivedAt,
+                    role,
+                    content,
                     kind: typeof msg.kind === 'string' ? msg.kind : undefined,
                     senderName: typeof msg.senderName === 'string' ? msg.senderName : undefined,
                     agent: agentType,
@@ -108,6 +221,8 @@ export class ChatHistoryWriter {
             const prevCount = this.lastSeenCounts.get(dedupKey) || 0;
             if (messages.length < prevCount * 0.5 && prevCount > 3) {
                 seenHashes.clear();
+                this.lastSeenSignatures.delete(dedupKey);
+                this.lastSeenTurnSignatures.delete(dedupKey);
                 for (const msg of messages) {
                     seenHashes.add(msg.historyDedupKey || `${msg.kind || 'standard'}:${msg.role}:${(msg.content || '').slice(0, 50)}`);
                 }
@@ -124,6 +239,62 @@ export class ChatHistoryWriter {
         }
     }
 
+    seedSessionHistory(
+        agentType: string,
+        messages: Array<{ role: string; content: string; receivedAt?: number; kind?: string; historyDedupKey?: string }> = [],
+        historySessionId?: string,
+        instanceId?: string,
+    ): void {
+        const effectiveHistoryKey = historySessionId || instanceId;
+        const dedupKey = effectiveHistoryKey ? `${agentType}:${effectiveHistoryKey}` : agentType;
+        const seenHashes = new Set<string>();
+
+        for (const raw of messages) {
+            const role = raw?.role as 'user' | 'assistant' | 'system';
+            if (role !== 'user' && role !== 'assistant' && role !== 'system') continue;
+            const content = cleanupHistoryContent(agentType, role, raw?.content || '');
+            if (!content) continue;
+            seenHashes.add(buildHistoryMessageHash(agentType, {
+                role,
+                content,
+                receivedAt: raw?.receivedAt || 0,
+                kind: typeof raw?.kind === 'string' ? raw.kind : undefined,
+                historyDedupKey: raw?.historyDedupKey,
+            }));
+        }
+
+        this.lastSeenHashes.set(dedupKey, seenHashes);
+        this.lastSeenCounts.set(dedupKey, messages.length);
+        const lastMessage = [...messages].reverse().find((raw) => {
+            const role = raw?.role as 'user' | 'assistant' | 'system';
+            if (role !== 'user' && role !== 'assistant' && role !== 'system') return false;
+            return !!cleanupHistoryContent(agentType, role, raw?.content || '');
+        });
+        const lastTurnMessage = [...messages].reverse().find((raw) => {
+            const role = raw?.role as 'user' | 'assistant';
+            if (role !== 'user' && role !== 'assistant') return false;
+            return !!cleanupHistoryContent(agentType, role, raw?.content || '');
+        });
+        if (lastMessage) {
+            this.lastSeenSignatures.set(dedupKey, buildHistoryMessageSignature(agentType, {
+                role: lastMessage.role as HistoryMessage['role'],
+                content: lastMessage.content,
+                kind: typeof lastMessage.kind === 'string' ? lastMessage.kind : undefined,
+            }));
+        } else {
+            this.lastSeenSignatures.delete(dedupKey);
+        }
+        if (lastTurnMessage) {
+            this.lastSeenTurnSignatures.set(dedupKey, buildHistoryMessageSignature(agentType, {
+                role: lastTurnMessage.role as 'user' | 'assistant',
+                content: lastTurnMessage.content,
+                kind: typeof lastTurnMessage.kind === 'string' ? lastTurnMessage.kind : undefined,
+            }));
+        } else {
+            this.lastSeenTurnSignatures.delete(dedupKey);
+        }
+    }
+
     appendSystemMarker(
         agentType: string,
         content: string,
@@ -171,6 +342,16 @@ export class ChatHistoryWriter {
                 this.lastSeenHashes.set(toDedupKey, nextHashes);
                 this.lastSeenHashes.delete(fromDedupKey);
             }
+            const fromSignature = this.lastSeenSignatures.get(fromDedupKey);
+            if (fromSignature) {
+                this.lastSeenSignatures.set(toDedupKey, fromSignature);
+                this.lastSeenSignatures.delete(fromDedupKey);
+            }
+            const fromTurnSignature = this.lastSeenTurnSignatures.get(fromDedupKey);
+            if (fromTurnSignature) {
+                this.lastSeenTurnSignatures.set(toDedupKey, fromTurnSignature);
+                this.lastSeenTurnSignatures.delete(fromDedupKey);
+            }
             const fromCount = this.lastSeenCounts.get(fromDedupKey);
             if (typeof fromCount === 'number') {
                 this.lastSeenCounts.set(toDedupKey, Math.max(fromCount, this.lastSeenCounts.get(toDedupKey) || 0));
@@ -221,10 +402,69 @@ export class ChatHistoryWriter {
         }
     }
 
+    compactHistorySession(agentType: string, historySessionId: string): void {
+        const sessionId = String(historySessionId || '').trim();
+        if (!sessionId) return;
+
+        try {
+            const dir = path.join(HISTORY_DIR, this.sanitize(agentType));
+            if (!fs.existsSync(dir)) return;
+
+            const prefix = `${this.sanitize(sessionId)}_`;
+            const files = fs.readdirSync(dir)
+                .filter((file) => file.startsWith(prefix) && file.endsWith('.jsonl'))
+                .sort();
+
+            const seen = new Set<string>();
+            for (const file of files) {
+                const filePath = path.join(dir, file);
+                const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+                const next: HistoryMessage[] = [];
+
+                for (const line of lines) {
+                    let parsed: HistoryMessage | null = null;
+                    try {
+                        parsed = JSON.parse(line) as HistoryMessage;
+                    } catch {
+                        parsed = null;
+                    }
+                    if (!parsed || parsed.historySessionId !== sessionId) continue;
+                    const sanitized = sanitizeHistoryMessage(agentType, parsed);
+                    if (!sanitized) continue;
+                    const hash = buildHistoryMessageHash(agentType, sanitized);
+                    if (seen.has(hash)) continue;
+                    seen.add(hash);
+                    next.push(sanitized);
+                }
+
+                next.sort((a, b) => a.receivedAt - b.receivedAt);
+                const dedupedAdjacent: HistoryMessage[] = [];
+                let lastTurn: HistoryMessage | null = null;
+                for (const entry of next) {
+                    const previous = dedupedAdjacent[dedupedAdjacent.length - 1];
+                    if (isAdjacentHistoryDuplicate(agentType, previous, entry)) continue;
+                    if (entry.role !== 'system' && isAdjacentHistoryDuplicate(agentType, lastTurn, entry)) continue;
+                    dedupedAdjacent.push(entry);
+                    if (entry.role !== 'system') lastTurn = entry;
+                }
+                const collapsed = collapseReplayAssistantTurns(agentType, dedupedAdjacent);
+                if (collapsed.length === 0) {
+                    fs.unlinkSync(filePath);
+                    continue;
+                }
+                fs.writeFileSync(filePath, `${collapsed.map((entry) => JSON.stringify(entry)).join('\n')}\n`, 'utf-8');
+            }
+        } catch {
+            // Ignore compaction failure.
+        }
+    }
+
 /** Called when agent session is explicitly changed */
     onSessionChange(agentType: string): void {
         this.lastSeenHashes.delete(agentType);
         this.lastSeenCounts.delete(agentType);
+        this.lastSeenSignatures.delete(agentType);
+        this.lastSeenTurnSignatures.delete(agentType);
     }
 
  /** Delete history files older than 30 days */
@@ -293,31 +533,42 @@ export function readChatHistory(
             .sort()
             .reverse();
 
- // Read lines from all files (reverse order)
         const allMessages: HistoryMessage[] = [];
-        const needed = offset + limit + 1; // hasMore check +1
+        const seen = new Set<string>();
 
         for (const file of files) {
-            if (allMessages.length >= needed) break;
             const filePath = path.join(dir, file);
             const content = fs.readFileSync(filePath, 'utf-8');
             const lines = content.trim().split('\n').filter(Boolean);
-            
- // Parse in reverse order
-            for (let i = lines.length - 1; i >= 0; i--) {
-                if (allMessages.length >= needed) break;
+
+            for (let i = 0; i < lines.length; i++) {
                 try {
-                    allMessages.push(JSON.parse(lines[i]));
+                    const parsed = JSON.parse(lines[i]) as HistoryMessage;
+                    const sanitizedMessage = sanitizeHistoryMessage(agentType, parsed);
+                    if (!sanitizedMessage) continue;
+                    const hash = buildHistoryMessageHash(agentType, sanitizedMessage);
+                    if (seen.has(hash)) continue;
+                    seen.add(hash);
+                    allMessages.push(sanitizedMessage);
                 } catch { /* skip invalid lines */ }
             }
         }
 
- // offset/limit apply
-        const sliced = allMessages.slice(offset, offset + limit);
-        const hasMore = allMessages.length > offset + limit;
+        allMessages.sort((a, b) => a.receivedAt - b.receivedAt);
+        const chronological: HistoryMessage[] = [];
+        let lastTurn: HistoryMessage | null = null;
+        for (const message of allMessages) {
+            const previous = chronological[chronological.length - 1];
+            if (isAdjacentHistoryDuplicate(agentType, previous, message)) continue;
+            if (message.role !== 'system' && isAdjacentHistoryDuplicate(agentType, lastTurn, message)) continue;
+            chronological.push(message);
+            if (message.role !== 'system') lastTurn = message;
+        }
+        const collapsed = collapseReplayAssistantTurns(agentType, chronological);
 
- // Sort in chronological order (top→bottom = oldest→newest)
-        sliced.reverse();
+ // offset/limit apply
+        const sliced = collapsed.slice(offset, offset + limit);
+        const hasMore = collapsed.length > offset + limit;
 
         return { messages: sliced, hasMore };
     } catch {

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

@@ -600,8 +600,10 @@ export class AcpProviderInstance implements ProviderInstance {
                 }
 
                 // ─── Auto-approve: skip user confirmation ───
-                if (this.settings.autoApprove) {
-                    this.log.info(`[${this.type}] Auto-approving: ${tc.title || tc.toolCallId}`);
+                if (this.settings.autoApprove !== false) {
+                    const toolTitle = tc.title || tc.toolCallId || 'tool call';
+                    this.log.info(`[${this.type}] Auto-approving: ${toolTitle}`);
+                    this.appendSystemMessage(`Auto-approved: ${toolTitle}`);
                     const allowOption = params.options.find(o => o.kind === 'allow_once') || params.options.find(o => o.kind === 'allow_always');
                     if (allowOption) {
                         return { outcome: { outcome: 'selected', optionId: allowOption.optionId } };
@@ -1143,6 +1145,19 @@ export class AcpProviderInstance implements ProviderInstance {
         if (this.events.length > 50) this.events = this.events.slice(-50);
     }
 
+    private appendSystemMessage(content: string, timestamp = Date.now()): void {
+        const normalizedContent = String(content || '').trim();
+        if (!normalizedContent) return;
+        this.messages.push({
+            role: 'system',
+            content: normalizedContent,
+            timestamp,
+        });
+        if (this.messages.length > 200) {
+            this.messages = this.messages.slice(-100);
+        }
+    }
+
     private flushEvents(): ProviderEvent[] {
         const events = [...this.events];
         this.events = [];

package/src/providers/approval-utils.ts

@@ -0,0 +1,66 @@
+import type { ProviderModule } from './contracts.js';
+
+const DEFAULT_APPROVAL_POSITIVE_HINTS = [
+    'run',
+    'approve',
+    'accept',
+    'allow once',
+    'always allow',
+    'allow',
+    'yes',
+    'proceed',
+    'continue',
+    'confirm',
+    'save',
+    'ok',
+    'trust',
+];
+
+function normalizeApprovalLabel(value: string): string {
+    return String(value || '')
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
+        .trim();
+}
+
+export function getApprovalPositiveHints(provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): string[] {
+    const customHints = Array.isArray(provider?.approvalPositiveHints)
+        ? provider.approvalPositiveHints
+            .map((hint) => normalizeApprovalLabel(String(hint || '')))
+            .filter(Boolean)
+        : [];
+    return customHints.length > 0 ? customHints : DEFAULT_APPROVAL_POSITIVE_HINTS;
+}
+
+export function pickApprovalButton(
+    buttons: string[] | null | undefined,
+    provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null,
+): { index: number; label: string } {
+    const labels = (buttons || []).map((button) => String(button || '').trim()).filter(Boolean);
+    if (labels.length === 0) {
+        return { index: 0, label: 'Approve' };
+    }
+
+    const normalizedButtons = labels.map((label) => normalizeApprovalLabel(label));
+    const hints = getApprovalPositiveHints(provider);
+
+    for (const hint of hints) {
+        const exactIndex = normalizedButtons.findIndex((label) => label === hint);
+        if (exactIndex >= 0) return { index: exactIndex, label: labels[exactIndex] };
+
+        const prefixIndex = normalizedButtons.findIndex((label) => label.startsWith(hint));
+        if (prefixIndex >= 0) return { index: prefixIndex, label: labels[prefixIndex] };
+
+        const includeIndex = normalizedButtons.findIndex((label) => label.includes(hint));
+        if (includeIndex >= 0) return { index: includeIndex, label: labels[includeIndex] };
+    }
+
+    return { index: 0, label: labels[0] };
+}
+
+export function formatAutoApprovalMessage(modalMessage?: string, buttonLabel?: string): string {
+    const lines = [`Auto-approved${buttonLabel ? `: ${buttonLabel}` : ''}`];
+    const cleanMessage = String(modalMessage || '').trim();
+    if (cleanMessage) lines.push(cleanMessage);
+    return lines.join('\n');
+}

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

@@ -20,6 +20,7 @@ import { ChatHistoryWriter, readChatHistory } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
 import type { ChatMessage } from '../types.js';
 import { extractProviderControlValues, normalizeProviderEffects } from './control-effects.js';
+import { formatAutoApprovalMessage, pickApprovalButton } from './approval-utils.js';
 
 let CachedDatabaseSync: (new (path: string, options?: { readOnly?: boolean }) => {
     prepare(sql: string): { get(...params: Array<string | number>): unknown };
@@ -60,6 +61,7 @@ export class CliProviderInstance implements ProviderInstance {
     private historyWriter: ChatHistoryWriter;
     private runtimeMessages: Array<{ key: string; message: ChatMessage }> = [];
     readonly instanceId: string;
+    private suppressIdleHistoryReplay = false;
 
     private presentationMode: 'terminal' | 'chat';
     private providerSessionId?: string;
@@ -135,7 +137,15 @@ export class CliProviderInstance implements ProviderInstance {
         await this.adapter.spawn();
         this.maybeAppendRuntimeRecoveryMessage(this.adapter.getRuntimeMetadata());
         if (this.providerSessionId) {
+            this.historyWriter.compactHistorySession(this.type, this.providerSessionId);
             const restoredHistory = readChatHistory(this.type, 0, 200, this.providerSessionId);
+            this.historyWriter.seedSessionHistory(
+                this.type,
+                restoredHistory.messages,
+                this.providerSessionId,
+                this.instanceId,
+            );
+            this.suppressIdleHistoryReplay = restoredHistory.messages.length > 0;
             if (restoredHistory.messages.length > 0) {
                 this.adapter.seedCommittedMessages(
                     restoredHistory.messages.map((message) => ({
@@ -184,7 +194,7 @@ export class CliProviderInstance implements ProviderInstance {
             } else if (this.type === 'codex-cli') {
                 probedSessionId = this.probeSessionIdFromConfig({
                     dbPath: '~/.codex/state_5.sqlite',
-                    query: 'select id from threads where cwd in ({dirs}) and created_at >= ? and archived = 0 order by created_at desc limit 1',
+                    query: 'select id from threads where cwd in ({dirs}) and updated_at >= ? and archived = 0 order by updated_at desc limit 1',
                     timestampFormat: 'unix_s',
                 });
             } else if (this.type === 'goose-cli') {
@@ -240,6 +250,8 @@ export class CliProviderInstance implements ProviderInstance {
     getState(): ProviderState {
         const adapterStatus = this.adapter.getStatus();
         const parsedStatus = this.adapter.getScriptParsedStatus?.() || null;
+        const autoApproveActive = adapterStatus.status === 'waiting_approval' && this.shouldAutoApprove();
+        const visibleStatus = autoApproveActive ? 'generating' : adapterStatus.status;
         const parsedProviderSessionId = typeof parsedStatus?.providerSessionId === 'string'
             ? parsedStatus.providerSessionId.trim()
             : '';
@@ -260,6 +272,10 @@ export class CliProviderInstance implements ProviderInstance {
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
 
         if (parsedMessages.length > 0) {
+            const shouldSkipReplayPersist =
+                this.suppressIdleHistoryReplay
+                && adapterStatus.status === 'idle'
+                && parsedStatus?.status === 'idle';
             let messagesToSave = parsedMessages;
             if ((parsedStatus?.status === 'generating' || parsedStatus?.status === 'long_generating')) {
                 const lastIdx = messagesToSave.length - 1;
@@ -267,7 +283,7 @@ export class CliProviderInstance implements ProviderInstance {
                     messagesToSave = messagesToSave.slice(0, lastIdx);
                 }
             }
-            if (messagesToSave.length > 0) {
+            if (!shouldSkipReplayPersist && messagesToSave.length > 0) {
                 this.historyWriter.appendNewMessages(
                     this.type,
                     messagesToSave,
@@ -284,14 +300,16 @@ export class CliProviderInstance implements ProviderInstance {
             type: this.type,
             name: this.provider.name,
             category: 'cli',
-            status: adapterStatus.status,
+            status: visibleStatus,
             mode: this.presentationMode,
             activeChat: {
                 id: `${this.type}_${this.workingDir}`,
                 title: parsedStatus?.title || dirName,
-                status: parsedStatus?.status || adapterStatus.status,
+                status: autoApproveActive && parsedStatus?.status === 'waiting_approval'
+                    ? 'generating'
+                    : (parsedStatus?.status || visibleStatus),
                 messages: mergedMessages,
-                activeModal: parsedStatus?.activeModal ?? adapterStatus.activeModal,
+                activeModal: autoApproveActive ? null : (parsedStatus?.activeModal ?? adapterStatus.activeModal),
                 inputContent: '',
             },
             workspace: this.workingDir,
@@ -362,7 +380,16 @@ export class CliProviderInstance implements ProviderInstance {
         const now = Date.now();
         const adapterStatus = this.adapter.getStatus();
         const parsedStatus = this.adapter.getScriptParsedStatus?.() || null;
-        const newStatus = adapterStatus.status;
+        const rawStatus = adapterStatus.status;
+        const autoApproveActive = rawStatus === 'waiting_approval' && this.shouldAutoApprove();
+        if (autoApproveActive) {
+            const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(adapterStatus.activeModal?.buttons, this.provider);
+            this.recordAutoApproval(adapterStatus.activeModal?.message, buttonLabel, now);
+            setTimeout(() => {
+                this.adapter.resolveModal(buttonIndex);
+            }, 0);
+        }
+        const newStatus = autoApproveActive ? 'generating' : rawStatus;
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
         const chatTitle = `${this.provider.name} · ${dirName}`;
         const partial = this.adapter.getPartialResponse();
@@ -374,6 +401,7 @@ export class CliProviderInstance implements ProviderInstance {
         if (newStatus !== this.lastStatus) {
             LOG.info('CLI', `[${this.type}] status: ${this.lastStatus} → ${newStatus}`);
             if (this.lastStatus === 'idle' && newStatus === 'generating') {
+                this.suppressIdleHistoryReplay = false;
                 // Cancel any pending completed event (multi-step: idle→generating resume)
                 if (this.completedDebouncePending) {
                     LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed generating)`);
@@ -394,6 +422,7 @@ export class CliProviderInstance implements ProviderInstance {
                     this.generatingDebounceTimer = null;
                 }, 1000);
             } else if (newStatus === 'waiting_approval') {
+                this.suppressIdleHistoryReplay = false;
                 // Flush pending generating_started if debounce still pending
                 if (this.generatingDebouncePending) {
                     if (this.generatingDebounceTimer) { clearTimeout(this.generatingDebounceTimer); this.generatingDebounceTimer = null; }
@@ -588,6 +617,18 @@ export class CliProviderInstance implements ProviderInstance {
     get cliType(): string { return this.type; }
     get cliName(): string { return this.provider.name; }
 
+    private shouldAutoApprove(): boolean {
+        return this.settings.autoApprove !== false;
+    }
+
+    private recordAutoApproval(modalMessage?: string, buttonLabel?: string, now = Date.now()): void {
+        this.appendRuntimeSystemMessage(
+            formatAutoApprovalMessage(modalMessage, buttonLabel),
+            `auto_approval:${now}:${buttonLabel || 'approve'}`,
+            now,
+        );
+    }
+
     recordApprovalSelection(buttonText: string): void {
         const cleanButton = String(buttonText || '').trim();
         if (!cleanButton) return;

package/src/providers/contracts.d.ts

@@ -253,6 +253,7 @@ export interface ProviderModule {
     };
     cleanOutput?: (raw: string, lastUserInput?: string) => string;
     resume?: ProviderResumeCapability;
+    approvalPositiveHints?: string[];
     scripts?: ProviderScripts;
     vscodeCommands?: {
         focusPanel?: string;

package/src/providers/contracts.ts

@@ -388,8 +388,10 @@ export interface ProviderModule {
   };
   cleanOutput?: (raw: string, lastUserInput?: string) => string;
   resume?: ProviderResumeCapability;
-  /** Session ID probe config — auto-discovers provider session ID from local SQLite DB */
+ /** Session ID probe config — auto-discovers provider session ID from local SQLite DB */
   sessionProbe?: ProviderSessionProbe;
+  /** Approval button priority hints used when auto-approve must pick a positive action */
+  approvalPositiveHints?: string[];
 
  // ─── CDP scripts (ide/extension category) ───
   scripts?: ProviderScripts;