@adhdev/daemon-core 0.9.82-rc.137 → 0.9.82-rc.138

package/src/cli-adapters/cli-state-engine.ts

@@ -93,6 +93,7 @@ const MAX_FINISH_RETRIES = 2;
 const FINISH_RETRY_DELAY_MS = 300;
 const MAX_TRACE_ENTRIES = 250;
 const APPROVAL_EXIT_TIMEOUT_MS = 60_000;
+const IDLE_CONFIRMATION_GRACE_MS = 2_000;
 
 // ─── Engine ────────────────────────────────────────────────────────────────
 
@@ -133,6 +134,21 @@ export class CliStateEngine {
     // ── Idle candidate ───────────────────────────────
     private idleFinishCandidate: IdleFinishCandidate | null = null;
 
+    // ── Idle confirmation grace ──────────────────────
+    /**
+     * `finishResponse` produces the `generating → idle` transition that
+     * coordinators interpret as "task complete". Some providers (antigravity-
+     * cli observed in the wild) briefly paint a screen that looks like an
+     * idle prompt between tool result frames while still actively running,
+     * which fired `response_finished` and broke completion semantics.
+     * We defer the actual idle transition by IDLE_CONFIRMATION_GRACE_MS and
+     * cancel it if the scripted detection re-detects generating during that
+     * window — a true completion stays idle for many seconds, so a 2-second
+     * grace is sufficient to filter the paint blip.
+     */
+    private pendingIdleFinishTimer: NodeJS.Timeout | null = null;
+    private pendingIdleFinishAt = 0;
+
     // ── Status history (debug) ───────────────────────
     private statusHistory: { status: string; at: number; trigger?: string }[] = [];
     private traceEntries: CliTraceEntry[] = [];
@@ -333,6 +349,7 @@ export class CliStateEngine {
         if (this.finishRetryTimer) { clearTimeout(this.finishRetryTimer); this.finishRetryTimer = null; }
         if (this.pendingScriptStatusTimer) { clearTimeout(this.pendingScriptStatusTimer); this.pendingScriptStatusTimer = null; }
         if (this.providerErrorRetryTimer) { clearTimeout(this.providerErrorRetryTimer); this.providerErrorRetryTimer = null; }
+        if (this.pendingIdleFinishTimer) { clearTimeout(this.pendingIdleFinishTimer); this.pendingIdleFinishTimer = null; this.pendingIdleFinishAt = 0; }
         this.providerErrorRetryKey = '';
     }
 
@@ -501,8 +518,19 @@ export class CliStateEngine {
             `[${this.provider.type}] settled diagnostics prompt=${JSON.stringify(this.currentTurnScope?.prompt || '').slice(0, 140)} status=${String(status || '')} parsedStatus=${String(parsedStatus || '')} parsedMsgCount=${parsedMessages.length} lastParsedAssistant=${JSON.stringify((lastParsedAssistant?.content || '').slice(0, 120)).slice(0, 160)} responseBuffer=${JSON.stringify((snap.responseBuffer || '').slice(0, 160)).slice(0, 220)}`
         );
 
-        const shouldHoldGenerating = status === 'idle' && this.isWaitingForResponse && !modal
-            && recentInteractiveActivity && !(parsedStatus === 'idle' && !!lastParsedAssistant);
+        // recent_activity_hold protects an in-flight user turn from a false
+        // idle blip. It must NOT fire during startup — when the adapter has
+        // no currentTurnScope, there is no user turn to protect; the recent
+        // activity is just the CLI painting its welcome screen. Firing here
+        // produced the startup status flip the user reported
+        // (generating → idle → generating → idle within the first few seconds
+        // of claude-cli launch).
+        const shouldHoldGenerating = status === 'idle'
+            && this.isWaitingForResponse
+            && !!this.currentTurnScope
+            && !modal
+            && recentInteractiveActivity
+            && !(parsedStatus === 'idle' && !!lastParsedAssistant);
 
         if (shouldHoldGenerating) { this.applyHoldGenerating(ctx); return; }
         if (status === 'error') {
@@ -588,20 +616,51 @@ export class CliStateEngine {
         if (!inCooldown) {
             if (!modal) {
                 LOG.warn('CLI', `[${this.provider.type}] detectStatus=waiting_approval but parseApproval returned null; ignoring`);
+                // (fix) If we previously surfaced waiting_approval but the
+                // modal extraction is now failing, do NOT keep the status
+                // pinned to waiting_approval forever — the dashboard would
+                // show a "waiting" badge with no buttons (activeModal=null)
+                // and the user perceives the agent as stuck. Drop the modal
+                // and fall back to generating so the rest of the run can
+                // settle normally; a future evaluate with a real modal will
+                // re-enter waiting_approval cleanly.
+                if (this.currentStatus === 'waiting_approval') {
+                    this.activeModal = null;
+                    this.setStatus('generating', 'approval_lost_modal');
+                    this.callbacks.onStatusChange();
+                }
                 return;
             }
             this.isWaitingForResponse = true;
             this.setStatus('waiting_approval', 'script_detect');
-            this.activeModal = modal;
+            // (fix) Don't overwrite an already-captured modal with a fresh
+            // re-parse on every evaluate — Claude TUI redraws option labels
+            // partially between paints (e.g. "Yes, and don't ask again for ..."
+            // is wider than the row and ships with a different trailing
+            // string each paint), which made the dashboard flap the modal
+            // signature continuously. Keep the first stable modal whose
+            // button count matches the latest parse; only swap when the
+            // shape clearly changed (different number of buttons → different
+            // approval).
+            const prev = this.activeModal;
+            const prevBtnCount = Array.isArray(prev?.buttons) ? prev!.buttons.length : 0;
+            const nextBtnCount = Array.isArray(modal.buttons) ? modal.buttons.length : 0;
+            if (!prev || prevBtnCount !== nextBtnCount) {
+                this.activeModal = modal;
+                this.callbacks.onStatusChange();
+            }
             if (this.idleTimeout) clearTimeout(this.idleTimeout);
             this.armApprovalExitTimeout();
-            this.callbacks.onStatusChange();
         }
     }
 
     private applyGenerating(ctx: SettledEvalContext): void {
         const { modal, parsedMessages, lastParsedAssistant, parsedStatus, prevStatus } = ctx;
         this.clearIdleFinishCandidate('generating');
+        // Cancel any pending grace-window idle transition. We have fresh
+        // evidence the provider is still generating; the previous
+        // finishResponse() was a paint blip, not a real completion.
+        this.cancelPendingIdleFinish('generating_signal_returned');
         const snap = this.transport.getSnapshot();
         const effectiveScreenText = snap.screenText || snap.accumulatedBuffer;
         const noActiveTurn = !this.currentTurnScope;
@@ -762,11 +821,49 @@ export class CliStateEngine {
         }
         this.resetActiveTurnState();
         this.callbacks.onTurnCompleted();
-        this.setStatus('idle', 'response_finished');
-        this.callbacks.onStatusChange();
+        // Defer the actual `generating → idle` transition by a short grace
+        // window. If applyGenerating fires again before the grace expires —
+        // antigravity's tool-result paint blips do this — cancelPendingIdle
+        // Finish() drops the pending transition and we stay generating.
+        this.scheduleIdleFinish('response_finished');
         this.transport.flushOutboundQueue();
     }
 
+    private scheduleIdleFinish(reason: string): void {
+        // If we are already deferring, replace the schedule so the most
+        // recent finishResponse "wins". Reasons accumulate via the trigger.
+        if (this.pendingIdleFinishTimer) clearTimeout(this.pendingIdleFinishTimer);
+        this.pendingIdleFinishAt = Date.now() + IDLE_CONFIRMATION_GRACE_MS;
+        this.pendingIdleFinishTimer = setTimeout(() => {
+            this.pendingIdleFinishTimer = null;
+            this.pendingIdleFinishAt = 0;
+            // If a new user turn started during the grace window, we owe
+            // generating semantics to that turn — do not retroactively idle.
+            if (this.isWaitingForResponse) return;
+            // The timer firing without a cancelPendingIdleFinish call means
+            // no fresh applyGenerating happened during the grace window;
+            // the previous fake-blip is over. Commit the idle.
+            //
+            // Note: the previous "currentStatus === 'generating' → return"
+            // guard caused stuck-generating sessions — finishResponse leaves
+            // currentStatus='generating' on purpose (so the dashboard keeps
+            // the spinner during the 2s grace), and then the timer fired
+            // without cancellation but refused to commit because the very
+            // status we are about to transition out of was still set.
+            // Re-checking currentStatus there meant idle was unreachable.
+            this.setStatus('idle', reason);
+            this.callbacks.onStatusChange();
+        }, IDLE_CONFIRMATION_GRACE_MS);
+    }
+
+    private cancelPendingIdleFinish(reason: string): void {
+        if (!this.pendingIdleFinishTimer) return;
+        clearTimeout(this.pendingIdleFinishTimer);
+        this.pendingIdleFinishTimer = null;
+        this.pendingIdleFinishAt = 0;
+        this.recordTrace('idle_finish_cancelled', { trigger: reason });
+    }
+
     // ─── Helpers ────────────────────────────────────────────────────────────
 
     private armApprovalExitTimeout(): void {

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

@@ -170,9 +170,10 @@ export class ProviderCliAdapter implements CliAdapter {
  // Resize redraw suppression
     private resizeSuppressUntil: number = 0;
 
-    // Native transcript anchor — when >0, native history was confirmed for this session.
-    // Prevents freshEnough flips caused by PTY buffer activity after the first successful native read.
-    nativeHistoryAnchoredAt: number = 0;
+    // (A2.2) Native transcript anchor moved to CHAT_SOURCE_REGISTRY.
+    // ChatSourceMachine holds the lock by state, not by a mutable field on
+    // the adapter. Removed entirely; no callers remain after the readChat
+    // ladder was replaced.
 
     // ─── Script runner (parsing isolated here, adapter stays as transport) ───
     private readonly runner: CliScriptRunner;
@@ -666,6 +667,14 @@ export class ProviderCliAdapter implements CliAdapter {
                 this.engine.lastApprovalResolvedAt = Date.now();
             }
             this.engine.activeModal = null;
+            // Clear the in-flight turn flag at the same time we declare
+            // startup-idle. Otherwise the next settled evaluation sees
+            // isWaitingForResponse=true + recent CLI welcome-screen paints
+            // and flips us right back to generating via the hold path
+            // (the "startup → generating → idle → generating → idle"
+            // flicker the user observed on claude-cli launch).
+            this.engine.isWaitingForResponse = false;
+            this.engine.currentTurnScope = null;
             this.engine.setStatus('idle', `startup_ready:${trigger}`);
         }
         LOG.info(
@@ -760,6 +769,7 @@ export class ProviderCliAdapter implements CliAdapter {
             isWaitingForResponse: this.engine.isWaitingForResponse,
             scope: this.engine.currentTurnScope,
             runtimeSettings: this.runtimeSettings,
+            spawnAt: this.spawnAt,
         });
         const session = this.runner.parseSession({
             ...input,
@@ -801,7 +811,7 @@ export class ProviderCliAdapter implements CliAdapter {
         const providerSessionId = typeof parsed?.providerSessionId === 'string' && parsed.providerSessionId.trim()
             ? parsed.providerSessionId.trim()
             : '';
-        if (providerSessionId) {
+        if (providerSessionId && providerSessionId !== this.providerSessionId) {
             this.providerSessionId = providerSessionId;
             this.updateRuntimeMeta({ providerSessionId });
         }
@@ -824,7 +834,42 @@ export class ProviderCliAdapter implements CliAdapter {
             : null;
         let effectiveStatus = this.projectEffectiveStatus(startupModal);
         let effectiveModal = startupModal || this.engine.activeModal;
-        if (startupDetectedStatus === 'waiting_approval') {
+        // (fix) When we have no captured modal yet, take one more live attempt
+        // with the current screen text — the engine's settle pass can miss
+        // the modal when it happens to fire exactly between writes, and
+        // without a modal here the dashboard could never show the buttons.
+        // We deliberately do NOT overwrite an existing engine.activeModal so
+        // a stable matched modal wins. This runs even outside the startup
+        // gate because Claude's approval frames can appear long after launch.
+        if (allowParse && !effectiveModal && this.engine.isWaitingForResponse) {
+            const liveDetect = this.runDetectStatus(this.recentOutputBuffer || this.terminalScreen.getText());
+            if (liveDetect === 'waiting_approval') {
+                const liveModal = this.runParseApproval(this.terminalScreen.getText())
+                    || this.runParseApproval(this.recentOutputBuffer);
+                if (liveModal) {
+                    effectiveModal = liveModal;
+                    // Promote so subsequent calls don't re-walk the buffer.
+                    // Only set if engine hasn't already captured one — keeps
+                    // the first stable modal as authoritative.
+                    if (!this.engine.activeModal) this.engine.activeModal = liveModal;
+                } else {
+                    LOG.warn('CLI', `[${this.cliType}] getStatus live re-extract: detect=waiting_approval but parseApproval still null (recentLen=${this.recentOutputBuffer.length} screenLen=${this.terminalScreen.getText().length})`);
+                }
+            } else if (liveDetect && liveDetect !== 'generating' && liveDetect !== 'idle') {
+                LOG.warn('CLI', `[${this.cliType}] getStatus live re-extract: detect=${liveDetect} (not waiting_approval)`);
+            } else if (this.engine.currentStatus === 'waiting_approval' && liveDetect !== 'waiting_approval') {
+                LOG.warn('CLI', `[${this.cliType}] getStatus live re-extract: engine.status=waiting_approval but live detect=${liveDetect}`);
+            }
+        } else if (!effectiveModal && this.engine.currentStatus === 'waiting_approval') {
+            LOG.warn('CLI', `[${this.cliType}] getStatus skipped live re-extract: allowParse=${allowParse} isWaitingForResponse=${this.engine.isWaitingForResponse}`);
+        }
+        // Only surface waiting_approval when we ALSO have a concrete modal
+        // (message + buttons). detectStatus alone can fire while parseApproval
+        // is still null — the engine logs "detectStatus=waiting_approval but
+        // parseApproval returned null; ignoring". Without this guard getStatus
+        // was shipping a bare waiting_approval with activeModal=null and the
+        // user perceived the flow as broken.
+        if (startupDetectedStatus === 'waiting_approval' && effectiveModal) {
             effectiveStatus = 'waiting_approval';
         } else if (startupDetectedStatus === 'idle' && !startupModal && !effectiveModal) {
             effectiveStatus = 'idle';
@@ -964,6 +1009,7 @@ export class ProviderCliAdapter implements CliAdapter {
             isWaitingForResponse: this.engine.isWaitingForResponse,
             scope: this.engine.currentTurnScope,
             runtimeSettings: this.runtimeSettings,
+            spawnAt: this.spawnAt,
         });
         return await Promise.resolve(this.runner.invokeByName(scriptName, {
             ...input,

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

@@ -43,6 +43,7 @@ export function buildCliParseInput(options: {
     isWaitingForResponse?: boolean;
     scope?: TurnParseScope | null;
     runtimeSettings: Record<string, any>;
+    spawnAt?: number;
 }): CliScriptInput {
     const {
         accumulatedBuffer,
@@ -57,6 +58,7 @@ export function buildCliParseInput(options: {
         isWaitingForResponse,
         scope,
         runtimeSettings,
+        spawnAt,
     } = options;
     const buffer = scope
         ? sliceFromOffset(accumulatedBuffer, scope.bufferStart)
@@ -84,6 +86,7 @@ export function buildCliParseInput(options: {
         isWaitingForResponse,
         promptText: scope?.prompt || '',
         settings: { ...runtimeSettings },
+        ...(typeof spawnAt === 'number' && spawnAt > 0 ? { spawnAt } : {}),
     };
 }
 

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

@@ -119,6 +119,7 @@ export interface CliScriptInput {
     promptText?: string;
     settings?: Record<string, any>;
     args?: Record<string, any>;
+    spawnAt?: number;
 }
 
 export interface CliStatusInput {
@@ -362,7 +363,18 @@ export class TerminalTranscriptAccumulator {
         this.ensureRow();
         if (final === 'A') this.row = Math.max(0, this.row - count);
         else if (final === 'B') this.row += count;
-        else if (final === 'C') this.col += count;
+        else if (final === 'C') {
+            // (fix) Cursor-forward must materialize spaces in the cells it
+            // skips, otherwise rendered transcripts collapse "Do you" written
+            // as "Do\x1b[1Cyou" into "Doyou". That mis-rendering broke
+            // Claude Code's approval-prompt and prompt-line detection
+            // (parseApproval saw "Doyouwanttoproceed?" and returned null).
+            const line = this.lines[this.row];
+            for (let c = this.col; c < this.col + count; c += 1) {
+                if (line[c] === undefined) line[c] = ' ';
+            }
+            this.col += count;
+        }
         else if (final === 'D') this.col = Math.max(0, this.col - count);
         else if (final === 'G') this.col = Math.max(0, count - 1);
         else if (final === 'H' || final === 'f') {

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

@@ -121,7 +121,23 @@ export class GhosttyVtTerminalBackend implements TerminalViewportBackend {
     }
 
     getText(): string {
-        return this.terminal.formatPlainText({ trim: true }) || '';
+        // (fix) ghostty's `trim:true` mode strips trailing whitespace per row
+        // AND collapses cells that were touched only by cursor-forward (ESC[<n>C)
+        // without a printable glyph. Many TUIs (Claude Code most prominently)
+        // render inter-word spaces via CUF rather than literal spaces, so
+        // trim:true would smash "Do you want to proceed?" into
+        // "Doyouwanttoproceed?" and break every downstream regex
+        // (approval detection, prompt-line discovery, etc.). Keep the per-row
+        // padding, then trim each row's trailing whitespace ourselves so the
+        // serialized text matches what the user sees in the terminal.
+        const raw = this.terminal.formatPlainText({ trim: false }) || '';
+        if (!raw) return '';
+        const lines = raw.split('\n').map((row) => row.replace(/\s+$/, ''));
+        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');
     }
 
     getCursorPosition(): { col: number; row: number } {

package/src/cli-adapters/terminal-backends/xterm-backend.ts

@@ -64,7 +64,14 @@ export class XtermTerminalBackend implements TerminalViewportBackend {
 
         for (let i = start; i < end; i++) {
             const line = buffer.getLine(i);
-            lines.push(line ? line.translateToString(true) : '');
+            // (fix) translateToString(true) strips trailing whitespace per row
+            // AND collapses cells touched only by cursor-forward (ESC[<n>C),
+            // so Claude Code's "Do you want to proceed?" arrives as
+            // "Doyouwanttoproceed?" — every downstream approval/prompt regex
+            // misses. Use false to preserve inter-word padding; we trim each
+            // row's trailing whitespace ourselves below.
+            const raw = line ? line.translateToString(false) : '';
+            lines.push(raw.replace(/\s+$/, ''));
         }
 
         let first = 0;