@adhdev/daemon-core 0.8.33 → 0.8.35

package/src/cdp/scanner.d.ts

@@ -0,0 +1,58 @@
+/**
+ * DaemonCdpScanner — Periodic CDP port scanning & auto-connect
+ *
+ * Periodic CDP port scanning and auto-connect for IDE discovery.
+ * Provides a unified approach to:
+ * 1. Initial CDP port discovery
+ * 2. Periodic scanning for newly launched IDEs
+ * 3. Multi-window support (multiple pages on same port)
+ */
+import { DaemonCdpManager } from './manager.js';
+import { type CdpSetupContext } from './setup.js';
+export interface CdpScannerOptions {
+    /** Context for setup operations */
+    ctx: CdpSetupContext;
+    /** Log function for per-IDE CDP logs */
+    logFn?: (ideType: string) => (msg: string) => void;
+    /** Whether to support multi-window (multiple pages per port) */
+    multiWindow?: boolean;
+    /** Scan interval in ms (default: 30000) */
+    scanIntervalMs?: number;
+    /** Callback when a new CDP connection is established */
+    onConnected?: (ideType: string, managerKey: string, manager: DaemonCdpManager) => void;
+}
+export declare class DaemonCdpScanner {
+    private ctx;
+    private opts;
+    private scanTimer;
+    private discoveryTimer;
+    constructor(opts: CdpScannerOptions);
+    /**
+     * Initial CDP discovery — connect to all available IDEs.
+     * Supports both single-window and multi-window modes.
+     */
+    initialScan(enabledIdes?: string[]): Promise<void>;
+    /**
+     * Start periodic scanning for newly launched IDEs.
+     */
+    startPeriodicScan(): void;
+    /**
+     * Start periodic agent webview discovery on all connected CDPs.
+     */
+    startWebviewDiscovery(intervalMs?: number): void;
+    /**
+     * Stop all timers.
+     */
+    stop(): void;
+    private getLogFn;
+    /**
+     * Single-window connection (standalone mode).
+     * One CDP manager per IDE, first working port wins.
+     */
+    private connectSingleWindow;
+    /**
+     * Multi-window connection.
+     * Multiple CDP managers per IDE — one per workbench page.
+     */
+    private connectMultiWindow;
+}

package/src/cdp/setup.d.ts

@@ -0,0 +1,58 @@
+/**
+ * DaemonCdpSetup — Shared CDP initialization helpers
+ *
+ * Common CDP setup logic for consistent
+ * CDP → ProviderInstance registration.
+ */
+import { DaemonCdpManager } from './manager.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import { IdeProviderInstance } from '../providers/ide-provider-instance.js';
+import { SessionRegistry } from '../sessions/registry.js';
+export interface CdpSetupContext {
+    providerLoader: ProviderLoader;
+    instanceManager: ProviderInstanceManager;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    sessionRegistry: SessionRegistry;
+    /** Server connection (optional) */
+    serverConn?: any;
+}
+export interface SetupIdeInstanceOptions {
+    /** Provider-based IDE type (e.g., 'antigravity', 'cursor') */
+    ideType: string;
+    /** Connected CDP manager */
+    manager: DaemonCdpManager;
+    /** CDP manager key (for multi-window: 'antigravity_remote_vs', single: 'antigravity') */
+    managerKey?: string;
+    /** Provider settings override */
+    settings?: Record<string, any>;
+}
+/**
+ * Register extension providers on a CDP manager.
+ * Common pattern used during CDP init and periodic scans.
+ */
+export declare function registerExtensionProviders(providerLoader: ProviderLoader, manager: DaemonCdpManager, ideType: string): void;
+/**
+ * Setup a CDP-connected IDE as a ProviderInstance.
+ *
+ * Performs:
+ * 1. providerLoader.resolve() to get scripts
+ * 2. Create IdeProviderInstance
+ * 3. Register in InstanceManager
+ * 4. Register enabled extensions
+ * 5. Register runtime sessions (workspace + extension children)
+ *
+ * @returns The created IdeProviderInstance, or null if provider not found
+ */
+export declare function setupIdeInstance(ctx: CdpSetupContext, opts: SetupIdeInstanceOptions): Promise<IdeProviderInstance | null>;
+/**
+ * Create and connect a DaemonCdpManager for a given port.
+ *
+ * @returns Connected manager or null if connection failed
+ */
+export declare function connectCdpManager(port: number, ideType: string, logFn: (msg: string) => void, providerLoader: ProviderLoader, targetId?: string): Promise<DaemonCdpManager | null>;
+/**
+ * Probe a CDP port to check if it's listening.
+ * @returns true if CDP is available on this port
+ */
+export declare function probeCdpPort(port: number, timeoutMs?: number): Promise<boolean>;

