@adhdev/daemon-core 0.9.82-rc.268 → 0.9.82-rc.269

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

@@ -36,6 +36,18 @@ export declare class CliProviderInstance implements ProviderInstance {
     private cliArgs;
     readonly type: string;
     readonly category: "cli";
+    /**
+     * Quiet period an approval modal's signature must be stable before
+     * auto-approve sends the approve key. Guards against firing on a prompt
+     * that is still streaming into the PTY (the "resolves too fast" symptom):
+     * while the modal text/buttons are still changing, every frame yields a
+     * new signature and the settle clock restarts. Once the prompt finishes
+     * rendering the signature holds and the key is sent after this window.
+     * Bounded + small so genuine approvals stay timely. The FSM is already
+     * authoritative over the `waiting_approval` state; this only delays the
+     * keystroke until the modal *content* has settled.
+     */
+    private static readonly AUTO_APPROVE_SETTLE_MS;
     private adapter;
     private context;
     private events;
@@ -49,6 +61,9 @@ export declare class CliProviderInstance implements ProviderInstance {
     private autoApproveBusy;
     private autoApproveBusyTimer;
     private lastAutoApprovalSignature;
+    private pendingAutoApprovalSignature;
+    private pendingAutoApprovalSince;
+    private autoApproveSettleTimer;
     private controlValues;
     private summaryMetadata;
     private appliedEffectKeys;
@@ -139,6 +154,15 @@ export declare class CliProviderInstance implements ProviderInstance {
     private scheduleCompletedDebounceFlush;
     private flushCompletedDebounceIfFinalized;
     private maybeAutoApproveStatus;
+    /**
+     * Re-drive the auto-approve check after the settle quiet window elapses.
+     * The PTY may have gone silent once the approval prompt finished painting,
+     * so no status-change frame is guaranteed to re-enter maybeAutoApproveStatus
+     * — this timer-driven re-check picks up the now-settled modal and fires.
+     * Deliberately lighter than detectStatusTransition(): it only re-evaluates
+     * the approval decision; the next real PTY frame refreshes visible status.
+     */
+    private recheckAutoApproveSettled;
     private detectStatusTransition;
     private pushEvent;
     private flushEvents;

package/dist/providers/spec/adapter.d.ts

@@ -40,6 +40,13 @@ export declare class TerminalAdapter {
     start(): void;
     resize(cols: number, rows: number): void;
     snapshot(): string;
+    /**
+     * Full-buffer snapshot including scrollback history. Unlike snapshot()
+     * (visible viewport only), this survives a tall prompt whose top has
+     * scrolled off-screen — used for content-pattern extraction (modal
+     * buttons / approval anchors), NOT for cursor-relative conditions.
+     */
+    snapshotWithScrollback(): string;
     getCursorPosition(): {
         row: number;
         col: number;

package/dist/providers/spec/fsm-driver.d.ts

@@ -193,6 +193,10 @@ export declare class FsmDriver implements ISpecDriver {
         col: number;
     };
     getScreen(): string;
+    /** Scrollback-inclusive screen as line array — used only for modal/button
+     *  content extraction so a tall prompt's off-screen anchors stay matchable.
+     *  Falls back to the viewport snapshot if scrollback read is unavailable. */
+    private scrollbackLines;
     getSpecPath(): string;
     shutdown(): void;
     getFsmDebug(): {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.268",
+  "version": "0.9.82-rc.269",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.268",
+    "@adhdev/mesh-shared": "0.9.82-rc.269",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/cli-adapters/terminal-backends/ghostty-vt-backend.ts

@@ -106,25 +106,43 @@ export class GhosttyVtTerminalBackend implements TerminalViewportBackend {
         this.terminal.write(data);
     }
 
-    getText(): string {
-        if (this.disposed) return '';
+    private formatLines(): string[] {
         // ghostty's `trim:true` collapses CUF-advanced cells — many TUIs including
         // Claude Code render spaces via cursor-forward rather than literal spaces,
         // which would break downstream regex matching. Keep per-row padding and
         // trim trailing whitespace ourselves.
         //
         // formatPlainText uses a .screen pin which includes scrollback history.
-        // Slice to the last `rows` lines to get only the visible viewport.
         const raw = this.terminal.formatPlainText({ trim: false }) || '';
-        if (!raw) return '';
-        const lines = raw.split('\n').map((row) => row.replace(/\s+$/, ''));
+        if (!raw) return [];
+        return raw.split('\n').map((row) => row.replace(/\s+$/, ''));
+    }
+
+    private static trimBlankEnds(lines: string[]): string {
+        let first = 0;
+        let last = lines.length;
+        while (first < last && !lines[first]) first += 1;
+        while (last > first && !lines[last - 1]) last -= 1;
+        return lines.slice(first, last).join('\n');
+    }
+
+    getText(): string {
+        if (this.disposed) return '';
+        const lines = this.formatLines();
+        if (lines.length === 0) return '';
         // Take only the viewport (last `rows` lines) to exclude scrollback history.
         const viewport = lines.length > this.rows ? lines.slice(-this.rows) : lines;
-        let first = 0;
-        let last = viewport.length;
-        while (first < last && !viewport[first]) first += 1;
-        while (last > first && !viewport[last - 1]) last -= 1;
-        return viewport.slice(first, last).join('\n');
+        return GhosttyVtTerminalBackend.trimBlankEnds(viewport);
+    }
+
+    getTextWithScrollback(): string {
+        if (this.disposed) return '';
+        const lines = this.formatLines();
+        if (lines.length === 0) return '';
+        // Full buffer including scrollback — does NOT slice to the viewport, so a
+        // tall prompt whose top has scrolled above the visible rows is still
+        // matchable by content patterns.
+        return GhosttyVtTerminalBackend.trimBlankEnds(lines);
     }
 
     getCursorPosition(): { col: number; row: number } {

package/src/cli-adapters/terminal-backends/types.ts

@@ -11,6 +11,15 @@ export interface TerminalViewportBackend {
     resize(rows: number, cols: number): void;
     write(data: string): void;
     getText(): string;
+    /**
+     * Like getText() but includes scrollback history (the lines that have
+     * scrolled above the visible viewport). Used by content-pattern matching
+     * (e.g. approval/modal button extraction) that must stay correct when a
+     * tall prompt — a big diff or long explanation — pushes part of the
+     * prompt box above the viewport. NOT for cursor-relative / stable_ms
+     * conditions, whose row indices are viewport-relative.
+     */
+    getTextWithScrollback(): string;
     getCursorPosition(): { col: number; row: number };
     dispose(): void;
 }

package/src/cli-adapters/terminal-screen.ts

@@ -47,6 +47,11 @@ export class TerminalScreen {
         return this.terminal.getText();
     }
 
+    /** Full buffer including scrollback history (see backend doc). */
+    getTextWithScrollback(): string {
+        return this.terminal.getTextWithScrollback();
+    }
+
     getCursorPosition(): { col: number; row: number } {
         return this.terminal.getCursorPosition();
     }

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

@@ -350,6 +350,19 @@ export class CliProviderInstance implements ProviderInstance {
     readonly type: string;
     readonly category = 'cli' as const;
 
+    /**
+     * Quiet period an approval modal's signature must be stable before
+     * auto-approve sends the approve key. Guards against firing on a prompt
+     * that is still streaming into the PTY (the "resolves too fast" symptom):
+     * while the modal text/buttons are still changing, every frame yields a
+     * new signature and the settle clock restarts. Once the prompt finishes
+     * rendering the signature holds and the key is sent after this window.
+     * Bounded + small so genuine approvals stay timely. The FSM is already
+     * authoritative over the `waiting_approval` state; this only delays the
+     * keystroke until the modal *content* has settled.
+     */
+    private static readonly AUTO_APPROVE_SETTLE_MS = 600;
+
     private adapter: ProviderCliAdapter;
     private context: InstanceContext | null = null;
     private events: ProviderEvent[] = [];
@@ -363,6 +376,14 @@ export class CliProviderInstance implements ProviderInstance {
     private autoApproveBusy = false;
     private autoApproveBusyTimer: NodeJS.Timeout | null = null;
     private lastAutoApprovalSignature = '';
+    // Settle gate: the approval modal's signature + the wall-clock when this
+    // exact signature was first observed. Auto-approve only fires once the
+    // SAME signature has been stable for AUTO_APPROVE_SETTLE_MS, so a prompt
+    // still streaming into the PTY (its buttons/message changing frame to
+    // frame) keeps resetting the timer and is never approved half-rendered.
+    private pendingAutoApprovalSignature = '';
+    private pendingAutoApprovalSince = 0;
+    private autoApproveSettleTimer: NodeJS.Timeout | null = null;
     private controlValues: Record<string, string | number | boolean> = {};
     private summaryMetadata: unknown = undefined;
     private appliedEffectKeys = new Set<string>();
@@ -951,6 +972,10 @@ export class CliProviderInstance implements ProviderInstance {
     dispose(): void {
         this.adapter.shutdown();
         this.monitor.reset();
+        // Cancel any armed auto-approve timers so a pending settle re-check
+        // can't fire resolveModal/detectStatusTransition against a dead adapter.
+        if (this.autoApproveSettleTimer) { clearTimeout(this.autoApproveSettleTimer); this.autoApproveSettleTimer = null; }
+        if (this.autoApproveBusyTimer) { clearTimeout(this.autoApproveBusyTimer); this.autoApproveBusyTimer = null; }
         this.appliedEffectKeys.clear();
         try { this.cachedSqliteDb?.close(); } catch { /* noop */ }
         this.cachedSqliteDb = null;
@@ -1373,6 +1398,11 @@ export class CliProviderInstance implements ProviderInstance {
         // still inside the short busy window.
         if (!autoApproveActive) {
             this.lastAutoApprovalSignature = '';
+            // Clear the settle gate so the next approval starts its own quiet
+            // window from scratch (a stale timestamp would let it fire instantly).
+            this.pendingAutoApprovalSignature = '';
+            this.pendingAutoApprovalSince = 0;
+            if (this.autoApproveSettleTimer) { clearTimeout(this.autoApproveSettleTimer); this.autoApproveSettleTimer = null; }
             return autoApproveActive;
         }
         const modal = adapterStatus.activeModal;
@@ -1410,23 +1440,67 @@ export class CliProviderInstance implements ProviderInstance {
             buttons.join('|'),
             buttonIndex,
         ].join('::');
-        if (!this.autoApproveBusy || signature !== this.lastAutoApprovalSignature) {
-            this.autoApproveBusy = true;
-            this.lastAutoApprovalSignature = signature;
-            if (this.autoApproveBusyTimer) clearTimeout(this.autoApproveBusyTimer);
-            this.autoApproveBusyTimer = setTimeout(() => {
-                this.autoApproveBusy = false;
-                this.autoApproveBusyTimer = null;
-                this.lastAutoApprovalSignature = '';
-            }, 5000);
-            this.recordAutoApproval(modal?.message, buttonLabel, now);
-            setTimeout(() => {
-                this.adapter.resolveModal(buttonIndex);
-            }, 0);
+        // Already fired for this exact modal and still inside the busy window —
+        // nothing to do (re-entry guard for repeated snapshots of one modal).
+        if (this.autoApproveBusy && signature === this.lastAutoApprovalSignature) {
+            return autoApproveActive;
         }
+
+        // Settle gate: only fire once this exact signature has been stable for
+        // AUTO_APPROVE_SETTLE_MS. A still-streaming prompt mutates its
+        // message/buttons each frame → new signature → clock restarts, so we
+        // never approve a half-rendered prompt (the "resolves too fast" bug).
+        if (signature !== this.pendingAutoApprovalSignature) {
+            this.pendingAutoApprovalSignature = signature;
+            this.pendingAutoApprovalSince = now;
+        }
+        const settledForMs = now - this.pendingAutoApprovalSince;
+        if (settledForMs < CliProviderInstance.AUTO_APPROVE_SETTLE_MS) {
+            // Not yet settled. Arm a timer to re-check after the remaining quiet
+            // window — the PTY may go silent once the prompt finishes painting,
+            // so there is no guaranteed status-change frame to re-drive us.
+            if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
+            this.autoApproveSettleTimer = setTimeout(() => {
+                this.autoApproveSettleTimer = null;
+                this.recheckAutoApproveSettled();
+            }, CliProviderInstance.AUTO_APPROVE_SETTLE_MS - settledForMs + 20);
+            return autoApproveActive;
+        }
+
+        // Settled — fire the approve key.
+        if (this.autoApproveSettleTimer) { clearTimeout(this.autoApproveSettleTimer); this.autoApproveSettleTimer = null; }
+        this.autoApproveBusy = true;
+        this.lastAutoApprovalSignature = signature;
+        this.pendingAutoApprovalSignature = '';
+        this.pendingAutoApprovalSince = 0;
+        if (this.autoApproveBusyTimer) clearTimeout(this.autoApproveBusyTimer);
+        this.autoApproveBusyTimer = setTimeout(() => {
+            this.autoApproveBusy = false;
+            this.autoApproveBusyTimer = null;
+            this.lastAutoApprovalSignature = '';
+        }, 5000);
+        this.recordAutoApproval(modal?.message, buttonLabel, now);
+        setTimeout(() => {
+            this.adapter.resolveModal(buttonIndex);
+        }, 0);
         return autoApproveActive;
     }
 
+    /**
+     * Re-drive the auto-approve check after the settle quiet window elapses.
+     * The PTY may have gone silent once the approval prompt finished painting,
+     * so no status-change frame is guaranteed to re-enter maybeAutoApproveStatus
+     * — this timer-driven re-check picks up the now-settled modal and fires.
+     * Deliberately lighter than detectStatusTransition(): it only re-evaluates
+     * the approval decision; the next real PTY frame refreshes visible status.
+     */
+    private recheckAutoApproveSettled(): void {
+        try {
+            const adapterStatus = this.adapter.getStatus({ allowParse: false });
+            this.maybeAutoApproveStatus(adapterStatus, Date.now());
+        } catch { /* adapter gone / transient — next frame retries */ }
+    }
+
     private detectStatusTransition(): void {
         const now = Date.now();
         // Status-change handling is a hot path: PTY output can fire it many times

package/src/providers/spec/adapter.ts

@@ -104,6 +104,16 @@ export class TerminalAdapter {
         return this.lastScreen || this.computeScreen();
     }
 
+    /**
+     * Full-buffer snapshot including scrollback history. Unlike snapshot()
+     * (visible viewport only), this survives a tall prompt whose top has
+     * scrolled off-screen — used for content-pattern extraction (modal
+     * buttons / approval anchors), NOT for cursor-relative conditions.
+     */
+    snapshotWithScrollback(): string {
+        return this.screen.getTextWithScrollback();
+    }
+
     getCursorPosition(): { row: number; col: number } {
         const pos = this.screen.getCursorPosition();
         return { row: pos.row, col: pos.col };

package/src/providers/spec/fsm-driver.ts

@@ -267,6 +267,18 @@ export class FsmDriver implements ISpecDriver {
     snapshot(): string { return this.adapter.snapshot(); }
     getCursorPosition(): { row: number; col: number } { return this.adapter.getCursorPosition(); }
     getScreen(): string { return this.adapter.snapshot(); }
+
+    /** Scrollback-inclusive screen as line array — used only for modal/button
+     *  content extraction so a tall prompt's off-screen anchors stay matchable.
+     *  Falls back to the viewport snapshot if scrollback read is unavailable. */
+    private scrollbackLines(): string[] {
+        let screen = '';
+        try {
+            screen = this.adapter.snapshotWithScrollback();
+        } catch { /* fall through to viewport */ }
+        if (!screen) screen = this.adapter.snapshot();
+        return screen.split('\n').map(l => l.endsWith('\r') ? l.slice(0, -1) : l);
+    }
     getSpecPath(): string { return this.opts.specPath; }
 
     shutdown(): void {
@@ -484,9 +496,26 @@ export class FsmDriver implements ISpecDriver {
         const lines = screen.split('\n').map(l => l.endsWith('\r') ? l.slice(0, -1) : l);
         const sections = resolveSections(this.spec.sections ?? {}, lines);
 
-        const modal = this.deriveModal(state, sections, lines.join('\n'));
+        // Modal states (approval / picker) extract their buttons + title from a
+        // SCROLLBACK-INCLUSIVE buffer: claude-cli renders an approval as a box,
+        // and when the prompt body (a big diff / long explanation) is tall the
+        // top of the box — including the `─────` separator that anchors the
+        // `modal` section — scrolls above the viewport. Matching only the
+        // viewport then yields < min_count buttons, deriveModal returns null,
+        // and auto-approve never fires (the "long prompts never auto-approve"
+        // bug). The viewport stays authoritative for transitions / cursor
+        // conditions; only this content-pattern extraction reads scrollback.
+        const modalLines = state.modal
+            ? this.scrollbackLines()
+            : lines;
+        const modalSections = state.modal
+            ? resolveSections(this.spec.sections ?? {}, modalLines)
+            : sections;
+        const modalFullScreen = modalLines.join('\n');
+
+        const modal = this.deriveModal(state, modalSections, modalFullScreen);
         const controls = this.deriveControls(state.id);
-        const title = modal?.title ?? this.deriveTitle(state, sections, lines.join('\n'));
+        const title = modal?.title ?? this.deriveTitle(state, modalSections, modalFullScreen);
 
         const next: CurrentEval = {
             // status is derived from the FSM state itself (statusForState), NOT from