@adhdev/daemon-core 0.6.56 → 0.6.58

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

@@ -57,6 +57,7 @@ export interface CliSessionStatus {
     messages: CliChatMessage[];
     workingDir: string;
     activeModal: { message: string; buttons: string[] } | null;
+    terminalHistory?: string;
 }
 
 /**
@@ -82,10 +83,19 @@ export interface CliScriptInput {
     rawBuffer: string;       // Raw PTY output (with ANSI)
     recentBuffer: string;    // Recent 1000 chars (ANSI-stripped)
     screenText: string;      // Current visible screen snapshot
+    terminalHistory?: string; // Rolling append-only terminal transcript
     messages: CliChatMessage[];  // Previously parsed messages
     partialResponse: string; // Current partial response being generated
 }
 
+interface TurnParseScope {
+    prompt: string;
+    startedAt: number;
+    bufferStart: number;
+    rawBufferStart: number;
+    terminalHistoryStart: number;
+}
+
 export interface CliProviderModule {
     type: string;
     name: string;
@@ -93,6 +103,7 @@ export interface CliProviderModule {
     binary: string;
     sendDelayMs?: number;
     sendKey?: string;
+    submitStrategy?: 'wait_for_echo' | 'immediate';
     spawn: {
         command: string;
         args: string[];
@@ -193,6 +204,94 @@ function shSingleQuote(arg: string): string {
     return `'${arg.replace(/'/g, `'\\''`)}'`;
 }
 
+function estimatePromptDisplayLines(text: string, cols = 100): number {
+    const normalized = String(text || '').replace(/\r/g, '');
+    if (!normalized) return 1;
+    return normalized
+        .split('\n')
+        .reduce((sum, line) => sum + Math.max(1, Math.ceil(Math.max(1, line.length) / cols)), 0);
+}
+
+function extractPromptRetrySnippet(text: string): string {
+    const lines = String(text || '')
+        .replace(/\r/g, '')
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean);
+    const candidate = lines[lines.length - 1] || lines[0] || '';
+    return candidate.slice(-120);
+}
+
+function normalizePromptText(text: string): string {
+    return String(text || '').replace(/\s+/g, ' ').trim();
+}
+
+function compactPromptText(text: string): string {
+    return String(text || '').replace(/\s+/g, '').trim();
+}
+
+function promptLikelyVisible(screenText: string, promptSnippet: string): boolean {
+    const snippet = normalizePromptText(promptSnippet);
+    if (!snippet) return false;
+
+    const normalizedScreen = normalizePromptText(screenText);
+    if (normalizedScreen.includes(snippet)) return true;
+
+    const compactScreen = compactPromptText(screenText);
+    const compactSnippet = compactPromptText(promptSnippet);
+    if (compactSnippet && compactScreen.includes(compactSnippet)) return true;
+
+    const tokens = snippet
+        .split(/[^A-Za-z0-9_.:/-]+/)
+        .map(token => token.trim())
+        .filter(token => token.length >= 4);
+    if (tokens.length === 0) return false;
+
+    const required = Math.min(tokens.length, 3);
+    const matched = tokens.filter(token =>
+        normalizedScreen.includes(token) || compactScreen.includes(compactPromptText(token)),
+    ).length;
+    return matched >= required;
+}
+
+function splitHistoryLines(text: string): string[] {
+    return String(text || '')
+        .split('\n')
+        .map(line => line.replace(/\s+$/, ''));
+}
+
+function normalizeHistoryLine(line: string): string {
+    return String(line || '').replace(/\s+/g, ' ').trim();
+}
+
+function mergeTerminalHistory(existing: string, snapshot: string): string {
+    const next = String(snapshot || '').trim();
+    if (!next) return existing;
+    const prev = String(existing || '').trim();
+    if (!prev) return next;
+    if (prev === next || prev.endsWith(next)) return prev;
+
+    const prevLines = splitHistoryLines(prev);
+    const nextLines = splitHistoryLines(next);
+    const prevNorm = prevLines.map(normalizeHistoryLine);
+    const nextNorm = nextLines.map(normalizeHistoryLine);
+
+    const maxOverlap = Math.min(prevLines.length, nextLines.length);
+    for (let overlap = maxOverlap; overlap >= 1; overlap -= 1) {
+        const prevTail = prevNorm.slice(prevNorm.length - overlap);
+        const nextHead = nextNorm.slice(0, overlap);
+        if (prevTail.every((line, index) => line === nextHead[index])) {
+            return [...prevLines, ...nextLines.slice(overlap)].join('\n').trim();
+        }
+    }
+
+    const compactPrev = prevNorm.join('\n');
+    const compactNext = nextNorm.join('\n');
+    if (compactPrev.includes(compactNext)) return prev;
+
+    return `${prev}\n${next}`.trim();
+}
+
 /**
  * Normalize provider.json for auto-implement approval detection.
  * Kept for backward compat with dev-server auto-impl pipeline only.
@@ -238,6 +337,7 @@ export class ProviderCliAdapter implements CliAdapter {
     private provider: CliProviderModule;
     private ptyProcess: any = null;
     private messages: CliChatMessage[] = [];
+    private committedMessages: CliChatMessage[] = [];
     private structuredMessages: CliChatMessage[] = [];
     private currentStatus: CliSessionStatus['status'] = 'starting';
     private onStatusChange: (() => void) | null = null;
@@ -273,6 +373,11 @@ export class ProviderCliAdapter implements CliAdapter {
     private settleTimer: NodeJS.Timeout | null = null;
     private settledBuffer: string = '';
     private submitPendingUntil = 0;
+    private responseSettleIgnoreUntil = 0;
+    private responseEpoch = 0;
+    private submitRetryTimer: NodeJS.Timeout | null = null;
+    private submitRetryUsed = false;
+    private submitRetryPromptSnippet = '';
 
  // Resize redraw suppression
     private resizeSuppressUntil: number = 0;
@@ -288,8 +393,47 @@ export class ProviderCliAdapter implements CliAdapter {
     private accumulatedRawBuffer: string = '';
     /** Current visible terminal screen snapshot */
     private terminalScreen = new TerminalScreen(40, 120);
