discoclaw 0.1.0

package/dist/runtime/session-scanner.test.js

@@ -0,0 +1,257 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { SessionFileScanner } from './session-scanner.js';
+import { toolActivityLabel } from './tool-labels.js';
+let tmpDir;
+beforeEach(async () => {
+    tmpDir = await fsp.mkdtemp(path.join('/tmp', 'scanner-test-'));
+    // Mock os.homedir() to point at our temp dir so the scanner finds session files there.
+    vi.spyOn(os, 'homedir').mockReturnValue(tmpDir);
+});
+afterEach(async () => {
+    vi.restoreAllMocks();
+    await fsp.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+});
+function sessionDir(cwd) {
+    const escaped = cwd.replace(/\//g, '-');
+    return path.join(tmpDir, '.claude', 'projects', escaped);
+}
+async function ensureSessionFile(cwd, sessionId) {
+    const dir = sessionDir(cwd);
+    await fsp.mkdir(dir, { recursive: true });
+    const filePath = path.join(dir, `${sessionId}.jsonl`);
+    await fsp.writeFile(filePath, '', 'utf8');
+    return filePath;
+}
+function makeToolUse(id, name, input) {
+    return JSON.stringify({
+        type: 'assistant',
+        message: {
+            content: [
+                { type: 'tool_use', id, name, input: input ?? {} },
+            ],
+        },
+    });
+}
+function makeToolResult(toolUseId, isError = false) {
+    return JSON.stringify({
+        type: 'user',
+        message: {
+            content: [
+                { type: 'tool_result', tool_use_id: toolUseId, is_error: isError },
+            ],
+        },
+    });
+}
+describe('SessionFileScanner', () => {
+    it('detects tool_use and emits tool_start', async () => {
+        const cwd = '/home/test/code/proj';
+        const sessionId = 'test-session-1';
+        const filePath = await ensureSessionFile(cwd, sessionId);
+        const events = [];
+        const scanner = new SessionFileScanner({ sessionId, cwd }, { onEvent: (evt) => events.push(evt) });
+        await scanner.start();
+        // Write a tool_use line after start.
+        await fsp.appendFile(filePath, makeToolUse('block-1', 'Read', { file_path: '/tmp/foo.ts' }) + '\n');
+        // Give the watcher/poll time to pick it up.
+        await new Promise((r) => setTimeout(r, 300));
+        scanner.stop();
+        const toolStarts = events.filter((e) => e.type === 'tool_start');
+        expect(toolStarts).toHaveLength(1);
+        expect(toolStarts[0]).toMatchObject({
+            type: 'tool_start',
+            name: 'Read',
+            input: { file_path: '/tmp/foo.ts' },
+        });
+    });
+    it('detects tool_result and emits tool_end with correct name/ok', async () => {
+        const cwd = '/home/test/code/proj';
+        const sessionId = 'test-session-2';
+        const filePath = await ensureSessionFile(cwd, sessionId);
+        const events = [];
+        const scanner = new SessionFileScanner({ sessionId, cwd }, { onEvent: (evt) => events.push(evt) });
+        await scanner.start();
+        await fsp.appendFile(filePath, makeToolUse('block-2', 'Bash') + '\n');
+        await fsp.appendFile(filePath, makeToolResult('block-2', false) + '\n');
+        await new Promise((r) => setTimeout(r, 300));
+        scanner.stop();
+        const toolEnds = events.filter((e) => e.type === 'tool_end');
+        expect(toolEnds).toHaveLength(1);
+        expect(toolEnds[0]).toMatchObject({
+            type: 'tool_end',
+            name: 'Bash',
+            ok: true,
+        });
+    });
+    it('handles tool_result with is_error=true', async () => {
+        const cwd = '/home/test/code/proj';
+        const sessionId = 'test-session-err';
+        const filePath = await ensureSessionFile(cwd, sessionId);
+        const events = [];
+        const scanner = new SessionFileScanner({ sessionId, cwd }, { onEvent: (evt) => events.push(evt) });
+        await scanner.start();
+        await fsp.appendFile(filePath, makeToolUse('block-e', 'Edit') + '\n');
+        await fsp.appendFile(filePath, makeToolResult('block-e', true) + '\n');
+        await new Promise((r) => setTimeout(r, 300));
+        scanner.stop();
+        const toolEnds = events.filter((e) => e.type === 'tool_end');
+        expect(toolEnds).toHaveLength(1);
+        expect(toolEnds[0]).toMatchObject({
+            type: 'tool_end',
+            name: 'Edit',
+            ok: false,
+        });
+    });
+    it('handles multiple sequential tools', async () => {
+        const cwd = '/home/test/code/proj';
+        const sessionId = 'test-session-3';
+        const filePath = await ensureSessionFile(cwd, sessionId);
+        const events = [];
+        const scanner = new SessionFileScanner({ sessionId, cwd }, { onEvent: (evt) => events.push(evt) });
+        await scanner.start();
+        await fsp.appendFile(filePath, makeToolUse('b1', 'Read') + '\n' +
+            makeToolResult('b1') + '\n' +
+            makeToolUse('b2', 'Bash') + '\n' +
+            makeToolResult('b2') + '\n');
+        await new Promise((r) => setTimeout(r, 300));
+        scanner.stop();
+        const starts = events.filter((e) => e.type === 'tool_start');
+        const ends = events.filter((e) => e.type === 'tool_end');
+        expect(starts).toHaveLength(2);
+        expect(ends).toHaveLength(2);
+        expect(starts[0]).toMatchObject({ name: 'Read' });
+        expect(starts[1]).toMatchObject({ name: 'Bash' });
+        expect(ends[0]).toMatchObject({ name: 'Read' });
+        expect(ends[1]).toMatchObject({ name: 'Bash' });
+    });
+    it('handles partial line buffering', async () => {
+        const cwd = '/home/test/code/proj';
+        const sessionId = 'test-session-4';
+        const filePath = await ensureSessionFile(cwd, sessionId);
+        const events = [];
+        const scanner = new SessionFileScanner({ sessionId, cwd }, { onEvent: (evt) => events.push(evt) });
+        await scanner.start();
+        // Write a partial line (no newline).
+        const fullLine = makeToolUse('b-partial', 'Grep');
+        const half1 = fullLine.slice(0, Math.floor(fullLine.length / 2));
+        const half2 = fullLine.slice(Math.floor(fullLine.length / 2));
+        await fsp.appendFile(filePath, half1);
+        await new Promise((r) => setTimeout(r, 300));
+        // No events yet — line is incomplete.
+        expect(events.filter((e) => e.type === 'tool_start')).toHaveLength(0);
+        // Complete the line.
+        await fsp.appendFile(filePath, half2 + '\n');
+        await new Promise((r) => setTimeout(r, 300));
+        scanner.stop();
+        const starts = events.filter((e) => e.type === 'tool_start');
+        expect(starts).toHaveLength(1);
+        expect(starts[0]).toMatchObject({ name: 'Grep' });
+    });
+    it('degrades gracefully when file does not exist', async () => {
+        const events = [];
+        const scanner = new SessionFileScanner({ sessionId: 'nonexistent', cwd: '/nonexistent/path' }, { onEvent: (evt) => events.push(evt) });
+        // Should not throw, should resolve within ~10s.
+        // We set a shorter timeout by testing that it doesn't crash.
+        await scanner.start();
+        scanner.stop();
+        expect(events).toHaveLength(0);
+    }, 15_000);
+    it('skips pre-existing content', async () => {
+        const cwd = '/home/test/code/proj';
+        const sessionId = 'test-session-5';
+        const filePath = await ensureSessionFile(cwd, sessionId);
+        const events = [];
+        // Write content before scanner starts.
+        await fsp.appendFile(filePath, makeToolUse('old-1', 'Read') + '\n');
+        await fsp.appendFile(filePath, makeToolResult('old-1') + '\n');
+        const scanner = new SessionFileScanner({ sessionId, cwd }, { onEvent: (evt) => events.push(evt) });
+        await scanner.start();
+        // Write new content after scanner starts.
+        await fsp.appendFile(filePath, makeToolUse('new-1', 'Bash') + '\n');
+        await new Promise((r) => setTimeout(r, 300));
+        scanner.stop();
+        const starts = events.filter((e) => e.type === 'tool_start');
+        expect(starts).toHaveLength(1);
+        expect(starts[0]).toMatchObject({ name: 'Bash' });
+    });
+    it('emits no events after stop()', async () => {
+        const cwd = '/home/test/code/proj';
+        const sessionId = 'test-session-6';
+        const filePath = await ensureSessionFile(cwd, sessionId);
+        const events = [];
+        const scanner = new SessionFileScanner({ sessionId, cwd }, { onEvent: (evt) => events.push(evt) });
+        await scanner.start();
+        scanner.stop();
+        const countAfterStop = events.length;
+        // Write content after stop.
+        await fsp.appendFile(filePath, makeToolUse('late-1', 'Write') + '\n');
+        await new Promise((r) => setTimeout(r, 500));
+        expect(events).toHaveLength(countAfterStop);
+    });
+    it('stop() emits tool_end for still-active tools', async () => {
+        const cwd = '/home/test/code/proj';
+        const sessionId = 'test-session-7';
+        const filePath = await ensureSessionFile(cwd, sessionId);
+        const events = [];
+        const scanner = new SessionFileScanner({ sessionId, cwd }, { onEvent: (evt) => events.push(evt) });
+        await scanner.start();
+        // Start a tool but don't finish it.
+        await fsp.appendFile(filePath, makeToolUse('dangling', 'Bash') + '\n');
+        await new Promise((r) => setTimeout(r, 300));
+        scanner.stop();
+        const ends = events.filter((e) => e.type === 'tool_end');
+        expect(ends).toHaveLength(1);
+        expect(ends[0]).toMatchObject({ name: 'Bash', ok: true });
+    });
+    it('concurrent readNewBytes calls do not produce duplicate events', async () => {
+        const cwd = '/home/test/code/proj';
+        const sessionId = 'test-session-concurrent';
+        const filePath = await ensureSessionFile(cwd, sessionId);
+        const events = [];
+        const scanner = new SessionFileScanner({ sessionId, cwd }, { onEvent: (evt) => events.push(evt) });
+        await scanner.start();
+        // Write a tool_use line.
+        await fsp.appendFile(filePath, makeToolUse('conc-1', 'Read') + '\n');
+        // Trigger readNewBytes concurrently by calling the scanner's
+        // internal method multiple times. Access via the poll/watch mechanism
+        // by triggering a rapid series of file changes.
+        await fsp.appendFile(filePath, makeToolUse('conc-2', 'Bash') + '\n');
+        await fsp.appendFile(filePath, makeToolResult('conc-1') + '\n');
+        await fsp.appendFile(filePath, makeToolResult('conc-2') + '\n');
+        await new Promise((r) => setTimeout(r, 500));
+        scanner.stop();
+        // Verify each tool_start appears exactly once.
+        const starts = events.filter((e) => e.type === 'tool_start');
+        const readStarts = starts.filter((e) => e.type === 'tool_start' && e.name === 'Read');
+        const bashStarts = starts.filter((e) => e.type === 'tool_start' && e.name === 'Bash');
+        expect(readStarts).toHaveLength(1);
+        expect(bashStarts).toHaveLength(1);
+        // Verify each tool_end appears exactly once.
+        const ends = events.filter((e) => e.type === 'tool_end');
+        expect(ends).toHaveLength(2);
+    });
+});
+describe('toolActivityLabel', () => {
+    it('returns file-specific label for Read', () => {
+        expect(toolActivityLabel('Read', { file_path: '/home/user/code/proj/src/index.ts' }))
+            .toBe('Reading .../src/index.ts');
+    });
+    it('returns generic label for Read without input', () => {
+        expect(toolActivityLabel('Read')).toBe('Reading file...');
+    });
+    it('returns label for Bash', () => {
+        expect(toolActivityLabel('Bash')).toBe('Running command...');
+    });
+    it('returns label for Grep', () => {
+        expect(toolActivityLabel('Grep')).toBe('Searching content...');
+    });
+    it('returns fallback for unknown tools', () => {
+        expect(toolActivityLabel('CustomTool')).toBe('Running CustomTool...');
+    });
+    it('handles short paths without truncation', () => {
+        expect(toolActivityLabel('Read', { file_path: 'src/foo.ts' }))
+            .toBe('Reading src/foo.ts');
+    });
+});

package/dist/runtime/strategies/claude-strategy.js

@@ -0,0 +1,193 @@
+// Claude Code CLI adapter strategy.
+// Provides model-specific logic for the universal CLI adapter factory.
+import { extractResultText, extractResultContentBlocks } from '../cli-output-parsers.js';
+const toolState = new WeakMap();
+function getToolState(ctx) {
+    let s = toolState.get(ctx);
+    if (!s) {
+        s = { activeTools: new Map(), inputBufs: new Map() };
+        toolState.set(ctx, s);
+    }
+    return s;
+}
+export const claudeStrategy = {
+    id: 'claude_code',
+    binaryDefault: 'claude',
+    defaultModel: 'opus',
+    capabilities: [
+        'streaming_text',
+        'sessions',
+        'workspace_instructions',
+        'tools_exec',
+        'tools_fs',
+        'tools_web',
+        'mcp',
+    ],
+    multiTurnMode: 'process-pool',
+    getOutputMode(ctx, opts) {
+        // Images require stream-json for content block parsing.
+        if (ctx.useStdin)
+            return 'jsonl';
+        return opts.outputFormat === 'stream-json' ? 'jsonl' : 'text';
+    },
+    buildArgs(ctx, opts) {
+        const { params, useStdin, hasImages } = ctx;
+        const effectiveOutputFormat = useStdin ? 'stream-json' : (opts.outputFormat ?? 'text');
+        const args = ['-p', '--model', params.model];
+        if (opts.dangerouslySkipPermissions) {
+            args.push('--dangerously-skip-permissions');
+        }
+        if (opts.strictMcpConfig) {
+            args.push('--strict-mcp-config');
+        }
+        if (opts.fallbackModel) {
+            args.push('--fallback-model', opts.fallbackModel);
+        }
+        if (opts.maxBudgetUsd != null) {
+            args.push('--max-budget-usd', String(opts.maxBudgetUsd));
+        }
+        if (opts.appendSystemPrompt) {
+            args.push('--append-system-prompt', opts.appendSystemPrompt);
+        }
+        if (opts.debugFile && opts.debugFile.trim()) {
+            args.push('--debug-file', opts.debugFile.trim());
+        }
+        if (opts.verbose) {
+            args.push('--verbose');
+        }
+        if (params.sessionId) {
+            args.push('--session-id', params.sessionId);
+        }
+        if (params.addDirs && params.addDirs.length > 0) {
+            for (const dir of params.addDirs) {
+                args.push('--add-dir', dir);
+            }
+        }
+        if (useStdin) {
+            args.push('--input-format', 'stream-json');
+        }
+        if (effectiveOutputFormat) {
+            args.push('--output-format', effectiveOutputFormat);
+        }
+        if (effectiveOutputFormat === 'stream-json') {
+            args.push('--include-partial-messages');
+        }
+        if (params.tools) {
+            if (params.tools.length > 0) {
+                args.push('--tools', params.tools.join(','));
+            }
+            else {
+                args.push('--tools=');
+            }
+        }
+        if (!useStdin) {
+            args.push('--', params.prompt);
+        }
+        return args;
+    },
+    buildStdinPayload(ctx) {
+        if (!ctx.useStdin)
+            return null;
+        const { params } = ctx;
+        const content = [
+            { type: 'text', text: params.prompt },
+        ];
+        if (ctx.hasImages && params.images) {
+            for (const img of params.images) {
+                content.push({
+                    type: 'image',
+                    source: { type: 'base64', media_type: img.mediaType, data: img.base64 },
+                });
+            }
+        }
+        return JSON.stringify({ type: 'user', message: { role: 'user', content } }) + '\n';
+    },
+    parseLine(evt, ctx) {
+        if (!evt || typeof evt !== 'object')
+            return null;
+        const obj = evt;
+        // --- stream_event wrapper (Anthropic API events) ---
+        if (obj.type === 'stream_event' && obj.event && typeof obj.event === 'object') {
+            const inner = obj.event;
+            const idx = typeof inner.index === 'number' ? inner.index : -1;
+            // content_block_start — detect tool_use blocks for activity labels.
+            if (inner.type === 'content_block_start' && inner.content_block && typeof inner.content_block === 'object') {
+                const cb = inner.content_block;
+                if (cb.type === 'tool_use' && typeof cb.name === 'string') {
+                    const ts = getToolState(ctx);
+                    ts.activeTools.set(idx, cb.name);
+                    ts.inputBufs.set(idx, '');
+                }
+                return {};
+            }
+            // content_block_delta — text, thinking, tool input, etc.
+            if (inner.type === 'content_block_delta' && inner.delta && typeof inner.delta === 'object') {
+                const delta = inner.delta;
+                if (delta.type === 'text_delta' && typeof delta.text === 'string') {
+                    return { text: delta.text };
+                }
+                // Accumulate input_json_delta for tool input (used by tool_end to provide file paths).
+                if (delta.type === 'input_json_delta' && typeof delta.partial_json === 'string') {
+                    const ts = getToolState(ctx);
+                    const buf = ts.inputBufs.get(idx);
+                    if (buf !== undefined)
+                        ts.inputBufs.set(idx, buf + delta.partial_json);
+                    // Signal activity so the progress stall timer resets — tool input
+                    // generation is real work, not a thinking spiral.
+                    return { activity: true };
+                }
+                // thinking_delta, signature_delta, etc. — consumed, no text, no activity signal.
+                // thinking_delta intentionally does NOT set activity: the spiral detector
+                // is specifically designed to catch long thinking spans with no output.
+                return {};
+            }
+            // content_block_stop — emit tool_start (with parsed input) + tool_end for activity labels.
+            if (inner.type === 'content_block_stop') {
+                const ts = getToolState(ctx);
+                const name = ts.activeTools.get(idx);
+                if (name) {
+                    let input;
+                    const buf = ts.inputBufs.get(idx);
+                    if (buf) {
+                        try {
+                            input = JSON.parse(buf);
+                        }
+                        catch { /* partial */ }
+                    }
+                    ts.activeTools.delete(idx);
+                    ts.inputBufs.delete(idx);
+                    // Emit tool_start with the full input (so toolActivityLabel gets file paths),
+                    // then tool_end to transition back. The ToolAwareQueue handles this sequence.
+                    const events = [
+                        { type: 'tool_start', name, ...(input ? { input } : {}) },
+                        { type: 'tool_end', name, ok: true },
+                    ];
+                    return { extraEvents: events };
+                }
+                return {};
+            }
+            // All other stream_event types (message_start, message_delta, message_stop) — consumed, no text.
+            return {};
+        }
+        // --- assistant partial messages (from --include-partial-messages) ---
+        if (obj.type === 'assistant')
+            return {};
+        // --- result event ---
+        if (obj.type === 'result') {
+            const rt = extractResultText(evt);
+            const blocks = extractResultContentBlocks(evt);
+            if (rt || blocks) {
+                return {
+                    resultText: rt ?? blocks?.text ?? null,
+                    resultImages: blocks?.images,
+                };
+            }
+            return {};
+        }
+        // --- system init event ---
+        if (obj.type === 'system')
+            return {};
+        // Unknown event — fall through to default parsing.
+        return null;
+    },
+};

package/dist/runtime/strategies/codex-strategy.js

@@ -0,0 +1,161 @@
+// Codex CLI adapter strategy.
+// Provides model-specific logic for the universal CLI adapter factory.
+/** Max chars for error messages exposed outside the adapter. Prevents prompt/session leaks. */
+const MAX_ERROR_LENGTH = 200;
+const CODEX_NOISY_LINE_PATTERNS = [
+    /^warning:/i,
+    /^openai codex v/i,
+    /^-+$/,
+    /^(workdir|model|provider|approval|sandbox|reasoning effort|reasoning summaries|session id):/i,
+    /^user$/i,
+    /^mcp startup:/i,
+    /^reconnecting\.\.\./i,
+];
+const CODEX_DIAGNOSTIC_LINE_PATTERN = /\berror\b|\bfailed\b|timed out|timeout|not found|permission denied|invalid|denied|unauthorized|forbidden|expired|rate limit|disconnected/i;
+function isNoisyCodexLine(line) {
+    return CODEX_NOISY_LINE_PATTERNS.some((re) => re.test(line));
+}
+/**
+ * Strip prompt content and internal details from error messages.
+ * Codex CLI can include the full prompt, session paths, and auth details in stderr on failure.
+ */
+function sanitizeCodexError(raw) {
+    if (!raw)
+        return 'codex failed (no details)';
+    const lines = raw
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean);
+    if (lines.length === 0)
+        return 'codex failed';
+    // Known Codex state DB corruption mode: stale/missing rollout paths in session index.
+    if (lines.some((l) => /state db (missing|returned stale) rollout path/i.test(l))) {
+        return 'codex session state appears corrupted (rollout path missing). Set CODEX_HOME to a clean directory and retry.'
+            .slice(0, MAX_ERROR_LENGTH);
+    }
+    const meaningful = lines.filter((l) => !isNoisyCodexLine(l));
+    const diagnostic = [...meaningful].reverse().find((l) => CODEX_DIAGNOSTIC_LINE_PATTERN.test(l));
+    if (diagnostic)
+        return diagnostic.slice(0, MAX_ERROR_LENGTH);
+    // Avoid leaking prompt content when stderr only contains non-diagnostic chatter.
+    return 'codex failed (no details)';
+}
+/**
+ * Create a Codex CLI adapter strategy.
+ * Factory function because defaultModel varies per runtime instance.
+ */
+export function createCodexStrategy(defaultModel) {
+    return {
+        id: 'codex',
+        binaryDefault: 'codex',
+        defaultModel,
+        capabilities: [
+            'streaming_text',
+            'tools_fs',
+            'tools_exec',
+            'tools_web',
+            'sessions',
+        ],
+        multiTurnMode: 'session-resume',
+        getOutputMode(ctx, _opts) {
+            const wantSession = ctx.sessionMap != null && Boolean(ctx.params.sessionKey);
+            return wantSession ? 'jsonl' : 'text';
+        },
+        buildArgs(ctx, opts) {
+            const { params, useStdin } = ctx;
+            const wantSession = ctx.sessionMap != null && Boolean(params.sessionKey);
+            const existingThreadId = params.sessionKey ? ctx.sessionMap?.get(params.sessionKey) : undefined;
+            const dangerousBypass = Boolean(opts.dangerouslySkipPermissions);
+            // When resuming, use `codex exec resume <thread_id>`.
+            // The resume subcommand does NOT support -s/--sandbox (inherits from original session).
+            // When starting a new session (or ephemeral), use `codex exec`.
+            const args = existingThreadId
+                ? ['exec', 'resume', existingThreadId, '-m', params.model, '--skip-git-repo-check']
+                : ['exec', '-m', params.model, '--skip-git-repo-check', ...(wantSession ? [] : ['--ephemeral'])];
+            if (dangerousBypass) {
+                args.push('--dangerously-bypass-approvals-and-sandbox');
+            }
+            else if (!existingThreadId) {
+                args.push('-s', 'read-only');
+            }
+            // When session tracking is active, use --json so we can capture the thread_id
+            // from the `thread.started` event.
+            if (wantSession) {
+                args.push('--json');
+            }
+            // Pass --add-dir flags for additional directories.
+            // The resume subcommand does NOT support --add-dir (inherits from original session).
+            if (!existingThreadId && params.addDirs && params.addDirs.length > 0) {
+                for (const dir of params.addDirs) {
+                    args.push('--add-dir', dir);
+                }
+            }
+            // `--` terminates option parsing so prompts like "--- SOUL.md ---" are
+            // always treated as positional input rather than CLI flags.
+            args.push('--');
+            if (useStdin) {
+                // Use `-` to signal stdin reading.
+                args.push('-');
+            }
+            else {
+                args.push(params.prompt);
+            }
+            return args;
+        },
+        buildStdinPayload(ctx) {
+            if (!ctx.useStdin)
+                return null;
+            // Codex uses raw text stdin (not JSON-wrapped like Claude).
+            return ctx.params.prompt;
+        },
+        parseLine(evt, ctx) {
+            const anyEvt = evt;
+            // Capture thread_id for session resume on subsequent calls.
+            if (anyEvt.type === 'thread.started' && anyEvt.thread_id && ctx.params.sessionKey && ctx.sessionMap) {
+                ctx.sessionMap.set(ctx.params.sessionKey, String(anyEvt.thread_id));
+                return {}; // Handled — no text to emit.
+            }
+            // Extract text from completed items.
+            if (anyEvt.type === 'item.completed') {
+                const item = anyEvt.item;
+                if (!item)
+                    return null;
+                // Reasoning items: stream as text_delta for the preview, but do not set
+                // resultText so the final reply remains answer-only.
+                if (item.type === 'reasoning') {
+                    const summary = item.summary;
+                    const text = item.text;
+                    const reasoningText = typeof summary === 'string' ? summary :
+                        typeof text === 'string' ? text :
+                            null;
+                    if (reasoningText)
+                        return { text: reasoningText };
+                    return {};
+                }
+                // Agent message: stream as text_delta and lock in resultText so that
+                // text_final uses the answer only and never falls back to merged
+                // (which now includes reasoning text).
+                if (item.type === 'agent_message' && typeof item.text === 'string') {
+                    return { text: item.text, resultText: item.text };
+                }
+            }
+            // Other JSONL events (turn.completed, etc.) — not handled by Codex strategy.
+            return null;
+        },
+        sanitizeError(raw) {
+            return sanitizeCodexError(raw);
+        },
+        handleSpawnError(err, binary) {
+            // Let the universal adapter handle timeouts.
+            if (err?.timedOut)
+                return null;
+            // Use fixed messages to prevent prompt/session leaks.
+            // execa's shortMessage/originalMessage can contain the full command line.
+            const code = err?.code || err?.errno || '';
+            const isNotFound = code === 'ENOENT' || String(err?.originalMessage || '').includes('ENOENT');
+            if (isNotFound)
+                return `codex binary not found (${binary}). Check CODEX_BIN or PATH.`;
+            return `codex process failed unexpectedly${code ? ` (${code})` : ''}`;
+        },
+    };
+}