package/src/cli-adapter-types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * CliAdapter — common interface for CLI agents
+ *
+ * Contract implemented by all CLI adapters (ProviderCliAdapter etc).
+ */
+import type { ChatMessage } from './types.js';
+export interface CliAdapterStatus {
+    status?: string;
+    messages?: ChatMessage[];
+    activeModal?: {
+        message: string;
+        buttons: string[];
+    } | null;
+}
+export interface AcpAdapterHandle {
+    onEvent(event: string, data?: unknown): void;
+    getState(): {
+        status: string;
+        activeChat?: {
+            messages?: ChatMessage[];
+            activeModal?: {
+                message: string;
+                buttons: string[];
+            } | null;
+        } | null;
+    };
+    setMode?(mode: string): Promise<void>;
+    setConfigOption?(configId: string, value: string): Promise<void>;
+    resolvePermission?(approved: boolean): Promise<void>;
+}
+export interface CliAdapter {
+    cliType: string;
+    cliName: string;
+    workingDir: string;
+    _acpInstance?: AcpAdapterHandle;
+    spawn(): Promise<void>;
+    sendMessage(text: string): Promise<void>;
+    getStatus(): CliAdapterStatus;
+    getScriptParsedStatus?(): unknown;
+    invokeScript?(scriptName: string, args?: Record<string, unknown>): Promise<unknown>;
+    getPartialResponse(): string;
+    saveAndStop?(): Promise<void>;
+    shutdown(): void;
+    detach?(): void;
+    cancel(): void;
+    isProcessing(): boolean;
+    isReady(): boolean;
+    setOnStatusChange(callback: () => void): void;
+    updateRuntimeSettings?(settings: Record<string, unknown>): void;
+    setServerConn?(serverConn: unknown): void;
+    clearHistory?(): void;
+    resolveAction?(data: unknown): Promise<void>;
+    resolveModal?(buttonIndex: number): void;
+    setOnPtyData?(callback: (data: string) => void): void;
+    writeRaw?(data: string): void;
+    resize?(cols: number, rows: number): void;
+}

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

