@adhdev/daemon-core 0.8.29 → 0.8.30

package/dist/providers/acp-provider-instance.d.ts

@@ -93,6 +93,7 @@ export declare class AcpProviderInstance implements ProviderInstance {
     private convertToolCallContent;
     private detectStatusTransition;
     private pushEvent;
+    private appendSystemMessage;
     private flushEvents;
     get cliType(): string;
     get cliName(): string;

package/dist/providers/approval-utils.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderModule } from './contracts.js';
+export declare function getApprovalPositiveHints(provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): string[];
+export declare function pickApprovalButton(buttons: string[] | null | undefined, provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): {
+    index: number;
+    label: string;
+};
+export declare function formatAutoApprovalMessage(modalMessage?: string, buttonLabel?: string): string;

package/dist/providers/cli-provider-instance.d.ts

@@ -71,6 +71,8 @@ export declare class CliProviderInstance implements ProviderInstance {
     getAdapter(): ProviderCliAdapter;
     get cliType(): string;
     get cliName(): string;
+    private shouldAutoApprove;
+    private recordAutoApproval;
     recordApprovalSelection(buttonText: string): void;
     private formatMarkerTimestamp;
     private maybeAppendRuntimeRecoveryMessage;

package/dist/providers/contracts.d.ts

@@ -313,6 +313,8 @@ export interface ProviderModule {
     resume?: ProviderResumeCapability;
     /** 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[];
     scripts?: ProviderScripts;
     vscodeCommands?: {
         focusPanel?: string;

package/dist/providers/ide-provider-instance.d.ts

@@ -65,5 +65,6 @@ export declare class IdeProviderInstance implements ProviderInstance {
     private getEffectDedupKey;
     private flushEvents;
     updateCdp(cdp: InstanceContext['cdp']): void;
+    private canAutoApprove;
     private autoApproveViaScript;
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.29",
+  "version": "0.8.30",
   "description": "ADHDev local session host core — 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.8.29",
+  "version": "0.8.30",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/agent-stream/poller.ts

@@ -19,6 +19,7 @@ import type { SessionRegistry } from '../sessions/registry.js';
 import { reconcileIdeRuntimeSessions } from '../sessions/reconcile.js';
 import { LOG } from '../logging/logger.js';
 import type { AgentStreamState } from './types.js';
+import { formatAutoApprovalMessage, pickApprovalButton } from '../providers/approval-utils.js';
 
 // ─── Types ───
 
@@ -189,7 +190,43 @@ export class AgentStreamPoller {
 
             try {
                 await agentStreamManager.syncActiveSession(cdp, parentSessionId);
-                const stream = await agentStreamManager.collectActiveSession(cdp, parentSessionId);
+                let stream = await agentStreamManager.collectActiveSession(cdp, parentSessionId);
+                if (stream?.status === 'waiting_approval') {
+                    const autoApprove = providerLoader.getSettings(stream.agentType).autoApprove !== false;
+                    if (autoApprove && resolvedActiveSessionId) {
+                        const provider = providerLoader.getMeta(stream.agentType);
+                        const { label: buttonLabel } = pickApprovalButton(stream.activeModal?.buttons, provider);
+                        const approved = await agentStreamManager.resolveSessionAction(cdp, resolvedActiveSessionId, 'approve', buttonLabel);
+                        if (approved) {
+                            const effectId = [
+                                'auto_approval',
+                                resolvedActiveSessionId,
+                                String(stream.messages?.length || 0),
+                                buttonLabel,
+                                String(stream.activeModal?.message || '').trim(),
+                            ].join(':');
+                            stream = {
+                                ...stream,
+                                status: 'streaming',
+                                activeModal: undefined,
+                                effects: [
+                                    ...(stream.effects || []),
+                                    {
+                                        type: 'message',
+                                        id: effectId,
+                                        persist: true,
+                                        message: {
+                                            role: 'system',
+                                            senderName: 'System',
+                                            kind: 'system',
+                                            content: formatAutoApprovalMessage(stream.activeModal?.message, buttonLabel),
+                                        },
+                                    },
+                                ],
+                            };
+                        }
+                    }
+                }
                 this.deps.onStreamsUpdated?.(ideType, stream ? [stream] : []);
             } 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 };
@@ -249,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()
             : '';
@@ -297,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,
@@ -375,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();
@@ -603,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;

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

@@ -19,6 +19,7 @@ import { ChatHistoryWriter } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
 import { extractProviderControlValues, normalizeProviderEffects } from './control-effects.js';
 import type { ChatMessage } from '../types.js';
+import { formatAutoApprovalMessage, pickApprovalButton } from './approval-utils.js';
 
 export class IdeProviderInstance implements ProviderInstance {
     readonly type: string;
@@ -103,6 +104,11 @@ export class IdeProviderInstance implements ProviderInstance {
 
     getState(): ProviderState {
         const cdp = this.context?.cdp;
+        const autoApproveActive = (
+            this.currentStatus === 'waiting_approval'
+            || this.cachedChat?.status === 'waiting_approval'
+        ) && this.canAutoApprove();
+        const visibleStatus = (autoApproveActive ? 'generating' : this.currentStatus) as ProviderState['status'];
 
  // Collect extension status
         const extensionStates: ProviderState[] = [];
@@ -114,13 +120,15 @@ export class IdeProviderInstance implements ProviderInstance {
             type: this.type,
             name: this.provider.name,
             category: 'ide',
-            status: this.currentStatus as ProviderState['status'],
+            status: visibleStatus,
             activeChat: this.cachedChat ? {
                 id: this.cachedChat.id || 'active_session',
                 title: this.cachedChat.title || this.type,
-                status: this.cachedChat.status || this.currentStatus,
+                status: autoApproveActive && this.cachedChat.status === 'waiting_approval'
+                    ? 'generating'
+                    : (this.cachedChat.status || visibleStatus),
                 messages: this.mergeConversationMessages(this.cachedChat.messages || []),
-                activeModal: this.cachedChat.activeModal || null,
+                activeModal: autoApproveActive ? null : (this.cachedChat.activeModal || null),
                 inputContent: this.cachedChat.inputContent || '',
             } : null,
             workspace: this.workspace || null,
@@ -370,9 +378,11 @@ export class IdeProviderInstance implements ProviderInstance {
         if (!chatStatus) return;
 
         const agentKey = `${this.type}:native`;
-        const agentStatus = (chatStatus === 'streaming' || chatStatus === 'generating') ? 'generating'
+        const rawAgentStatus = (chatStatus === 'streaming' || chatStatus === 'generating') ? 'generating'
             : chatStatus === 'waiting_approval' ? 'waiting_approval'
             : 'idle';
+        const autoApproveActive = rawAgentStatus === 'waiting_approval' && this.canAutoApprove();
+        const agentStatus = autoApproveActive ? 'generating' : rawAgentStatus;
         const lastMsg = Array.isArray(chatData?.messages) && chatData.messages.length > 0
             ? chatData.messages[chatData.messages.length - 1]
             : null;
@@ -414,7 +424,7 @@ export class IdeProviderInstance implements ProviderInstance {
         });
 
  // Auto-approve: when waiting_approval + settings.autoApprove → auto-click approve via CDP
-        if (agentStatus === 'waiting_approval' && this.settings.autoApprove && !this.autoApproveBusy) {
+        if (rawAgentStatus === 'waiting_approval' && autoApproveActive && !this.autoApproveBusy) {
             this.autoApproveViaScript(chatData);
         }
 
@@ -590,6 +600,12 @@ export class IdeProviderInstance implements ProviderInstance {
         if (this.context) this.context.cdp = cdp;
     }
 
+    private canAutoApprove(): boolean {
+        return this.settings.autoApprove !== false
+            && typeof this.provider.scripts?.resolveAction === 'function'
+            && !!this.context?.cdp?.isConnected;
+    }
+
  // ─── Auto-approve via CDP script ────────────────────
 
     private async autoApproveViaScript(_chatData: any): Promise<void> {
@@ -605,20 +621,16 @@ export class IdeProviderInstance implements ProviderInstance {
 
         this.autoApproveBusy = true;
         try {
-            let targetButton = _chatData?.activeModal?.buttons?.[0] || 'Run';
-            const buttons = _chatData?.activeModal?.buttons || [];
-            
-            // Prefer buttons like 'Run', 'Approve', 'Yes'
-            for (const b of buttons) {
-                const lower = String(b).toLowerCase().replace(/[^\w]/g, '');
-                if (/^(run|approve|accept|yes|allow|always|proceed|save)/.test(lower)) {
-                    targetButton = b;
-                    break;
-                }
-            }
+            const { label: targetButton } = pickApprovalButton(_chatData?.activeModal?.buttons, this.provider);
 
             const script = scriptFn({ action: 'approve', button: targetButton, buttonText: targetButton });
             if (!script) return;
+            const now = Date.now();
+            this.appendRuntimeSystemMessage(
+                formatAutoApprovalMessage(_chatData?.activeModal?.message, targetButton),
+                `auto_approval:${now}:${targetButton}`,
+                now,
+            );
 
             LOG.info('IdeInstance', `[IdeInstance:${this.type}] autoApprove: executing resolveAction for "${targetButton}"`);
             let rawResult = await cdp.evaluate(script, 10000);
@@ -641,13 +653,6 @@ export class IdeProviderInstance implements ProviderInstance {
                     LOG.warn('IdeInstance', `[IdeInstance:${this.type}] autoApprove: cdp.send() not available for coordinate click`);
                 }
             }
-
-            this.pushEvent({
-                event: 'agent:auto_approved',
-                chatTitle: _chatData?.title || this.provider.name,
-                timestamp: Date.now(),
-                ideType: this.type,
-            });
         } catch (e: any) {
             LOG.warn('IdeInstance', `[IdeInstance:${this.type}] autoApprove error: ${e?.message}`);
         } finally {

package/src/providers/provider-loader.ts

@@ -994,7 +994,11 @@ export class ProviderLoader {
  */
   getSettingValue(type: string, key: string): any {
     const schemaDef = this.getSettingsSchema(type)[key];
-    const defaultVal = schemaDef ? (schemaDef as any).default : undefined;
+    const defaultVal = schemaDef
+      ? (key === 'autoApprove' && (schemaDef as any).type === 'boolean'
+        ? true
+        : (schemaDef as any).default)
+      : undefined;
 
  // Load user-saved value
     try {
@@ -1064,15 +1068,35 @@ export class ProviderLoader {
   private getSettingsSchema(type: string): Record<string, ProviderSettingDef> {
     const provider = this.providers.get(type);
     if (!provider) return {};
-    return {
+    const result = {
       ...this.getSyntheticSettings(type, provider),
       ...(provider.settings || {}),
     };
+    if (result.autoApprove?.type === 'boolean') {
+      result.autoApprove = {
+        ...result.autoApprove,
+        default: true,
+        public: true,
+        label: result.autoApprove.label || 'Auto Approve',
+        description: result.autoApprove.description || 'Automatically approve actionable prompts without sending approval alerts.',
+      };
+    }
+    return result;
   }
 
   private getSyntheticSettings(type: string, provider: ProviderModule): Record<string, ProviderSettingDef> {
     const result: Record<string, ProviderSettingDef> = {};
 
+    if (!provider.settings?.autoApprove) {
+      result.autoApprove = {
+        type: 'boolean',
+        default: true,
+        public: true,
+        label: 'Auto Approve',
+        description: 'Automatically approve actionable prompts without sending approval alerts.',
+      };
+    }
+
     if ((provider.category === 'cli' || provider.category === 'acp') && provider.spawn?.command && !provider.settings?.executablePath) {
       result.executablePath = {
         type: 'string',