@adhdev/daemon-core 0.8.28 → 0.8.30

package/src/agent-stream/manager.ts

@@ -244,7 +244,7 @@ export class DaemonAgentStreamManager {
         }
     }
 
-    async resolveSessionAction(cdp: DaemonCdpManager, sessionId: string, action: 'approve' | 'reject'): Promise<boolean> {
+    async resolveSessionAction(cdp: DaemonCdpManager, sessionId: string, action: 'approve' | 'reject', button?: string): Promise<boolean> {
         await this.ensureSessionPanelOpen(sessionId);
         const target = this.getSessionTarget(sessionId);
         if (!target?.parentSessionId) return false;
@@ -255,7 +255,7 @@ export class DaemonAgentStreamManager {
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
                 cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
-            return await agent.adapter.resolveAction(evaluate, action);
+            return await agent.adapter.resolveAction(evaluate, action, button);
         } catch (e) {
             this.logFn(`[AgentStream] resolveAction(${sessionId}) error: ${(e as Error).message}`);
             return false;

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/agent-stream/provider-adapter.ts

@@ -70,6 +70,64 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
             || /Cannot find context with specified id/i.test(reason);
     }
 
+    private titlesMatch(actual: string, expected: string): boolean {
+        const lhs = actual.trim().toLowerCase();
+        const rhs = expected.trim().toLowerCase();
+        if (!lhs || !rhs) return false;
+        return lhs === rhs || lhs.includes(rhs) || rhs.includes(lhs);
+    }
+
+    private messageCount(state: AgentStreamState | null | undefined): number {
+        return Array.isArray(state?.messages) ? state!.messages.length : 0;
+    }
+
+    private lastMessageSignature(state: AgentStreamState | null | undefined): string {
+        const messages = Array.isArray(state?.messages) ? state!.messages : [];
+        const last = messages[messages.length - 1] as any;
+        if (!last) return '';
+        return `${last.role || ''}:${String(last.content || '').replace(/\s+/g, ' ').trim()}`;
+    }
+
+    private async verifySendOutcome(
+        evaluate: AgentEvaluateFn,
+        before: AgentStreamState | null,
+    ): Promise<boolean> {
+        const beforeCount = this.messageCount(before);
+        const beforeSignature = this.lastMessageSignature(before);
+
+        for (let attempt = 0; attempt < 12; attempt += 1) {
+            await new Promise((resolve) => setTimeout(resolve, 250));
+            let state: AgentStreamState;
+            try {
+                state = await this.readChat(evaluate);
+            } catch {
+                continue;
+            }
+
+            if (state.status === 'waiting_approval') {
+                return true;
+            }
+
+            const afterCount = this.messageCount(state);
+            const afterSignature = this.lastMessageSignature(state);
+            if (afterCount > beforeCount) return true;
+            if (afterSignature && afterSignature !== beforeSignature) return true;
+        }
+
+        return false;
+    }
+
+    private async readStableBaselineState(evaluate: AgentEvaluateFn): Promise<AgentStreamState | null> {
+        const first = await this.readChat(evaluate);
+        if (this.messageCount(first) > 0 || this.lastMessageSignature(first)) {
+            return first;
+        }
+
+        await new Promise((resolve) => setTimeout(resolve, 150));
+        const second = await this.readChat(evaluate);
+        return this.messageCount(second) >= this.messageCount(first) ? second : first;
+    }
+
     async readChat(evaluate: AgentEvaluateFn): Promise<AgentStreamState> {
         const script = this.callScript('readChat');
         if (!script) return this.errorState('readChat script not available');
@@ -96,6 +154,9 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
                 mode: data.mode,
                 activeModal: data.activeModal,
             };
+            if (typeof data.title === 'string' && data.title.trim()) {
+                (state as any).title = data.title.trim();
+            }
             const controlValues = extractProviderControlValues(this.provider.controls, data);
             if (controlValues) state.controlValues = controlValues;
             const effects = normalizeProviderEffects(data);
@@ -120,6 +181,13 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
     }
 
     async sendMessage(evaluate: AgentEvaluateFn, text: string): Promise<void> {
+        let beforeState: AgentStreamState | null = null;
+        try {
+            beforeState = await this.readStableBaselineState(evaluate);
+        } catch {
+            beforeState = null;
+        }
+
         const params = { message: text };
         const script = this.callScript('sendMessage', params) || this.callScript('sendMessage', text);
         if (!script) throw new Error(`[${this.agentName}] sendMessage script not available`);
@@ -138,7 +206,9 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
         }
         if (parsed && typeof parsed === 'object') {
             if (parsed.sent === true || parsed.success === true || parsed.ok === true || parsed.submitted === true || parsed.dispatched === true) {
-                return;
+                const verified = await this.verifySendOutcome(evaluate, beforeState);
+                if (verified) return;
+                throw new Error(`[${this.agentName}] sendMessage was not observed in chat state`);
             }
             if (typeof parsed.error === 'string' && parsed.error.trim()) {
                 throw new Error(`[${this.agentName}] sendMessage failed: ${parsed.error}`);
@@ -151,7 +221,23 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
     async resolveAction(evaluate: AgentEvaluateFn, action: string, button?: string): Promise<boolean> {
         const script = this.callScript('resolveAction', { action, button });
         if (!script) return false; // Not supported if provider has no resolveAction
-        return (await evaluate(script)) === true;
+        const result = await evaluate(script);
+        const parsed = this.parseMaybeJson(result);
+        if (parsed === true) return true;
+        if (typeof parsed === 'string') {
+            const normalized = parsed.trim().toLowerCase();
+            return normalized === 'ok'
+                || normalized === 'success'
+                || normalized === 'true'
+                || normalized === 'resolved'
+                || normalized === 'approved'
+                || normalized === 'rejected';
+        }
+        if (!parsed || typeof parsed !== 'object') return false;
+        return parsed.resolved === true
+            || parsed.success === true
+            || parsed.ok === true
+            || parsed.found === true;
     }
 
     async newSession(evaluate: AgentEvaluateFn): Promise<void> {
@@ -189,7 +275,15 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
             return normalized === 'true' || normalized === 'ok' || normalized === 'switched' || normalized === 'success';
         }
         if (data && typeof data === 'object') {
-            return data.switched === true || data.success === true || data.ok === true;
+            if (data.switched === true || data.success === true || data.ok === true) return true;
+            if (typeof data.error === 'string' && data.error.trim()) return false;
+        }
+
+        for (let attempt = 0; attempt < 6; attempt += 1) {
+            await new Promise((resolve) => setTimeout(resolve, 250));
+            const state = await this.readChat(evaluate);
+            const title = typeof (state as any).title === 'string' ? (state as any).title : '';
+            if (this.titlesMatch(title, sessionId)) return true;
         }
         return false;
     }

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

@@ -1241,6 +1241,9 @@ export class ProviderCliAdapter implements CliAdapter {
     private looksLikeVisibleIdlePrompt(screenText: string): boolean {
         const text = String(screenText || '');
         if (!text.trim()) return false;
+        if (this.cliType === 'codex-cli' && /(^|\n)\s*[❯›>]\s+(?:Find and fix a bug in @filename|Improve documentation in @filename|Use \/skills|Write tests for @filename|Explain this codebase|Summarize recent commits|Implement \{feature\}|Run \/review on my current changes)(?:\n|$)/im.test(text)) {
+            return true;
+        }
         return /(^|\n)\s*[❯›>]\s*(?:\n|$)/m.test(text)
             || /⏎\s+send/i.test(text)
             || /\?\s*for\s*shortcuts/i.test(text)

package/src/commands/chat-commands.ts

@@ -115,6 +115,51 @@ function didProviderConfirmSend(result: any): boolean {
         || parsed.dispatched === true;
 }
 
+async function readExtensionChatState(h: CommandHelpers): Promise<any | null> {
+    try {
+        const evalResult = await h.evaluateProviderScript('readChat', undefined, 50000);
+        if (!evalResult?.result) return null;
+        const parsed = parseMaybeJson(evalResult.result);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    } catch {
+        return null;
+    }
+}
+
+function getStateMessageCount(state: any): number {
+    return Array.isArray(state?.messages) ? state.messages.length : 0;
+}
+
+function getStateLastSignature(state: any): string {
+    const messages = Array.isArray(state?.messages) ? state.messages : [];
+    const last = messages[messages.length - 1];
+    if (!last) return '';
+    return `${last.role || ''}:${String(last.content || '').replace(/\s+/g, ' ').trim()}`;
+}
+
+async function getStableExtensionBaseline(h: CommandHelpers): Promise<any | null> {
+    const first = await readExtensionChatState(h);
+    if (getStateMessageCount(first) > 0 || getStateLastSignature(first)) return first;
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    const second = await readExtensionChatState(h);
+    return getStateMessageCount(second) >= getStateMessageCount(first) ? second : first;
+}
+
+async function verifyExtensionSendObserved(h: CommandHelpers, before: any): Promise<boolean> {
+    const beforeCount = getStateMessageCount(before);
+    const beforeSignature = getStateLastSignature(before);
+    for (let attempt = 0; attempt < 12; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        const state = await readExtensionChatState(h);
+        if (state?.status === 'waiting_approval') return true;
+        const afterCount = getStateMessageCount(state);
+        const afterSignature = getStateLastSignature(state);
+        if (afterCount > beforeCount) return true;
+        if (afterSignature && afterSignature !== beforeSignature) return true;
+    }
+    return false;
+}
+
 export async function handleChatHistory(h: CommandHelpers, args: any): Promise<CommandResult> {
     const { agentType, offset, limit } = args;
     const historySessionId = getHistorySessionId(h, args);
@@ -303,12 +348,17 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
         _log(`Extension: ${provider?.type || 'unknown_extension'}`);
         // Method 1: provider sendMessage script via evaluateInSession
         try {
+            const beforeState = await getStableExtensionBaseline(h);
             const evalResult = await h.evaluateProviderScript('sendMessage', { message: text }, 30000);
             if (evalResult?.result) {
                 const parsed = parseMaybeJson(evalResult.result);
                 if (didProviderConfirmSend(parsed)) {
-                    _log(`Extension script sent OK`);
-                    return _logSendSuccess('extension-script');
+                    const observed = await verifyExtensionSendObserved(h, beforeState);
+                    if (observed) {
+                        _log(`Extension script sent OK`);
+                        return _logSendSuccess('extension-script');
+                    }
+                    _log(`Extension script reported send but no chat-state change was observed`);
                 }
                 if (parsed?.needsTypeAndSend) {
                     _log(`Extension needsTypeAndSend → AgentStreamManager`);
@@ -829,7 +879,7 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
 
     // 1. Extension transport: via AgentStreamManager
     if (isExtensionTransport(transport) && h.agentStream && h.getCdp() && h.currentSession?.sessionId) {
-        const ok = await h.agentStream.resolveSessionAction(h.getCdp()!, h.currentSession.sessionId, action);
+        const ok = await h.agentStream.resolveSessionAction(h.getCdp()!, h.currentSession.sessionId, action, button);
         return { success: ok };
     }
 

package/src/commands/cli-manager.ts

@@ -687,6 +687,7 @@ export class DaemonCliManager {
         if (!instanceManager) return 0;
         const sessions = records || await this.deps.listHostedCliRuntimes?.() || [];
         let restored = 0;
+        const restoredBindings = new Set<string>();
 
         for (const record of sessions) {
             if (!record?.runtimeId || !record?.cliType || !record?.workspace) continue;
@@ -702,6 +703,18 @@ export class DaemonCliManager {
                 record.cliArgs,
                 record.providerSessionId,
             );
+            const bindingKey = [
+                normalizedType,
+                record.workspace,
+                sessionBinding.providerSessionId || record.runtimeId,
+            ].join('::');
+            if (restoredBindings.has(bindingKey)) {
+                LOG.info(
+                    'CLI',
+                    `↷ Skipping duplicate hosted runtime restore: ${record.runtimeKey || record.runtimeId} (${normalizedType} @ ${record.workspace}) binding=${sessionBinding.providerSessionId || 'runtime'}`
+                );
+                continue;
+            }
             try {
                 await this.registerCliInstance(
                     record.runtimeId,
@@ -717,6 +730,7 @@ export class DaemonCliManager {
                         launchMode: 'manual',
                     },
                 );
+                restoredBindings.add(bindingKey);
                 restored += 1;
                 LOG.info('CLI', `♻ Restored hosted runtime: ${record.runtimeKey || record.runtimeId} (${record.displayName || record.workspace})`);
             } catch (error: any) {

package/src/commands/router.ts

@@ -44,6 +44,7 @@ export interface SessionHostControlPlane {
     restartSession(sessionId: string): Promise<any>;
     sendSignal(sessionId: string, signal: string): Promise<any>;
     forceDetachClient(sessionId: string, clientId: string): Promise<any>;
+    pruneDuplicateSessions(payload?: { providerType?: string; workspace?: string; dryRun?: boolean }): Promise<any>;
     acquireWrite(payload: { sessionId: string; clientId: string; ownerType: 'agent' | 'user'; force?: boolean }): Promise<any>;
     releaseWrite(payload: { sessionId: string; clientId: string }): Promise<any>;
 }
@@ -265,6 +266,16 @@ export class DaemonCommandRouter {
                 return { success: true, record };
             }
 
+            case 'session_host_prune_duplicate_sessions': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const result = await this.deps.sessionHostControl.pruneDuplicateSessions({
+                    providerType: typeof args?.providerType === 'string' ? args.providerType : undefined,
+                    workspace: typeof args?.workspace === 'string' ? args.workspace : undefined,
+                    dryRun: args?.dryRun === true,
+                });
+                return { success: true, result };
+            }
+
             case 'session_host_acquire_write': {
                 if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
                 const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';