@adhdev/daemon-core 0.6.56 → 0.6.58

package/providers/_builtin/cli/claude-cli/scripts/1.0/parse_output.js

@@ -1,156 +1,409 @@
 /**
  * Claude Code — parse_output
  *
- * Full PTY buffer → ReadChatResult conversion.
- * Called less frequently than detectStatus (on demand, not polling).
- *
- * Input: {
- *   buffer: string,       // Full ANSI-stripped accumulated PTY output
- *   rawBuffer: string,    // Raw PTY output (with ANSI)
- *   recentBuffer: string, // Recent 1000 chars (ANSI-stripped)
- *   messages: Array,      // Previously parsed messages (for delta)
- *   partialResponse: string, // Current partial response being generated
- * }
- *
- * Output: ReadChatResult {
- *   messages: [{ id, role, content, index, kind?, meta? }],
- *   status: AgentStatus,
- *   activeModal?: ModalInfo | null,
- *   title?: string,
- * }
+ * Reference implementation for CLI PTY parsing:
+ * - prefer the visible screen snapshot (`screenText`)
+ * - keep transcript state incrementally via `messages`
+ * - fall back to noisy rolling buffers when older runtimes do not provide screenText
  */
 
 'use strict';
 
-const detectStatus  = require('./detect_status.js');
+const detectStatus = require('./detect_status.js');
 const parseApproval = require('./parse_approval.js');
 
+function splitLines(text) {
+    return String(text || '')
+        .replace(/\u0007/g, '')
+        .split(/\r\n|\n|\r/g)
+        .map(line => line.replace(/\s+$/, ''));
+}
+
+function sanitizeLine(line) {
+    return String(line || '')
+        .replace(/\u0007/g, '')
+        .replace(/^\d+;/, '')
+        .replace(/\s+$/, '');
+}
+
 function normalizeText(text) {
     return String(text || '')
         .replace(/\s+/g, ' ')
         .trim();
 }
 
