discoclaw 0.1.0

package/dist/runtime/long-running-process.test.js

@@ -0,0 +1,318 @@
+import { beforeEach, describe, expect, it, vi, afterEach } from 'vitest';
+import { EventEmitter } from 'node:events';
+vi.mock('execa', () => ({
+    execa: vi.fn(),
+}));
+import { execa } from 'execa';
+import { LongRunningProcess } from './long-running-process.js';
+function createMockSubprocess() {
+    const stdout = new EventEmitter();
+    const stderr = new EventEmitter();
+    const stdin = { write: vi.fn(), end: vi.fn() };
+    let resolvePromise;
+    let rejectPromise;
+    const promise = new Promise((res, rej) => {
+        resolvePromise = res;
+        rejectPromise = rej;
+    });
+    const proc = Object.assign(promise, {
+        stdout,
+        stderr,
+        stdin,
+        kill: vi.fn(),
+        pid: 12345,
+    });
+    return { proc, stdout, stderr, stdin, resolve: resolvePromise, reject: rejectPromise };
+}
+const baseOpts = {
+    claudeBin: 'claude',
+    model: 'opus',
+    cwd: '/tmp',
+    dangerouslySkipPermissions: true,
+    hangTimeoutMs: 5000,
+    idleTimeoutMs: 10000,
+};
+beforeEach(() => {
+    vi.useFakeTimers();
+    execa.mockReset?.();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+describe('LongRunningProcess', () => {
+    it('spawns with correct args', () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess({ ...baseOpts, tools: ['Read', 'Bash'], addDirs: ['/workspace'] });
+        const ok = proc.spawn();
+        expect(ok).toBe(true);
+        expect(proc.state).toBe('idle');
+        expect(proc.isAlive).toBe(true);
+        const callArgs = execa.mock.calls[0]?.[1] ?? [];
+        expect(callArgs).toContain('--input-format');
+        expect(callArgs).toContain('stream-json');
+        expect(callArgs).toContain('--output-format');
+        expect(callArgs).toContain('--include-partial-messages');
+        expect(callArgs).toContain('--model');
+        expect(callArgs).toContain('opus');
+        expect(callArgs).toContain('--dangerously-skip-permissions');
+        expect(callArgs).toContain('--tools');
+        expect(callArgs).toContain('Read,Bash');
+        expect(callArgs).toContain('--add-dir');
+        expect(callArgs).toContain('/workspace');
+        // -p is required for --input-format stream-json
+        expect(callArgs).toContain('-p');
+    });
+    it('first turn yields text_delta and text_final from stream', async () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess(baseOpts);
+        proc.spawn();
+        const events = [];
+        const gen = proc.sendTurn('Hello');
+        // Simulate stdout data arriving
+        const resultLine = JSON.stringify({ type: 'message_delta', text: 'Hi there' });
+        const finalLine = JSON.stringify({ type: 'result', result: 'Hi there' });
+        // Process events in microtasks
+        queueMicrotask(() => {
+            mock.stdout.emit('data', resultLine + '\n' + finalLine + '\n');
+        });
+        for await (const evt of gen) {
+            events.push(evt);
+        }
+        expect(events.find((e) => e.type === 'text_delta')?.text).toBe('Hi there');
+        expect(events.find((e) => e.type === 'text_final')?.text).toBe('Hi there');
+        expect(events.find((e) => e.type === 'done')).toBeTruthy();
+        expect(proc.state).toBe('idle');
+        // Verify stdin was written with correct NDJSON (API-shaped message)
+        const written = mock.stdin.write.mock.calls[0]?.[0];
+        const parsed = JSON.parse(written.trim());
+        expect(parsed.type).toBe('user');
+        expect(parsed.message.role).toBe('user');
+        expect(parsed.message.content).toBe('Hello');
+    });
+    it('second turn reuses the same process', async () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess(baseOpts);
+        proc.spawn();
+        // First turn
+        queueMicrotask(() => {
+            mock.stdout.emit('data', JSON.stringify({ type: 'result', result: 'response1' }) + '\n');
+        });
+        const events1 = [];
+        for await (const evt of proc.sendTurn('turn1')) {
+            events1.push(evt);
+        }
+        expect(events1.find((e) => e.type === 'text_final')?.text).toBe('response1');
+        expect(proc.state).toBe('idle');
+        // Second turn (should reuse, not respawn)
+        queueMicrotask(() => {
+            mock.stdout.emit('data', JSON.stringify({ type: 'result', result: 'response2' }) + '\n');
+        });
+        const events2 = [];
+        for await (const evt of proc.sendTurn('turn2')) {
+            events2.push(evt);
+        }
+        expect(events2.find((e) => e.type === 'text_final')?.text).toBe('response2');
+        expect(proc.state).toBe('idle');
+        // execa should have been called only once
+        expect(execa.mock.calls).toHaveLength(1);
+    });
+    it('hang timeout triggers error and kills process', async () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess({ ...baseOpts, hangTimeoutMs: 1000 });
+        proc.spawn();
+        const events = [];
+        const genPromise = (async () => {
+            for await (const evt of proc.sendTurn('Hello')) {
+                events.push(evt);
+            }
+        })();
+        // No stdout data arrives — advance past hang timeout
+        await vi.advanceTimersByTimeAsync(1100);
+        await genPromise;
+        expect(events.find((e) => e.type === 'error')?.message).toContain('hang detected');
+        expect(events.find((e) => e.type === 'done')).toBeTruthy();
+        expect(proc.state).toBe('dead');
+    });
+    it('idle timeout kills idle process', async () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess({ ...baseOpts, idleTimeoutMs: 2000 });
+        proc.spawn();
+        expect(proc.state).toBe('idle');
+        // Advance past idle timeout
+        await vi.advanceTimersByTimeAsync(2100);
+        expect(proc.state).toBe('dead');
+    });
+    it('process crash during turn emits error + done', async () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess(baseOpts);
+        proc.spawn();
+        const events = [];
+        const genPromise = (async () => {
+            for await (const evt of proc.sendTurn('Hello')) {
+                events.push(evt);
+            }
+        })();
+        // Simulate process exit while busy
+        queueMicrotask(() => {
+            mock.resolve({ exitCode: 1 });
+        });
+        await genPromise;
+        expect(events.find((e) => e.type === 'error')?.message).toContain('process exited unexpectedly');
+        expect(events.find((e) => e.type === 'done')).toBeTruthy();
+        expect(proc.state).toBe('dead');
+    });
+    it('kill() while busy unblocks the consumer (emits done)', async () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess(baseOpts);
+        proc.spawn();
+        const events = [];
+        const genPromise = (async () => {
+            for await (const evt of proc.sendTurn('Hello')) {
+                events.push(evt);
+            }
+        })();
+        queueMicrotask(() => {
+            proc.kill();
+        });
+        await genPromise;
+        expect(events.find((e) => e.type === 'done')).toBeTruthy();
+        expect(proc.state).toBe('dead');
+        expect(events.find((e) => e.type === 'error')?.message).toBe('multi-turn: terminated');
+    });
+    it('forceKill() while busy unblocks the consumer (emits done)', async () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess(baseOpts);
+        proc.spawn();
+        const events = [];
+        const genPromise = (async () => {
+            for await (const evt of proc.sendTurn('Hello')) {
+                events.push(evt);
+            }
+        })();
+        queueMicrotask(() => {
+            proc.forceKill();
+        });
+        await genPromise;
+        expect(events.find((e) => e.type === 'done')).toBeTruthy();
+        expect(proc.state).toBe('dead');
+        expect(events.find((e) => e.type === 'error')?.message).toBe('multi-turn: terminated');
+    });
+    it('sendTurn on non-idle process yields error', async () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess(baseOpts);
+        proc.spawn();
+        proc.kill();
+        const events = [];
+        for await (const evt of proc.sendTurn('Hello')) {
+            events.push(evt);
+        }
+        expect(events.find((e) => e.type === 'error')?.message).toContain('cannot send turn');
+        expect(events.find((e) => e.type === 'done')).toBeTruthy();
+    });
+    it('kill() transitions to dead', () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess(baseOpts);
+        proc.spawn();
+        expect(proc.isAlive).toBe(true);
+        proc.kill();
+        expect(proc.state).toBe('dead');
+        expect(proc.isAlive).toBe(false);
+    });
+    it('strips tool use blocks from final text', async () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess(baseOpts);
+        proc.spawn();
+        queueMicrotask(() => {
+            mock.stdout.emit('data', JSON.stringify({ type: 'message_delta', text: 'thinking...' }) + '\n' +
+                JSON.stringify({ type: 'message_delta', text: '<tool_use>read</tool_use>' }) + '\n' +
+                JSON.stringify({ type: 'message_delta', text: 'The answer is 42.' }) + '\n' +
+                JSON.stringify({ type: 'result', result: 'The answer is 42.' }) + '\n');
+        });
+        const events = [];
+        for await (const evt of proc.sendTurn('test')) {
+            events.push(evt);
+        }
+        expect(events.find((e) => e.type === 'text_final')?.text).toBe('The answer is 42.');
+    });
+    it('sendTurn with images writes content-block array to stdin', async () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess(baseOpts);
+        proc.spawn();
+        queueMicrotask(() => {
+            mock.stdout.emit('data', JSON.stringify({ type: 'result', result: 'I see an image' }) + '\n');
+        });
+        const images = [{ base64: 'iVBORw0KGgo=', mediaType: 'image/png' }];
+        const events = [];
+        for await (const evt of proc.sendTurn('Describe this', images)) {
+            events.push(evt);
+        }
+        expect(events.find((e) => e.type === 'text_final')?.text).toBe('I see an image');
+        // Verify stdin was written with content-block array
+        const written = mock.stdin.write.mock.calls[0]?.[0];
+        const parsed = JSON.parse(written.trim());
+        expect(parsed.type).toBe('user');
+        expect(parsed.message.role).toBe('user');
+        expect(Array.isArray(parsed.message.content)).toBe(true);
+        expect(parsed.message.content[0]).toEqual({ type: 'text', text: 'Describe this' });
+        expect(parsed.message.content[1].type).toBe('image');
+        expect(parsed.message.content[1].source.type).toBe('base64');
+        expect(parsed.message.content[1].source.media_type).toBe('image/png');
+        expect(parsed.message.content[1].source.data).toBe('iVBORw0KGgo=');
+    });
+    it('spawns with --fallback-model, --max-budget-usd, --append-system-prompt when set', () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess({
+            ...baseOpts,
+            fallbackModel: 'sonnet',
+            maxBudgetUsd: 7.5,
+            appendSystemPrompt: 'You are Weston.',
+        });
+        proc.spawn();
+        const callArgs = execa.mock.calls[0]?.[1] ?? [];
+        expect(callArgs).toContain('--fallback-model');
+        expect(callArgs[callArgs.indexOf('--fallback-model') + 1]).toBe('sonnet');
+        expect(callArgs).toContain('--max-budget-usd');
+        expect(callArgs[callArgs.indexOf('--max-budget-usd') + 1]).toBe('7.5');
+        expect(callArgs).toContain('--append-system-prompt');
+        expect(callArgs[callArgs.indexOf('--append-system-prompt') + 1]).toBe('You are Weston.');
+    });
+    it('omits new flags when not set', () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess(baseOpts);
+        proc.spawn();
+        const callArgs = execa.mock.calls[0]?.[1] ?? [];
+        expect(callArgs).not.toContain('--fallback-model');
+        expect(callArgs).not.toContain('--max-budget-usd');
+        expect(callArgs).not.toContain('--append-system-prompt');
+    });
+    it('sendTurn without images writes plain string content (no regression)', async () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess(baseOpts);
+        proc.spawn();
+        queueMicrotask(() => {
+            mock.stdout.emit('data', JSON.stringify({ type: 'result', result: 'ok' }) + '\n');
+        });
+        const events = [];
+        for await (const evt of proc.sendTurn('Hello')) {
+            events.push(evt);
+        }
+        const written = mock.stdin.write.mock.calls[0]?.[0];
+        const parsed = JSON.parse(written.trim());
+        expect(parsed.message.content).toBe('Hello');
+    });
+});

