@adhdev/daemon-core 0.5.3 → 0.5.6

package/providers/_builtin/ide/cursor/scripts/0.49.bak/send_message.js

@@ -0,0 +1,23 @@
+/**
+ * Cursor — send_message
+ *
+ * Cursor는 cdp-type-and-send 방식:
+ *   1. 입력 필드 존재 확인
+ *   2. needsTypeAndSend: true 반환 → daemon이 CDP로 타이핑 + Enter 처리
+ *
+ * 입력 셀렉터: .aislash-editor-input[contenteditable="true"]
+ * 파라미터: ${ MESSAGE } (사용되지 않음 — daemon이 직접 타이핑)
+ */
+(() => {
+  try {
+    const input = document.querySelector('.aislash-editor-input[contenteditable="true"]');
+    if (!input) return JSON.stringify({ sent: false, error: 'Input box not found' });
+    return JSON.stringify({
+      sent: false,
+      needsTypeAndSend: true,
+      selector: '.aislash-editor-input[contenteditable="true"]',
+    });
+  } catch(e) {
+    return JSON.stringify({ sent: false, error: e.message });
+  }
+})()

package/providers/_builtin/ide/cursor/scripts/0.49.bak/set_mode.js

@@ -0,0 +1,38 @@
+/**
+ * Cursor — set_mode
+ *
+ * 모드 드롭다운에서 대상 모드 선택:
+ *   1. 드롭다운 열기
+ *   2. 매칭 아이템 클릭
+ *
+ * params.mode: string — 모드 이름
+ * → { success: true/false, mode? }
+ */
+async (params) => {
+  try {
+    const target = params.mode;
+
+    const modeBtn = document.querySelector('.composer-unified-dropdown:not(.composer-unified-dropdown-model)');
+    if (!modeBtn) return JSON.stringify({ success: false, error: 'Mode button not found' });
+
+    modeBtn.click();
+    await new Promise(r => setTimeout(r, 500));
+
+    const menu = document.querySelector('[data-testid="model-picker-menu"]') || document.querySelector('.typeahead-popover');
+    if (!menu) return JSON.stringify({ success: false, error: 'Mode menu not found' });
+
+    const items = menu.querySelectorAll('.composer-unified-context-menu-item');
+    for (const item of items) {
+      const nameEl = item.querySelector('.monaco-highlighted-label');
+      const name = nameEl?.textContent?.trim() || '';
+      if (name && (name === target || name.toLowerCase() === target.toLowerCase())) {
+        item.click();
+        await new Promise(r => setTimeout(r, 200));
+        return JSON.stringify({ success: true, mode: name });
+      }
+    }
+
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+    return JSON.stringify({ success: false, error: 'mode not found: ' + target });
+  } catch(e) { return JSON.stringify({ success: false, error: e.message }); }
+}

package/providers/_builtin/ide/cursor/scripts/0.49.bak/set_model.js