@@ -0,0 +1,177 @@
+/**
+ * ProviderCliAdapter — Script-based CLI Adapter
+ *
+ * All CLI providers use versioned scripts (like IDE providers).
+ * Scripts are Node.js functions that receive PTY buffer data and return structured results.
+ *
+ * Required scripts in scripts/{version}/scripts.js:
+ *   - detectStatus(input)  → AgentStatus string ('idle' | 'generating' | 'waiting_approval')
+ *   - parseOutput(input)   → ReadChatResult { messages, status, activeModal, ... }
+ *   - parseApproval(input) → ModalInfo | null
+ *
+ * provider.json contract:
+ *   type, name, category: 'cli', binary, spawn, approvalKeys
+ *   compatibility: [{ ideVersion, scriptDir }]  ← versioned scripts
+ */
+import type { CliAdapter } from '../cli-adapter-types.js';
+import { type PtyRuntimeMetadata, type PtyTransportFactory } from './pty-transport.js';
+import { type CliChatMessage, type CliProviderModule, type CliScripts, type CliSessionStatus } from './provider-cli-shared.js';
+import { type ProviderResolutionMeta } from './provider-cli-config.js';
+export { normalizeCliProviderForRuntime, type CliApprovalInput, type CliChatMessage, type CliProviderModule, type CliScreenLine, type CliScreenSnapshot, type CliScriptInput, type CliScripts, type CliSessionStatus, type CliStatusInput, type CliTraceEntry, } from './provider-cli-shared.js';
+type SeedCliChatMessage = Omit<Partial<CliChatMessage>, 'role'> & {
+    role?: string;
+    content?: string;
+};
+export declare class ProviderCliAdapter implements CliAdapter {
+    private extraArgs;
+    readonly cliType: string;
+    readonly cliName: string;
+    workingDir: string;
+    private provider;
+    private ptyProcess;
+    private transportFactory;
+    private messages;
+    private committedMessages;
+    private structuredMessages;
+    private currentStatus;
+    private onStatusChange;
+    private responseBuffer;
+    private recentOutputBuffer;
+    private isWaitingForResponse;
+    private activeModal;
+    private responseTimeout;
+    private idleTimeout;
+    private ready;
+    private startupBuffer;
+    private startupParseGate;
+    private startupSettleTimer;
+    private spawnAt;
+    private startupFirstOutputAt;
+    private onPtyDataCallback;
+    private pendingOutputParseBuffer;
+    private pendingOutputParseTimer;
+    private ptyOutputBuffer;
+    private ptyOutputFlushTimer;
+    private pendingTerminalQueryTail;
+    private lastOutputAt;
+    private lastNonEmptyOutputAt;
+    private lastScreenChangeAt;
+    private lastScreenSnapshot;
+    private serverConn;
+    private logBuffer;
+    private lastApprovalResolvedAt;
+    private approvalTransitionBuffer;
+    private approvalExitTimeout;
+    private pendingScriptStatus;
+    private pendingScriptStatusSince;
+    private pendingScriptStatusTimer;
+    private settleTimer;
+    private settledBuffer;
+    private submitPendingUntil;
+    private responseSettleIgnoreUntil;
+    private responseEpoch;
+    private submitRetryTimer;
+    private submitRetryUsed;
+    private submitRetryPromptSnippet;
+    private idleFinishCandidate;
+    private finishRetryTimer;
+    private finishRetryCount;
+    private resizeSuppressUntil;
+    private statusHistory;
+    private cliScripts;
+    private runtimeSettings;
+    /** Full accumulated ANSI-stripped PTY output */
+    private accumulatedBuffer;
+    /** Full accumulated raw PTY output (with ANSI) */
+    private accumulatedRawBuffer;
+    /** Current visible terminal screen snapshot */
+    private terminalScreen;
+    /** Max accumulated buffer size (last 50KB) */
+    private static readonly MAX_ACCUMULATED_BUFFER;
+    private currentTurnScope;
+    private traceEntries;
+    private traceSeq;
+    private traceSessionId;
+    private static readonly MAX_TRACE_ENTRIES;
+    private readonly providerResolutionMeta;
+    private static readonly IDLE_FINISH_CONFIRM_MS;
+    private static readonly STATUS_ACTIVITY_HOLD_MS;
+    private static readonly FINISH_RETRY_DELAY_MS;
+    private static readonly MAX_FINISH_RETRIES;
+    private syncMessageViews;
+    private setStatus;
+    private clearIdleFinishCandidate;
+    private armIdleFinishCandidate;
+    private recordTrace;
+    private resetTraceSession;
+    private readonly timeouts;
+    private readonly approvalKeys;
+    private readonly sendDelayMs;
+    private readonly sendKey;
+    private readonly submitStrategy;
+    private static readonly SCRIPT_STATUS_DEBOUNCE_MS;
+    constructor(provider: CliProviderModule, workingDir: string, extraArgs?: string[], transportFactory?: PtyTransportFactory);
+    /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
+    setCliScripts(scripts: CliScripts): void;
+    updateRuntimeSettings(settings: Record<string, any>): void;
+    setServerConn(serverConn: any): void;
+    setOnStatusChange(callback: () => void): void;
+    setOnPtyData(callback: (data: string) => void): void;
+    private flushPendingOutputParse;
+    spawn(): Promise<void>;
+    private handleOutput;
+    private resolveStartupState;
+    private scheduleStartupSettleCheck;
+    private scheduleSettle;
+    private armApprovalExitTimeout;
+    private looksLikeVisibleIdlePrompt;
+    private findLastMatchingLineIndex;
+    private looksLikeClaudeGeneratingLine;
+    private detectClaudeGeneratingOverride;
+    private refineDetectedStatus;
+    private looksLikeVisibleAssistantCandidate;
+    private shouldRetryFinishResponse;
+    private hasRecentInteractiveActivity;
+    private getStartupConfirmationModal;
+    private shouldResolveModalWithEnter;
+    private waitForInteractivePrompt;
+    private evaluateSettled;
+    private finishResponse;
+    private commitCurrentTranscript;
+    private runDetectStatus;
+    private runParseApproval;
+    getStatus(): CliSessionStatus;
+    seedCommittedMessages(messages: SeedCliChatMessage[]): void;
+    /**
+     * Script-based full parse — returns ReadChatResult.
+     * Called by command handler / dashboard for rich content rendering.
+     */
+    getScriptParsedStatus(): any;
+    invokeScript(scriptName: string, args?: Record<string, any>): Promise<any>;
+    private parseCurrentTranscript;
+    /** Whether this adapter has CLI scripts loaded */
+    hasCliScripts(): boolean;
+    /**
+     * Resolves an action (like 'fix' lint error) from the dashboard.
+     * Uses resolveAction script if available, otherwise falls back to standard text.
+     */
+    resolveAction(data: any): Promise<void>;
+    sendMessage(text: string): Promise<void>;
+    getPartialResponse(): string;
+    getRuntimeMetadata(): PtyRuntimeMetadata | null;
+    updateRuntimeMeta(meta: Record<string, unknown>, replace?: boolean): void;
+    cancel(): void;
+    saveAndStop(): Promise<void>;
+    private waitForStopped;
+    shutdown(): void;
+    detach(): void;
+    clearHistory(): void;
+    isProcessing(): boolean;
+    isReady(): boolean;
+    writeRaw(data: string): void;
+    resolveModal(buttonIndex: number): void;
+    resize(cols: number, rows: number): void;
+    getDebugState(): Record<string, any>;
+    getTraceState(limit?: number): Record<string, any>;
+    getProviderResolutionMeta(): ProviderResolutionMeta;
+}

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

