@adhdev/daemon-core 0.9.82-rc.11 → 0.9.82-rc.111

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

@@ -110,6 +110,14 @@ interface SendMessageCompletion {
     rejectOnce: (error: unknown) => void;
 }
 
+interface PendingOutboundMessage {
+    id: string;
+    role: 'user';
+    content: string;
+    queuedAt: number;
+    source: 'sendMessage';
+}
+
 export function appendBoundedText(current: string, chunk: string, maxChars: number): string {
     if (!chunk) return current.length <= maxChars ? current : current.slice(-maxChars);
     if (maxChars <= 0) return '';
@@ -137,6 +145,9 @@ export class ProviderCliAdapter implements CliAdapter {
     private isWaitingForResponse = false;
     private activeModal: { message: string; buttons: string[] } | null = null;
     private parseErrorMessage: string | null = null;
+    private providerSessionId: string | null = null;
+    private providerErrorMessage: string | null = null;
+    private providerErrorReason: string | null = null;
     private responseTimeout: NodeJS.Timeout | null = null;
     private idleTimeout: NodeJS.Timeout | null = null;
     private ready = false;
@@ -186,6 +197,11 @@ export class ProviderCliAdapter implements CliAdapter {
     private idleFinishCandidate: IdleFinishCandidate | null = null;
     private finishRetryTimer: NodeJS.Timeout | null = null;
     private finishRetryCount = 0;
+    private pendingOutboundQueue: PendingOutboundMessage[] = [];
+    private pendingOutboundFlushTimer: NodeJS.Timeout | null = null;
+    private pendingOutboundFlushInFlight = false;
+    private providerErrorRetryTimer: NodeJS.Timeout | null = null;
+    private providerErrorRetryKey = '';
 
  // Resize redraw suppression
     private resizeSuppressUntil: number = 0;
@@ -761,6 +777,17 @@ export class ProviderCliAdapter implements CliAdapter {
         if (stableMs < 2000) return;
 
         const startupModal = this.runParseApproval(this.recentOutputBuffer);
+        const startupStatus = this.runDetectStatus(screenText || this.recentOutputBuffer);
+        if (!startupModal && startupStatus !== 'idle') {
+            this.recordTrace('startup_settle_deferred', {
+                trigger,
+                startupStatus,
+                stableMs,
+                screenText: summarizeCliTraceText(screenText, 500),
+            });
+            this.scheduleStartupSettleCheck();
+            return;
+        }
         this.startupParseGate = false;
         if (this.startupSettleTimer) {
             clearTimeout(this.startupSettleTimer);
@@ -934,6 +961,8 @@ export class ProviderCliAdapter implements CliAdapter {
         if (this.pendingScriptStatusTimer) { clearTimeout(this.pendingScriptStatusTimer); this.pendingScriptStatusTimer = null; }
         if (this.pendingOutputParseTimer) { clearTimeout(this.pendingOutputParseTimer); this.pendingOutputParseTimer = null; }
         if (this.ptyOutputFlushTimer) { clearTimeout(this.ptyOutputFlushTimer); this.ptyOutputFlushTimer = null; }
+        if (this.providerErrorRetryTimer) { clearTimeout(this.providerErrorRetryTimer); this.providerErrorRetryTimer = null; }
+        this.providerErrorRetryKey = '';
     }
 
     private clearStaleIdleResponseGuard(reason: string): boolean {
@@ -956,6 +985,38 @@ export class ProviderCliAdapter implements CliAdapter {
         return true;
     }
 
+    private clearParsedIdleResponseGuard(reason: string, parsedStatus: any): boolean {
+        const parsedRawStatus = typeof parsedStatus?.status === 'string' ? parsedStatus.status.trim() : '';
+        const parsedModal = parsedStatus?.activeModal ?? parsedStatus?.modal ?? null;
+        const blockingModal = this.activeModal || this.runParseApproval(this.recentOutputBuffer);
+        if (
+            !this.isWaitingForResponse
+            || parsedRawStatus !== 'idle'
+            || !!parsedModal
+            || !!blockingModal
+            || !this.parsedStatusHasFinalAssistantMessage(parsedStatus)
+        ) {
+            return false;
+        }
+        this.clearAllTimers();
+        this.clearIdleFinishCandidate(reason);
+        this.responseBuffer = '';
+        this.isWaitingForResponse = false;
+        this.responseSettleIgnoreUntil = 0;
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = '';
+        this.finishRetryCount = 0;
+        this.currentTurnScope = null;
+        this.activeModal = null;
+        this.setStatus('idle', reason);
+        this.recordTrace('parsed_idle_response_cleared', {
+            reason,
+            parsedStatus: parsedRawStatus,
+            parsedMessageCount: Array.isArray(parsedStatus?.messages) ? parsedStatus.messages.length : 0,
+        });
+        return true;
+    }
+
     private hasMeaningfulResponseBuffer(promptSnippet: string): boolean {
         const raw = String(this.responseBuffer || '').trim();
         if (!raw) return false;
@@ -1097,6 +1158,11 @@ export class ProviderCliAdapter implements CliAdapter {
             && !(parsedStatus === 'idle' && !!lastParsedAssistant);
 
         if (shouldHoldGenerating) { this.applyHoldGenerating(ctx, recentInteractiveActivity); return; }
+        if (status === 'error') {
+            if (this.maybeScheduleProviderErrorRetry(ctx, session)) return;
+            this.applyError(ctx, session);
+            return;
+        }
         if (status === 'waiting_approval') { this.applyWaitingApproval(ctx); return; }
         if (status === 'generating') { this.applyGenerating(ctx); return; }
         if (status === 'idle') { this.applyIdle(ctx, now); }
@@ -1240,6 +1306,107 @@ export class ProviderCliAdapter implements CliAdapter {
         this.onStatusChange?.();
     }
 
+    private applyError(ctx: SettledEvalContext, session: ParsedSession): void {
+        this.clearIdleFinishCandidate('provider_error');
+        if (this.responseTimeout) { clearTimeout(this.responseTimeout); this.responseTimeout = null; }
+        if (this.idleTimeout) { clearTimeout(this.idleTimeout); this.idleTimeout = null; }
+        if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
+        this.isWaitingForResponse = false;
+        this.responseSettleIgnoreUntil = 0;
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = '';
+        this.finishRetryCount = 0;
+        this.currentTurnScope = null;
+        this.activeModal = null;
+        this.providerErrorMessage = typeof session.errorMessage === 'string' && session.errorMessage.trim()
+            ? session.errorMessage.trim()
+            : 'Provider reported an error';
+        this.providerErrorReason = typeof session.errorReason === 'string' && session.errorReason.trim()
+            ? session.errorReason.trim()
+            : 'provider_error';
+        this.setStatus('error', this.providerErrorReason);
+        this.recordTrace('provider_error', {
+            errorMessage: this.providerErrorMessage,
+            errorReason: this.providerErrorReason,
+            parsedStatus: ctx.parsedStatus || ctx.status,
+            messageCount: ctx.parsedMessages.length,
+            ...buildCliTraceParseSnapshot({
+                accumulatedBuffer: this.accumulatedBuffer,
+                accumulatedRawBuffer: this.accumulatedRawBuffer,
+                responseBuffer: this.responseBuffer,
+                partialResponse: this.responseBuffer,
+                scope: this.currentTurnScope,
+            }),
+        });
+        this.onStatusChange?.();
+    }
+
+    private maybeScheduleProviderErrorRetry(ctx: SettledEvalContext, session: ParsedSession): boolean {
+        const retryPrompt = typeof (session as any).retryPrompt === 'string'
+            ? String((session as any).retryPrompt).trim()
+            : '';
+        const retryDelayMs = typeof (session as any).retryDelayMs === 'number'
+            ? Number((session as any).retryDelayMs)
+            : NaN;
+        if (!retryPrompt || !Number.isFinite(retryDelayMs) || retryDelayMs < 0) return false;
+        if (!this.ptyProcess) return false;
+
+        const retryAttempt = typeof (session as any).retryAttempt === 'number'
+            ? Number((session as any).retryAttempt)
+            : 0;
+        const retryMaxAttempts = typeof (session as any).retryMaxAttempts === 'number'
+            ? Number((session as any).retryMaxAttempts)
+            : 0;
+        const errorReason = typeof session.errorReason === 'string' && session.errorReason.trim()
+            ? session.errorReason.trim()
+            : 'provider_error';
+        const retryKey = `${errorReason}:${retryAttempt}:${retryPrompt}`;
+        if (this.providerErrorRetryTimer && this.providerErrorRetryKey === retryKey) return true;
+
+        if (this.providerErrorRetryTimer) clearTimeout(this.providerErrorRetryTimer);
+        this.providerErrorRetryKey = retryKey;
+        this.clearIdleFinishCandidate('provider_error_retry');
+        if (this.idleTimeout) { clearTimeout(this.idleTimeout); this.idleTimeout = null; }
+        if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
+        this.providerErrorMessage = typeof session.errorMessage === 'string' && session.errorMessage.trim()
+            ? session.errorMessage.trim()
+            : 'Provider reported an error';
+        this.providerErrorReason = errorReason;
+        this.activeModal = null;
+        this.responseSettleIgnoreUntil = Date.now() + retryDelayMs + this.timeouts.outputSettle + 400;
+        this.setStatus('generating', 'provider_error_retry_scheduled');
+        this.recordTrace('provider_error_retry_scheduled', {
+            retryPrompt,
+            retryDelayMs,
+            retryAttempt,
+            retryMaxAttempts,
+            errorReason,
+            parsedStatus: ctx.parsedStatus || ctx.status,
+        });
+        this.onStatusChange?.();
+        this.providerErrorRetryTimer = setTimeout(() => {
+            this.providerErrorRetryTimer = null;
+            this.providerErrorRetryKey = '';
+            if (!this.ptyProcess) return;
+            this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
+            this.submitRetryUsed = false;
+            this.recordTrace('provider_error_retry_write', {
+                retryPrompt,
+                retryAttempt,
+                retryMaxAttempts,
+                errorReason,
+            });
+            this.ptyProcess.write(`${retryPrompt}\r`);
+            if (this.settleTimer) clearTimeout(this.settleTimer);
+            this.settleTimer = setTimeout(() => {
+                this.settleTimer = null;
+                this.settledBuffer = this.recentOutputBuffer;
+                this.evaluateSettled();
+            }, this.timeouts.outputSettle + 150);
+        }, retryDelayMs);
+        return true;
+    }
+
     private applyIdle(ctx: SettledEvalContext, now: number): void {
         const { modal, lastParsedAssistant, prevStatus } = ctx;
         if (prevStatus === 'waiting_approval') {
@@ -1318,6 +1485,11 @@ export class ProviderCliAdapter implements CliAdapter {
         this.idleTimeout = setTimeout(() => {
             if (this.isWaitingForResponse && !this.hasActionableApproval()) {
                 if (this.shouldDeferIdleTimeoutFinish()) return;
+                const parsed = this.runParseSession();
+                if (this.shouldKeepCodexTurnOpenForFinish(parsed)) {
+                    this.rescheduleCodexFinishCheck('codex_idle_timeout_not_final');
+                    return;
+                }
                 this.clearIdleFinishCandidate('idle_timeout_finish');
                 this.finishResponse();
             }
@@ -1327,6 +1499,11 @@ export class ProviderCliAdapter implements CliAdapter {
     private finishResponse(): void {
         if (this.submitPendingUntil > Date.now()) return;
         if (this.responseSettleIgnoreUntil > Date.now()) return;
+        const parsedBeforeFinish = this.runParseSession();
+        if (this.shouldKeepCodexTurnOpenForFinish(parsedBeforeFinish)) {
+            this.rescheduleCodexFinishCheck('codex_finish_not_final');
+            return;
+        }
         this.clearIdleFinishCandidate('finish_response_enter');
         this.recordTrace('finish_response', {
             ...buildCliTraceParseSnapshot({
@@ -1372,6 +1549,7 @@ export class ProviderCliAdapter implements CliAdapter {
         this.activeModal = null;
         this.setStatus('idle', 'response_finished');
         this.onStatusChange?.();
+        this.schedulePendingOutboundFlush();
     }
 
     private maybeCommitVisibleIdleTranscript(session: ParsedSession, parsedMessages: CliChatMessage[]): boolean {
@@ -1402,6 +1580,7 @@ export class ProviderCliAdapter implements CliAdapter {
         this.activeModal = null;
         this.setStatus('idle', 'script_idle_commit');
         this.onStatusChange?.();
+        this.schedulePendingOutboundFlush();
         this.recordTrace('script_idle_commit', {
             messageCount: parsedMessages.length,
             lastAssistant: summarizeCliTraceText(visibleAssistant.content, 320),
@@ -1489,6 +1668,7 @@ export class ProviderCliAdapter implements CliAdapter {
                 accumulatedRawBuffer: this.accumulatedRawBuffer,
                 recentOutputBuffer: this.recentOutputBuffer,
                 terminalScreenText: parseScreenText,
+                workingDir: this.workingDir,
                 baseMessages: [],
                 partialResponse: this.responseBuffer,
                 isWaitingForResponse: this.isWaitingForResponse,
@@ -1500,6 +1680,7 @@ export class ProviderCliAdapter implements CliAdapter {
                 { ...input, tail, tailScreen: buildCliScreenSnapshot(tail) },
             );
             this.parseErrorMessage = null;
+            if (session && typeof session === 'object') this.applyParsedSessionMetadata(session);
             return session && typeof session === 'object' ? session : null;
         } catch (e: any) {
             const message = e?.message || String(e);
@@ -1552,6 +1733,74 @@ export class ProviderCliAdapter implements CliAdapter {
         return !!(startupModal || this.activeModal);
     }
 
+    private parsedStatusHasFinalAssistantMessage(parsed: any): boolean {
+        const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
+        const lastAssistant = [...messages].reverse().find((message: any) => {
+            if (!message || message.role !== 'assistant') return false;
+            return typeof message.content === 'string' && message.content.trim().length > 0;
+        });
+        return !!lastAssistant;
+    }
+
+    private applyParsedSessionMetadata(parsed: any): void {
+        const providerSessionId = typeof parsed?.providerSessionId === 'string' && parsed.providerSessionId.trim()
+            ? parsed.providerSessionId.trim()
+            : '';
+        if (providerSessionId) {
+            this.providerSessionId = providerSessionId;
+            this.updateRuntimeMeta({ providerSessionId });
+        }
+        this.providerErrorMessage = typeof parsed?.errorMessage === 'string' && parsed.errorMessage.trim()
+            ? parsed.errorMessage.trim()
+            : null;
+        this.providerErrorReason = typeof parsed?.errorReason === 'string' && parsed.errorReason.trim()
+            ? parsed.errorReason.trim()
+            : null;
+    }
+
+    private parsedStatusHasFinalStandardAssistantMessage(parsed: any): boolean {
+        const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
+        const lastAssistant = [...messages].reverse().find((message: any) => {
+            if (!message || message.role !== 'assistant') return false;
+            return typeof message.content === 'string' && message.content.trim().length > 0;
+        });
+        if (!lastAssistant) return false;
+        const kind = typeof lastAssistant.kind === 'string' && lastAssistant.kind.trim()
+            ? lastAssistant.kind.trim()
+            : 'standard';
+        return kind === 'standard' && lastAssistant.meta?.streaming !== true;
+    }
+
+    private shouldKeepCodexTurnOpenForFinish(parsed: any): boolean {
+        if (this.cliType !== 'codex-cli') return false;
+        if (!this.isWaitingForResponse || !this.currentTurnScope || this.hasActionableApproval()) return false;
+        const parsedStatus = typeof parsed?.status === 'string' ? parsed.status.trim() : '';
+        if (parsedStatus !== 'idle') return true;
+        if (parsed?.activeModal || parsed?.modal) return true;
+        return !this.parsedStatusHasFinalStandardAssistantMessage(parsed);
+    }
+
+    private rescheduleCodexFinishCheck(reason: string): void {
+        this.clearIdleFinishCandidate(reason);
+        this.setStatus('generating', reason);
+        if (this.idleTimeout) clearTimeout(this.idleTimeout);
+        this.idleTimeout = setTimeout(() => {
+            if (!this.isWaitingForResponse || this.hasActionableApproval()) return;
+            this.settledBuffer = this.recentOutputBuffer;
+            this.evaluateSettled();
+        }, this.getIdleFinishConfirmMs());
+        this.recordTrace('codex_finish_deferred', {
+            reason,
+            ...buildCliTraceParseSnapshot({
+                accumulatedBuffer: this.accumulatedBuffer,
+                accumulatedRawBuffer: this.accumulatedRawBuffer,
+                responseBuffer: this.responseBuffer,
+                partialResponse: this.responseBuffer,
+                scope: this.currentTurnScope,
+            }),
+        });
+    }
+
     private projectEffectiveStatus(startupModal: { message: string; buttons: string[] } | null = null): CliSessionStatus['status'] {
         if (this.parseErrorMessage) return 'error';
         if (this.hasActionableApproval(startupModal)) return 'waiting_approval';
@@ -1564,8 +1813,16 @@ export class ProviderCliAdapter implements CliAdapter {
     getStatus(options: { allowParse?: boolean } = {}): CliSessionStatus {
         const allowParse = options.allowParse !== false;
         const startupModal = allowParse && this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
+        const startupDetectedStatus = allowParse && this.startupParseGate && !startupModal
+            ? this.runDetectStatus(this.recentOutputBuffer || this.terminalScreen.getText())
+            : null;
         let effectiveStatus = this.projectEffectiveStatus(startupModal);
         let effectiveModal = startupModal || this.activeModal;
+        if (startupDetectedStatus === 'waiting_approval') {
+            effectiveStatus = 'waiting_approval';
+        } else if (startupDetectedStatus === 'idle' && !startupModal && !effectiveModal) {
+            effectiveStatus = 'idle';
+        }
         if (allowParse && !startupModal && !effectiveModal) {
             const parsed = this.getFreshParsedStatusCache();
             const parsedModal = parsed?.activeModal && Array.isArray(parsed.activeModal.buttons)
@@ -1575,6 +1832,18 @@ export class ProviderCliAdapter implements CliAdapter {
             if (parsed?.status === 'waiting_approval' && parsedModal) {
                 effectiveStatus = 'waiting_approval';
                 effectiveModal = parsedModal;
+            } else if (
+                effectiveStatus === 'idle'
+                && parsed?.status === 'generating'
+                && !this.parsedStatusHasFinalAssistantMessage(parsed)
+            ) {
+                effectiveStatus = 'generating';
+            } else if (
+                effectiveStatus === 'generating'
+                && parsed?.status === 'idle'
+                && this.parsedStatusHasFinalAssistantMessage(parsed)
+            ) {
+                effectiveStatus = 'idle';
             }
         }
         const bufferState = this.getBufferState();
@@ -1583,8 +1852,17 @@ export class ProviderCliAdapter implements CliAdapter {
             messages: [],
             workingDir: this.workingDir,
             activeModal: effectiveModal,
-            errorMessage: this.parseErrorMessage || undefined,
-            errorReason: this.parseErrorMessage ? 'parse_error' : undefined,
+            pendingOutboundCount: this.pendingOutboundQueue.length,
+            pendingOutboundMessages: this.pendingOutboundQueue.map((message) => ({
+                id: message.id,
+                role: message.role,
+                content: message.content,
+                queuedAt: message.queuedAt,
+                source: message.source,
+            })),
+            errorMessage: this.parseErrorMessage || this.providerErrorMessage || undefined,
+            errorReason: this.parseErrorMessage ? 'parse_error' : (this.providerErrorReason || undefined),
+            providerSessionId: this.providerSessionId || undefined,
             ...(bufferState ? { bufferState } : {}),
         };
     }
@@ -1600,7 +1878,8 @@ export class ProviderCliAdapter implements CliAdapter {
         const cached = this.parsedStatusCache;
         const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
         if (
-            cached
+            !this.providerOwnsTranscript()
+            && cached
             && cached.responseBuffer === this.responseBuffer
             && cached.currentTurnScope === this.currentTurnScope
             && cached.recentOutputBuffer === this.recentOutputBuffer
@@ -1630,7 +1909,13 @@ export class ProviderCliAdapter implements CliAdapter {
                 lastOutputAt: this.lastOutputAt,
             }),
             activeModal,
-            providerSessionId: typeof (parsed as any).providerSessionId === 'string' ? (parsed as any).providerSessionId : undefined,
+            providerSessionId: this.providerSessionId || (typeof (parsed as any).providerSessionId === 'string' ? (parsed as any).providerSessionId : undefined),
+            errorMessage: typeof (parsed as any).errorMessage === 'string' && (parsed as any).errorMessage.trim()
+                ? (parsed as any).errorMessage.trim()
+                : undefined,
+            errorReason: typeof (parsed as any).errorReason === 'string' && (parsed as any).errorReason.trim()
+                ? (parsed as any).errorReason.trim()
+                : undefined,
             ...(bufferState ? { bufferState } : {}),
             ...((parsed as any).transcriptAuthority === 'provider' || (parsed as any).transcriptAuthority === 'daemon'
                 ? { transcriptAuthority: (parsed as any).transcriptAuthority }
@@ -1665,6 +1950,7 @@ export class ProviderCliAdapter implements CliAdapter {
             accumulatedRawBuffer: this.accumulatedRawBuffer,
             recentOutputBuffer: this.recentOutputBuffer,
             terminalScreenText: this.getParseScreenText(this.terminalScreen.getText()),
+            workingDir: this.workingDir,
             baseMessages: [],
             partialResponse: this.responseBuffer,
             isWaitingForResponse: this.isWaitingForResponse,
@@ -1925,6 +2211,104 @@ export class ProviderCliAdapter implements CliAdapter {
     }
 
     async sendMessage(text: string): Promise<void> {
+        await this.sendMessageNow(text, true);
+    }
+
+    private enqueuePendingOutboundMessage(text: string, reason: string): void {
+        const content = String(text || '');
+        const duplicate = this.pendingOutboundQueue.some((message) => message.content === content);
+        if (duplicate) {
+            this.recordTrace('send_message_queued_duplicate_suppressed', {
+                reason,
+                queueLength: this.pendingOutboundQueue.length,
+                text: summarizeCliTraceText(content, 500),
+            });
+            return;
+        }
+        const queuedAt = Date.now();
+        const message: PendingOutboundMessage = {
+            id: `${queuedAt}:${this.pendingOutboundQueue.length}:${Math.random().toString(36).slice(2, 10)}`,
+            role: 'user',
+            content,
+            queuedAt,
+            source: 'sendMessage',
+        };
+        this.pendingOutboundQueue.push(message);
+        this.recordTrace('send_message_queued', {
+            reason,
+            queueLength: this.pendingOutboundQueue.length,
+            queuedAt,
+            text: summarizeCliTraceText(content, 500),
+        });
+        LOG.info('CLI', `[${this.cliType}] queued outbound message while busy (${reason}); queue=${this.pendingOutboundQueue.length}`);
+        this.onStatusChange?.();
+    }
+
+    private shouldQueuePendingOutboundMessage(parsedStatusBeforeSend: any | null = null): string | null {
+        if (this.provider.allowInputDuringGeneration === true) return null;
+        if (this.hasActionableApproval()) return null;
+        const parsedSessionStatus = typeof parsedStatusBeforeSend?.status === 'string'
+            ? String(parsedStatusBeforeSend.status)
+            : '';
+        if (parsedSessionStatus === 'idle' && this.parsedStatusHasFinalAssistantMessage(parsedStatusBeforeSend)) return null;
+        if (this.currentStatus === 'generating') return 'current_status_generating';
+        if (parsedSessionStatus === 'generating' || parsedSessionStatus === 'long_generating') {
+            const parsedModal = parsedStatusBeforeSend?.activeModal ?? parsedStatusBeforeSend?.modal ?? null;
+            const parsedHasActionableModal = Boolean(
+                parsedModal
+                && Array.isArray(parsedModal.buttons)
+                && parsedModal.buttons.some((candidate: unknown) => typeof candidate === 'string' && candidate.trim()),
+            );
+            const terminalLooksIdle = this.currentStatus === 'idle'
+                && this.runDetectStatus(this.recentOutputBuffer) === 'idle'
+                && !this.isWaitingForResponse
+                && !this.currentTurnScope
+                && !this.hasActionableApproval()
+                && !parsedHasActionableModal;
+            return terminalLooksIdle ? null : `parsed_status_${parsedSessionStatus}`;
+        }
+        if (this.isWaitingForResponse && this.currentTurnScope) return 'active_turn_in_progress';
+        return null;
+    }
+
+    private schedulePendingOutboundFlush(delayMs = 0): void {
+        if (this.pendingOutboundFlushTimer) clearTimeout(this.pendingOutboundFlushTimer);
+        this.pendingOutboundFlushTimer = setTimeout(() => {
+            this.pendingOutboundFlushTimer = null;
+            void this.flushPendingOutboundQueue();
+        }, Math.max(0, delayMs));
+    }
+
+    private async flushPendingOutboundQueue(): Promise<void> {
+        if (this.pendingOutboundFlushInFlight || this.pendingOutboundQueue.length === 0) return;
+        if (this.currentStatus !== 'idle' || this.isWaitingForResponse || this.hasActionableApproval()) return;
+        this.pendingOutboundFlushInFlight = true;
+        try {
+            while (this.pendingOutboundQueue.length > 0) {
+                if (this.currentStatus !== 'idle' || this.isWaitingForResponse || this.hasActionableApproval()) break;
+                const next = this.pendingOutboundQueue[0];
+                this.recordTrace('send_message_queue_flush', {
+                    id: next.id,
+                    queuedAt: next.queuedAt,
+                    queueLength: this.pendingOutboundQueue.length,
+                    text: summarizeCliTraceText(next.content, 500),
+                });
+                try {
+                    await this.sendMessageNow(next.content, false);
+                    this.pendingOutboundQueue.shift();
+                    this.onStatusChange?.();
+                } catch (error: any) {
+                    LOG.warn('CLI', `[${this.cliType}] queued outbound flush failed: ${error?.message || error}`);
+                    this.schedulePendingOutboundFlush(1000);
+                    break;
+                }
+            }
+        } finally {
+            this.pendingOutboundFlushInFlight = false;
+        }
+    }
+
+    private async sendMessageNow(text: string, allowQueue: boolean): Promise<void> {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         const allowInputDuringGeneration = this.provider.allowInputDuringGeneration === true;
         const allowInterventionPrompt = allowInputDuringGeneration
@@ -1937,27 +2321,33 @@ export class ProviderCliAdapter implements CliAdapter {
                 await new Promise(resolve => setTimeout(resolve, 50));
             }
         }
+        const parsedStatusBeforeSend = !allowInputDuringGeneration
+            ? (() => {
+                try {
+                    return this.getScriptParsedStatus?.() || null;
+                } catch {
+                    return null;
+                }
+            })()
+            : null;
+        const queueReason = this.shouldQueuePendingOutboundMessage(parsedStatusBeforeSend);
+        if (allowQueue && queueReason) {
+            this.enqueuePendingOutboundMessage(text, queueReason);
+            return;
+        }
         if (!allowInterventionPrompt) {
             await this.waitForInteractivePrompt();
         }
         if (!this.ready) {
             this.resolveStartupState('send_precheck');
-            if (this.runDetectStatus(this.recentOutputBuffer) === 'idle' && this.currentStatus === 'idle') {
+            if (this.runDetectStatus(this.recentOutputBuffer) === 'idle') {
                 this.ready = true;
                 this.startupParseGate = false;
+                this.setStatus('idle', 'send_message_idle_prompt_recovery');
                 LOG.info('CLI', `[${this.cliType}] sendMessage recovered idle prompt readiness`);
             }
         }
         if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.currentStatus})`);
-        const parsedStatusBeforeSend = !allowInputDuringGeneration
-            ? (() => {
-                try {
-                    return this.getScriptParsedStatus?.() || null;
-                } catch {
-                    return null;
-                }
-            })()
-            : null;
         const parsedSessionStatus = typeof parsedStatusBeforeSend?.status === 'string'
             ? String(parsedStatusBeforeSend.status)
             : '';
@@ -1975,11 +2365,22 @@ export class ProviderCliAdapter implements CliAdapter {
                 && !this.hasActionableApproval()
                 && !parsedHasActionableModal;
             if (!terminalLooksIdle) {
+                if (allowQueue) {
+                    this.enqueuePendingOutboundMessage(text, `parsed_status_${parsedSessionStatus}`);
+                    return;
+                }
                 throw new Error(`${this.cliName} is still processing the previous prompt`);
             }
         }
         if (this.isWaitingForResponse && !allowInputDuringGeneration) {
-            if (!this.clearStaleIdleResponseGuard('send_message_guard')) {
+            if (
+                !this.clearStaleIdleResponseGuard('send_message_guard')
+                && !this.clearParsedIdleResponseGuard('send_message_parsed_idle_guard', parsedStatusBeforeSend)
+            ) {
+                if (allowQueue) {
+                    this.enqueuePendingOutboundMessage(text, 'waiting_for_response');
+                    return;
+                }
                 throw new Error(`${this.cliName} is still processing the previous prompt`);
             }
         }
@@ -2230,6 +2631,9 @@ export class ProviderCliAdapter implements CliAdapter {
         this.pendingTerminalQueryTail = '';
         this.ptyOutputChunks = [];
         this.finishRetryCount = 0;
+        if (this.pendingOutboundFlushTimer) { clearTimeout(this.pendingOutboundFlushTimer); this.pendingOutboundFlushTimer = null; }
+        this.pendingOutboundQueue = [];
+        this.pendingOutboundFlushInFlight = false;
         if (this.ptyProcess) {
             this.ptyProcess.write('\x03');
             setTimeout(() => {
@@ -2251,6 +2655,9 @@ export class ProviderCliAdapter implements CliAdapter {
         this.pendingTerminalQueryTail = '';
         this.ptyOutputChunks = [];
         this.finishRetryCount = 0;
+        if (this.pendingOutboundFlushTimer) { clearTimeout(this.pendingOutboundFlushTimer); this.pendingOutboundFlushTimer = null; }
+        this.pendingOutboundQueue = [];
+        this.pendingOutboundFlushInFlight = false;
         if (this.ptyProcess) {
             try {
                 if (typeof this.ptyProcess.detach === 'function') {
@@ -2281,6 +2688,9 @@ export class ProviderCliAdapter implements CliAdapter {
         this.ptyOutputChunks = [];
         if (this.finishRetryTimer) { clearTimeout(this.finishRetryTimer); this.finishRetryTimer = null; }
         this.finishRetryCount = 0;
+        if (this.pendingOutboundFlushTimer) { clearTimeout(this.pendingOutboundFlushTimer); this.pendingOutboundFlushTimer = null; }
+        this.pendingOutboundQueue = [];
+        this.pendingOutboundFlushInFlight = false;
         this.resetTerminalScreen();
         this.ptyProcess?.clearBuffer?.();
         this.onStatusChange?.();
@@ -2369,10 +2779,26 @@ export class ProviderCliAdapter implements CliAdapter {
     getDebugState(): Record<string, any> {
         const screenText = sanitizeTerminalText(this.terminalScreen.getText());
         const startupModal = this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
-        const effectiveStatus = this.projectEffectiveStatus(startupModal);
-        const effectiveReady = this.ready || !!startupModal;
+        const startupDetectedStatus = this.startupParseGate && !startupModal
+            ? this.runDetectStatus(this.recentOutputBuffer || screenText)
+            : null;
+        const effectiveReady = this.ready || !!startupModal || startupDetectedStatus === 'waiting_approval';
         const parsedDebugState = this.getParsedDebugState();
         const parsedMessages = Array.isArray(parsedDebugState?.messages) ? parsedDebugState.messages : [];
+        let effectiveStatus = this.projectEffectiveStatus(startupModal);
+        if (parsedDebugState?.status === 'error') {
+            effectiveStatus = 'error';
+        }
+        if (startupDetectedStatus === 'waiting_approval') {
+            effectiveStatus = 'waiting_approval';
+        }
+        if (
+            effectiveStatus === 'idle'
+            && parsedDebugState?.status === 'generating'
+            && !this.parsedStatusHasFinalAssistantMessage(parsedDebugState)
+        ) {
+            effectiveStatus = 'generating';
+        }
         return {
             type: this.cliType,
             name: this.cliName,
@@ -2394,6 +2820,8 @@ export class ProviderCliAdapter implements CliAdapter {
                 providerSessionId: parsedDebugState.providerSessionId,
                 transcriptAuthority: parsedDebugState.transcriptAuthority,
                 coverage: parsedDebugState.coverage,
+                errorMessage: parsedDebugState.errorMessage,
+                errorReason: parsedDebugState.errorReason,
                 activeModal: parsedDebugState.activeModal,
                 messageCount: parsedMessages.length,
             } : null,
@@ -2407,6 +2835,14 @@ export class ProviderCliAdapter implements CliAdapter {
             rawBufferPreview: this.accumulatedRawBuffer.slice(-1000),
             sanitizedRawPreview: sanitizeTerminalText(this.accumulatedRawBuffer).slice(-1000),
             responseBuffer: this.responseBuffer.slice(-1000),
+            pendingOutboundQueue: this.pendingOutboundQueue.map((message) => ({
+                id: message.id,
+                role: message.role,
+                content: message.content,
+                queuedAt: message.queuedAt,
+                source: message.source,
+            })),
+            pendingOutboundCount: this.pendingOutboundQueue.length,
             lastOutputAt: this.lastOutputAt,
             lastNonEmptyOutputAt: this.lastNonEmptyOutputAt,
             lastScreenChangeAt: this.lastScreenChangeAt,