@@ -0,0 +1,81 @@
+/**
+ * Cursor — set_model
+ *
+ * 모델 드롭다운에서 대상 모델 선택:
+ *   1. 드롭다운 열기
+ *   2. Auto 토글 끄기 (필요 시)
+ *   3. 검색 입력으로 필터
+ *   4. 매칭 아이템 클릭
+ *   5. 원래 Auto 상태 복원
+ *
+ * params.model: string — 모델 이름 (🧠 접미사 가능)
+ * → { success: true/false, model? }
+ */
+async (params) => {
+  try {
+    const target = params.model;
+
+    const modelBtn = document.querySelector('.composer-unified-dropdown-model');
+    if (!modelBtn) return JSON.stringify({ success: false, error: 'Model button not found' });
+
+    modelBtn.click();
+    await new Promise(r => setTimeout(r, 500));
+
+    const menu = document.querySelector('[data-testid="model-picker-menu"]');
+    if (!menu) return JSON.stringify({ success: false, error: 'Model picker menu not found' });
+
+    // 🧠 접미사 처리
+    const wantBrain = target.includes('🧠');
+    const searchName = target.replace(/\s*🧠\s*$/, '').trim();
+
+    // Auto 토글 끄기
+    const autoItem = menu.querySelector('.composer-unified-context-menu-item[data-is-selected="true"]');
+    const autoToggle = autoItem ? [...autoItem.querySelectorAll('[class*="rounded-full"]')].find(el => el.offsetWidth === 24 && el.offsetHeight === 14) : null;
+    let wasAutoOn = false;
+    if (autoToggle) {
+      const bgStyle = autoToggle.getAttribute('style') || '';
+      wasAutoOn = bgStyle.includes('green');
+      if (wasAutoOn) {
+        autoToggle.click();
+        await new Promise(r => setTimeout(r, 500));
+      }
+    }
+
+    // 검색 입력으로 필터링
+    const refreshedMenu = document.querySelector('[data-testid="model-picker-menu"]');
+    const searchInput = refreshedMenu?.querySelector('input[placeholder="Search models"]');
+    if (searchInput) {
+      searchInput.focus();
+      searchInput.value = searchName;
+      searchInput.dispatchEvent(new Event('input', { bubbles: true }));
+      await new Promise(r => setTimeout(r, 300));
+    }
+
+    // 아이템에서 찾기
+    const items = (refreshedMenu || menu).querySelectorAll('.composer-unified-context-menu-item');
+    for (const item of items) {
+      const nameEl = item.querySelector('.monaco-highlighted-label');
+      const name = nameEl?.textContent?.trim() || '';
+      if (!name || name === 'Add Models') continue;
+      const hasBrain = !!item.querySelector('[class*="codicon-br"]');
+
+      if (name.toLowerCase().includes(searchName.toLowerCase()) && hasBrain === wantBrain) {
+        item.click();
+        await new Promise(r => setTimeout(r, 200));
+        const displayName = hasBrain ? name + ' 🧠' : name;
+        return JSON.stringify({ success: true, model: displayName });
+      }
+    }
+
+    // Auto 복원 + 닫기
+    if (wasAutoOn) {
+      const nm = document.querySelector('[data-testid="model-picker-menu"]');
+      const nai = nm?.querySelector('.composer-unified-context-menu-item');
+      const nt = nai ? [...nai.querySelectorAll('[class*="rounded-full"]')].find(el => el.offsetWidth === 24) : null;
+      if (nt) nt.click();
+      await new Promise(r => setTimeout(r, 200));
+    }
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+    return JSON.stringify({ success: false, error: 'model not found: ' + target });
+  } catch(e) { return JSON.stringify({ success: false, error: e.message }); }
+}

package/providers/_builtin/ide/cursor/scripts/0.49.bak/switch_session.js

@@ -0,0 +1,28 @@
+/**
+ * Cursor — switch_session
+ *
+ * 사이드바 셀 클릭으로 세션 전환:
+ *   제목 매칭 (params.title) 또는 인덱스 (params.index)
+ *
+ * params.index: number, params.title: string|null
+ * → { switched: true/false, title?, error? }
+ */
+(params) => {
+  try {
+    const cells = [...document.querySelectorAll('.agent-sidebar-cell')];
+    let target;
+    if (params.title) {
+      target = cells.find(c => {
+        const t = c.querySelector('.agent-sidebar-cell-text')?.textContent?.trim() || '';
+        return t.toLowerCase().includes(params.title.toLowerCase());
+      });
+    } else {
+      target = cells[params.index || 0];
+    }
+    if (!target) return JSON.stringify({ switched: false, error: 'Session not found', available: cells.length });
+    target.click();
+    return JSON.stringify({ switched: true, title: target.querySelector('.agent-sidebar-cell-text')?.textContent?.trim() });
+  } catch(e) {
+    return JSON.stringify({ switched: false, error: e.message });
+  }
+}

package/providers/_builtin/ide/windsurf/scripts/read_chat.js

@@ -86,6 +86,23 @@
         const title = document.title.split(' \u2014 ')[0].trim() || 'Cascade';
 
         // ─── 4. HTML → Markdown 변환기 ───