@@ -1428,8 +1428,6 @@ export class ProviderCliAdapter implements CliAdapter {
             throw new Error(`${this.cliName} is awaiting confirmation before it can accept a prompt`);
         }
 
-        this.committedMessages.push({ role: 'user', content: text, timestamp: Date.now() });
-        this.syncMessageViews();
         this.isWaitingForResponse = true;
         this.responseBuffer = '';
         this.finishRetryCount = 0;
@@ -1458,6 +1456,13 @@ export class ProviderCliAdapter implements CliAdapter {
         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)));
+        let didCommitUserTurn = false;
+        const commitUserTurn = () => {
+            if (didCommitUserTurn) return;
+            didCommitUserTurn = true;
+            this.committedMessages.push({ role: 'user', content: text, timestamp: Date.now() });
+            this.syncMessageViews();
+        };
         if (this.settleTimer) {
             clearTimeout(this.settleTimer);
             this.settleTimer = null;
@@ -1470,115 +1475,134 @@ export class ProviderCliAdapter implements CliAdapter {
                 if (this.isWaitingForResponse) this.finishResponse();
             }, this.timeouts.maxResponse);
         };
+        await new Promise<void>((resolve) => {
+            let resolved = false;
+            const resolveOnce = () => {
+                if (resolved) return;
+                resolved = true;
+                resolve();
+            };
 
-        const submit = () => {
-            if (!this.ptyProcess) return;
-            this.submitPendingUntil = 0;
-            this.recordTrace('submit_write', {
-                mode: 'submit_key',
-                sendKey: this.sendKey,
-                screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500),
-            });
-            this.ptyProcess.write(this.sendKey);
-            const retrySubmitIfStuck = (attempt: number) => {
-                this.submitRetryTimer = null;
-                if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
-                if (this.currentStatus === 'waiting_approval') return;
-                if ((this.responseBuffer || '').trim()) return;
+            const submit = () => {
+                if (!this.ptyProcess) {
+                    resolveOnce();
+                    return;
+                }
+                commitUserTurn();
+                this.submitPendingUntil = 0;
                 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.recordTrace('submit_write', {
-                    mode: 'submit_retry',
-                    attempt,
+                    mode: 'submit_key',
                     sendKey: this.sendKey,
                     screenText: summarizeCliTraceText(screenText, 500),
                 });
-                this.ptyProcess.write(this.sendKey);
-                if (attempt >= 3) {
-                    this.submitRetryUsed = true;
-                    return;
-                }
-                this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(attempt + 1), retryDelayMs);
+                this.ptyProcess!.write(this.sendKey);
+                const retrySubmitIfStuck = (attempt: number) => {
+                    this.submitRetryTimer = null;
+                    if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
+                    if (this.currentStatus === 'waiting_approval') 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.recordTrace('submit_write', {
+                        mode: 'submit_retry',
+                        attempt,
+                        sendKey: this.sendKey,
+                        screenText: summarizeCliTraceText(screenText, 500),
+                    });
+                    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();
+                resolveOnce();
             };
-            this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(1), retryDelayMs);
-            startResponseTimeout();
-        };
 
-        if (this.submitStrategy === 'immediate') {
-            this.submitPendingUntil = 0;
+            if (this.submitStrategy === 'immediate') {
+                commitUserTurn();
+                this.submitPendingUntil = 0;
+                this.recordTrace('submit_write', {
+                    mode: 'immediate',
+                    text: summarizeCliTraceText(text, 500),
+                    sendKey: this.sendKey,
+                    screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500),
+                });
+                this.ptyProcess!.write(text + this.sendKey);
+                this.submitRetryTimer = setTimeout(() => {
+                    this.submitRetryTimer = null;
+                    if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
+                    if (this.currentStatus === 'waiting_approval') 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.recordTrace('submit_write', {
+                        mode: 'immediate_retry',
+                        attempt: 1,
+                        sendKey: this.sendKey,
+                        screenText: summarizeCliTraceText(screenText, 500),
+                    });
+                    this.ptyProcess.write(this.sendKey);
+                    this.submitRetryUsed = true;
+                }, retryDelayMs);
+                startResponseTimeout();
+                resolveOnce();
+                return;
+            }
+
+            if (submitDelayMs > 0) {
+                this.submitPendingUntil = Date.now() + submitDelayMs;
+            }
+            this.ptyProcess!.write(text);
             this.recordTrace('submit_write', {
-                mode: 'immediate',
+                mode: 'type_then_submit',
                 text: summarizeCliTraceText(text, 500),
                 sendKey: this.sendKey,
                 screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500),
             });