-function sanitizeLine(line) {
-    return String(line || '').replace(/\s+$/, '');
+function looksLikeSamePrompt(left, right) {
+    const a = normalizeText(left);
+    const b = normalizeText(right);
+    if (!a || !b) return false;
+    if (a === b) return true;
+    const minLength = Math.min(a.length, b.length);
+    if (minLength < 24) return false;
+    return a.startsWith(b) || b.startsWith(a) || a.includes(b) || b.includes(a);
+}
+
+function isSpinnerOnlyText(text) {
+    const lines = splitLines(text)
+        .map(line => stripAssistantPrefix(sanitizeLine(line).trim()))
+        .filter(Boolean);
+    if (lines.length === 0) return true;
+    return lines.every(line => isStatusLine(line) || /^(?:[A-Z][a-z]+ing\u2026?|[✻✶✳✢✽⠂⠐⠒⠓⠦⠴⠶⠷⠿]+)$/.test(line));
+}
+
+function looksLikePromptEchoText(candidate, promptText, previousMessages) {
+    const normalizedCandidate = normalizeText(candidate);
+    if (!normalizedCandidate) return false;
+    if (promptText && looksLikeSamePrompt(normalizedCandidate, promptText)) return true;
+
+    const lastUser = [...(Array.isArray(previousMessages) ? previousMessages : [])]
+        .reverse()
+        .find(message => message?.role === 'user' && typeof message.content === 'string');
+    return !!lastUser && looksLikeSamePrompt(normalizedCandidate, lastUser.content);
+}
+
+function parsePromptLine(line) {
+    const trimmed = sanitizeLine(line).trim();
+    const match = trimmed.match(/^[❯›>]\s*(.*)$/);
+    if (!match) return null;
+    const body = match[1].trim();
+    if (/^\d+[.)]\s+/.test(body)) return null;
+    return body;
+}
+
+function isBoxLine(trimmed) {
+    return /^[─═╭╮╰╯│┌┐└┘├┤┬┴┼]+$/.test(trimmed);
+}
+
+function isFooterLine(trimmed) {
+    return /^➜\s+\S+/.test(trimmed)
+        || /^Update available!/i.test(trimmed)
+        || /Claude Code v\d/i.test(trimmed)
+        || /^(Sonnet|Opus|Haiku)\b/i.test(trimmed)
+        || /^[◐◑◒◓◴◵◶◷◸◹◺◿].*\/effort/i.test(trimmed)
+        || /^⏵⏵\s+accept edits on/i.test(trimmed)
+        || /^ctrl\+g to edit in VS Code/i.test(trimmed)
+        || /^✳\s*Claude Code/i.test(trimmed)
+        || /^[▗▖▘▝\s]+~\//.test(trimmed);
+}
+
+function isStatusLine(trimmed) {
+    if (!trimmed) return true;
+    if (/^[✻✶✳✢✽⠂⠐⠒⠓⠦⠴⠶⠷⠿]+$/.test(trimmed)) return true;
+    if (/^[⠂⠐⠒⠓⠦⠴⠶⠷⠿]\s+/.test(trimmed)) return true;
+    if (/esc to (cancel|interrupt|stop)/i.test(trimmed)) return true;
+    if (/(?:Finagling|Scurrying|Bloviating|Whatchamacallit(?:ing)?|Hatching|Tinkering|Thinking|Processing|Working|Analyzing|Planning|Drafting|Synthesizing|Inspecting|Reading|Searching)\u2026?$/i.test(trimmed)) return true;
+    if (/Allow\s*once|Always\s*allow|\(y\/n\)|\[Y\/n\]/i.test(trimmed)) return true;
+    return false;
 }
 
 function isNoiseLine(line) {
-    const trimmed = line.trim();
+    const trimmed = sanitizeLine(line).trim();
     if (!trimmed) return true;
-    if (/^[─═╭╮╰╯│┌┐└┘├┤┬┴┼]+$/.test(trimmed)) return true;
+    if (/^…\s+\+\d+\s+lines\b/i.test(trimmed)) return true;
+    if (isBoxLine(trimmed)) return true;
+    if (isFooterLine(trimmed)) return true;
+    if (isStatusLine(trimmed)) return true;
     if (/^Type your message/i.test(trimmed)) return true;
     if (/^for\s*shortcuts/i.test(trimmed)) return true;
     if (/^\? for help/i.test(trimmed)) return true;
     if (/^Press enter/i.test(trimmed)) return true;
-    if (/^[\u2800-\u28ff]+$/.test(trimmed)) return true;
-    if (/^esc to (cancel|interrupt|stop)/i.test(trimmed)) return true;
-    if (/^Allow\s*once/i.test(trimmed)) return true;
-    if (/^Always\s*allow/i.test(trimmed)) return true;
-    if (/^\[(Y\/n|y\/n)\]$/i.test(trimmed)) return true;
     return false;
 }
 
