@adhdev/daemon-core 0.5.62 → 0.5.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.5.62",
+  "version": "0.5.64",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -11,7 +11,7 @@
  * binary: string — binary name
  * spawn: { command, args, shell, env }
  * patterns: { prompt, generating, approval, ready }
- * timeouts?: { idleFinish, generatingIdle, maxResponse, approvalCooldown, ... }
+ * timeouts?: { idleFinish, generatingIdle, maxResponse, approvalCooldown, outputSettle, ... }
  * cleanOutput(raw, lastUserInput): string
  */
 
@@ -89,6 +89,8 @@ export interface CliProviderModule {
         maxResponse?: number;
  /** shutdown after kill wait (default 1000ms) */
         shutdownGrace?: number;
+ /** Output settle debounce before evaluating idle/approval (default 300ms) */
+        outputSettle?: number;
     };
     cleanOutput(raw: string, lastUserInput?: string): string;
 }
@@ -271,6 +273,10 @@ export class ProviderCliAdapter implements CliAdapter {
     private approvalTransitionBuffer: string = '';
     private approvalExitTimeout: NodeJS.Timeout | null = null;
 
+ // Output settle debounce — fires after PTY output goes quiet
+    private settleTimer: NodeJS.Timeout | null = null;
+    private settledBuffer: string = ''; // snapshot of recentOutputBuffer at settle time
+
  // Resize redraw suppression
     private resizeSuppressUntil: number = 0;
 
@@ -310,6 +316,7 @@ export class ProviderCliAdapter implements CliAdapter {
             idleFinish: t.idleFinish ?? 5000,
             maxResponse: t.maxResponse ?? 300000,
             shutdownGrace: t.shutdownGrace ?? 1000,
+            outputSettle: t.outputSettle ?? 300,
         };
 
  // Load approval key mapping from provider (e.g. approvalKeys: {"0":"1","1":"2","2":"3"})
@@ -474,55 +481,69 @@ export class ProviderCliAdapter implements CliAdapter {
             return;
         }
 
- // ─── Phase 2: Approval detect
-        // DEBUG: log recent output for approval pattern debugging
         if (cleanData.trim().length > 5) {
             LOG.debug('CLI', `[${this.cliType}] output chunk (${cleanData.length}): ${cleanData.slice(0, 300).replace(/\n/g, '\\n')}`);
         }
-        const hasApproval = patterns.approval.some(p => p.test(this.recentOutputBuffer));
-        if (hasApproval && this.currentStatus !== 'waiting_approval') {
-            const inCooldown = this.lastApprovalResolvedAt && (Date.now() - this.lastApprovalResolvedAt) < this.timeouts.approvalCooldown;
-            if (!inCooldown) {
-                // Capture context before clearing (recentOutputBuffer still has content here)
-                const ctxLines = this.recentOutputBuffer.split('\n')
-                    .map(l => l.trim())
-                    .filter(l => l && !/^[─═╭╮╰╯│]+$/.test(l));
+
+ // ─── Phase 2: generating — immediate detection (fast UX response)
+        if (!this.isWaitingForResponse) {
+            if (patterns.generating.some(p => p.test(cleanData))) {
+                if (this.settleTimer) { clearTimeout(this.settleTimer); this.settleTimer = null; }
                 this.isWaitingForResponse = true;
-                this.setStatus('waiting_approval', 'approval_pattern');
-                this.recentOutputBuffer = '';
-                this.approvalTransitionBuffer = '';
-                this.activeModal = {
-                    message: ctxLines.slice(-5).join(' ').slice(0, 200) || 'Approval required',
-                    buttons: this.cliType === 'claude-cli'
-                        ? ['Yes (y)', 'Always allow (a)', 'Deny (Esc)']
-                        : ['Allow once', 'Always allow', 'Deny'],
-                };
-                if (this.idleTimeout) clearTimeout(this.idleTimeout);
-                // Safety timeout — if stuck in waiting_approval, auto-exit after 60s
-                if (this.approvalExitTimeout) clearTimeout(this.approvalExitTimeout);
-                this.approvalExitTimeout = setTimeout(() => {
-                    if (this.currentStatus === 'waiting_approval') {
-                        LOG.warn('CLI', `[${this.cliType}] Approval timeout — auto-exiting waiting_approval`);
-                        this.activeModal = null;
-                        this.lastApprovalResolvedAt = Date.now();
-                        this.recentOutputBuffer = '';
-                        this.approvalTransitionBuffer = '';
-                        this.approvalExitTimeout = null;
-                        this.setStatus(this.isWaitingForResponse ? 'generating' : 'idle', 'approval_cleared');
-                        this.onStatusChange?.();
-                    }
-                }, 60000);
+                this.responseBuffer = '';
+                this.setStatus('generating', 'autonomous_gen');
+                this.onStatusChange?.();
+            }
+        }
+
+        if (this.isWaitingForResponse) {
+            this.responseBuffer += cleanData;
+            if (this.idleTimeout) clearTimeout(this.idleTimeout);
+
+ // ─── Phase 3: still generating
+            if (patterns.generating.some(p => p.test(cleanData))) {
+                this.setStatus('generating', 'still_generating');
+                this.idleTimeout = setTimeout(() => {
+                    if (this.isWaitingForResponse) this.finishResponse();
+                }, this.timeouts.generatingIdle);
                 this.onStatusChange?.();
+                // Cancel any pending settle — we're clearly still generating
+                if (this.settleTimer) { clearTimeout(this.settleTimer); this.settleTimer = null; }
                 return;
             }
-            // In cooldown — don't set approval, but DO continue to other phases
         }
 
- // ─── Phase 3: Approval release
- // Accumulate chunks into approvalTransitionBuffer — the approval dialog clears via ANSI
- // sequences that strip to nothing, so we can't rely on a single cleanData chunk matching.
+ // ─── Phase 4: waiting_approval — accumulate transition buffer
         if (this.currentStatus === 'waiting_approval') {
             this.approvalTransitionBuffer = (this.approvalTransitionBuffer + cleanData).slice(-500);
+            // Schedule settle check — output may still be arriving (ANSI redraws etc)
+            this.scheduleSettle();
+            return;
+        }
+
+ // ─── Phase 5: settle debounce — schedule idle/approval evaluation
+        this.scheduleSettle();
+    }
+
+ /**
+  * Fired after output goes quiet for outputSettle ms.
+  * Evaluates the stabilised buffer for approval, prompt (idle), or timeout.
+  */
+    private scheduleSettle(): void {
+        if (this.settleTimer) clearTimeout(this.settleTimer);
+        this.settleTimer = setTimeout(() => {
+            this.settleTimer = null;
+            this.settledBuffer = this.recentOutputBuffer;
+            this.evaluateSettled();
+        }, this.timeouts.outputSettle);
+    }
+
+    private evaluateSettled(): void {
+        const { patterns } = this.provider;
+        const buf = this.settledBuffer;
+
+ // ─── waiting_approval: check for transition out
+        if (this.currentStatus === 'waiting_approval') {
             const genResume = patterns.generating.some(p => p.test(this.approvalTransitionBuffer));
             const promptResume = patterns.prompt.some(p => p.test(this.approvalTransitionBuffer));
             if (genResume) {
@@ -541,47 +562,56 @@ export class ProviderCliAdapter implements CliAdapter {
                 this.lastApprovalResolvedAt = Date.now();
                 this.finishResponse();
             }
+            // else: still waiting — approvalExitTimeout will handle the 60s safety case
             return;
         }
 
- // ─── Phase 4: autonomous generation detection (generating starts without sendMessage)
-        if (!this.isWaitingForResponse) {
-            if (patterns.generating.some(p => p.test(cleanData))) {
+ // ─── check for approval on stabilised buffer
+        const hasApproval = patterns.approval.some(p => p.test(buf));
+        if (hasApproval) {
+            const inCooldown = this.lastApprovalResolvedAt && (Date.now() - this.lastApprovalResolvedAt) < this.timeouts.approvalCooldown;
+            if (!inCooldown) {
+                const ctxLines = buf.split('\n')
+                    .map(l => l.trim())
+                    .filter(l => l && !/^[─═╭╮╰╯│]+$/.test(l));
                 this.isWaitingForResponse = true;
-                this.responseBuffer = '';
-                this.setStatus('generating', 'autonomous_gen');
+                this.setStatus('waiting_approval', 'approval_pattern');
+                this.recentOutputBuffer = '';
+                this.approvalTransitionBuffer = '';
+                this.activeModal = {
+                    message: ctxLines.slice(-5).join(' ').slice(0, 200) || 'Approval required',
+                    buttons: this.cliType === 'claude-cli'
+                        ? ['Yes (y)', 'Always allow (a)', 'Deny (Esc)']
+                        : ['Allow once', 'Always allow', 'Deny'],
+                };
+                if (this.idleTimeout) clearTimeout(this.idleTimeout);
+                if (this.approvalExitTimeout) clearTimeout(this.approvalExitTimeout);
+                this.approvalExitTimeout = setTimeout(() => {
+                    if (this.currentStatus === 'waiting_approval') {
+                        LOG.warn('CLI', `[${this.cliType}] Approval timeout — auto-exiting waiting_approval`);
+                        this.activeModal = null;
+                        this.lastApprovalResolvedAt = Date.now();
+                        this.recentOutputBuffer = '';
+                        this.approvalTransitionBuffer = '';
+                        this.approvalExitTimeout = null;
+                        this.setStatus(this.isWaitingForResponse ? 'generating' : 'idle', 'approval_cleared');
+                        this.onStatusChange?.();
+                    }
+                }, 60000);
                 this.onStatusChange?.();
+                return;
             }
         }
 
- // ─── Phase 5: response collect
+ // ─── check for prompt (idle) on stabilised buffer
         if (this.isWaitingForResponse) {
-            this.responseBuffer += cleanData;
-            if (this.idleTimeout) clearTimeout(this.idleTimeout);
-
-            const stillGenerating = patterns.generating.some(p => p.test(cleanData));
-            if (stillGenerating) {
-                this.setStatus('generating', 'still_generating');
-                this.idleTimeout = setTimeout(() => {
-                    if (this.isWaitingForResponse) this.finishResponse();
-                }, this.timeouts.generatingIdle);
-                this.onStatusChange?.();
-                return;
-            }
-
- // Prompt → response complete
- // Only check the LAST 2 lines of cleanData — the prompt appears at the very end of the
- // output stream. Checking the full chunk causes false positives when response content
- // has '>' in code blocks, shell examples, or mid-response lines.
-            const trailingLines = cleanData.split('\n').slice(-2).join('\n');
-            if (patterns.prompt.some(p => p.test(trailingLines))) {
-                // Guard: don't finishResponse if approval text is also present —
-                // Claude Code's approval UI can contain prompt-like characters
-                const hasApprovalHere = patterns.approval.some(p => p.test(this.recentOutputBuffer));
-                if (!hasApprovalHere) {
-                    this.finishResponse();
-                }
-            } else {
+            // Only look at the trailing portion — prompt appears at the very end
+            const trailingLines = buf.split('\n').slice(-3).join('\n');
+            if (patterns.prompt.some(p => p.test(trailingLines)) && !hasApproval) {
+                this.finishResponse();
+            } else if (!patterns.generating.some(p => p.test(buf))) {
+                // Output has settled with no generating signal and no prompt — schedule idle finish
+                if (this.idleTimeout) clearTimeout(this.idleTimeout);
                 this.idleTimeout = setTimeout(() => {
                     if (this.isWaitingForResponse && this.responseBuffer.trim()) {
                         this.finishResponse();
@@ -659,6 +689,7 @@ export class ProviderCliAdapter implements CliAdapter {
     cancel(): void { this.shutdown(); }
 
     shutdown(): void {
+        if (this.settleTimer) { clearTimeout(this.settleTimer); this.settleTimer = null; }
         if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
         if (this.ptyProcess) {
             this.ptyProcess.write('\x03');
@@ -730,6 +761,7 @@ export class ProviderCliAdapter implements CliAdapter {
             // Buffers
             startupBuffer: this.startupBuffer.slice(-500),
             recentOutputBuffer: this.recentOutputBuffer.slice(-500),
+            settledBuffer: this.settledBuffer.slice(-500),
             responseBuffer: this.responseBuffer.slice(-500),
             approvalTransitionBuffer: this.approvalTransitionBuffer.slice(-500),
             // State

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

@@ -117,39 +117,30 @@ export class ExtensionProviderInstance implements ProviderInstance {
     }
 
  // ─── status transition detect ──────────────────────────────
+    // NOTE: Extension transitions are TRACKED but NOT emitted as events.
+    // The parent IdeProviderInstance already emits identical events
+    // (generating_started, generating_completed, waiting_approval)
+    // via its own detectAgentTransitions(). Emitting here would cause
+    // duplicate toasts with slightly different content.
 
-    private detectTransition(newStatus: string, data: any): void {
+    private detectTransition(newStatus: string, _data: any): void {
         const now = Date.now();
         const agentStatus = (newStatus === 'streaming' || newStatus === 'generating') ? 'generating'
             : newStatus === 'waiting_approval' ? 'waiting_approval'
             : 'idle';
 
         if (agentStatus !== this.lastAgentStatus) {
-            const chatTitle = this.provider.name;
-
+            // Track generating start time (for monitor elapsed calculation)
             if (this.lastAgentStatus === 'idle' && agentStatus === 'generating') {
                 this.generatingStartedAt = now;
-                this.pushEvent({ event: 'agent:generating_started', chatTitle, timestamp: now });
-            } else if (agentStatus === 'waiting_approval') {
-                if (!this.generatingStartedAt) this.generatingStartedAt = now;
-                const msg = data?.activeModal?.message || data?.modalMessage;
-                this.pushEvent({
-                    event: 'agent:waiting_approval', chatTitle, timestamp: now,
-                    ideType: this.ideType,
-                    agentType: this.type,
-                    modalMessage: msg,
-                    modalButtons: data?.activeModal?.buttons || data?.modalButtons,
-                });
             } else if (agentStatus === 'idle' && (this.lastAgentStatus === 'generating' || this.lastAgentStatus === 'waiting_approval')) {
-                const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : 0;
-                this.pushEvent({ event: 'agent:generating_completed', chatTitle, duration, timestamp: now });
                 this.generatingStartedAt = 0;
             }
-
+            // Do NOT pushEvent for transitions — parent IDE instance handles these
             this.lastAgentStatus = agentStatus;
         }
 
- // Monitor check (cooldown based notification)
+ // Monitor check (cooldown based notification) — keep monitor events (long_generating etc)
         const agentKey = `${this.type}:ext`;
         const monitorEvents = this.monitor.check(agentKey, agentStatus, now);
         for (const me of monitorEvents) {