package/dist/runtime/strategies/gemini-strategy.js

@@ -0,0 +1,64 @@
+// Gemini CLI adapter strategy.
+// Phase 1: one-shot text output, no sessions.
+// Provides model-specific logic for the universal CLI adapter factory.
+/** Max chars for error messages exposed outside the adapter. Prevents prompt leaks. */
+const MAX_ERROR_LENGTH = 200;
+function sanitizeGeminiError(raw) {
+    if (!raw)
+        return 'gemini failed (no details)';
+    const lines = raw
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean);
+    if (lines.length === 0)
+        return 'gemini failed';
+    // Return only the first meaningful line to avoid leaking prompt content.
+    return lines[0].slice(0, MAX_ERROR_LENGTH);
+}
+/**
+ * Create a Gemini CLI adapter strategy.
+ * Factory function because defaultModel varies per runtime instance.
+ */
+export function createGeminiStrategy(defaultModel) {
+    return {
+        id: 'gemini',
+        binaryDefault: 'gemini',
+        defaultModel,
+        capabilities: ['streaming_text'],
+        getOutputMode(_ctx, _opts) {
+            return 'text';
+        },
+        buildArgs(ctx, _opts) {
+            const { params, useStdin } = ctx;
+            const args = ['--model', params.model];
+            if (!useStdin) {
+                // `--` terminates option parsing so prompts like "--- SOUL.md ---" are
+                // always treated as positional input rather than CLI flags.
+                args.push('--', params.prompt);
+            }
+            // When useStdin is true, no positional arg is added — the binary reads from stdin.
+            return args;
+        },
+        buildStdinPayload(ctx) {
+            if (!ctx.useStdin)
+                return null;
+            // Gemini CLI reads raw text from stdin when no positional prompt is given.
+            return ctx.params.prompt;
+        },
+        sanitizeError(raw) {
+            return sanitizeGeminiError(raw);
+        },
+        handleSpawnError(err, binary) {
+            // Let the universal adapter handle timeouts.
+            if (err?.timedOut)
+                return null;
+            // Use fixed messages to prevent prompt leaks.
+            // execa's shortMessage/originalMessage can contain the full command line.
+            const code = err?.code || err?.errno || '';
+            const isNotFound = code === 'ENOENT' || String(err?.originalMessage || '').includes('ENOENT');
+            if (isNotFound)
+                return `gemini binary not found (${binary}). Check GEMINI_BIN or PATH.`;
+            return `gemini process failed unexpectedly${code ? ` (${code})` : ''}`;
+        },
+    };
+}