-            this.ptyProcess.write(text + this.sendKey);
-            this.submitRetryTimer = setTimeout(() => {
-                this.submitRetryTimer = null;
-                if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
-                if (this.currentStatus === 'waiting_approval') return;
-                if ((this.responseBuffer || '').trim()) return;
+            const submitStartedAt = Date.now();
+            let lastNormalizedScreen = '';
+            let lastScreenChangeAt = submitStartedAt;
+            const waitForEchoAndSubmit = () => {
+                if (!this.ptyProcess) {
+                    resolveOnce();
+                    return;
+                }
+                const now = Date.now();
+                const elapsed = now - submitStartedAt;
                 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.recordTrace('submit_write', {
-                    mode: 'immediate_retry',
-                    attempt: 1,
-                    sendKey: this.sendKey,
-                    screenText: summarizeCliTraceText(screenText, 500),
-                });
-                this.ptyProcess.write(this.sendKey);
-                this.submitRetryUsed = true;
-            }, retryDelayMs);
-            startResponseTimeout();
-            return;
-        }
+                const normalizedScreen = normalizePromptText(screenText);
+                if (normalizedScreen !== lastNormalizedScreen) {
+                    lastNormalizedScreen = normalizedScreen;
+                    lastScreenChangeAt = now;
+                }
+                const echoVisible = !normalizedPromptSnippet || promptLikelyVisible(screenText, normalizedPromptSnippet);
 