+        const BLOCK_TAGS = new Set(['DIV', 'P', 'BR', 'LI', 'TR', 'SECTION', 'ARTICLE', 'HEADER', 'FOOTER']);
+        function extractCodeText(node) {
+            if (node.nodeType === 3) return node.textContent || '';
+            if (node.nodeType !== 1) return '';
+            if (node.tagName === 'BR') return '\n';
+            const parts = [];
+            for (const child of node.childNodes) {
+                const isBlock = child.nodeType === 1 && BLOCK_TAGS.has(child.tagName);
+                const text = extractCodeText(child);
+                if (text) {
+                    if (isBlock && parts.length > 0) parts.push('\n');
+                    parts.push(text);
+                    if (isBlock) parts.push('\n');
+                }
+            }
+            return parts.join('').replace(/\n{2,}/g, '\n');
+        }
         function htmlToMd(node) {
             if (node.nodeType === 3) return node.textContent || '';
             if (node.nodeType !== 1) return '';
@@ -121,7 +138,7 @@
             if (tag === 'PRE') {
                 const codeEl = node.querySelector('code');
                 const lang = codeEl ? (codeEl.className.match(/language-(\w+)/)?.[1] || '') : '';
-                const code = (codeEl || node).textContent || '';
+                const code = extractCodeText(codeEl || node);
                 return '\n```' + lang + '\n' + code.trim() + '\n```\n';
             }
             if (tag === 'CODE') {

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

@@ -16,6 +16,7 @@
  */
 
 import * as os from 'os';
+import * as path from 'path';
 import { execSync } from 'child_process';
 import type { CliAdapter } from '../cli-adapter-types.js';
 import { LOG } from '../logging/logger.js';
@@ -23,6 +24,22 @@ import { LOG } from '../logging/logger.js';
 let pty: any;
 try {
     pty = require('node-pty');
+    // node-pty@1.1.0 ships spawn-helper without +x on macOS — fix it
+    if (os.platform() !== 'win32') {
+        try {
+            const fs = require('fs');
+            const ptyDir = path.dirname(require.resolve('node-pty'));
+            const arch = os.arch() === 'arm64' ? 'darwin-arm64' : 'darwin-x64';
+            const helper = path.join(ptyDir, 'prebuilds', arch, 'spawn-helper');
+            if (fs.existsSync(helper)) {
+                const stat = fs.statSync(helper);
+                if (!(stat.mode & 0o111)) {
+                    fs.chmodSync(helper, stat.mode | 0o755);
+                    LOG.info('CLI', '[node-pty] Fixed spawn-helper permissions');
+                }
+            }
+        } catch { /* best-effort */ }
+    }
 } catch {
     LOG.error('CLI', '[ProviderCliAdapter] node-pty not found. Install: npm install node-pty@1.0.0');
 }
@@ -93,6 +110,125 @@ function findBinary(name: string): string {
     }
 }
 
+/** True if file starts with a UTF-8 BOM then #!, or plain #!. */
+function isScriptBinary(binaryPath: string): boolean {
+    if (!path.isAbsolute(binaryPath)) return false;
+    try {
+        const fs = require('fs');
+        const resolved = fs.realpathSync(binaryPath);
+        const head = Buffer.alloc(8);
+        const fd = fs.openSync(resolved, 'r');
+        fs.readSync(fd, head, 0, 8, 0);
+        fs.closeSync(fd);
+        let i = 0;
+        if (head[0] === 0xef && head[1] === 0xbb && head[2] === 0xbf) i = 3;
+        return head[i] === 0x23 && head[i + 1] === 0x21; // '#!'
+    } catch {
+        return false;
+    }
+}
+
+/** True only for Mach-O / ELF — npm shims and shell scripts return false. */
+function looksLikeMachOOrElf(filePath: string): boolean {
+    if (!path.isAbsolute(filePath)) return false;
+    try {
+        const fs = require('fs');
+        const resolved = fs.realpathSync(filePath);
+        const buf = Buffer.alloc(8);
+        const fd = fs.openSync(resolved, 'r');
+        fs.readSync(fd, buf, 0, 8, 0);
+        fs.closeSync(fd);
+        let i = 0;
+        if (buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) i = 3;
+        const b = buf.subarray(i);
+        if (b.length < 4) return false;
+        // ELF
+        if (b[0] === 0x7f && b[1] === 0x45 && b[2] === 0x4c && b[3] === 0x46) return true;
+        const le = b.readUInt32LE(0);
+        const be = b.readUInt32BE(0);
+        const magics = [0xfeedface, 0xfeedfacf, 0xcafebabe, 0xbebafeca];
+        return magics.some(m => m === le || m === be);
+    } catch {
+        return false;
+    }
+}
+
+function shSingleQuote(arg: string): string {
+    if (/^[a-zA-Z0-9@%_+=:,./-]+$/.test(arg)) return arg;
+    return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+
+/**
+ * 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.).
+ */
+function parsePatternEntry(x: unknown): RegExp | null {
+    if (x instanceof RegExp) return x;
+    if (x && typeof x === 'object' && typeof (x as { source?: string }).source === 'string') {
+        try {
+            const s = x as { source: string; flags?: string };
+            return new RegExp(s.source, s.flags || '');
+        } catch {
+            return 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,
+    /^>\s*$/m,             // '>' alone on its own line
+    /[›➤]\s*$/,
+    /for shortcuts/i,
+    /\?\s*for help/i,
+    /Press enter/i,
+    // NOTE: removed /^[\s\u2500-\u257f]*>\s*$/m — the box-drawing char range is too wide and
+    // can match dialog-clearing ANSI output, causing false prompt detection in approval state.
+];
+
+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,
+    /Always\s+allow/i,
+    /\(y\/n\)/i,
+    /\[Y\/n\]/i,
+    /Run\s+this\s+command/i,
+    // NOTE: removed /Do you want to (?:run|execute|allow)/i — too broad, matches AI explanation
+    // text like "Do you want to allow this feature?" causing false approval notifications.
+];
+
+function defaultCleanOutput(raw: string, _lastUserInput?: string): string {
+    return stripAnsi(raw).trim();
+}
+
+export function normalizeCliProviderForRuntime(raw: any): CliProviderModule {
+    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, []),
+        },
+        cleanOutput: typeof raw?.cleanOutput === 'function' ? raw.cleanOutput : defaultCleanOutput,
+    };
+}
+
 export class ProviderCliAdapter implements CliAdapter {
     readonly cliType: string;
     readonly cliName: string;
@@ -125,11 +261,18 @@ export class ProviderCliAdapter implements CliAdapter {
  // Approval cooldown
     private lastApprovalResolvedAt: number = 0;
 
+ // Approval state machine
+    private approvalTransitionBuffer: string = '';
+    private approvalExitTimeout: NodeJS.Timeout | null = null;
+
+ // Resize redraw suppression
+    private resizeSuppressUntil: number = 0;
+
  // Resolved timeouts (provider defaults + overrides)
     private readonly timeouts: Required<NonNullable<CliProviderModule['timeouts']>>;
 
     constructor(provider: CliProviderModule, workingDir: string, private extraArgs: string[] = []) {
-        this.provider = provider;
+        this.provider = normalizeCliProviderForRuntime(provider);
         this.cliType = provider.type;
         this.cliName = provider.name;
         this.workingDir = workingDir.startsWith('~')
@@ -180,18 +323,28 @@ export class ProviderCliAdapter implements CliAdapter {
 
         let shellCmd: string;
         let shellArgs: string[];
-
-        if (spawnConfig.shell) {
- // Execute via shell (for gemini etc npm shim compat)
+        const useShellUnix = !isWin && (
+            !!spawnConfig.shell
+            || !path.isAbsolute(binaryPath)
+            || isScriptBinary(binaryPath)
+            || !looksLikeMachOOrElf(binaryPath)
+        );
+        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)`);
+            }
             shellCmd = isWin ? 'cmd.exe' : (process.env.SHELL || '/bin/zsh');
-            const fullCmd = [binaryPath, ...allArgs].join(' ');
+            const fullCmd = [binaryPath, ...allArgs].map(shSingleQuote).join(' ');
             shellArgs = isWin ? ['/c', fullCmd] : ['-l', '-c', fullCmd];
         } else {
             shellCmd = binaryPath;
             shellArgs = allArgs;
         }
 
-        this.ptyProcess = pty.spawn(shellCmd, shellArgs, {
+        const ptyOpts = {
             name: 'xterm-256color',
             cols: 120,
             rows: 40,
@@ -200,7 +353,22 @@ export class ProviderCliAdapter implements CliAdapter {
                 ...process.env,
                 ...spawnConfig.env,
             } as Record<string, string>,
-        });
+        };
+
+        try {
+            this.ptyProcess = pty.spawn(shellCmd, shellArgs, ptyOpts);
+        } catch (err: any) {
+            const msg = err?.message || String(err);
+            if (!isWin && !useShell && /posix_spawn|spawn/i.test(msg)) {
+                LOG.warn('CLI', `[${this.cliType}] Direct spawn failed (${msg}), retrying via login shell`);
+                shellCmd = process.env.SHELL || '/bin/zsh';
+                const fullCmd = [binaryPath, ...allArgs].map(shSingleQuote).join(' ');
+                shellArgs = ['-l', '-c', fullCmd];
+                this.ptyProcess = pty.spawn(shellCmd, shellArgs, ptyOpts);
+            } else {
+                throw err;
+            }
+        }
 
         this.ptyProcess.onData((data: string) => {
             this.handleOutput(data);
@@ -234,6 +402,9 @@ export class ProviderCliAdapter implements CliAdapter {
  // ─── Output state machine ────────────────────────────
 
     private handleOutput(rawData: string): void {
+ // Suppress output processing briefly after resize to avoid false triggers from screen redraws
+        if (Date.now() < this.resizeSuppressUntil) return;
+
         const cleanData = stripAnsi(rawData);
         const { patterns } = this.provider;
 
@@ -279,32 +450,57 @@ export class ProviderCliAdapter implements CliAdapter {
         if (hasApproval && this.currentStatus !== 'waiting_approval') {
             if (this.lastApprovalResolvedAt && (Date.now() - this.lastApprovalResolvedAt) < this.timeouts.approvalCooldown) return;
 
+            // Capture context before clearing (recentOutputBuffer still has content here)
+            const ctxLines = this.recentOutputBuffer.split('\n')
+                .map(l => l.trim())
+                .filter(l => l && !/^[─═╭╮╰╯│]+$/.test(l));
             this.isWaitingForResponse = true;
             this.currentStatus = 'waiting_approval';
             this.recentOutputBuffer = '';
-            const ctxLines = cleanData.split('\n').map(l => l.trim()).filter(l => l && !/^[─═╭╮╰╯│]+$/.test(l));
+            this.approvalTransitionBuffer = '';
             this.activeModal = {
                 message: ctxLines.slice(-5).join(' ').slice(0, 200) || 'Approval required',
                 buttons: ['Allow once', 'Always allow', 'Deny'],
             };
             if (this.idleTimeout) clearTimeout(this.idleTimeout);
+            // Safety timeout — if stuck in waiting_approval, auto-exit after 60s
+            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`);
+                    this.activeModal = null;
+                    this.lastApprovalResolvedAt = Date.now();
+                    this.recentOutputBuffer = '';
+                    this.approvalTransitionBuffer = '';
+                    this.approvalExitTimeout = null;
+                    this.currentStatus = this.isWaitingForResponse ? 'generating' : 'idle';
+                    this.onStatusChange?.();
+                }
+            }, 60000);
             this.onStatusChange?.();
             return;
         }
 
  // ─── Phase 3: Approval release
