@adhdev/daemon-core 0.9.82-rc.267 → 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.267",
+  "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.267",
+    "@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/commands/chat-commands.ts

@@ -33,6 +33,13 @@ import { filterUserFacingChatMessages, normalizeChatMessages } from '../provider
 
 const RECENT_SEND_WINDOW_MS = 1200;
 export const READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25_000;
+// Minimum tail floor for hot-path history/mirror reads. The dashboard requests a
+// bounded tail (~60); we keep a small floor so a tiny requested tailLimit still
+// has enough surrounding context for seed/mirror dedup correctness, but it must
+// NOT dominate the hot subscribe/poll path the way the previous 200 floor did.
+// readChatHistory now serves this as an O(tail) bounded read, so the cost scales
+// with this floor, not with total accumulated history.
+const HOT_TAIL_MIN_LIMIT = 60;
 const HERMES_CLI_STARTING_SEND_SETTLE_MS = 2_000;
 // (A2.2) CLI_NATIVE_HISTORY_FRESH_MS removed with isNativeHistoryFreshEnough.
 // Hardcoded native-transcript provider allow-list. Deprecated. Kept only as a
@@ -963,7 +970,7 @@ function readExactRuntimeMirrorMessages(args: {
     const history = readChatHistory(
         args.providerType,
         0,
-        Math.max(args.tailLimit || 0, 200),
+        Math.max(args.tailLimit || 0, HOT_TAIL_MIN_LIMIT),
         targetSessionId,
         0,
         args.historyBehavior,
@@ -2206,7 +2213,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
             const nativeHistoryLimit = Math.max(
                 normalizeReadChatTailLimit(args) || 0,
                 returnedMessages.length,
-                200,
+                HOT_TAIL_MIN_LIMIT,
             );
             const nativeHistorySessionId = supportsNative
                 ? resolveCliNativeHistorySessionId(args, historySessionId, providerSessionId)

package/src/config/chat-history.ts

@@ -58,6 +58,40 @@ const savedHistoryFileSummaryCache = new Map<string, SavedHistoryFileSummaryCach
 const savedHistoryBackgroundRefresh = new Set<string>();
 const savedHistoryRollupInFlight = new Set<string>();
 
+// Bounded-tail read cache. The dashboard re-subscribes and polls hot sessions
+// every ~2.5s; without a cache each poll re-reads/parses/sorts the whole
+// conversation just to slice a small tail. We key on (type, sessionId,
+// pagination args) plus the on-disk size+mtime signature so an UNCHANGED
+// session returns the previously computed tail in O(1) and only re-reads when a
+// new message is appended (signature changes). The map is bounded by a small
+// LRU to keep memory flat regardless of how many sessions are touched.
+interface BoundedTailCacheEntry {
+    signature: string;
+    result: { messages: HistoryMessage[]; hasMore: boolean };
+}
+
+const BOUNDED_TAIL_CACHE_MAX_ENTRIES = 64;
+const boundedTailReadCache = new Map<string, BoundedTailCacheEntry>();
+
+function readBoundedTailCache(key: string, signature: string): { messages: HistoryMessage[]; hasMore: boolean } | null {
+    const cached = boundedTailReadCache.get(key);
+    if (!cached || cached.signature !== signature) return null;
+    // Refresh LRU recency.
+    boundedTailReadCache.delete(key);
+    boundedTailReadCache.set(key, cached);
+    return cached.result;
+}
+
+function writeBoundedTailCache(key: string, signature: string, result: { messages: HistoryMessage[]; hasMore: boolean }): void {
+    boundedTailReadCache.delete(key);
+    boundedTailReadCache.set(key, { signature, result });
+    while (boundedTailReadCache.size > BOUNDED_TAIL_CACHE_MAX_ENTRIES) {
+        const oldest = boundedTailReadCache.keys().next().value;
+        if (oldest === undefined) break;
+        boundedTailReadCache.delete(oldest);
+    }
+}
+
 interface HistoryMessage {
     ts: string;           // ISO timestamp
     receivedAt: number;   // epoch ms
@@ -1180,6 +1214,79 @@ function pageHistoryRecords(
     return { messages: sliced, hasMore: startInclusive > 0 };
 }
 
+// A finite tail request can be served by reading only the newest files instead
+// of the whole conversation. Treat very large limits (e.g. MAX_SAFE_INTEGER, or
+// anything past a generous ceiling) as a full-history request so restore/seed
+// callers keep their existing behavior.
+const BOUNDED_TAIL_MAX_LIMIT = 5_000;
+// Slack added to the requested window before sorting/dedup/collapse so the
+// boundary message at the top of the tail dedupes/collapses identically to a
+// full read. Modest and bounded — it only widens the parse window, not output.
+const BOUNDED_TAIL_SLACK = 50;
+
+function isBoundedTailRequest(limit: number, offset: number, excludeRecentCount: number): boolean {
+    const numericLimit = Number(limit);
+    if (!Number.isFinite(numericLimit) || numericLimit <= 0) return false;
+    if (numericLimit > BOUNDED_TAIL_MAX_LIMIT) return false;
+    const numericOffset = Number(offset);
+    const numericExclude = Number(excludeRecentCount);
+    if (!Number.isFinite(numericOffset) || !Number.isFinite(numericExclude)) return false;
+    return true;
+}
+
+// Read newest-first only as many files as needed to cover the requested window
+// plus slack. listHistoryFiles already returns files reversed (newest-first), so
+// we accumulate (de-duped) candidates from the end and stop once we have enough,
+// then hand the bounded window to pageHistoryRecords in chronological order.
+function readBoundedTailRecords(
+    agentType: string,
+    dir: string,
+    files: string[],
+    needed: number,
+): { records: HistoryMessage[]; readAllFiles: boolean } {
+    const collected: HistoryMessage[] = [];
+    const seen = new Set<string>();
+    let readAllFiles = true;
+
+    for (let f = 0; f < files.length; f++) {
+        const filePath = path.join(dir, files[f]);
+        let content: string;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        } catch {
+            continue;
+        }
+        const lines = content.trim().split('\n').filter(Boolean);
+        // Walk this file's lines newest-first so we fill the tail window from the
+        // bottom. seen-dedup keeps the same first-wins-by-newest semantics the
+        // full read produced (files are processed newest-first there too).
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                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);
+                collected.push(sanitizedMessage);
+            } catch { /* skip invalid lines */ }
+        }
+        // Stop once we have the window AND there is at least one more file (so a
+        // potential older boundary message exists). If this is the last file we
+        // fall through and mark the whole history as read.
+        if (collected.length >= needed && f < files.length - 1) {
+            readAllFiles = false;
+            break;
+        }
+    }
+
+    // collected is newest-first across the bounded window; restore chronological
+    // (oldest-first) order before paging. pageHistoryRecords re-sorts by
+    // receivedAt regardless, so this is purely for stable input ordering.
+    collected.reverse();
+    return { records: collected, readAllFiles };
+}
+
 export function readChatHistory(
     agentType: string,
     offset: number = 0,
@@ -1196,6 +1303,33 @@ export function readChatHistory(
  // JSONL file list — filter by persistent history key when specified
         const files = listHistoryFiles(dir, historySessionId);
 
+        const bounded = isBoundedTailRequest(limit, offset, excludeRecentCount);
+
+        if (bounded) {
+            const fileSignatures = buildSavedHistoryFileSignatureMap(dir, files);
+            const cacheKey = `${sanitized}\0${historySessionId || ''}\0${offset}\0${limit}\0${excludeRecentCount}\0${historyBehavior?.collapseConsecutiveAssistantTurns ? '1' : '0'}`;
+            const signature = buildSavedHistoryCacheSignature(files, fileSignatures);
+            const cached = readBoundedTailCache(cacheKey, signature);
+            if (cached) return cached;
+
+            // Window large enough that the top boundary dedupes/collapses the same
+            // as a full read. hasMore reflects whether older messages exist beyond
+            // the window we actually read.
+            const numericLimit = Math.max(1, Number(limit));
+            const numericOffset = Math.max(0, Number(offset));
+            const numericExclude = Math.max(0, Number(excludeRecentCount));
+            const needed = numericLimit + numericOffset + numericExclude + Math.max(BOUNDED_TAIL_SLACK, numericLimit);
+            const { records, readAllFiles } = readBoundedTailRecords(agentType, dir, files, needed);
+            const result = pageHistoryRecords(agentType, records, offset, limit, excludeRecentCount, historyBehavior);
+            // If we read every file, the conversation is fully represented in the
+            // window and pageHistoryRecords' hasMore is authoritative. If we
+            // stopped early there are older messages we never read, so hasMore
+            // must stay true regardless of the in-window slice position.
+            const boundedResult = readAllFiles ? result : { messages: result.messages, hasMore: true };
+            writeBoundedTailCache(cacheKey, signature, boundedResult);
+            return boundedResult;
+        }
+
         const allMessages: HistoryMessage[] = [];
         const seen = new Set<string>();
 

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
@@ -2135,6 +2209,14 @@ export class CliProviderInstance implements ProviderInstance {
             if (!materializeProviderNativeHistory(this.type, canonicalHistory, this.providerSessionId, this.workingDir, this.provider.scripts as any)) {
                 return false;
             }
+            // Full read is intentional: lastPersistedHistoryMessages is the COMPLETE
+            // session transcript — emitted as statusMessages and used as the
+            // prefix-comparison base for incremental appends — so a bounded tail
+            // would both truncate output and break prefix dedup. This is gated to
+            // once-per-2s (cache key above) for resume/manual launches only, so it
+            // does not run on the per-subscribe/per-poll dashboard tail path (that
+            // path goes through handleReadChat → readChatHistory with a bounded
+            // tailLimit, which is now O(tail)).
             const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
             this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
                 role: message.role,

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

package/src/providers/types/interactive-prompt.ts

@@ -346,11 +346,32 @@ export function buildClaudeInteractiveTuiAnswerSteps(
   if (response.promptId !== prompt.promptId) throw new Error('Interactive prompt response does not match active prompt');
   const steps: string[] = [];
   for (const question of prompt.questions) {
-    if (question.multiSelect) throw new Error('Claude TUI multi-select prompts are not supported yet');
     const answer = response.answers[question.questionId];
     if (!answer) throw new Error(`Missing answer for ${question.questionId}`);
     const freeformText = answer.freeformText?.trim() ?? '';
-    if (freeformText) {
+
+    if (question.multiSelect) {
+      // Multi-select: Claude TUI renders each option as a checkbox and the
+      // footer reads "Space to select". A numeric digit jumps the cursor to
+      // that option; Space toggles its checkbox. So for every selected label
+      // emit `[digit, ' ']` to land on it and toggle it on. After toggling all
+      // boxes for this question, Enter advances to the next question (or to the
+      // final confirm screen for the last question).
+      const labels = answer.selectedLabels;
+      if (labels.length === 0) {
+        throw new Error(`Expected at least one selected label for ${question.questionId}`);
+      }
+      for (const label of labels) {
+        const selectedIndex = question.options.findIndex(option => option.label === label);
+        if (selectedIndex < 0) throw new Error(`Unknown option for ${question.questionId}: ${label}`);
+        steps.push(String(selectedIndex + 1));
+        steps.push(' ');
+      }
+      // Confirm this question's checked set and move on. Unlike single-select
+      // (where the digit auto-advances), multi-select stays on the page until an
+      // explicit Enter so the user can toggle multiple boxes.
+      steps.push('\r');
+    } else if (freeformText) {
       // Freeform: select the "Type something." option (always the last visible
       // option before "Chat about this"), then type the text and confirm.
       const typeOptionIndex = question.options.findIndex(o => /^Type something\.?$/i.test(o.label));