@adhdev/daemon-core 0.6.53 → 0.6.56

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

@@ -1,18 +1,17 @@
 /**
- * ProviderCliAdapter — generic CLI Adapter based on provider.js
+ * ProviderCliAdapter — Script-based CLI Adapter
  *
- * Replaces individual adapters (gemini-cli.ts, claude-cli.ts, codex-cli.ts).
- * Single engine driven by provider.js patterns, spawn, and cleanOutput.
+ * All CLI providers use versioned scripts (like IDE providers).
+ * Scripts are Node.js functions that receive PTY buffer data and return structured results.
  *
- * provider.js contract:
- * type: string — 'gemini-cli', 'claude-cli', 'codex-cli', ...
- * name: string — 'Gemini CLI', 'Claude Code', ...
- * category: 'cli'
- * binary: string — binary name
- * spawn: { command, args, shell, env }
- * patterns: { prompt, generating, approval, ready } — prompt helps end startup splash-gate early; sendMessage does not wait for it
- * timeouts?: { idleFinish, generatingIdle, maxResponse, approvalCooldown, outputSettle, ... }
- * cleanOutput(raw, lastUserInput): string
+ * 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 * as os from 'os';
@@ -20,6 +19,7 @@ import * as path from 'path';
 import { execSync } from 'child_process';
 import type { CliAdapter } from '../cli-adapter-types.js';
 import { LOG } from '../logging/logger.js';
+import { TerminalScreen } from './terminal-screen.js';
 
 let pty: any;
 try {
@@ -44,6 +44,8 @@ try {
     LOG.error('CLI', '[ProviderCliAdapter] node-pty not found. Terminal features disabled.');
 }
 
+// ─── Types ──────────────────────────────────────────
+
 export interface CliChatMessage {
     role: 'user' | 'assistant';
     content: string;
@@ -57,23 +59,46 @@ export interface CliSessionStatus {
     activeModal: { message: string; buttons: string[] } | null;
 }
 
+/**
+ * CLI Script Functions.
+ * Unlike IDE scripts (which return JS code strings for CDP evaluate),
+ * CLI scripts are Node.js functions that receive PTY buffer data and return structured results.
+ */
+export interface CliScripts {
+    /** Full PTY buffer → ReadChatResult (messages, status, activeModal) */
+    parseOutput?: (input: CliScriptInput) => any;
+    /** Lightweight status detection (high-frequency polling) → AgentStatus string */
+    detectStatus?: (input: { tail: string; screenText?: string; rawBuffer?: string }) => string | null;
+    /** Parse approval modal from PTY output → ModalInfo | null */
+    parseApproval?: (input: { buffer: string; rawBuffer?: string; tail: string }) => { message: string; buttons: string[] } | null;
+    /** Produce a cli-specific prompt from a dashboard action payload */
+    resolveAction?: (data: any) => string;
+    /** Custom scripts */
+    [name: string]: ((input: any) => any) | undefined;
+}
+
+export interface CliScriptInput {
+    buffer: string;          // Full ANSI-stripped accumulated PTY output
+    rawBuffer: string;       // Raw PTY output (with ANSI)
+    recentBuffer: string;    // Recent 1000 chars (ANSI-stripped)
+    screenText: string;      // Current visible screen snapshot
+    messages: CliChatMessage[];  // Previously parsed messages
+    partialResponse: string; // Current partial response being generated
+}
+
 export interface CliProviderModule {
     type: string;
     name: string;
     category: 'cli';
     binary: string;
+    sendDelayMs?: number;
+    sendKey?: string;
     spawn: {
         command: string;
         args: string[];
         shell: boolean;
         env: Record<string, string>;
     };
-    patterns: {
-        prompt: RegExp[];
-        generating: RegExp[];
-        approval: RegExp[];
-        ready: RegExp[];
-    };
     timeouts?: {
  /** PTY output batch transmit interval (default 50ms) */
         ptyFlush?: number;
@@ -89,12 +114,13 @@ export interface CliProviderModule {
         maxResponse?: number;
  /** shutdown after kill wait (default 1000ms) */
         shutdownGrace?: number;
- /** Output settle debounce before evaluating idle/approval (default 300ms) */
+ /** Output settle debounce before evaluating status (default 300ms) */
         outputSettle?: number;
     };
-    cleanOutput(raw: string, lastUserInput?: string): string;
 }
 
+// ─── Utility Functions ──────────────────────────────
+
 function stripAnsi(str: string): string {
  // eslint-disable-next-line no-control-regex
     return str
@@ -168,9 +194,8 @@ function shSingleQuote(arg: string): string {
 }
 
 /**
- * provider.json stores regex placeholders as `{}` — JSON.parse leaves plain objects,
- * so `.test` is missing and the PTY handler throws on first output. Coerce to RegExp
- * (including `{ "source": "...", "flags": "i" }`) or fall back to generic TUIs (Claude Code, etc.).
+ * Normalize provider.json for auto-implement approval detection.
+ * Kept for backward compat with dev-server auto-impl pipeline only.
  */
 function parsePatternEntry(x: unknown): RegExp | null {
     if (x instanceof RegExp) return x;
@@ -185,55 +210,26 @@ function parsePatternEntry(x: unknown): RegExp | null {
     return null;
 }
 
-function coercePatternArray(raw: unknown, fallbacks: RegExp[]): RegExp[] {
-    if (!Array.isArray(raw)) return [...fallbacks];
-    const parsed = raw.map(parsePatternEntry).filter((r): r is RegExp => r != null);
-    return parsed.length > 0 ? parsed : [...fallbacks];
-}
-
-/** Defaults tuned for Claude Code / similar agent CLIs when provider.json patterns are empty. */
-const FALLBACK_PROMPT: RegExp[] = [
-    /Type your message/i,
-    /for\s*shortcuts/i,    // Claude Code prompt
-    /\?\s*for\s*help/i,    // Claude Code help prompt
-    /Press enter/i,
-    /^[>›❯]\s*$/i,         // Prompt char as the complete evaluated string
-    /[>›❯]\s*$/,           // Prompt char at the very end of evaluated string
-];
-
-const FALLBACK_GENERATING: RegExp[] = [
-    /[\u2800-\u28ff]/,                             // Braille spinner blocks (universal TUI)
-    /esc to (cancel|interrupt|stop)/i,             // Common TUI generation status line
-    /generating\.\.\./i,
-    /Claude is (?:thinking|processing|working)/i,  // Specific Claude Code status
-];
-
-const FALLBACK_APPROVAL: RegExp[] = [
-    /Allow\s*once/i,         // ANSI strip may remove spaces
-    /Always\s*allow/i,
-    /\(y\/n\)/i,
-    /\[Y\/n\]/i,
-    /Yes,?\s*don'?t\s*ask/i, // "Yes, don't ask again" (Claude Code)
-];
-
-function defaultCleanOutput(raw: string, _lastUserInput?: string): string {
-    return stripAnsi(raw).trim();
+function coercePatternArray(raw: unknown): RegExp[] {
+    if (!Array.isArray(raw)) return [];
+    return raw.map(parsePatternEntry).filter((r): r is RegExp => r != null);
 }
 
-export function normalizeCliProviderForRuntime(raw: any): CliProviderModule {
+/**
+ * Normalize raw provider JSON for auto-implement approval patterns.
+ * Used by dev-server only — ProviderCliAdapter itself uses scripts.
+ */
+export function normalizeCliProviderForRuntime(raw: any): { patterns: { approval: RegExp[] } } {
     const patterns = raw?.patterns || {};
     return {
-        ...raw,
         patterns: {
-            prompt: coercePatternArray(patterns.prompt, FALLBACK_PROMPT),
-            generating: coercePatternArray(patterns.generating, FALLBACK_GENERATING),
-            approval: coercePatternArray(patterns.approval, FALLBACK_APPROVAL),
-            ready: coercePatternArray(patterns.ready, []),
+            approval: coercePatternArray(patterns.approval),
         },
-        cleanOutput: typeof raw?.cleanOutput === 'function' ? raw.cleanOutput : defaultCleanOutput,
     };
 }
 
+// ─── Adapter ────────────────────────────────────────
+
 export class ProviderCliAdapter implements CliAdapter {
     readonly cliType: string;
     readonly cliName: string;
@@ -242,6 +238,7 @@ export class ProviderCliAdapter implements CliAdapter {
     private provider: CliProviderModule;
     private ptyProcess: any = null;
     private messages: CliChatMessage[] = [];
+    private structuredMessages: CliChatMessage[] = [];
     private currentStatus: CliSessionStatus['status'] = 'starting';
     private onStatusChange: (() => void) | null = null;
 
@@ -253,7 +250,6 @@ export class ProviderCliAdapter implements CliAdapter {
     private idleTimeout: NodeJS.Timeout | null = null;
     private ready = false;
     private startupBuffer = '';
-    /** After spawn: briefly skip generating/settle so splash/redraw does not flip status; not used to gate sendMessage */
     private startupParseGate = false;
     private spawnAt = 0;
 
@@ -275,7 +271,8 @@ export class ProviderCliAdapter implements CliAdapter {
 
  // Output settle debounce — fires after PTY output goes quiet
     private settleTimer: NodeJS.Timeout | null = null;
-    private settledBuffer: string = ''; // snapshot of recentOutputBuffer at settle time
+    private settledBuffer: string = '';
+    private submitPendingUntil = 0;
 
  // Resize redraw suppression
     private resizeSuppressUntil: number = 0;
@@ -283,6 +280,17 @@ export class ProviderCliAdapter implements CliAdapter {
  // Debug: status transition history
     private statusHistory: { status: string; at: number; trigger?: string }[] = [];
 
+ // ─── CLI Scripts (script-based parsing) ───
+    private cliScripts: CliScripts;
+    /** Full accumulated ANSI-stripped PTY output */
+    private accumulatedBuffer: string = '';
+    /** Full accumulated raw PTY output (with ANSI) */
+    private accumulatedRawBuffer: string = '';
+    /** Current visible terminal screen snapshot */
+    private terminalScreen = new TerminalScreen(40, 120);
+    /** Max accumulated buffer size (last 50KB) */
+    private static readonly MAX_ACCUMULATED_BUFFER = 50000;
+
     private setStatus(status: CliSessionStatus['status'], trigger?: string): void {
         const prev = this.currentStatus;
         if (prev === status) return;
@@ -292,21 +300,22 @@ export class ProviderCliAdapter implements CliAdapter {
         LOG.info('CLI', `[${this.cliType}] status: ${prev} → ${status}${trigger ? ` (${trigger})` : ''}`);
     }
 
- // Resolved timeouts (provider defaults + overrides)
+ // Resolved timeouts
     private readonly timeouts: Required<NonNullable<CliProviderModule['timeouts']>>;
 
- // Provider approval key mapping (e.g. { 0: '1', 1: '2', 2: '3' }) — loaded from provider.json
+ // Provider approval key mapping
     private readonly approvalKeys: Record<number, string>;
+    private readonly sendDelayMs: number;
+    private readonly sendKey: string;
 
     constructor(provider: CliProviderModule, workingDir: string, private extraArgs: string[] = []) {
-        this.provider = normalizeCliProviderForRuntime(provider);
+        this.provider = provider;
         this.cliType = provider.type;
         this.cliName = provider.name;
         this.workingDir = workingDir.startsWith('~')
             ? workingDir.replace(/^~/, os.homedir())
             : workingDir;
 
- // Apply timeout overrides from Provider
         const t = provider.timeouts || {};
         this.timeouts = {
             ptyFlush: t.ptyFlush ?? 50,
@@ -319,9 +328,28 @@ export class ProviderCliAdapter implements CliAdapter {
             outputSettle: t.outputSettle ?? 300,
         };
 
- // Load approval key mapping from provider (e.g. approvalKeys: {"0":"1","1":"2","2":"3"})
         const rawKeys = (provider as any).approvalKeys;
         this.approvalKeys = (rawKeys && typeof rawKeys === 'object') ? rawKeys : {};
+        this.sendDelayMs = typeof (provider as any).sendDelayMs === 'number' ? Math.max(0, (provider as any).sendDelayMs) : 0;
+        this.sendKey = typeof (provider as any).sendKey === 'string' && (provider as any).sendKey.length > 0
+            ? (provider as any).sendKey
+            : '\r';
+
+        // Scripts are required — loaded by ProviderLoader via compatibility array
+        this.cliScripts = (provider as any).scripts || {};
+        const scriptNames = Object.keys(this.cliScripts).filter(k => typeof (this.cliScripts as any)[k] === 'function');
+        if (scriptNames.length > 0) {
+            LOG.info('CLI', `[${this.cliType}] CLI scripts: [${scriptNames.join(', ')}]`);
+        } else {
+            LOG.warn('CLI', `[${this.cliType}] ⚠ No CLI scripts loaded! Provider needs scripts/{version}/scripts.js`);
+        }
+    }
+
+    /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
+    setCliScripts(scripts: CliScripts): void {
+        this.cliScripts = scripts;
+        const scriptNames = Object.keys(scripts).filter(k => typeof (scripts as any)[k] === 'function');
+        LOG.info('CLI', `[${this.cliType}] CLI scripts injected: [${scriptNames.join(', ')}]`);
     }
 
  // ─── Lifecycle ─────────────────────────────────
@@ -364,7 +392,6 @@ export class ProviderCliAdapter implements CliAdapter {
         const useShell = isWin ? !!spawnConfig.shell : useShellUnix;
 
         if (useShell) {
- // Execute via shell (npm shims, shebang scripts, anything that is not a bare Mach-O/ELF)
             if (!spawnConfig.shell && !isWin) {
                 LOG.info('CLI', `[${this.cliType}] Using login shell (script shim or non-native binary)`);
             }
@@ -404,7 +431,6 @@ export class ProviderCliAdapter implements CliAdapter {
 
         this.ptyProcess.onData((data: string) => {
             this.handleOutput(data);
- // PTY output batch transmit (50ms)
             if (this.onPtyDataCallback) {
                 this.ptyOutputBuffer += data;
                 if (!this.ptyOutputFlushTimer) {
@@ -432,21 +458,30 @@ export class ProviderCliAdapter implements CliAdapter {
         this.spawnAt = Date.now();
         this.startupParseGate = true;
         this.startupBuffer = '';
+        this.terminalScreen.reset(40, 120);
         this.ready = true;
         this.setStatus('idle', 'pty_ready');
         this.onStatusChange?.();
     }
 
- // ─── Output state machine ────────────────────────────
+ // ─── Output Handling ────────────────────────────
 
     private handleOutput(rawData: string): void {
- // Suppress output processing briefly after resize to avoid false triggers from screen redraws
         if (Date.now() < this.resizeSuppressUntil) return;
 
+        if (rawData.includes('\x1b[6n') || rawData.includes('\x1b[?6n')) {
+            // Some TUIs probe cursor position during startup; node-pty does not answer automatically.
+            this.ptyProcess?.write('\x1b[1;1R');
+        }
+
+        this.terminalScreen.write(rawData);
         const cleanData = stripAnsi(rawData);
-        const { patterns } = this.provider;
 
- // Server log forwarding
+        if (this.isWaitingForResponse && cleanData) {
+            this.responseBuffer = (this.responseBuffer + cleanData).slice(-8000);
+        }
+
+        // Server log forwarding
         if (cleanData.trim()) {
             if (this.serverConn) {
                 this.serverConn.sendMessage('log', { message: cleanData.trim(), level: 'info' });
@@ -455,13 +490,14 @@ export class ProviderCliAdapter implements CliAdapter {
             }
         }
 
- // Rolling buffer (recent 1000 chars)
+        // Rolling buffers
         this.recentOutputBuffer = (this.recentOutputBuffer + cleanData).slice(-1000);
+        this.accumulatedBuffer = (this.accumulatedBuffer + cleanData).slice(-ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        this.accumulatedRawBuffer = (this.accumulatedRawBuffer + rawData).slice(-ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
 
- // ─── Startup window: first-run dialogs + avoid false generating during splash (sendMessage is not gated on prompt text)
+        // ─── Startup window: auto-proceed first-run dialogs
         if (this.startupParseGate) {
             this.startupBuffer += cleanData;
-            LOG.info('CLI', `[${this.cliType}] startup chunk (${cleanData.length} chars): ${cleanData.slice(0, 200).replace(/\n/g, '\\n')}`);
 
             const dialogPatterns = [
                 /Do you want to connect/i,
@@ -478,133 +514,63 @@ export class ProviderCliAdapter implements CliAdapter {
 
             const elapsed = Date.now() - this.spawnAt;
             const bufCap = this.startupBuffer.length > 12000;
-            const promptMatched = patterns.prompt.some(p => p.test(this.startupBuffer));
-            if (promptMatched || elapsed > 8000 || bufCap) {
-                this.startupParseGate = false;
-                if (promptMatched) {
-                    LOG.info('CLI', `[${this.cliType}] ✓ Startup gate end (prompt matched)`);
-                } else {
-                    LOG.info('CLI', `[${this.cliType}] startup gate end (${elapsed}ms, cap=${bufCap}, prompt=${promptMatched})`);
-                }
-            } else {
-                return;
-            }
-        }
 
-        if (cleanData.trim().length > 5) {
-            LOG.debug('CLI', `[${this.cliType}] output chunk (${cleanData.length}): ${cleanData.slice(0, 300).replace(/\n/g, '\\n')}`);
-        }
-
- // ─── Phase 2: generating — immediate detection (fast UX response)
-        if (!this.isWaitingForResponse) {
-            if (patterns.generating.some(p => p.test(cleanData))) {
-                if (this.settleTimer) { clearTimeout(this.settleTimer); this.settleTimer = null; }
-                this.isWaitingForResponse = true;
-                this.responseBuffer = '';
-                this.setStatus('generating', 'autonomous_gen');
-                this.onStatusChange?.();
-            }
-        }
+            // Use detectStatus script to check if CLI is ready (shows a prompt)
+            const scriptStatus = this.runDetectStatus(this.startupBuffer);
+            const isReady = scriptStatus === 'idle' || elapsed > 8000 || bufCap;
 
-        if (this.isWaitingForResponse) {
-            this.responseBuffer += cleanData;
-            if (this.idleTimeout) clearTimeout(this.idleTimeout);
-
- // ─── Phase 3: still generating
-            if (patterns.generating.some(p => p.test(cleanData))) {
-                this.setStatus('generating', 'still_generating');
-                this.idleTimeout = setTimeout(() => {
-                    if (this.isWaitingForResponse) this.finishResponse();
-                }, this.timeouts.generatingIdle);
-                this.onStatusChange?.();
-                // Cancel any pending settle — we're clearly still generating
-                if (this.settleTimer) { clearTimeout(this.settleTimer); this.settleTimer = null; }
+            if (isReady) {
+                this.startupParseGate = false;
+                LOG.info('CLI', `[${this.cliType}] Startup gate end (${elapsed}ms, scriptStatus=${scriptStatus})`);
+            } else {
                 return;
             }
         }
 
- // ─── Phase 4: waiting_approval — accumulate transition buffer
-        if (this.currentStatus === 'waiting_approval') {
-            this.approvalTransitionBuffer = (this.approvalTransitionBuffer + cleanData).slice(-500);
-            // Schedule settle check — output may still be arriving (ANSI redraws etc)
-            this.scheduleSettle();
-            return;
-        }
-
- // ─── Phase 5: settle debounce — schedule idle/approval evaluation
+        // ─── Script-based status detection
         this.scheduleSettle();
     }
 
- /**
-  * Fired after output goes quiet for outputSettle ms.
-  * Evaluates the stabilised buffer for approval, prompt (idle), or timeout.
-  */
     private scheduleSettle(): void {
         if (this.settleTimer) clearTimeout(this.settleTimer);
+        const delay = Math.max(
+            this.timeouts.outputSettle,
+            this.submitPendingUntil > Date.now()
+                ? (this.submitPendingUntil - Date.now()) + this.timeouts.outputSettle
+                : 0,
+        );
         this.settleTimer = setTimeout(() => {
             this.settleTimer = null;
             this.settledBuffer = this.recentOutputBuffer;
             this.evaluateSettled();
-        }, this.timeouts.outputSettle);
+        }, delay);
     }
 
     private evaluateSettled(): void {
-        const { patterns } = this.provider;
-        const buf = this.settledBuffer;
-
- // ─── waiting_approval: check for transition out
-        if (this.currentStatus === 'waiting_approval') {
-            const genResume = patterns.generating.some(p => p.test(this.approvalTransitionBuffer));
-            const promptResume = patterns.prompt.some(p => p.test(this.approvalTransitionBuffer));
-            if (genResume) {
-                if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
-                this.setStatus('generating', 'approval_gen_resume');
-                this.activeModal = null;
-                this.recentOutputBuffer = '';
-                this.approvalTransitionBuffer = '';
-                this.lastApprovalResolvedAt = Date.now();
-                this.onStatusChange?.();
-            } else if (promptResume) {
-                if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
-                this.activeModal = null;
-                this.recentOutputBuffer = '';
-                this.approvalTransitionBuffer = '';
-                this.lastApprovalResolvedAt = Date.now();
-                this.finishResponse();
-            }
-            // else: still waiting — approvalExitTimeout will handle the 60s safety case
-            return;
-        }
+        const tail = this.settledBuffer;
+        const scriptStatus = this.runDetectStatus(tail);
+        if (!scriptStatus) return;
 
- // ─── check for approval on stabilised buffer
-        const hasApproval = patterns.approval.some(p => p.test(buf));
-        if (hasApproval) {
+        const prevStatus = this.currentStatus;
+
+        if (scriptStatus === 'waiting_approval') {
             const inCooldown = this.lastApprovalResolvedAt && (Date.now() - this.lastApprovalResolvedAt) < this.timeouts.approvalCooldown;
             if (!inCooldown) {
-                const ctxLines = buf.split('\n')
-                    .map(l => l.trim())
-                    .filter(l => l && !/^[─═╭╮╰╯│]+$/.test(l));
                 this.isWaitingForResponse = true;
-                this.setStatus('waiting_approval', 'approval_pattern');
-                this.recentOutputBuffer = '';
-                this.approvalTransitionBuffer = '';
-                this.activeModal = {
-                    message: ctxLines.slice(-5).join(' ').slice(0, 200) || 'Approval required',
-                    buttons: this.cliType === 'claude-cli'
-                        ? ['Yes (y)', 'Always allow (a)', 'Deny (Esc)']
-                        : ['Allow once', 'Always allow', 'Deny'],
-                };
+                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-exiting waiting_approval`);
+                        LOG.warn('CLI', `[${this.cliType}] Approval timeout — auto-clearing`);
                         this.activeModal = null;
                         this.lastApprovalResolvedAt = Date.now();
-                        this.recentOutputBuffer = '';
-                        this.approvalTransitionBuffer = '';
-                        this.approvalExitTimeout = null;
-                        this.setStatus(this.isWaitingForResponse ? 'generating' : 'idle', 'approval_cleared');
+                        this.setStatus('idle', 'approval_timeout');
                         this.onStatusChange?.();
                     }
                 }, 60000);
@@ -613,22 +579,39 @@ export class ProviderCliAdapter implements CliAdapter {
             }
         }
 
- // ─── check for prompt (idle) on stabilised buffer
-        if (this.isWaitingForResponse) {
-            // Only look at the trailing portion — prompt appears at the very end
-            const trailingLines = buf.split('\n').slice(-3).join('\n');
-            if (patterns.prompt.some(p => p.test(trailingLines)) && !hasApproval) {
-                this.finishResponse();
-            } else if (!patterns.generating.some(p => p.test(buf))) {
-                // Output has settled with no generating signal and no prompt — schedule idle finish
-                if (this.idleTimeout) clearTimeout(this.idleTimeout);
-                this.idleTimeout = setTimeout(() => {
-                    if (this.isWaitingForResponse && this.responseBuffer.trim()) {
-                        this.finishResponse();
-                    }
-                }, this.timeouts.idleFinish);
+        if (scriptStatus === 'generating') {
+            if (prevStatus === 'waiting_approval') {
+                // Transitioned out of approval → generating
+                if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
+                this.activeModal = null;
+                this.lastApprovalResolvedAt = Date.now();
+            }
+            if (!this.isWaitingForResponse) {
+                this.isWaitingForResponse = true;
+                this.responseBuffer = '';
             }
+            this.setStatus('generating', 'script_detect');
+            // Reset idle timeout
+            if (this.idleTimeout) clearTimeout(this.idleTimeout);
+            this.idleTimeout = setTimeout(() => {
+                if (this.isWaitingForResponse) this.finishResponse();
+            }, this.timeouts.generatingIdle);
             this.onStatusChange?.();
+            return;
+        }
+
+        if (scriptStatus === 'idle') {
+            if (prevStatus === 'waiting_approval') {
+                if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
+                this.activeModal = null;
+                this.lastApprovalResolvedAt = Date.now();
+            }
+            if (this.isWaitingForResponse) {
+                this.finishResponse();
+            } else if (prevStatus !== 'idle') {
+                this.setStatus('idle', 'script_detect');
+                this.onStatusChange?.();
+            }
         }
     }
 
@@ -637,23 +620,6 @@ export class ProviderCliAdapter implements CliAdapter {
         if (this.idleTimeout) { clearTimeout(this.idleTimeout); this.idleTimeout = null; }
         if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
 
-        const lastUserText = this.messages.filter(m => m.role === 'user').pop()?.content;
-        let response = this.provider.cleanOutput(this.responseBuffer, lastUserText);
-
- // Remove user input echo
-        if (lastUserText && response) {
-            const userTrimmed = lastUserText.trim();
-            response = response.split('\n')
-                .filter(l => l.trim() !== userTrimmed)
-                .join('\n').trim();
-        }
-
-        if (response) {
-            this.messages.push({ role: 'assistant', content: response, timestamp: Date.now() });
-            if (this.messages.length > 200) this.messages = this.messages.slice(-200);
-            LOG.info('CLI', `[${this.cliType}] Response (${response.length} chars)`);
-        }
-
         this.responseBuffer = '';
         this.isWaitingForResponse = false;
         this.activeModal = null;
@@ -661,9 +627,54 @@ export class ProviderCliAdapter implements CliAdapter {
         this.onStatusChange?.();
     }
 
- // ─── Public API (CliAdapter interface) ──────────
+ // ─── Script Execution ──────────────────────────
+
+    private runDetectStatus(text: string): string | null {
+        if (!this.cliScripts?.detectStatus) return null;
+        try {
+            return this.cliScripts.detectStatus({
+                tail: text.slice(-500),
+                screenText: this.terminalScreen.getText(),
+                rawBuffer: this.accumulatedRawBuffer,
+            });
+        } catch (e: any) {
+            LOG.warn('CLI', `[${this.cliType}] detectStatus error: ${e.message}`);
+            return null;
+        }
+    }
+
+    private runParseApproval(tail: string): { message: string; buttons: string[] } | null {
+        if (!this.cliScripts?.parseApproval) return null;
+        try {
+            return this.cliScripts.parseApproval({
+                buffer: this.terminalScreen.getText() || this.accumulatedBuffer,
+                rawBuffer: this.accumulatedRawBuffer,
+                tail,
+            });
+        } catch (e: any) {
+            LOG.warn('CLI', `[${this.cliType}] parseApproval error: ${e.message}`);
+            return null;
+        }
+    }
+
+ // ─── 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],
@@ -672,28 +683,97 @@ export class ProviderCliAdapter implements CliAdapter {
         };
     }
 
+    /**
+     * Script-based full parse — returns ReadChatResult.
+     * Called by command handler / dashboard for rich content rendering.
+     */
+    getScriptParsedStatus(): 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;
+            }
+        } catch (e: any) {
+            LOG.warn('CLI', `[${this.cliType}] parseOutput error: ${e.message}`);
+        }
+        return null;
+    }
+
+    /** Whether this adapter has CLI scripts loaded */
+    hasCliScripts(): boolean {
+        return typeof this.cliScripts?.detectStatus === 'function';
+    }
+
+    /**
+     * Resolves an action (like 'fix' lint error) from the dashboard.
+     * Uses resolveAction script if available, otherwise falls back to standard text.
+     */
+    async resolveAction(data: any): Promise<void> {
+        let promptText = '';
+        if (this.cliScripts && typeof this.cliScripts.resolveAction === 'function') {
+            try {
+                promptText = this.cliScripts.resolveAction(data);
+            } catch (e: any) {
+                LOG.warn('CLI', `[${this.cliType}] resolveAction error: ${e.message}`);
+            }
+        }
+        if (!promptText && data) {
+            // Default fallback
+            promptText = `Please fix the following issue:\n${data.title || ''}\n${data.explanation || ''}\n\n${data.message || ''}`.trim();
+        }
+        if (promptText) {
+            await this.sendMessage(promptText);
+        }
+    }
+
     async sendMessage(text: string): Promise<void> {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         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.isWaitingForResponse = true;
         this.responseBuffer = '';
         this.setStatus('generating', 'sendMessage');
         this.onStatusChange?.();
-
-        this.ptyProcess.write(text + '\r');
-
-        this.responseTimeout = setTimeout(() => {
-            if (this.isWaitingForResponse) this.finishResponse();
-        }, this.timeouts.maxResponse);
+        this.ptyProcess.write(text);
+
+        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);
+        };
+        if (this.sendDelayMs > 0) {
+            this.submitPendingUntil = Date.now() + this.sendDelayMs;
+            setTimeout(submit, this.sendDelayMs);
+        } else {
+            submit();
+        }
     }
 
     getPartialResponse(): string {
         if (!this.isWaitingForResponse) return '';
-        const partial = this.provider.cleanOutput(this.responseBuffer);
-        return partial || (this.isWaitingForResponse ? '(generating...)' : '');
+        return this.responseBuffer;
     }
 
     cancel(): void { this.shutdown(); }
@@ -717,6 +797,10 @@ export class ProviderCliAdapter implements CliAdapter {
 
     clearHistory(): void {
         this.messages = [];
+        this.structuredMessages = [];
+        this.accumulatedBuffer = '';
+        this.accumulatedRawBuffer = '';
+        this.terminalScreen.reset();
         this.onStatusChange?.();
     }
 
@@ -727,19 +811,11 @@ export class ProviderCliAdapter implements CliAdapter {
         this.ptyProcess?.write(data);
     }
 
- /**
- * Resolve an approval modal by navigating to the button at `buttonIndex` and pressing Enter.
- * Index 0 = first option (already selected by default — just Enter).
- * Index N = press Arrow Down N times, then Enter.
- */
     resolveModal(buttonIndex: number): void {
         if (!this.ptyProcess || this.currentStatus !== 'waiting_approval') return;
-        // Use provider-defined approval keys if available
-        // Each provider.json can define: { "approvalKeys": { "0": "1", "1": "2", "2": "3" } }
         if (buttonIndex in this.approvalKeys) {
             this.ptyProcess.write(this.approvalKeys[buttonIndex]);
         } else {
-            // Generic fallback: Arrow Down to navigate + Enter to select
             const DOWN = '\x1B[B';
             const keys = DOWN.repeat(Math.max(0, buttonIndex)) + '\r';
             this.ptyProcess.write(keys);
@@ -750,27 +826,13 @@ export class ProviderCliAdapter implements CliAdapter {
         if (this.ptyProcess) {
             try {
                 this.ptyProcess.resize(cols, rows);
- // Suppress output for 300ms after resize — PTY redraws the screen and
- // the redrawn content (spinners, status text) would falsely trigger generating detection
+                this.terminalScreen.resize(rows, cols);
                 this.resizeSuppressUntil = Date.now() + 300;
             } catch { }
         }
     }
 
- /**
- * Full debug state — exposes all internal buffers, status, and patterns for debugging.
- * Used by DevServer /api/cli/debug endpoint.
- */
     getDebugState(): Record<string, any> {
-        const sb = this.startupBuffer;
-        const testOnStartup = (p: RegExp): boolean => {
-            const flags = p.flags.includes('g') ? p.flags.replace(/g/g, '') : p.flags;
-            return new RegExp(p.source, flags).test(sb);
-        };
-        const promptDiagnostics = this.provider.patterns.prompt.map((p) => ({
-            pattern: p.toString(),
-            matchedAgainstStartupBuffer: testOnStartup(p),
-        }));
         return {
             type: this.cliType,
             name: this.cliName,
@@ -780,32 +842,24 @@ export class ProviderCliAdapter implements CliAdapter {
             spawnAt: this.spawnAt,
             workingDir: this.workingDir,
             messages: this.messages.slice(-20),
+            structuredMessages: this.structuredMessages.slice(-20),
             messageCount: this.messages.length,
-            // Buffers (longer tails here than in periodic logs — for matching provider.json patterns)
-            startupBuffer: sb.slice(-4000),
-            startupBufferLength: sb.length,
-            promptDiagnostics,
+            screenText: this.terminalScreen.getText().slice(-4000),
+            startupBuffer: this.startupBuffer.slice(-4000),
             recentOutputBuffer: this.recentOutputBuffer.slice(-500),
             settledBuffer: this.settledBuffer.slice(-500),
-            responseBuffer: this.responseBuffer.slice(-500),
-            approvalTransitionBuffer: this.approvalTransitionBuffer.slice(-500),
-            // State
+            accumulatedBufferLength: this.accumulatedBuffer.length,
+            accumulatedRawBufferLength: this.accumulatedRawBuffer.length,
+            rawBufferPreview: this.accumulatedRawBuffer.slice(-1000),
+            responseBuffer: this.responseBuffer.slice(-1000),
             isWaitingForResponse: this.isWaitingForResponse,
             activeModal: this.activeModal,
             lastApprovalResolvedAt: this.lastApprovalResolvedAt,
             resizeSuppressUntil: this.resizeSuppressUntil,
-            // Provider patterns (serialized)
-            patterns: {
-                prompt: this.provider.patterns.prompt.map(p => p.toString()),
-                generating: this.provider.patterns.generating.map(p => p.toString()),
-                approval: this.provider.patterns.approval.map(p => p.toString()),
-                ready: this.provider.patterns.ready.map(p => p.toString()),
-            },
-            // Status history
+            hasCliScripts: this.hasCliScripts(),
+            scriptNames: Object.keys(this.cliScripts).filter(k => typeof (this.cliScripts as any)[k] === 'function'),
             statusHistory: this.statusHistory.slice(-30),
-            // Timeouts config
             timeouts: this.timeouts,
-            // PTY alive
             ptyAlive: !!this.ptyProcess,
         };
     }