+ // Accumulate chunks into approvalTransitionBuffer — the approval dialog clears via ANSI
+ // sequences that strip to nothing, so we can't rely on a single cleanData chunk matching.
         if (this.currentStatus === 'waiting_approval') {
-            const genResume = patterns.generating.some(p => p.test(cleanData));
-            const promptResume = patterns.prompt.some(p => p.test(cleanData));
+            this.approvalTransitionBuffer = (this.approvalTransitionBuffer + cleanData).slice(-500);
+            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.currentStatus = 'generating';
                 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();
             }
@@ -337,7 +533,11 @@ export class ProviderCliAdapter implements CliAdapter {
             }
 
  // Prompt → response complete
-            if (patterns.prompt.some(p => p.test(this.responseBuffer))) {
+ // Only check the LAST 2 lines of cleanData — the prompt appears at the very end of the
+ // output stream. Checking the full chunk causes false positives when response content
+ // has '>' in code blocks, shell examples, or mid-response lines.
+            const trailingLines = cleanData.split('\n').slice(-2).join('\n');
+            if (patterns.prompt.some(p => p.test(trailingLines))) {
                 this.finishResponse();
             } else {
                 this.idleTimeout = setTimeout(() => {
@@ -353,6 +553,7 @@ export class ProviderCliAdapter implements CliAdapter {
     private finishResponse(): void {
         if (this.responseTimeout) { clearTimeout(this.responseTimeout); this.responseTimeout = null; }
         if (this.idleTimeout) { clearTimeout(this.idleTimeout); this.idleTimeout = null; }
+        if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
 
         const lastUserText = this.messages.filter(m => m.role === 'user').pop()?.content;
         let response = this.provider.cleanOutput(this.responseBuffer, lastUserText);
@@ -416,6 +617,7 @@ export class ProviderCliAdapter implements CliAdapter {
     cancel(): void { this.shutdown(); }
 
     shutdown(): void {
+        if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
         if (this.ptyProcess) {
             this.ptyProcess.write('\x03');
             setTimeout(() => {
@@ -440,9 +642,26 @@ 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;
+        const DOWN = '\x1B[B'; // Arrow Down
+        const keys = DOWN.repeat(Math.max(0, buttonIndex)) + '\r';
+        this.ptyProcess.write(keys);
+    }
+
     resize(cols: number, rows: number): void {
         if (this.ptyProcess) {
-            try { this.ptyProcess.resize(cols, rows); } catch { }
+            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.resizeSuppressUntil = Date.now() + 300;
+            } catch { }
         }
     }
 }

package/src/commands/chat-commands.ts

@@ -601,6 +601,42 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
 
     LOG.info('Command', `[resolveAction] action=${action} button="${button}" provider=${provider?.type}`);
 
+    // 0. CLI / ACP category: navigate approval dialog via PTY arrow keys + Enter
+    if (provider?.category === 'cli') {
+        const adapter = h.getCliAdapter(provider.type);
+        if (!adapter) return { success: false, error: 'CLI adapter not running' };
+        const status = (adapter as any).getStatus?.();
+        if (status?.status !== 'waiting_approval') {
+            return { success: false, error: 'Not in approval state' };
+        }
+        const buttons: string[] = status.activeModal?.buttons || ['Allow once', 'Always allow', 'Deny'];
+        // Resolve button index: explicit buttonIndex arg → button text match → action fallback
+        let buttonIndex = typeof args?.buttonIndex === 'number' ? args.buttonIndex : -1;
+        if (buttonIndex < 0) {
+            const btnLower = button.toLowerCase();
+            buttonIndex = buttons.findIndex(b => b.toLowerCase().includes(btnLower));
+        }
+        if (buttonIndex < 0) {
+            if (action === 'reject' || action === 'deny') {
+                buttonIndex = buttons.findIndex(b => /deny|reject|no/i.test(b));
+                if (buttonIndex < 0) buttonIndex = buttons.length - 1;
+            } else if (action === 'always' || /always/i.test(button)) {
+                buttonIndex = buttons.findIndex(b => /always/i.test(b));
+                if (buttonIndex < 0) buttonIndex = 1;
+            } else {
+                buttonIndex = 0; // approve → first option (default selected)
+            }
+        }
+        if (typeof (adapter as any).resolveModal === 'function') {
+            (adapter as any).resolveModal(buttonIndex);
+        } else {
+            const keys = '\x1B[B'.repeat(Math.max(0, buttonIndex)) + '\r';
+            (adapter as any).writeRaw?.(keys);
+        }
+        LOG.info('Command', `[resolveAction] CLI PTY → buttonIndex=${buttonIndex} "${buttons[buttonIndex] ?? '?'}"`);
+        return { success: true, buttonIndex, button: buttons[buttonIndex] ?? button };
+    }
+
     // 1. Extension: via AgentStreamManager
     if (provider?.category === 'extension' && h.agentStream && h.getCdp()) {
         const ok = await h.agentStream.resolveAgentAction(