+    /** Rolling append-only terminal transcript built from screen snapshots */
+    private terminalHistory: string = '';
     /** Max accumulated buffer size (last 50KB) */
     private static readonly MAX_ACCUMULATED_BUFFER = 50000;
+    private currentTurnScope: TurnParseScope | null = null;
+
+    private syncMessageViews(): void {
+        this.messages = [...this.committedMessages];
+        this.structuredMessages = [...this.committedMessages];
+    }
+
+    private sliceFromOffset(text: string, start: number): string {
+        if (!text) return '';
+        if (!Number.isFinite(start) || start <= 0) return text;
+        if (start >= text.length) return '';
+        return text.slice(start);
+    }
+
+    private buildParseInput(baseMessages: CliChatMessage[], partialResponse: string, scope?: TurnParseScope | null): CliScriptInput {
+        const buffer = scope
+            ? (this.sliceFromOffset(this.terminalHistory, scope.terminalHistoryStart)
+                || this.sliceFromOffset(this.accumulatedBuffer, scope.bufferStart)
+                || this.accumulatedBuffer)
+            : this.accumulatedBuffer;
+        const rawBuffer = scope
+            ? (this.sliceFromOffset(this.accumulatedRawBuffer, scope.rawBufferStart) || this.accumulatedRawBuffer)
+            : this.accumulatedRawBuffer;
+        const terminalHistory = scope
+            ? (this.sliceFromOffset(this.terminalHistory, scope.terminalHistoryStart) || this.terminalHistory)
+            : this.terminalHistory;
+
+        return {
+            buffer,
+            rawBuffer,
+            recentBuffer: buffer.slice(-1000) || this.recentOutputBuffer,
+            screenText: this.terminalScreen.getText(),
+            terminalHistory,
+            messages: [...baseMessages],
+            partialResponse,
+        };
+    }
 
     private setStatus(status: CliSessionStatus['status'], trigger?: string): void {
         const prev = this.currentStatus;
@@ -307,6 +451,7 @@ export class ProviderCliAdapter implements CliAdapter {
     private readonly approvalKeys: Record<number, string>;
     private readonly sendDelayMs: number;
     private readonly sendKey: string;
+    private readonly submitStrategy: 'wait_for_echo' | 'immediate';
 
     constructor(provider: CliProviderModule, workingDir: string, private extraArgs: string[] = []) {
         this.provider = provider;
@@ -334,6 +479,7 @@ export class ProviderCliAdapter implements CliAdapter {
         this.sendKey = typeof (provider as any).sendKey === 'string' && (provider as any).sendKey.length > 0
             ? (provider as any).sendKey
             : '\r';
+        this.submitStrategy = (provider as any).submitStrategy === 'immediate' ? 'immediate' : 'wait_for_echo';
 
         // Scripts are required — loaded by ProviderLoader via compatibility array
         this.cliScripts = (provider as any).scripts || {};
@@ -459,7 +605,9 @@ export class ProviderCliAdapter implements CliAdapter {
         this.startupParseGate = true;
         this.startupBuffer = '';
         this.terminalScreen.reset(40, 120);
-        this.ready = true;
+        this.terminalHistory = '';
+        this.currentTurnScope = null;
+        this.ready = false;
         this.setStatus('idle', 'pty_ready');
         this.onStatusChange?.();
     }
@@ -475,6 +623,7 @@ export class ProviderCliAdapter implements CliAdapter {
         }
 
         this.terminalScreen.write(rawData);
+        this.terminalHistory = mergeTerminalHistory(this.terminalHistory, this.terminalScreen.getText());
         const cleanData = stripAnsi(rawData);
 
         if (this.isWaitingForResponse && cleanData) {
@@ -521,7 +670,9 @@ export class ProviderCliAdapter implements CliAdapter {
 
             if (isReady) {
                 this.startupParseGate = false;
+                this.ready = true;
                 LOG.info('CLI', `[${this.cliType}] Startup gate end (${elapsed}ms, scriptStatus=${scriptStatus})`);
+                this.onStatusChange?.();
             } else {
                 return;
             }
@@ -533,6 +684,7 @@ export class ProviderCliAdapter implements CliAdapter {
 
     private scheduleSettle(): void {
         if (this.settleTimer) clearTimeout(this.settleTimer);
+        const settleEpoch = this.responseEpoch;
         const delay = Math.max(
             this.timeouts.outputSettle,
             this.submitPendingUntil > Date.now()
@@ -541,14 +693,40 @@ export class ProviderCliAdapter implements CliAdapter {
         );
         this.settleTimer = setTimeout(() => {
             this.settleTimer = null;
+            if (settleEpoch !== this.responseEpoch) return;
             this.settledBuffer = this.recentOutputBuffer;
             this.evaluateSettled();
         }, delay);
     }
 
+    private armApprovalExitTimeout(): void {
+        if (this.approvalExitTimeout) clearTimeout(this.approvalExitTimeout);
+        this.approvalExitTimeout = setTimeout(() => {
+            if (this.currentStatus !== 'waiting_approval') return;
+            const tail = this.recentOutputBuffer;
+            const modal = this.runParseApproval(tail);
+            const stillWaiting = this.runDetectStatus(tail) === 'waiting_approval' || !!modal;
+            if (stillWaiting) {
+                this.activeModal = modal || this.activeModal || { message: 'Approval required', buttons: ['Allow', 'Deny'] };
+                this.onStatusChange?.();
+                this.armApprovalExitTimeout();
+                return;
+            }
+            LOG.warn('CLI', `[${this.cliType}] Approval timeout — auto-clearing`);
+            this.activeModal = null;
+            this.lastApprovalResolvedAt = Date.now();
+            this.setStatus('idle', 'approval_timeout');
+            this.onStatusChange?.();
+        }, 60000);
+    }
+
     private evaluateSettled(): void {
+        if (this.submitPendingUntil > Date.now()) return;
+        if (this.responseSettleIgnoreUntil > Date.now()) return;
         const tail = this.settledBuffer;
-        const scriptStatus = this.runDetectStatus(tail);
+        const modal = this.runParseApproval(tail);
+        const rawScriptStatus = this.runDetectStatus(tail);
+        const scriptStatus = rawScriptStatus === 'waiting_approval' || modal ? 'waiting_approval' : rawScriptStatus;
         if (!scriptStatus) return;
 
         const prevStatus = this.currentStatus;
@@ -560,20 +738,10 @@ export class ProviderCliAdapter implements CliAdapter {
                 this.setStatus('waiting_approval', 'script_detect');
 
                 // Use parseApproval script for modal info
-                const modal = this.runParseApproval(tail);
                 this.activeModal = modal || { message: 'Approval required', buttons: ['Allow', 'Deny'] };
 
                 if (this.idleTimeout) clearTimeout(this.idleTimeout);
-                if (this.approvalExitTimeout) clearTimeout(this.approvalExitTimeout);
-                this.approvalExitTimeout = setTimeout(() => {
-                    if (this.currentStatus === 'waiting_approval') {
-                        LOG.warn('CLI', `[${this.cliType}] Approval timeout — auto-clearing`);
-                        this.activeModal = null;
-                        this.lastApprovalResolvedAt = Date.now();
-                        this.setStatus('idle', 'approval_timeout');
-                        this.onStatusChange?.();
-                    }
-                }, 60000);
+                this.armApprovalExitTimeout();
                 this.onStatusChange?.();
                 return;
             }
@@ -607,7 +775,12 @@ export class ProviderCliAdapter implements CliAdapter {
                 this.lastApprovalResolvedAt = Date.now();
             }
             if (this.isWaitingForResponse) {
-                this.finishResponse();
+                if (this.idleTimeout) clearTimeout(this.idleTimeout);
+                this.idleTimeout = setTimeout(() => {
+                    if (this.isWaitingForResponse && this.currentStatus !== 'waiting_approval') {
+                        this.finishResponse();
+                    }
+                }, this.timeouts.idleFinish);
             } else if (prevStatus !== 'idle') {
                 this.setStatus('idle', 'script_detect');
                 this.onStatusChange?.();
@@ -616,17 +789,78 @@ export class ProviderCliAdapter implements CliAdapter {
     }
 
     private finishResponse(): void {
+        if (this.submitPendingUntil > Date.now()) return;
+        if (this.responseSettleIgnoreUntil > Date.now()) return;
+        this.commitCurrentTranscript();
         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; }
+        if (this.submitRetryTimer) { clearTimeout(this.submitRetryTimer); this.submitRetryTimer = null; }
 
         this.responseBuffer = '';
         this.isWaitingForResponse = false;
+        this.responseSettleIgnoreUntil = 0;
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = '';
+        this.currentTurnScope = null;
         this.activeModal = null;
         this.setStatus('idle', 'response_finished');
         this.onStatusChange?.();
     }
 
+    private commitCurrentTranscript(): void {
+        const baseMessages = [...this.committedMessages];
+        const parsed = this.parseCurrentTranscript(baseMessages, '', this.currentTurnScope);
+        if (parsed && Array.isArray(parsed.messages) && parsed.messages.length > 0) {
+            const parsedMessages = parsed.messages
+                .filter((m: any) => m && (m.role === 'user' || m.role === 'assistant'))
+                .map((m: any) => ({
+                    role: m.role,
+                    content: typeof m.content === 'string' ? m.content : String(m.content || ''),
+                    timestamp: m.timestamp,
+                }));
+            const latestAssistant = [...parsedMessages]
+                .reverse()
+                .find((m: CliChatMessage) => m.role === 'assistant' && m.content.trim());
+            if (latestAssistant) {
+                LOG.info('CLI', `[${this.cliType}] commitCurrentTranscript parsed assistant len=${latestAssistant.content.length} scopePrompt=${JSON.stringify(this.currentTurnScope?.prompt || '').slice(0, 120)}`);
+                const nextMessages = [...baseMessages];
+                const last = nextMessages[nextMessages.length - 1];
+                if (last?.role === 'assistant') {
+                    last.content = latestAssistant.content;
+                    last.timestamp = latestAssistant.timestamp || last.timestamp;
+                } else if (last?.role === 'user') {
+                    nextMessages.push({
+                        role: 'assistant',
+                        content: latestAssistant.content,
+                        timestamp: latestAssistant.timestamp || Date.now(),
+                    });
+                } else {
+                    nextMessages.push({
+                        role: 'assistant',
+                        content: latestAssistant.content,
+                        timestamp: latestAssistant.timestamp || Date.now(),
+                    });
+                }
+                this.committedMessages = nextMessages;
+                this.syncMessageViews();
+                return;
+            }
+        }
+
+        const fallback = String(this.responseBuffer || '').trim();
+        LOG.info('CLI', `[${this.cliType}] commitCurrentTranscript fallback len=${fallback.length} scopePrompt=${JSON.stringify(this.currentTurnScope?.prompt || '').slice(0, 120)}`);
+        if (!fallback) return;
+        const last = baseMessages[baseMessages.length - 1];
+        if (last?.role === 'assistant') {
+            last.content = fallback;
+        } else {
+            baseMessages.push({ role: 'assistant', content: fallback, timestamp: Date.now() });
+        }
+        this.committedMessages = baseMessages;
+        this.syncMessageViews();
+    }
+
  // ─── Script Execution ──────────────────────────
 
     private runDetectStatus(text: string): string | null {
@@ -660,26 +894,12 @@ export class ProviderCliAdapter implements CliAdapter {
  // ─── Public API (CliAdapter) ───────────────────
 
     getStatus(): CliSessionStatus {
-        // Use parseOutput script for full result when available
-        const scriptResult = this.getScriptParsedStatus();
-        if (scriptResult) {
-            return {
-                status: this.currentStatus,
-                messages: (scriptResult.messages || []).map((m: any) => ({
-                    role: m.role,
-                    content: m.content,
-                    timestamp: m.timestamp,
-                })),
-                workingDir: this.workingDir,
-                activeModal: this.activeModal,
-            };
-        }
-
         return {
             status: this.currentStatus,
-            messages: [...this.messages],
+            messages: [...this.committedMessages],
             workingDir: this.workingDir,
             activeModal: this.activeModal,
+            terminalHistory: this.terminalHistory,
         };
     }
 
@@ -688,31 +908,33 @@ export class ProviderCliAdapter implements CliAdapter {
      * Called by command handler / dashboard for rich content rendering.
      */
     getScriptParsedStatus(): any {
+        const messages = [...this.committedMessages];
+        return {
+            id: 'cli_session',
+            status: this.currentStatus,
+            title: this.cliName,
+            terminalHistory: this.terminalHistory,
+            messages: messages.slice(-50).map((message, index) => ({
+                id: `msg_${index}`,
+                role: message.role,
+                content: message.content,
+                timestamp: message.timestamp,
+                index,
+                kind: 'standard',
+            })),
+            activeModal: this.activeModal,
+        };
+    }
+
+    private parseCurrentTranscript(baseMessages: CliChatMessage[], partialResponse: string, scope?: TurnParseScope | null): any {
         if (!this.cliScripts?.parseOutput) return null;
         try {
-            const input: CliScriptInput = {
-                buffer: this.accumulatedBuffer,
-                rawBuffer: this.accumulatedRawBuffer,
-                recentBuffer: this.recentOutputBuffer,
-                screenText: this.terminalScreen.getText(),
-                messages: [...(this.structuredMessages.length > 0 ? this.structuredMessages : this.messages)],
-                partialResponse: this.responseBuffer,
-            };
-            const result = this.cliScripts.parseOutput(input);
-            if (result && typeof result === 'object') {
-                if (Array.isArray((result as any).messages)) {
-                    this.structuredMessages = (result as any).messages.map((m: any) => ({
-                        role: m.role,
-                        content: m.content,
-                        timestamp: m.timestamp,
-                    }));
-                }
-                return result;
-            }
+            const input = this.buildParseInput(baseMessages, partialResponse, scope);
+            return this.cliScripts.parseOutput(input);
         } catch (e: any) {
             LOG.warn('CLI', `[${this.cliType}] parseOutput error: ${e.message}`);
+            return null;
         }
-        return null;
     }
 
     /** Whether this adapter has CLI scripts loaded */
@@ -744,31 +966,132 @@ export class ProviderCliAdapter implements CliAdapter {
 
     async sendMessage(text: string): Promise<void> {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
+        if (this.startupParseGate) {
+            const deadline = Date.now() + 10000;
+            while (this.startupParseGate && Date.now() < deadline) {
+                await new Promise(resolve => setTimeout(resolve, 50));
+            }
+        }
         if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.currentStatus})`);
         if (this.isWaitingForResponse) return;
 
-        this.messages.push({ role: 'user', content: text, timestamp: Date.now() });
-        this.structuredMessages.push({ role: 'user', content: text, timestamp: Date.now() });
+        this.committedMessages.push({ role: 'user', content: text, timestamp: Date.now() });
+        this.syncMessageViews();
         this.isWaitingForResponse = true;
         this.responseBuffer = '';
+        this.currentTurnScope = {
+            prompt: text,
+            startedAt: Date.now(),
+            bufferStart: this.accumulatedBuffer.length,
+            rawBufferStart: this.accumulatedRawBuffer.length,
+            terminalHistoryStart: this.terminalHistory.length,
+        };
+        LOG.info('CLI', `[${this.cliType}] sendMessage turn scope buffer=${this.currentTurnScope.bufferStart} raw=${this.currentTurnScope.rawBufferStart} terminal=${this.currentTurnScope.terminalHistoryStart} prompt=${JSON.stringify(text).slice(0, 120)}`);
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = extractPromptRetrySnippet(text);
+        const normalizedPromptSnippet = normalizePromptText(this.submitRetryPromptSnippet);
+        if (this.submitRetryTimer) {
+            clearTimeout(this.submitRetryTimer);
+            this.submitRetryTimer = null;
+        }
+        const estimatedLines = estimatePromptDisplayLines(text);
+        const submitDelayMs = this.sendDelayMs + Math.min(2000, Math.max(0, estimatedLines - 1) * 350);
+        const maxEchoWaitMs = submitDelayMs + Math.max(1500, Math.min(5000, estimatedLines * 500));
+        const retryDelayMs = Math.max(350, Math.min(1500, Math.max(this.sendDelayMs, submitDelayMs)));
+        if (this.settleTimer) {
+            clearTimeout(this.settleTimer);
+            this.settleTimer = null;
+        }
+        this.responseEpoch += 1;
+        this.responseSettleIgnoreUntil = Date.now() + submitDelayMs + this.timeouts.outputSettle + 250;
         this.setStatus('generating', 'sendMessage');
         this.onStatusChange?.();
-        this.ptyProcess.write(text);
+        const startResponseTimeout = () => {
+            if (this.responseTimeout) clearTimeout(this.responseTimeout);
+            this.responseTimeout = setTimeout(() => {
+                if (this.isWaitingForResponse) this.finishResponse();
+            }, this.timeouts.maxResponse);
+        };
 
         const submit = () => {
             if (!this.ptyProcess) return;
             this.submitPendingUntil = 0;
             this.ptyProcess.write(this.sendKey);
-            this.responseTimeout = setTimeout(() => {
-                if (this.isWaitingForResponse) this.finishResponse();
-            }, this.timeouts.maxResponse);
+            const retrySubmitIfStuck = (attempt: number) => {
+                this.submitRetryTimer = null;
+                if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
+                if (this.currentStatus !== 'generating') return;
+                if ((this.responseBuffer || '').trim()) return;
+                const screenText = this.terminalScreen.getText();
+                if (!promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
+                if (/Esc to interrupt|Do you want to proceed|This command requires approval|Allow Codex to|Approve and run now|Always approve this session|Running…|Running\.\.\./i.test(screenText)) return;
+                this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
+                LOG.info('CLI', `[${this.cliType}] Retrying submit key for stuck prompt (attempt ${attempt})`);
+                this.ptyProcess.write(this.sendKey);
+                if (attempt >= 3) {
+                    this.submitRetryUsed = true;
+                    return;
+                }
+                this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(attempt + 1), retryDelayMs);
+            };
+            this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(1), retryDelayMs);
+            startResponseTimeout();
         };
-        if (this.sendDelayMs > 0) {
-            this.submitPendingUntil = Date.now() + this.sendDelayMs;
-            setTimeout(submit, this.sendDelayMs);
-        } else {
-            submit();
+
+        if (this.submitStrategy === 'immediate') {
+            this.submitPendingUntil = 0;
+            this.ptyProcess.write(text + this.sendKey);
+            this.submitRetryTimer = setTimeout(() => {
+                this.submitRetryTimer = null;
+                if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
+                if (this.currentStatus !== 'generating') return;
+                if ((this.responseBuffer || '').trim()) return;
+                const screenText = this.terminalScreen.getText();
+                if (!promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
+                LOG.info('CLI', `[${this.cliType}] Retrying submit key for stuck prompt (attempt 1)`);
+                this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
+                this.ptyProcess.write(this.sendKey);
+                this.submitRetryUsed = true;
+            }, retryDelayMs);
+            startResponseTimeout();
+            return;
         }
+
+        if (submitDelayMs > 0) {
+            this.submitPendingUntil = Date.now() + submitDelayMs;
+        }
+        this.ptyProcess.write(text);
+        const submitStartedAt = Date.now();
+        let lastNormalizedScreen = '';
+        let lastScreenChangeAt = submitStartedAt;
+        const waitForEchoAndSubmit = () => {
+            if (!this.ptyProcess) return;
+            const now = Date.now();
+            const elapsed = now - submitStartedAt;
+            const screenText = this.terminalScreen.getText();
+            const normalizedScreen = normalizePromptText(screenText);
+            if (normalizedScreen !== lastNormalizedScreen) {
+                lastNormalizedScreen = normalizedScreen;
+                lastScreenChangeAt = now;
+            }
+            const echoVisible = !normalizedPromptSnippet || promptLikelyVisible(screenText, normalizedPromptSnippet);
+
+            if (echoVisible) {
+                const screenSettled = (now - lastScreenChangeAt) >= 500;
+                if (elapsed >= submitDelayMs && screenSettled) {
+                    submit();
+                    return;
+                }
+            }
+
+            if (elapsed >= maxEchoWaitMs) {
+                submit();
+                return;
+            }
+
+            setTimeout(waitForEchoAndSubmit, 50);
+        };
+        waitForEchoAndSubmit();
     }
 
     getPartialResponse(): string {
@@ -781,6 +1104,7 @@ export class ProviderCliAdapter implements CliAdapter {
     shutdown(): void {
         if (this.settleTimer) { clearTimeout(this.settleTimer); this.settleTimer = null; }
         if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
+        if (this.submitRetryTimer) { clearTimeout(this.submitRetryTimer); this.submitRetryTimer = null; }
         if (this.ptyProcess) {
             this.ptyProcess.write('\x03');
             setTimeout(() => {
@@ -796,10 +1120,14 @@ export class ProviderCliAdapter implements CliAdapter {
     }
 
     clearHistory(): void {
-        this.messages = [];
-        this.structuredMessages = [];
+        this.committedMessages = [];
+        this.syncMessageViews();
         this.accumulatedBuffer = '';
         this.accumulatedRawBuffer = '';
+        this.terminalHistory = '';
+        this.currentTurnScope = null;
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = '';
         this.terminalScreen.reset();
         this.onStatusChange?.();
     }
@@ -812,7 +1140,16 @@ export class ProviderCliAdapter implements CliAdapter {
     }
 
     resolveModal(buttonIndex: number): void {
-        if (!this.ptyProcess || this.currentStatus !== 'waiting_approval') return;
+        if (!this.ptyProcess || (this.currentStatus !== 'waiting_approval' && !this.activeModal)) return;
+        this.activeModal = null;
+        this.lastApprovalResolvedAt = Date.now();
+        this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
+        if (this.approvalExitTimeout) {
+            clearTimeout(this.approvalExitTimeout);
+            this.approvalExitTimeout = null;
+        }
+        this.setStatus('generating', 'approval_resolved');
+        this.onStatusChange?.();
         if (buttonIndex in this.approvalKeys) {
             this.ptyProcess.write(this.approvalKeys[buttonIndex]);
         } else {
@@ -842,9 +1179,12 @@ export class ProviderCliAdapter implements CliAdapter {
             spawnAt: this.spawnAt,
             workingDir: this.workingDir,
             messages: this.messages.slice(-20),
+            committedMessages: this.committedMessages.slice(-20),
             structuredMessages: this.structuredMessages.slice(-20),
-            messageCount: this.messages.length,
+            messageCount: this.committedMessages.length,
             screenText: this.terminalScreen.getText().slice(-4000),
+            terminalHistory: this.terminalHistory.slice(-8000),
+            currentTurnScope: this.currentTurnScope,
             startupBuffer: this.startupBuffer.slice(-4000),
             recentOutputBuffer: this.recentOutputBuffer.slice(-500),
             settledBuffer: this.settledBuffer.slice(-500),
@@ -855,6 +1195,11 @@ export class ProviderCliAdapter implements CliAdapter {
             isWaitingForResponse: this.isWaitingForResponse,
             activeModal: this.activeModal,
             lastApprovalResolvedAt: this.lastApprovalResolvedAt,
+            sendDelayMs: this.sendDelayMs,
+            sendKey: this.sendKey,
+            submitStrategy: this.submitStrategy,
+            submitPendingUntil: this.submitPendingUntil,
+            responseSettleIgnoreUntil: this.responseSettleIgnoreUntil,
             resizeSuppressUntil: this.resizeSuppressUntil,
             hasCliScripts: this.hasCliScripts(),
             scriptNames: Object.keys(this.cliScripts).filter(k => typeof (this.cliScripts as any)[k] === 'function'),