vibeman 0.0.2 → 0.0.5

package/dist/runtime/api/agent/ai-providers/codex-cli-provider.js

@@ -6,6 +6,29 @@ import { spawn } from 'child_process';
 import { getSettingsService } from '../../settings-service.js';
 import { getProviderDetectionService } from '../../lib/provider-detection.js';
 import { logger } from '../../lib/logger.js';
+const CODEX_BASE_MODELS = [
+    'gpt-5.1-codex-max',
+    'gpt-5.1-codex',
+    'gpt-5.1-codex-mini',
+    'gpt-5.2',
+    'gpt-5.1',
+];
+const CODEX_BASE_LABELS = {
+    'gpt-5.1-codex-max': 'gpt-5.1 Codex Max (current)',
+    'gpt-5.1-codex': 'gpt-5.1 Codex',
+    'gpt-5.1-codex-mini': 'gpt-5.1 Codex Mini',
+    'gpt-5.2': 'gpt-5.2',
+    'gpt-5.1': 'gpt-5.1',
+};
+const REASONING_SUFFIXES = [
+    'minimal',
+    'low',
+    'medium',
+    'high',
+    'extra',
+    'extra-high',
+    'extra_high',
+];
 export class CodexCliProvider {
     constructor(config = {}) {
         this.config = config;
@@ -37,26 +60,52 @@ export class CodexCliProvider {
         // Default to binary name (resolve via PATH)
         return 'codex';
     }
+    normalizeReasoningEffort(value) {
+        if (!value)
+            return undefined;
+        const normalized = value.toLowerCase().replace(/\s+/g, '-');
+        if (normalized === 'minimal')
+            return 'low';
+        if (normalized === 'extra-high' || normalized === 'extra_high' || normalized === 'extra') {
+            return 'extra_high';
+        }
+        const allowed = ['low', 'medium', 'high'];
+        return allowed.includes(normalized)
+            ? normalized
+            : undefined;
+    }
+    resolveModelSpec(model, fallbackEffort) {
+        const fallback = this.normalizeReasoningEffort(fallbackEffort);
+        if (!model) {
+            return { reasoning: fallback };
+        }
+        const trimmed = model.trim();
+        const normalized = trimmed.toLowerCase();
+        const basePattern = CODEX_BASE_MODELS.map((m) => m.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')).join('|');
+        const reasoningPattern = [...REASONING_SUFFIXES].join('|');
+        const match = normalized.match(new RegExp(`^(${basePattern})(?:-(${reasoningPattern}))?$`));
+        if (!match) {
+            return {
+                cliModel: trimmed,
+                requestedModel: trimmed,
+                reasoning: fallback,
+            };
+        }
+        const baseModel = match[1];
+        const reasoning = this.normalizeReasoningEffort(match[2]);
+        return {
+            cliModel: baseModel,
+            requestedModel: trimmed,
+            reasoning: reasoning ?? fallback,
+        };
+    }
     async *execute(prompt, options) {
         // Effective options
         const cwd = options?.workingDirectory || this.config.defaultWorkingDirectory || process.cwd();
-        const mapModel = (m) => {
-            if (!m)
-                return m;
-            // Normalize reasoning-effort variants to the canonical model id
-            // Users reported only `gpt-5` is selectable; variants are effort levels in the TUI.
-            const lower = m.toLowerCase();
-            if (lower === 'gpt-5-minimal' ||
-                lower === 'gpt-5-low' ||
-                lower === 'gpt-5-medium' ||
-                lower === 'gpt-5-high') {
-                return 'gpt-5';
-            }
-            return m;
-        };
-        const model = mapModel(options?.model || this.config.defaultModel);
+        const resolvedModel = this.resolveModelSpec(options?.model || this.config.defaultModel, options?.effort);
+        const model = resolvedModel.cliModel;
         const images = (options?.images || []).filter(Boolean);
-        const effort = options?.effort;
+        const reasoningEffort = resolvedModel.reasoning;
         const timeoutMs = options?.timeout ?? this.config.defaultTimeoutMs ?? 10 * 60 * 1000; // 10m
         const systemPrompt = options?.systemPrompt?.trim();
         const appendSystemPrompt = options?.appendSystemPrompt?.trim();
@@ -74,6 +123,9 @@ export class CodexCliProvider {
         if (model) {
             argv.push('--model', model);
         }
+        if (reasoningEffort) {
+            argv.push('-c', `model_reasoning_effort=${reasoningEffort}`);
+        }
         // Prefer spawning with cwd, but also set --cd to make Codex aware of root
         if (cwd) {
             argv.push('--cd', cwd);
@@ -82,7 +134,9 @@ export class CodexCliProvider {
             argv.push('--image', images.join(','));
         }
         if (options?.dangerouslyBypassApprovalsAndSandbox) {
-            argv.push('--dangerously-bypass-approvals-and-sandbox');
+            // Codex CLI >= 0.73.0 replaces the legacy bypass flag with --full-auto + sandbox selection
+            argv.push('--full-auto');
+            argv.push('--sandbox', 'danger-full-access');
         }
         const cmd = await this.resolveExecutable();
         const child = spawn(cmd, argv, {
@@ -95,7 +149,7 @@ export class CodexCliProvider {
             type: 'init',
             timestamp: new Date().toISOString(),
             sessionId: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-            model: model || 'default',
+            model: resolvedModel.requestedModel || model || 'default',
             provider: this.name,
         };
         yield init;
@@ -108,7 +162,7 @@ export class CodexCliProvider {
             metadata: {
                 provider: this.name,
                 images,
-                effort,
+                effort: reasoningEffort || options?.effort,
                 systemPrompt,
                 appendSystemPrompt,
                 dangerouslyBypassApprovalsAndSandbox: !!options?.dangerouslyBypassApprovalsAndSandbox,
@@ -242,6 +296,7 @@ export class CodexCliProvider {
         // Convenience: collect from execute()
         let content = '';
         const start = Date.now();
+        const resolvedModel = this.resolveModelSpec(options?.model || this.config.defaultModel, options?.effort);
         for await (const msg of this.execute(prompt, options)) {
             if (msg.type === 'assistant' && typeof msg.content === 'string') {
                 content += (content ? '\n' : '') + msg.content;
@@ -250,26 +305,31 @@ export class CodexCliProvider {
         return {
             id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
             provider: this.name,
-            model: options?.model || this.config.defaultModel || 'default',
+            model: resolvedModel.requestedModel || resolvedModel.cliModel || 'default',
             content,
             usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
             duration: Date.now() - start,
         };
     }
     async detectAvailableModels() {
-        // Current public CLI exposes `--model gpt-5`; effort levels are chosen in-CLI.
-        return [
-            {
-                id: 'gpt-5',
-                name: 'gpt-5',
-                displayName: 'gpt‑5',
-                provider: this.name,
-                contextWindow: 256000,
-                maxOutputTokens: 16384,
-                // Capabilities per Codex docs: supports images via --image and advanced reasoning
-                capabilities: ['code', 'analysis', 'tools', 'vision', 'image', 'reasoning'],
-            },
+        const capabilities = ['code', 'analysis', 'tools', 'vision', 'image', 'reasoning'];
+        const makeModel = (id, displayName) => ({
+            id,
+            name: id,
+            displayName,
+            provider: this.name,
+            contextWindow: 256000,
+            maxOutputTokens: 16384,
+            capabilities,
+        });
+        const addReasoningVariants = (base, label) => [
+            makeModel(base, label),
+            makeModel(`${base}-low`, `${label} · low reasoning`),
+            makeModel(`${base}-medium`, `${label} · medium reasoning`),
+            makeModel(`${base}-high`, `${label} · high reasoning`),
+            makeModel(`${base}-extra-high`, `${label} · extra-high reasoning`),
         ];
+        return Object.entries(CODEX_BASE_LABELS).flatMap(([id, label]) => addReasoningVariants(id, label));
     }
     async validateSetup() {
         try {

package/dist/runtime/api/agent/ai-providers/gemini-cli-provider.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Gemini CLI Provider
+ * Headless wrapper around the Gemini CLI binary (default command `gemini`).
+ */
+import { AIProvider, ExecutionMessage, ExecutionOptions, ModelInfo, ProviderCapabilities, ProviderStatus } from './types.js';
+export interface GeminiCliConfig {
+    geminiBinPath?: string;
+    defaultWorkingDirectory?: string;
+    defaultModel?: string;
+    defaultTimeoutMs?: number;
+}
+export declare class GeminiCliProvider implements AIProvider {
+    private config;
+    readonly name = "gemini";
+    readonly displayName = "Gemini CLI";
+    constructor(config?: GeminiCliConfig);
+    private resolveExecutable;
+    private normalizeReasoningEffort;
+    private resolveModelSpec;
+    execute(prompt: string, options?: ExecutionOptions): AsyncIterableIterator<ExecutionMessage>;
+    detectAvailableModels(): Promise<ModelInfo[]>;
+    validateSetup(): Promise<ProviderStatus>;
+    getCapabilities(): ProviderCapabilities;
+}

package/dist/runtime/api/agent/ai-providers/gemini-cli-provider.js

@@ -0,0 +1,291 @@
+/**
+ * Gemini CLI Provider
+ * Headless wrapper around the Gemini CLI binary (default command `gemini`).
+ */
+import { spawn } from 'child_process';
+import { getSettingsService } from '../../settings-service.js';
+import { getProviderDetectionService } from '../../lib/provider-detection.js';
+export class GeminiCliProvider {
+    constructor(config = {}) {
+        this.config = config;
+        this.name = 'gemini';
+        this.displayName = 'Gemini CLI';
+    }
+    async resolveExecutable() {
+        if (this.config.geminiBinPath)
+            return this.config.geminiBinPath;
+        // Use enhanced detection service
+        const detectionService = getProviderDetectionService();
+        const result = await detectionService.detectProvider('gemini');
+        if (result.found && result.path) {
+            return result.path;
+        }
+        // Fallback: try old settings-based approach for backwards compatibility
+        const settingsBinPath = (() => {
+            try {
+                const svc = getSettingsService();
+                const s = svc.getSettings();
+                return s?.agents?.providers?.gemini?.binPath;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        if (settingsBinPath?.trim())
+            return settingsBinPath.trim();
+        // Default to binary name (resolve via PATH)
+        return 'gemini';
+    }
+    normalizeReasoningEffort(value) {
+        if (!value)
+            return undefined;
+        const normalized = value.toLowerCase();
+        if (normalized === 'minimal')
+            return 'low';
+        const allowed = ['low', 'medium', 'high'];
+        return allowed.includes(normalized)
+            ? normalized
+            : undefined;
+    }
+    resolveModelSpec(model, fallbackEffort) {
+        const fallback = this.normalizeReasoningEffort(fallbackEffort);
+        if (!model) {
+            return { reasoning: fallback };
+        }
+        const trimmed = model.trim();
+        const normalized = trimmed.toLowerCase();
+        // Recognize a few common Gemini model aliases; keep passthrough for others
+        const knownPrefixes = [
+            'gemini-3-pro-preview',
+            'gemini-3-flash-preview',
+            'gemini-2.5-pro',
+            'gemini-2.5-flash',
+            'gemini-2.5-flash-lite',
+            'gemini-3',
+            'gemini-2.5',
+            'gemini',
+        ];
+        const isKnown = knownPrefixes.some((p) => normalized.startsWith(p));
+        return {
+            cliModel: isKnown ? trimmed : trimmed,
+            requestedModel: trimmed,
+            reasoning: fallback,
+        };
+    }
+    async *execute(prompt, options) {
+        // Effective options
+        const cwd = options?.workingDirectory || this.config.defaultWorkingDirectory || process.cwd();
+        const resolvedModel = this.resolveModelSpec(options?.model || this.config.defaultModel, options?.effort);
+        const model = resolvedModel.cliModel;
+        const images = (options?.images || []).filter(Boolean);
+        const timeoutMs = options?.timeout ?? this.config.defaultTimeoutMs ?? 10 * 60 * 1000; // 10m
+        const temperature = options?.temperature;
+        const systemPrompt = options?.systemPrompt?.trim();
+        const appendSystemPrompt = options?.appendSystemPrompt?.trim();
+        const promptSegments = [];
+        if (systemPrompt)
+            promptSegments.push(systemPrompt);
+        if (appendSystemPrompt)
+            promptSegments.push(appendSystemPrompt);
+        promptSegments.push(prompt);
+        const effectivePrompt = promptSegments.join('\n\n');
+        // Build argv for `gemini` CLI. Use a simple subcommand 'chat' with flags; passthrough prompt as arg.
+        const argv = [];
+        // Prefer a subcommand if used by the CLI; otherwise just supply flags
+        // We keep it generic so detection/validation works even if CLI differs
+        if (model) {
+            argv.push('--model', model);
+        }
+        if (typeof temperature === 'number') {
+            argv.push('--temperature', String(temperature));
+        }
+        if (images.length) {
+            argv.push('--image', images.join(','));
+        }
+        // YOLO mode auto-approves tool calls to allow code edits without prompts
+        argv.push('--yolo');
+        // Push the prompt last (many CLIs accept final arg as the prompt)
+        argv.push(effectivePrompt);
+        const cmd = await this.resolveExecutable();
+        const child = spawn(cmd, argv, {
+            cwd,
+            env: { ...process.env },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        // Emit an init/system message with effective command
+        const init = {
+            type: 'init',
+            timestamp: new Date().toISOString(),
+            sessionId: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            model: resolvedModel.requestedModel || model || 'default',
+            provider: this.name,
+        };
+        yield init;
+        yield {
+            type: 'system',
+            timestamp: new Date().toISOString(),
+            content: `Running: ${cmd} ${argv
+                .map((a) => (a.includes(' ') ? '"' + a + '"' : a))
+                .join(' ')} (cwd=${cwd})`,
+            metadata: {
+                provider: this.name,
+                images,
+                systemPrompt,
+                appendSystemPrompt,
+            },
+        };
+        let stdoutBuf = '';
+        let finished = false;
+        let lastFlushedIndex = 0;
+        let lineCarry = '';
+        const flushNewOutput = () => {
+            const newChunk = stdoutBuf.slice(lastFlushedIndex);
+            if (!newChunk)
+                return;
+            lastFlushedIndex = stdoutBuf.length;
+            lineCarry += newChunk;
+            const parts = lineCarry.split(/\r?\n/);
+            lineCarry = parts.pop() || '';
+            return parts.map((l) => l.trimEnd());
+        };
+        const onAbort = () => {
+            try {
+                child.kill('SIGTERM');
+            }
+            catch (err) {
+                void err; // ignore if process already exited
+            }
+            setTimeout(() => {
+                if (!finished) {
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch (err) {
+                        void err; // ignore if process already exited
+                    }
+                }
+            }, 3000);
+        };
+        if (options?.abortSignal) {
+            if (options.abortSignal.aborted)
+                onAbort();
+            else
+                options.abortSignal.addEventListener('abort', onAbort, { once: true });
+        }
+        const guard = setTimeout(() => onAbort(), timeoutMs);
+        child.stdout?.on('data', (data) => {
+            stdoutBuf += data.toString('utf8');
+        });
+        const exitPromise = new Promise((resolve) => {
+            child.on('exit', (code, signal) => resolve({ code, signal }));
+        });
+        let exitStatus;
+        while (!finished) {
+            const tick = new Promise((r) => setTimeout(r, 150));
+            const exit = await Promise.race([exitPromise, tick]);
+            if (exit && typeof exit.code !== 'undefined') {
+                const lines = flushNewOutput();
+                if (lines && lines.length) {
+                    for (const text of lines) {
+                        if (!text)
+                            continue;
+                        yield { type: 'assistant', timestamp: new Date().toISOString(), content: text };
+                    }
+                }
+                finished = true;
+                exitStatus = exit;
+                break;
+            }
+            const lines = flushNewOutput();
+            if (lines && lines.length) {
+                for (const text of lines) {
+                    if (!text)
+                        continue;
+                    yield { type: 'assistant', timestamp: new Date().toISOString(), content: text };
+                }
+            }
+        }
+        const exit = exitStatus ?? (await exitPromise);
+        finished = true;
+        clearTimeout(guard);
+        if (lineCarry.trim()) {
+            yield {
+                type: 'assistant',
+                timestamp: new Date().toISOString(),
+                content: lineCarry.trimEnd(),
+            };
+            lineCarry = '';
+        }
+        const success = (exit.code ?? 1) === 0 && !exit.signal;
+        const remainingStdout = stdoutBuf.trim();
+        const resultMsg = {
+            type: 'result',
+            timestamp: new Date().toISOString(),
+            success,
+            result: success ? (remainingStdout || '').toString() : undefined,
+            error: success
+                ? undefined
+                : `gemini exited ${exit.signal ? 'by ' + exit.signal : 'with code ' + exit.code}`,
+            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        };
+        yield resultMsg;
+    }
+    async detectAvailableModels() {
+        const capabilities = ['code', 'analysis', 'tools', 'vision', 'image', 'reasoning'];
+        const makeModel = (id, displayName) => ({
+            id,
+            name: id,
+            displayName,
+            provider: this.name,
+            contextWindow: 128000,
+            maxOutputTokens: 8192,
+            capabilities,
+        });
+        return [
+            makeModel('gemini-3-pro-preview', 'Gemini 3 Pro Preview'),
+            makeModel('gemini-3-flash-preview', 'Gemini 3 Flash Preview'),
+            makeModel('gemini-2.5-pro', 'Gemini 2.5 Pro'),
+            makeModel('gemini-2.5-flash', 'Gemini 2.5 Flash'),
+            makeModel('gemini-2.5-flash-lite', 'Gemini 2.5 Flash Lite'),
+        ];
+    }
+    async validateSetup() {
+        try {
+            const detectionService = getProviderDetectionService();
+            const result = await detectionService.detectProvider('gemini');
+            if (!result.found) {
+                return {
+                    available: false,
+                    error: result.error ||
+                        'Gemini CLI not found. Install the Gemini CLI and ensure it is available on PATH as "gemini" or set VIBEMAN_GEMINI_BIN.',
+                    models: [],
+                    capabilities: this.getCapabilities(),
+                };
+            }
+            return {
+                available: true,
+                models: await this.detectAvailableModels(),
+                capabilities: this.getCapabilities(),
+            };
+        }
+        catch (error) {
+            return {
+                available: false,
+                error: error instanceof Error ? error.message : String(error),
+                models: [],
+                capabilities: this.getCapabilities(),
+            };
+        }
+    }
+    getCapabilities() {
+        return {
+            streaming: true,
+            tools: true,
+            functionCalling: false,
+            vision: true,
+            codeExecution: true,
+            maxContextWindow: 128000,
+            maxOutputTokens: 8192,
+        };
+    }
+}

package/dist/runtime/api/agent/ai-providers/index.d.ts

@@ -2,8 +2,8 @@
  * AI Providers Module
  * Export all provider types and implementations
  */
-export * from './types.js';
 export { ClaudeCodeAdapter } from './claude-code-adapter.js';
-export type { ClaudeCodeConfig } from './claude-code-adapter.js';
 export { CodexCliProvider } from './codex-cli-provider.js';
-export type { CodexCliConfig } from './codex-cli-provider.js';
+export { GeminiCliProvider } from './gemini-cli-provider.js';
+export { AmpCliProvider } from './amp-cli-provider.js';
+export * from './types.js';

package/dist/runtime/api/agent/ai-providers/index.js

@@ -2,6 +2,8 @@
  * AI Providers Module
  * Export all provider types and implementations
  */
-export * from './types.js';
 export { ClaudeCodeAdapter } from './claude-code-adapter.js';
 export { CodexCliProvider } from './codex-cli-provider.js';
+export { GeminiCliProvider } from './gemini-cli-provider.js';
+export { AmpCliProvider } from './amp-cli-provider.js';
+export * from './types.js';

package/dist/runtime/api/agent/ai-providers/types.d.ts

@@ -43,9 +43,12 @@ export interface ExecutionOptions {
     permissionMode?: 'default' | 'acceptEdits' | 'bypassPermissions';
     /** Optional list of image file paths to attach (Codex CLI: --image) */
     images?: string[];
-    /** Optional effort hint for reasoning presets (e.g., 'minimal'|'low'|'medium'|'high'); informational only */
+    /** Optional effort hint for reasoning presets (e.g., 'minimal'|'low'|'medium'|'high'|'extra_high'); informational only */
     effort?: string;
-    /** Enable Codex CLI sandbox bypass flag when running automation that must edit files */
+    /**
+     * Enable Codex CLI full-auto + danger-full-access sandbox mode (>= v0.73) so automation
+     * can edit files and run privileged commands.
+     */
     dangerouslyBypassApprovalsAndSandbox?: boolean;
 }
 /**

package/dist/runtime/api/agent/amp-cli-provider.test.js

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+// Toggle real CLI integration via env
+const USE_REAL = process.env.VITEST_USE_REAL_AMP === 'true';
+describe('AmpCliProvider (mocked)', () => {
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    it('streams stdout, passes flags, and returns result', async () => {
+        vi.resetModules();
+        vi.doMock('child_process', () => {
+            let captured = [];
+            return {
+                __captured: () => captured,
+                spawn: (cmd, args, opts) => {
+                    captured = [cmd, args, opts];
+                    const { EventEmitter } = require('events');
+                    const stdout = new EventEmitter();
+                    const stderr = new EventEmitter();
+                    const proc = new EventEmitter();
+                    proc.stdout = stdout;
+                    proc.stderr = stderr;
+                    setTimeout(() => stdout.emit('data', Buffer.from('Hello from Amp\n')), 10);
+                    setTimeout(() => proc.emit('exit', 0, null), 20);
+                    return proc;
+                },
+                exec: vi.fn(),
+                execFile: vi.fn(),
+            };
+        });
+        const { AmpCliProvider } = await import('./ai-providers/amp-cli-provider.js');
+        const provider = new AmpCliProvider({ defaultTimeoutMs: 1000, ampBinPath: 'amp' });
+        const messages = [];
+        const iter = provider.execute('What is this project about?', {
+            workingDirectory: process.cwd(),
+            model: 'auto',
+            dangerouslyBypassApprovalsAndSandbox: true,
+        });
+        for await (const m of iter)
+            messages.push(m);
+        const resultMsg = messages.find((m) => m.type === 'result');
+        expect(!!resultMsg).toBe(true);
+        const assistantMsg = messages.find((m) => m.type === 'assistant');
+        if (assistantMsg && typeof assistantMsg.content === 'string') {
+            expect(assistantMsg.content.length).toBeGreaterThan(0);
+        }
+        else if (resultMsg && typeof resultMsg.result === 'string') {
+            expect(resultMsg.result.length).toBeGreaterThan(0);
+        }
+        const mockSpawn = await import('child_process');
+        const captured = mockSpawn.__captured();
+        expect(captured[0]).toBe('amp');
+        expect(Array.isArray(captured[1])).toBe(true);
+        expect(captured[1]).toContain('-x');
+        // Amp integration runs in auto mode (no explicit model flag)
+        expect(captured[1]).not.toContain('--use-sonnet');
+        // Check bypass
+        expect(captured[1]).toContain('--dangerously-allow-all');
+        // Check prompt passed as arg
+        const promptArg = captured[1][1];
+        expect(promptArg).toContain('What is this project about?');
+    });
+    it('prepends system prompts', async () => {
+        vi.resetModules();
+        vi.doMock('child_process', () => {
+            let captured = [];
+            return {
+                __captured: () => captured,
+                spawn: (cmd, args, opts) => {
+                    captured = [cmd, args, opts];
+                    const { EventEmitter } = require('events');
+                    const stdout = new EventEmitter();
+                    const proc = new EventEmitter();
+                    proc.stdout = stdout;
+                    setTimeout(() => stdout.emit('data', Buffer.from('Done\n')), 5);
+                    setTimeout(() => proc.emit('exit', 0, null), 10);
+                    return proc;
+                },
+                exec: vi.fn(),
+                execFile: vi.fn(),
+            };
+        });
+        const { AmpCliProvider } = await import('./ai-providers/amp-cli-provider.js');
+        const provider = new AmpCliProvider({ ampBinPath: 'amp' });
+        const iter = provider.execute('Implement feature', {
+            workingDirectory: '/tmp/project',
+            systemPrompt: 'Base system prompt',
+            appendSystemPrompt: 'Additional guidance',
+        });
+        for await (const _ of iter) {
+            // drain iterator
+        }
+        const mockSpawn = await import('child_process');
+        const captured = mockSpawn.__captured();
+        const promptArg = captured[1][1];
+        expect(promptArg).toContain('Base system prompt');
+        expect(promptArg).toContain('Additional guidance');
+        expect(promptArg).toContain('Implement feature');
+    });
+});