-function extractPromptLine(lines) {
-    for (let i = lines.length - 1; i >= 0; i--) {
-        const trimmed = lines[i].trim();
-        const match = trimmed.match(/^[❯›>]\s+(.+)$/);
-        if (match && match[1].trim().length > 0) {
-            return { index: i, text: match[1].trim() };
+function stripAssistantPrefix(trimmed) {
+    return trimmed
+        .replace(/^[⏺•]\s+/, '')
+        .replace(/^⎿\s+/, '')
+        .replace(/^[✻✶✳✢✽]\s+/, '')
+        .trim();
+}
+
+function collectMeaningfulLines(lines) {
+    const out = [];
+    let captureDetails = false;
+    for (let index = 0; index < lines.length; index++) {
+        const rawLine = lines[index];
+        const promptText = parsePromptLine(rawLine);
+        if (promptText !== null) continue;
+
+        const sanitized = sanitizeLine(rawLine);
+        const trimmed = sanitized.trim();
+        if (isNoiseLine(trimmed)) continue;
+        const nextTrimmed = sanitizeLine(lines[index + 1] || '').trim();
+        if (/\u2026\)$/.test(trimmed) && /^⎿\s+/.test(nextTrimmed)) continue;
+
+        const cleaned = stripAssistantPrefix(trimmed);
+        if (!cleaned) continue;
+        if (/^⏺\s+/.test(trimmed)) {
+            captureDetails = /^(?:Bash|Read|Task)\(/.test(cleaned)
+                || /^(?:Exact output|Output|Result):/i.test(cleaned);
+            if (out[out.length - 1] !== cleaned) out.push(cleaned);
+            continue;
+        }
+
+        if (/^⎿\s+/.test(trimmed)) {
+            if (!captureDetails || /^…\s+\+\d+\s+lines\b/i.test(cleaned)) continue;
+            if (out[out.length - 1] !== cleaned) out.push(cleaned);
+            continue;
         }
+
+        if (!captureDetails && /^\d+\s+/.test(trimmed)) continue;
+        if (cleaned.length === 1 && /^[A-Za-z]$/.test(cleaned)) continue;
+        if (out[out.length - 1] !== cleaned) out.push(cleaned);
     }
-    return { index: -1, text: '' };
+    return out;
+}
+
+function looksLikeStructuredDataLine(text) {
+    const line = stripAssistantPrefix(sanitizeLine(text).trim());
+    if (!line) return false;
+    return /^[{\[]/.test(line)
+        || /^[A-Z0-9_]+=/.test(line)
+        || /^\/[A-Za-z0-9._/-]+$/.test(line)
+        || /^\d+$/.test(line);
 }
 
-function extractVisibleAssistant(screenText) {
-    if (!screenText) return { promptText: '', assistantText: '' };
-    const lines = screenText.split('\n').map(sanitizeLine);
-    const prompt = extractPromptLine(lines);
-    const afterPrompt = prompt.index >= 0 ? lines.slice(prompt.index + 1) : lines;
-    const contentLines = afterPrompt.filter(line => !isNoiseLine(line));
+function extractDenseOutputBlock(text) {
+    const lines = splitLines(text);
+    const blocks = [];
+    let current = [];
+
+    for (const rawLine of lines) {
+        const promptText = parsePromptLine(rawLine);
+        const sanitized = sanitizeLine(rawLine).trim();
+        if (promptText !== null || isNoiseLine(sanitized)) {
+            if (current.length > 0) {
+                blocks.push(current);
+                current = [];
+            }
+            continue;
+        }
+
+        const cleaned = stripAssistantPrefix(sanitized);
+        if (!cleaned) {
+            if (current.length > 0) {
+                blocks.push(current);
+                current = [];
+            }
+            continue;
+        }
+        current.push(cleaned);
+    }
+
+    if (current.length > 0) blocks.push(current);
+
+    const scored = blocks
+        .map(block => ({
+            block,
+            structured: block.filter(looksLikeStructuredDataLine).length,
+        }))
+        .filter(entry => entry.block.length >= 5 && entry.structured >= Math.max(3, Math.floor(entry.block.length * 0.6)));
+
+    const mergeBlocks = (existing, next) => {
+        if (existing.length === 0) return [...next];
+        const maxOverlap = Math.min(existing.length, next.length);
+        for (let overlap = maxOverlap; overlap >= 1; overlap--) {
+            let matches = true;
+            for (let i = 0; i < overlap; i++) {
+                if (existing[existing.length - overlap + i] !== next[i]) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches) {
+                return existing.concat(next.slice(overlap));
+            }
+        }
+        return existing.concat(next);
+    };
+
+    const merged = scored.reduce((acc, entry) => mergeBlocks(acc, entry.block), []);
+    return merged.join('\n').trim();
+}
+
+function collectAssistantBlocks(lines) {
+    const blocks = [];
+    let current = null;
+    for (const rawLine of lines) {
+        const sanitized = sanitizeLine(rawLine);
+        const trimmed = sanitized.trim();
+        if (!trimmed || isNoiseLine(trimmed)) continue;
+
+        if (/^⏺\s+/.test(trimmed)) {
+            const title = stripAssistantPrefix(trimmed);
+            if (!title) {
+                current = null;
+                continue;
+            }
+            current = {
+                title,
+                lines: [title],
+                isTool: /^(?:Bash|Read|Write|Edit|MultiEdit|Task|Glob|Grep|LS|NotebookEdit)\(/.test(title),
+            };
+            blocks.push(current);
+            continue;
+        }
+
+        if (!current) continue;
+        const cleaned = stripAssistantPrefix(trimmed);
+        if (!cleaned || /^…\s+\+\d+\s+lines\b/i.test(cleaned)) continue;
+        current.lines.push(cleaned);
+    }
+    return blocks;
+}
+
+function extractVisibleTurn(text, previousMessages) {
+    const lines = splitLines(text);
+    const emptyPromptIndex = (() => {
+        for (let i = lines.length - 1; i >= 0; i--) {
+            if (parsePromptLine(lines[i]) === '') return i;
+        }
+        return -1;
+    })();
+
+    const userPrompt = (() => {
+        const upperBound = emptyPromptIndex >= 0 ? emptyPromptIndex - 1 : lines.length - 1;
+        for (let i = upperBound; i >= 0; i--) {
+            const parsed = parsePromptLine(lines[i]);
+            if (parsed) return { index: i, text: parsed };
+        }
+        return { index: -1, text: '' };
+    })();
+
+    const promptLines = [];
+    let assistantStart = userPrompt.index >= 0 ? userPrompt.index + 1 : 0;
+    if (userPrompt.index >= 0) {
+        promptLines.push(userPrompt.text);
+        for (let i = userPrompt.index + 1; i < lines.length; i++) {
+            const trimmed = sanitizeLine(lines[i]).trim();
+            if (!trimmed) {
+                assistantStart = i + 1;
+                break;
+            }
+            if (/^[⏺•]/.test(trimmed) || isBoxLine(trimmed) || isFooterLine(trimmed) || isStatusLine(trimmed) || /^([❯›>]\s*)?\d+[.)]\s+/.test(trimmed)) {
+                assistantStart = i;
+                break;
+            }
+            promptLines.push(trimmed);
+            assistantStart = i + 1;
+        }
+    }
+
+    const end = emptyPromptIndex >= 0 ? emptyPromptIndex : lines.length;
+    const assistantWindow = lines.slice(assistantStart, end);
+    const blocks = collectAssistantBlocks(assistantWindow);
+    const lastNarrativeBlock = [...blocks].reverse().find(block => !block.isTool);
+    let assistantLines = lastNarrativeBlock
+        ? lastNarrativeBlock.lines
+        : collectMeaningfulLines(assistantWindow);
+
+    if (assistantLines.length === 0 && Array.isArray(previousMessages) && previousMessages.length > 0) {
+        assistantLines = collectMeaningfulLines(lines);
+    }
+
     return {
-        promptText: prompt.text,
-        assistantText: contentLines.join('\n').trim(),
+        promptText: promptLines.join(' ').trim(),
+        assistantText: assistantLines.join('\n').trim(),
     };
 }
 
-function toMessageObjects(messages, status) {
-    const max = 50;
-    const slice = messages.slice(-max);
-    return slice.map((message, index) => ({
-        id: `msg_${index}`,
-        role: message.role,
-        content: typeof message.content === 'string' && message.content.length > 6000
-            ? message.content.slice(0, 6000) + '\n[... truncated]'
-            : message.content,
-        index,
-        kind: 'standard',
-        ...(status === 'generating' && index === slice.length - 1 && message.role === 'assistant'
-            ? { meta: { streaming: true } }
-            : {}),
-    }));
+function extractPartialAssistant(text) {
+    const meaningful = collectMeaningfulLines(splitLines(text));
+    return meaningful.join('\n').trim();
 }
 
-function buildMessages(previousMessages, promptText, assistantText, status, partialResponse) {
+function buildMessages(previousMessages, promptText, assistantText, partialText) {
     const base = Array.isArray(previousMessages)
-        ? previousMessages.map(m => ({
-            role: m.role,
-            content: typeof m.content === 'string' ? m.content : String(m.content || ''),
-            timestamp: m.timestamp,
-        }))
+        ? previousMessages
+            .filter(message => message && (message.role === 'user' || message.role === 'assistant'))
+            .map(message => ({
+                role: message.role,
+                content: typeof message.content === 'string' ? message.content : String(message.content || ''),
+                timestamp: message.timestamp,
+            }))
         : [];
 
-    const last = base[base.length - 1];
+    if (!promptText && base.length === 0) {
+        return base;
+    }
+
     if (promptText) {
         const normalizedPrompt = normalizeText(promptText);
-        if (!last || last.role !== 'user' || normalizeText(last.content) !== normalizedPrompt) {
+        const last = base[base.length - 1];
+        const previousUser = last?.role === 'assistant' ? base[base.length - 2] : last;
+        if (!previousUser || previousUser.role !== 'user' || !looksLikeSamePrompt(previousUser.content, normalizedPrompt)) {
             base.push({ role: 'user', content: promptText });
         }
     }
 
-    const candidateAssistant = normalizeText(partialResponse || '') || assistantText;
-    if (candidateAssistant) {
-        const normalizedAssistant = normalizeText(candidateAssistant);
-        const lastMsg = base[base.length - 1];
-        if (lastMsg && lastMsg.role === 'assistant') {
-            const existing = normalizeText(lastMsg.content);
-            if (normalizedAssistant !== existing) {
-                lastMsg.content = candidateAssistant;
-            }
-        } else {
-            base.push({ role: 'assistant', content: candidateAssistant });
-        }
-    }
+    const candidateAssistant = assistantText || partialText;
+    if (!candidateAssistant) return base;
 
-    if (status !== 'generating') {
-        const lastMsg = base[base.length - 1];
-        if (lastMsg?.role === 'assistant') {
-            const visible = normalizeText(assistantText);
-            if (visible && visible !== normalizeText(lastMsg.content)) {
-                lastMsg.content = assistantText;
-            }
+    const normalizedAssistant = normalizeText(candidateAssistant);
+    if (!normalizedAssistant) return base;
+    if (looksLikePromptEchoText(candidateAssistant, promptText, previousMessages)) return base;
+    if (!assistantText && isSpinnerOnlyText(candidateAssistant)) return base;
+
+    const last = base[base.length - 1];
+    if (last && last.role === 'assistant') {
+        if (normalizeText(last.content) !== normalizedAssistant) {
+            last.content = candidateAssistant;
         }
+    } else {
+        base.push({ role: 'assistant', content: candidateAssistant });
     }
 
     return base;
 }
 
+function toMessageObjects(messages, status) {
+    return messages.slice(-50).map((message, index, slice) => ({
+        id: `msg_${index}`,
+        role: message.role,
+        content: typeof message.content === 'string' && message.content.length > 6000
+            ? message.content.slice(0, 6000) + '\n[... truncated]'
+            : message.content,
+        index,
+        kind: 'standard',
+        ...(status === 'generating' && index === slice.length - 1 && message.role === 'assistant'
+            ? { meta: { streaming: true } }
+            : {}),
+    }));
+}
+
 module.exports = function parseOutput(input) {
-    const { buffer, recentBuffer, partialResponse, screenText, messages: previousMessages } = input;
-    const transcript = screenText || buffer || '';
+    const screenText = String(input?.screenText || '');
+    const buffer = String(input?.buffer || '');
+    const terminalHistory = String(input?.terminalHistory || '');
+    const tail = String(input?.recentBuffer || (screenText || buffer).slice(-500));
+    const previousMessages = Array.isArray(input?.messages) ? input.messages : [];
+    const transcriptSource = screenText || buffer;
 
-    // Status
-    const tail = (recentBuffer || (transcript || '').slice(-500));
-    const status = detectStatus({ tail });
+    const status = detectStatus({
+        tail,
+        screenText,
+        rawBuffer: input?.rawBuffer || '',
+    });
 
-    // Modal
     const activeModal = status === 'waiting_approval'
-        ? parseApproval({ buffer: transcript, tail })
+        ? parseApproval({ buffer: screenText || buffer, rawBuffer: input?.rawBuffer || '', tail })
         : null;
 
-    const { promptText, assistantText } = extractVisibleAssistant(transcript);
+    const { promptText, assistantText: visibleAssistantText } = status === 'waiting_approval'
+        ? { promptText: '', assistantText: '' }
+        : extractVisibleTurn(transcriptSource, previousMessages);
+    const denseTerminalOutput = extractDenseOutputBlock(terminalHistory || buffer);
+    const assistantText = denseTerminalOutput || visibleAssistantText;
+    const rawPartialText = status === 'generating'
+        ? extractPartialAssistant(input?.partialResponse || '')
+        : '';
+    const partialText = (!rawPartialText
+        || isSpinnerOnlyText(rawPartialText)
+        || looksLikePromptEchoText(rawPartialText, promptText, previousMessages))
+        ? ''
+        : rawPartialText;
     const messages = toMessageObjects(
-        buildMessages(previousMessages, promptText, assistantText, status, partialResponse),
+        buildMessages(previousMessages, promptText, assistantText, partialText),
         status
     );
 

package/providers/_builtin/cli/codex-cli/provider.json

@@ -57,6 +57,8 @@
     }
   },
   "binary": "codex",
+  "sendDelayMs": 1200,
+  "sendKey": "\r",
   "spawn": {
     "command": "codex",
     "args": [],

package/providers/_builtin/cli/codex-cli/scripts/1.0/detect_status.js

@@ -1,20 +1,54 @@
 /**
  * Codex CLI — detect_status
- * OpenAI Codex CLI uses a different TUI pattern.
  */
 'use strict';
+
+function sourceText(input) {
+    return `${String(input?.screenText || '')}\n${String(input?.tail || '')}`;
+}
+
+function hasWelcomeScreen(text) {
+    return /OpenAI Codex/i.test(text)
+        && /To get started, describe a task/i.test(text);
+}
+
+function hasStartupApproval(text) {
+    return /You are running Codex in/i.test(text)
+        && /Press Enter to continue/i.test(text)
+        && /(?:^|\n)[▌> \t]*1\.\s+/m.test(text)
+        && /(?:^|\n)[▌> \t]*2\.\s+/m.test(text);
+}
+
+function hasCommandApproval(text) {
+    const hasAllowPrompt = /Allow Codex to (?:run|apply)/i.test(text)
+        || /Allow command\?/i.test(text);
+    const hasButtons = /Approve and run now/i.test(text)
+        || /Always approve this session/i.test(text)
+        || /(?:^|\n)[▌> \t]*1\.\s+.*(?:approve|allow|run)/im.test(text)
+        || /(?:^|\n)[▌> \t]*2\.\s+.*(?:always|session)/im.test(text);
+    const hasFooter = /Press Enter to confirm/i.test(text)
+        || /Esc to cancel/i.test(text);
+    return hasAllowPrompt
+        || (hasButtons && hasFooter)
+        || /Approve and run now/i.test(text)
+        || /Always approve this session/i.test(text)
+        || /(?:^|\n)[▌> \t]*1\.\s+.*(?:approve|allow|run)/im.test(text);
+}
+
 module.exports = function detectStatus(input) {
-    const { tail } = input;
-    if (!tail) return 'idle';
+    const text = sourceText(input);
+    if (!text.trim()) return 'idle';
+
+    if (hasStartupApproval(text) || hasCommandApproval(text)) return 'waiting_approval';
 
-    // waiting_approval
-    if (/approve|deny|allow|reject/i.test(tail) && /\[.*\]/i.test(tail)) return 'waiting_approval';
-    if (/Run command/i.test(tail) && /\(y\/n\)/i.test(tail)) return 'waiting_approval';
+    if (/Esc to interrupt/i.test(text)) return 'generating';
+    if (/(?:Thinking|Planning|Searching|Reading|Working|Analyzing|Inspecting|Responding|Following instructions clearly)[^\n]*\(\d+s\b/i.test(text)) {
+        return 'generating';
+    }
+    if (/[⠁-⣿]/.test(text) && /(?:Working|Thinking|Esc to interrupt)/i.test(text)) return 'generating';
 
-    // generating
-    if (/[\u2800-\u28ff]/.test(tail)) return 'generating';
-    if (/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/.test(tail)) return 'generating';
-    if (/thinking|processing|running/i.test(tail)) return 'generating';
+    if (hasWelcomeScreen(text)) return 'idle';
+    if (/⏎\s+send/i.test(text)) return 'idle';
 
     return 'idle';
 };

package/providers/_builtin/cli/codex-cli/scripts/1.0/parse_approval.js

@@ -2,14 +2,90 @@
  * Codex CLI — parse_approval
  */
 'use strict';
+
+function splitLines(text) {
+    return String(text || '')
+        .replace(/\u0007/g, '')
+        .split(/\r\n|\n|\r/g)
+        .map(line => line.replace(/\s+$/, ''));
+}
+
+function normalize(line) {
+    return String(line || '')
+        .replace(/\u0007/g, '')
+        .replace(/^\d+;/, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
+function isBoxLine(line) {
+    return /^[─═╭╮╰╯│┌┐└┘├┤┬┴┼]+$/.test(line);
+}
+
+function isFooterLine(line) {
+    return /⏎\s+send/i.test(line)
+        || /⌃J\s+newline/i.test(line)
+        || /⌃T\s+transcript/i.test(line)
+        || /⌃C\s+quit/i.test(line)
+        || /Press Enter to (?:continue|confirm)/i.test(line)
+        || /Esc to cancel/i.test(line);
+}
+
+function stripLeadingMarkers(s) {
+    return s.replace(/^(?:[▌>]\s*)+/, '').trim();
+}
+
+function normalizeButton(line) {
+    return stripLeadingMarkers(normalize(line))
+        .replace(/^\d+\.\s+/, '')
+        .replace(/\s{2,}\([A-Za-z]\)\s.*$/, '')
+        .trim();
+}
+
+function isButtonLine(line) {
+    return /^\d+\.\s+/.test(stripLeadingMarkers(normalize(line)));
+}
+
 module.exports = function parseApproval(input) {
-    const { tail } = input;
-    if (!tail) return null;
-    const hasApproval = /approve|allow/i.test(tail) && /deny|reject/i.test(tail);
-    if (!hasApproval && !/\(y\/n\)/i.test(tail)) return null;
-    const lines = tail.split('\n').map(l => l.trim()).filter(l => l && !/^[─═╭╮╰╯│]+$/.test(l));
+    const text = String(input?.buffer || input?.tail || '');
+    const lines = splitLines(text);
+    if (lines.length === 0) return null;
+
+    const buttons = [];
+    let currentButton = '';
+    const recentLines = lines.slice(-60);
+    for (const rawLine of recentLines) {
+        const line = normalize(rawLine);
+        if (!line) continue;
+        if (isButtonLine(rawLine)) {
+            if (currentButton && !buttons.includes(currentButton)) buttons.push(currentButton);
+            currentButton = normalizeButton(rawLine);
+            continue;
+        }
+        if (!currentButton) continue;
+        if (isFooterLine(line) || isBoxLine(line)) continue;
+        if (/^(?:model|directory):/i.test(line)) continue;
+        const continuation = stripLeadingMarkers(line);
+        if (!continuation) continue;
+        currentButton = `${currentButton} ${continuation}`.replace(/\s+/g, ' ').trim();
+    }
+    if (currentButton && !buttons.includes(currentButton)) buttons.push(currentButton);
+
+    const approvalText = lines
+        .map(normalize)
+        .filter(line => line && !isBoxLine(line) && !isButtonLine(line) && !isFooterLine(line))
+        .filter(line => !/^OpenAI Codex\b/i.test(line))
+        .filter(line => !/^model:/i.test(line))
+        .filter(line => !/^directory:/i.test(line));
+
+    const hasApproval = /You are running Codex in/i.test(text)
+        || /Allow Codex to (?:run|apply)/i.test(text)
+        || /Allow command\?/i.test(text)
+        || buttons.length > 0;
+    if (!hasApproval) return null;
+
     return {
-        message: lines.slice(-5).join(' ').slice(0, 200) || 'Approval required',
-        buttons: ['Approve', 'Deny'],
+        message: approvalText.slice(-3).join(' ').slice(0, 240) || 'Codex approval required',
+        buttons: buttons.length > 0 ? buttons : ['Approve', 'Deny'],
     };
 };