-        if (submitDelayMs > 0) {
-            this.submitPendingUntil = Date.now() + submitDelayMs;
-        }
-        this.ptyProcess.write(text);
-        this.recordTrace('submit_write', {
-            mode: 'type_then_submit',
-            text: summarizeCliTraceText(text, 500),
-            sendKey: this.sendKey,
-            screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500),
-        });
-        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 (echoVisible) {
-                const screenSettled = (now - lastScreenChangeAt) >= 500;
-                if (elapsed >= submitDelayMs && screenSettled) {
+                if (elapsed >= maxEchoWaitMs) {
                     submit();
                     return;
                 }
-            }
 
-            if (elapsed >= maxEchoWaitMs) {
-                submit();
-                return;
-            }
-
-            setTimeout(waitForEchoAndSubmit, 50);
-        };
-        waitForEchoAndSubmit();
+                setTimeout(waitForEchoAndSubmit, 50);
+            };
+            waitForEchoAndSubmit();
+        });
     }
 
     getPartialResponse(): string {

package/src/cli-adapters/provider-cli-config.d.ts

@@ -0,0 +1,30 @@
+import type { CliProviderModule } from './provider-cli-shared.js';
+export interface ProviderResolutionMeta {
+    type: string;
+    name: string;
+    resolvedVersion: string | null;
+    resolvedOs: string | null;
+    providerDir: string | null;
+    scriptDir: string | null;
+    scriptsPath: string | null;
+    scriptsSource: string | null;
+    versionWarning: string | null;
+}
+export interface ResolvedCliAdapterConfig {
+    timeouts: {
+        ptyFlush: number;
+        dialogAccept: number;
+        approvalCooldown: number;
+        generatingIdle: number;
+        idleFinish: number;
+        maxResponse: number;
+        shutdownGrace: number;
+        outputSettle: number;
+    };
+    approvalKeys: Record<number, string>;
+    sendDelayMs: number;
+    sendKey: string;
+    submitStrategy: 'wait_for_echo' | 'immediate';
+    providerResolutionMeta: ProviderResolutionMeta;
+}
+export declare function resolveCliAdapterConfig(provider: CliProviderModule): ResolvedCliAdapterConfig;

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

@@ -0,0 +1,42 @@
+import { type CliChatMessage, type CliScriptInput } from './provider-cli-shared.js';
+export interface TurnParseScope {
+    prompt: string;
+    startedAt: number;
+    bufferStart: number;
+    rawBufferStart: number;
+}
+export declare function hydrateCliParsedMessages(parsedMessages: any[], options: {
+    committedMessages: CliChatMessage[];
+    scope?: TurnParseScope | null;
+    lastOutputAt: number;
+    now?: number;
+}): any[];
+export declare function normalizeCliParsedMessages(parsedMessages: any[], options: {
+    committedMessages: CliChatMessage[];
+    scope?: TurnParseScope | null;
+    lastOutputAt: number;
+    now?: number;
+}): CliChatMessage[];
+export declare function buildCliParseInput(options: {
+    accumulatedBuffer: string;
+    accumulatedRawBuffer: string;
+    recentOutputBuffer: string;
+    terminalScreenText: string;
+    baseMessages: CliChatMessage[];
+    partialResponse: string;
+    scope?: TurnParseScope | null;
+    runtimeSettings: Record<string, any>;
+}): CliScriptInput;
+export declare function summarizeCliTraceText(text: string, max?: number): string;
+export declare function summarizeCliTraceMessages(messages: CliChatMessage[], limit?: number): {
+    role: string;
+    content: string;
+    timestamp?: number;
+}[];
+export declare function buildCliTraceParseSnapshot(options: {
+    accumulatedBuffer: string;
+    accumulatedRawBuffer: string;
+    responseBuffer: string;
+    partialResponse?: string;
+    scope?: TurnParseScope | null;
+}): Record<string, any>;