package/dist/runtime/model-smoke-helpers.js

@@ -0,0 +1,160 @@
+/**
+ * Smoke-test helpers: prompt definitions, response validation, and env-driven
+ * runtime factories.  Used by model-smoke.test.ts to exercise each configured
+ * model tier through the full RuntimeAdapter.invoke() → EngineEvent pipeline.
+ *
+ * Runtime factories:
+ *   buildSmokeRuntime        — Claude Code CLI (CLAUDE_BIN, CLAUDE_OUTPUT_FORMAT, …)
+ *   buildGeminiSmokeRuntime  — Gemini CLI      (GEMINI_BIN, GEMINI_MODEL)
+ *   buildOpenAISmokeRuntime  — OpenAI API      (OPENAI_API_KEY, OPENAI_BASE_URL, OPENAI_MODEL)
+ *   buildCodexSmokeRuntime   — Codex CLI       (CODEX_BIN, CODEX_MODEL)
+ */
+import { createClaudeCliRuntime } from './claude-code-cli.js';
+import { createGeminiCliRuntime } from './gemini-cli.js';
+import { createOpenAICompatRuntime } from './openai-compat.js';
+import { createCodexCliRuntime } from './codex-cli.js';
+export const PROMPT_CATEGORIES = [
+    {
+        name: 'greeting',
+        prompt: 'Say hello in exactly one sentence. Output only that sentence.',
+        // Non-empty text is sufficient for greeting.
+    },
+    {
+        name: 'code_block',
+        prompt: 'Write a JavaScript function called add that takes two numbers and returns their sum. Wrap your answer in a fenced code block.',
+        validate: (text) => text.includes('```'),
+    },
+    {
+        name: 'structured_markdown',
+        prompt: 'List the three primary colors of light as a markdown bullet list. Output only the list.',
+        validate: (text) => text.includes('-') || text.includes('*'),
+    },
+    {
+        name: 'cron_style',
+        prompt: 'What cron expression runs a job every day at midnight? Output only the cron expression, nothing else.',
+        validate: (text) => /\d/.test(text) && text.includes('*'),
+    },
+    {
+        name: 'unicode',
+        prompt: 'Echo back this emoji exactly: 🎉 Output only the emoji.',
+        validate: (text) => text.includes('🎉'),
+    },
+    {
+        name: 'empty_input',
+        prompt: '   ',
+        // No strict validate; model should respond without crashing.
+    },
+];
+/**
+ * Validate a pre-collected EngineEvent array and return a diagnostic result.
+ *
+ * Fails if:
+ * - an `error` event appears in the stream
+ * - the stream ends without a `done` event
+ * - the accumulated response text is empty (except for `empty_input` category)
+ *
+ * Tier and category labels are included in all diagnostic messages.
+ */
+export function validateSmokeResponse(events, tierLabel, categoryName) {
+    const label = `[${tierLabel}/${categoryName}]`;
+    const errorEvt = events.find((e) => e.type === 'error');
+    if (errorEvt) {
+        return {
+            ok: false,
+            text: '',
+            errorMessage: `${label} error event: ${errorEvt.message}`,
+            events,
+        };
+    }
+    if (!events.some((e) => e.type === 'done')) {
+        return {
+            ok: false,
+            text: '',
+            errorMessage: `${label} stream ended without done event`,
+            events,
+        };
+    }
+    // Prefer text_final; fall back to concatenated text_delta events.
+    const finalEvt = events.find((e) => e.type === 'text_final');
+    const text = finalEvt
+        ? finalEvt.text
+        : events
+            .filter((e) => e.type === 'text_delta')
+            .map((e) => e.text)
+            .join('');
+    // For empty_input category, an empty response is acceptable.
+    if (!text.trim() && categoryName !== 'empty_input') {
+        return { ok: false, text, errorMessage: `${label} response text is empty`, events };
+    }
+    return { ok: true, text, events };
+}
+/**
+ * Build a RuntimeAdapter from env vars, applying the same normalization rules
+ * as `parseConfig` in src/config.ts:
+ * - `CLAUDE_OUTPUT_FORMAT` validated as `text` | `stream-json`
+ * - verbose suppressed when outputFormat is `text`
+ * - `RUNTIME_MAX_BUDGET_USD` validated as a positive finite number
+ *
+ * Returns both the adapter and the resolved binary path so callers can run a
+ * binary availability check before invoking.
+ */
+export function buildSmokeRuntime(env = process.env) {
+    const claudeBin = env.CLAUDE_BIN?.trim() || 'claude';
+    const outputFormatRaw = env.CLAUDE_OUTPUT_FORMAT?.trim();
+    if (outputFormatRaw && outputFormatRaw !== 'text' && outputFormatRaw !== 'stream-json') {
+        throw new Error(`CLAUDE_OUTPUT_FORMAT must be "text" or "stream-json", got "${outputFormatRaw}"`);
+    }
+    const outputFormat = outputFormatRaw === 'stream-json' ? 'stream-json' : 'text';
+    const rawVerbose = env.CLAUDE_VERBOSE === '1';
+    const verbose = rawVerbose && outputFormat !== 'text';
+    const dangerouslySkipPermissions = env.CLAUDE_DANGEROUSLY_SKIP_PERMISSIONS === '1';
+    let maxBudgetUsd;
+    const budgetRaw = env.RUNTIME_MAX_BUDGET_USD?.trim();
+    if (budgetRaw) {
+        const parsed = Number(budgetRaw);
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            throw new Error(`RUNTIME_MAX_BUDGET_USD must be a positive number, got "${budgetRaw}"`);
+        }
+        maxBudgetUsd = parsed;
+    }
+    const runtime = createClaudeCliRuntime({
+        claudeBin,
+        dangerouslySkipPermissions,
+        outputFormat,
+        verbose,
+        maxBudgetUsd,
+    });
+    return { runtime, claudeBin };
+}
+/**
+ * Build a Gemini RuntimeAdapter from env vars.
+ * Reads `GEMINI_BIN` (default: `gemini`) and `GEMINI_MODEL` (default: `gemini-2.5-flash`).
+ */
+export function buildGeminiSmokeRuntime(env = process.env) {
+    const geminiBin = env.GEMINI_BIN?.trim() || 'gemini';
+    const defaultModel = env.GEMINI_MODEL?.trim() || 'gemini-2.5-flash';
+    const runtime = createGeminiCliRuntime({ geminiBin, defaultModel });
+    return { runtime, geminiBin };
+}
+/**
+ * Build an OpenAI RuntimeAdapter from env vars.
+ * Reads `OPENAI_API_KEY`, `OPENAI_BASE_URL` (default: `https://api.openai.com/v1`),
+ * and `OPENAI_MODEL` (default: `gpt-4o`).
+ */
+export function buildOpenAISmokeRuntime(env = process.env) {
+    const apiKey = env.OPENAI_API_KEY?.trim() || '';
+    const baseUrl = env.OPENAI_BASE_URL?.trim() || 'https://api.openai.com/v1';
+    const defaultModel = env.OPENAI_MODEL?.trim() || 'gpt-4o';
+    const runtime = createOpenAICompatRuntime({ auth: 'api_key', apiKey, baseUrl, defaultModel });
+    return { runtime, apiKey };
+}
+/**
+ * Build a Codex CLI RuntimeAdapter from env vars.
+ * Reads `CODEX_BIN` (default: `codex`) and `CODEX_MODEL` (default: `gpt-5.3-codex`).
+ */
+export function buildCodexSmokeRuntime(env = process.env) {
+    const codexBin = env.CODEX_BIN?.trim() || 'codex';
+    const defaultModel = env.CODEX_MODEL?.trim() || 'gpt-5.3-codex';
+    const runtime = createCodexCliRuntime({ codexBin, defaultModel });
+    return { runtime, codexBin };
+}

package/dist/runtime/model-smoke.test.js

@@ -0,0 +1,194 @@
+/**
+ * Model smoke tests — end-to-end validation of each configured runtime.
+ *
+ * Opt-in via provider-specific env vars (all skipped by default so normal
+ * `pnpm test` runs are not slowed down):
+ *
+ *   SMOKE_TEST_TIERS=fast,capable pnpm test
+ *     Run Claude Code smoke tests for the fast and capable tiers.
+ *
+ *   GEMINI_SMOKE_TEST_TIERS=fast pnpm test
+ *     Run Gemini smoke tests for the fast tier.
+ *
+ *   OPENAI_SMOKE_TEST_TIERS=fast pnpm test
+ *     Run OpenAI smoke tests (requires OPENAI_API_KEY).
+ *
+ *   CODEX_SMOKE_TEST_TIERS=fast pnpm test
+ *     Run Codex smoke tests (requires codex binary on PATH).
+ *
+ *   SMOKE_TEST_TIERS=fast SMOKE_TEST_TIMEOUT_MS=120000 pnpm test
+ *     Override per-prompt timeout.
+ *
+ * Catches: bad API keys, wrong tier mappings, malformed system prompts,
+ * missing binaries — all surfaces as error events or empty text.
+ */
+import { describe, expect, it, beforeAll } from 'vitest';
+import { execFileSync } from 'node:child_process';
+import { PROMPT_CATEGORIES, validateSmokeResponse, buildSmokeRuntime, buildGeminiSmokeRuntime, buildOpenAISmokeRuntime, buildCodexSmokeRuntime, } from './model-smoke-helpers.js';
+import { resolveModel } from './model-tiers.js';
+/** Working directory passed to every invocation. */
+const CWD = '/tmp';
+/** Per-test timeout — configurable via SMOKE_TEST_TIMEOUT_MS (default 60 s). */
+const rawTimeout = process.env.SMOKE_TEST_TIMEOUT_MS?.trim();
+const TIMEOUT = (() => {
+    if (!rawTimeout)
+        return 60_000;
+    const n = Number(rawTimeout);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new Error(`SMOKE_TEST_TIMEOUT_MS must be a positive number, got "${rawTimeout}"`);
+    }
+    return n;
+})();
+/**
+ * Comma-separated tier names or literal model IDs from SMOKE_TEST_TIERS.
+ * Empty = all smoke tests skipped.
+ */
+const SMOKE_TIERS = process.env.SMOKE_TEST_TIERS?.trim()
+    ? process.env.SMOKE_TEST_TIERS.trim()
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : [];
+/**
+ * Comma-separated tier names or literal model IDs from GEMINI_SMOKE_TEST_TIERS.
+ * Empty = all Gemini smoke tests skipped.
+ */
+const GEMINI_SMOKE_TIERS = process.env.GEMINI_SMOKE_TEST_TIERS?.trim()
+    ? process.env.GEMINI_SMOKE_TEST_TIERS.trim()
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : [];
+/**
+ * Comma-separated tier names or literal model IDs from OPENAI_SMOKE_TEST_TIERS.
+ * Empty = all OpenAI smoke tests skipped.
+ */
+const OPENAI_SMOKE_TIERS = process.env.OPENAI_SMOKE_TEST_TIERS?.trim()
+    ? process.env.OPENAI_SMOKE_TEST_TIERS.trim()
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : [];
+/**
+ * Comma-separated tier names or literal model IDs from CODEX_SMOKE_TEST_TIERS.
+ * Empty = all Codex smoke tests skipped.
+ */
+const CODEX_SMOKE_TIERS = process.env.CODEX_SMOKE_TEST_TIERS?.trim()
+    ? process.env.CODEX_SMOKE_TEST_TIERS.trim()
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : [];
+// Only build when opt-in is requested; avoids config-error noise in normal CI runs.
+const smokeState = SMOKE_TIERS.length > 0 ? buildSmokeRuntime() : null;
+const geminiSmokeState = GEMINI_SMOKE_TIERS.length > 0 ? buildGeminiSmokeRuntime() : null;
+const openaiSmokeState = OPENAI_SMOKE_TIERS.length > 0 ? buildOpenAISmokeRuntime() : null;
+const codexSmokeState = CODEX_SMOKE_TIERS.length > 0 ? buildCodexSmokeRuntime() : null;
+// ---------------------------------------------------------------------------
+// Claude Code — one describe block per requested tier
+// ---------------------------------------------------------------------------
+describe.each(SMOKE_TIERS)('claude_code / %s', (tierOrModel) => {
+    const model = resolveModel(tierOrModel, 'claude_code');
+    const { runtime, claudeBin } = smokeState;
+    beforeAll(() => {
+        try {
+            execFileSync('which', [claudeBin], { stdio: 'pipe' });
+        }
+        catch {
+            throw new Error(`Smoke test opt-in (SMOKE_TEST_TIERS="${process.env.SMOKE_TEST_TIERS}") ` +
+                `requires binary "${claudeBin}" on PATH. ` +
+                `Install the Claude CLI or set CLAUDE_BIN to the correct path.`);
+        }
+    });
+    it.each(PROMPT_CATEGORIES)('$name', async ({ prompt, validate, name }) => {
+        const events = [];
+        for await (const evt of runtime.invoke({ prompt, model, cwd: CWD, tools: [] })) {
+            events.push(evt);
+        }
+        const result = validateSmokeResponse(events, tierOrModel, name);
+        expect(result.ok, `smoke failed: ${result.errorMessage}`).toBe(true);
+        if (validate) {
+            expect(validate(result.text), `[${tierOrModel}/${name}] validation failed for text: ${JSON.stringify(result.text)}`).toBe(true);
+        }
+    }, TIMEOUT);
+});
+// ---------------------------------------------------------------------------
+// Gemini CLI — one describe block per requested tier
+// ---------------------------------------------------------------------------
+describe.each(GEMINI_SMOKE_TIERS)('gemini / %s', (tierOrModel) => {
+    const model = resolveModel(tierOrModel, 'gemini');
+    const { runtime, geminiBin } = geminiSmokeState;
+    beforeAll(() => {
+        try {
+            execFileSync('which', [geminiBin], { stdio: 'pipe' });
+        }
+        catch {
+            throw new Error(`Smoke test opt-in (GEMINI_SMOKE_TEST_TIERS="${process.env.GEMINI_SMOKE_TEST_TIERS}") ` +
+                `requires binary "${geminiBin}" on PATH. ` +
+                `Install the Gemini CLI or set GEMINI_BIN to the correct path.`);
+        }
+    });
+    it.each(PROMPT_CATEGORIES)('$name', async ({ prompt, validate, name }) => {
+        const events = [];
+        for await (const evt of runtime.invoke({ prompt, model, cwd: CWD, tools: [] })) {
+            events.push(evt);
+        }
+        const result = validateSmokeResponse(events, tierOrModel, name);
+        expect(result.ok, `smoke failed: ${result.errorMessage}`).toBe(true);
+        if (validate) {
+            expect(validate(result.text), `[${tierOrModel}/${name}] validation failed for text: ${JSON.stringify(result.text)}`).toBe(true);
+        }
+    }, TIMEOUT);
+});
+// ---------------------------------------------------------------------------
+// OpenAI API — one describe block per requested tier
+// ---------------------------------------------------------------------------
+describe.each(OPENAI_SMOKE_TIERS)('openai / %s', (tierOrModel) => {
+    const model = resolveModel(tierOrModel, 'openai');
+    const { runtime, apiKey } = openaiSmokeState;
+    beforeAll(() => {
+        if (!apiKey) {
+            throw new Error(`Smoke test opt-in (OPENAI_SMOKE_TEST_TIERS="${process.env.OPENAI_SMOKE_TEST_TIERS}") ` +
+                `requires OPENAI_API_KEY to be set.`);
+        }
+    });
+    it.each(PROMPT_CATEGORIES)('$name', async ({ prompt, validate, name }) => {
+        const events = [];
+        for await (const evt of runtime.invoke({ prompt, model, cwd: CWD, tools: [] })) {
+            events.push(evt);
+        }
+        const result = validateSmokeResponse(events, tierOrModel, name);
+        expect(result.ok, `smoke failed: ${result.errorMessage}`).toBe(true);
+        if (validate) {
+            expect(validate(result.text), `[${tierOrModel}/${name}] validation failed for text: ${JSON.stringify(result.text)}`).toBe(true);
+        }
+    }, TIMEOUT);
+});
+// ---------------------------------------------------------------------------
+// Codex CLI — one describe block per requested tier
+// ---------------------------------------------------------------------------
+describe.each(CODEX_SMOKE_TIERS)('codex / %s', (tierOrModel) => {
+    const model = resolveModel(tierOrModel, 'codex');
+    const { runtime, codexBin } = codexSmokeState;
+    beforeAll(() => {
+        try {
+            execFileSync('which', [codexBin], { stdio: 'pipe' });
+        }
+        catch {
+            throw new Error(`Smoke test opt-in (CODEX_SMOKE_TEST_TIERS="${process.env.CODEX_SMOKE_TEST_TIERS}") ` +
+                `requires binary "${codexBin}" on PATH. ` +
+                `Install the Codex CLI or set CODEX_BIN to the correct path.`);
+        }
+    });
+    it.each(PROMPT_CATEGORIES)('$name', async ({ prompt, validate, name }) => {
+        const events = [];
+        for await (const evt of runtime.invoke({ prompt, model, cwd: CWD, tools: [] })) {
+            events.push(evt);
+        }
+        const result = validateSmokeResponse(events, tierOrModel, name);
+        expect(result.ok, `smoke failed: ${result.errorMessage}`).toBe(true);
+        if (validate) {
+            expect(validate(result.text), `[${tierOrModel}/${name}] validation failed for text: ${JSON.stringify(result.text)}`).toBe(true);
+        }
+    }, TIMEOUT);
+});