codehere 0.8.0 → 1.0.1

package/dist/infrastructure/orchestration/mocks/mock-agent-repl.js

@@ -65,8 +65,17 @@ function readStdin(timeoutMs = 1500) {
         setTimeout(finish, timeoutMs);
     });
 }
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// CODEHERE_MOCK_SLOW multiplies step delays so the "watch it work" running
+// state can actually be observed — for dogfood screenshots and the record-replay
+// webm. Default 1 (fast, for tests). e.g. CODEHERE_MOCK_SLOW=8 ≈ 1s/step.
+const SLOW = Math.max(1, Number(process.env.CODEHERE_MOCK_SLOW) || 1);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms * SLOW));
 const out = (o) => process.stdout.write(JSON.stringify(o) + '\n');
+// Mock-currency rule: every agent emits token usage in ITS vendor's exact
+// shape, so each adapter's cost-parse branch runs under CODEHERE_MOCK instead
+// of being dead-until-a-real-run. Small fixed values → the session cost
+// estimate is deterministic and non-zero under mock.
+const MOCK_TOKENS = { input: 1200, output: 800 };
 // Derive a few plausible steps from the prompt. Heuristic, not modeled — enough
 // for the execution path to produce real steps/artifacts without an API call.
 function plannedSteps(p) {
@@ -82,11 +91,114 @@ function plannedSteps(p) {
         steps.push({ tool: 'Bash', input: { command: 'npm run build' }, result: 'build clean' });
     return steps;
 }
+/** The wrap-up say every real agent emits before its result. The mock never
+ *  did, so a mock report's only prose was the "On it" ack and every glance
+ *  led with narration instead of the finding (journey-QA 2026-07-06).
+ *  Finding first, in the same artifacts plannedSteps claims. */
+function wrapUpText(steps) {
+    const edit = steps.find((s) => s.tool === 'Edit');
+    const check = steps.find((s) => s.tool === 'Bash');
+    const wrote = edit
+        ? 'Wrote the change to ' + String(edit.input.file_path) + ' (' + edit.result.split(' ·')[0] + ')'
+        : 'No file changes';
+    const checked = check ? String(check.input.command) + ' — ' + check.result : '';
+    return wrote + (checked ? '; ' + checked : '') + '. (mock · no API spend)';
+}
 async function runClaudeCode() {
-    const sid = 'mock-' + Math.random().toString(36).slice(2, 10);
-    out({ type: 'system', subtype: 'init', session_id: sid, tools: ['Read', 'Edit', 'Bash'], model: 'mock' });
+    const resumeId = argVal('--resume');
+    const sid = resumeId || 'mock-' + Math.random().toString(36).slice(2, 10);
+    out({
+        type: 'system',
+        subtype: 'init',
+        session_id: sid,
+        tools: ['Read', 'Edit', 'Bash', 'AskUserQuestion'],
+        model: 'mock',
+    });
     await sleep(120);
+    // Continuation (answering a question / a follow-up): acknowledge + do the work.
+    if (resumeId) {
+        const ans = prompt.replace(/^[\s\S]*?My answer:\s*/i, '').trim() || prompt;
+        out({
+            type: 'assistant',
+            message: {
+                content: [{ type: 'thinking', thinking: 'The user chose: ' + ans + '. I will implement that path now.' }],
+            },
+        });
+        await sleep(160);
+        out({
+            type: 'assistant',
+            message: { content: [{ type: 'text', text: 'Got it — going with **' + ans + '**. Implementing now.' }] },
+        });
+        await sleep(160);
+        out({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', id: 'r0', name: 'Edit', input: { file_path: MOCK_EDIT_FILE } }] },
+        });
+        await sleep(160);
+        out({
+            type: 'user',
+            message: {
+                content: [
+                    { type: 'tool_result', tool_use_id: 'r0', content: '+18 lines · applied your choice', is_error: false },
+                ],
+            },
+        });
+        await sleep(140);
+        out({
+            type: 'result',
+            subtype: 'success',
+            session_id: sid,
+            result: 'Done — applied your answer (' + ans + ').',
+            usage: { input_tokens: MOCK_TOKENS.input, output_tokens: MOCK_TOKENS.output },
+        });
+        return;
+    }
     out({ type: 'assistant', message: { content: [{ type: 'text', text: 'On it — ' + prompt }] } });
+    // Ambiguous prompt → ask the user, then pause (the headless tool can't be
+    // answered, so the turn ends; codehere surfaces the card + resumes on answer).
+    if (/\bask\b|which|approach|prefer|option|client|server/.test(prompt.toLowerCase())) {
+        await sleep(160);
+        out({
+            type: 'assistant',
+            message: {
+                content: [
+                    {
+                        type: 'tool_use',
+                        id: 'tu_ask',
+                        name: 'AskUserQuestion',
+                        input: {
+                            questions: [
+                                {
+                                    question: 'Which approach should I use?',
+                                    header: 'Approach',
+                                    options: [
+                                        { label: 'Client-side only', description: 'fast, no backend changes' },
+                                        { label: 'Client + server', description: 'safer — validates on the server too' },
+                                    ],
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        });
+        await sleep(120);
+        out({
+            type: 'user',
+            message: {
+                content: [{ type: 'tool_result', tool_use_id: 'tu_ask', is_error: true, content: 'awaiting your answer' }],
+            },
+        });
+        await sleep(120);
+        out({
+            type: 'result',
+            subtype: 'success',
+            session_id: sid,
+            result: 'Waiting for your answer to continue.',
+            usage: { input_tokens: MOCK_TOKENS.input, output_tokens: MOCK_TOKENS.output },
+        });
+        return;
+    }
     const steps = plannedSteps(prompt);
     for (let i = 0; i < steps.length; i++) {
         const s = steps[i];
@@ -100,11 +212,17 @@ async function runClaudeCode() {
         });
     }
     await sleep(140);
+    // The wrap-up say (real claude always emits one) — the report leads with it.
+    out({ type: 'assistant', message: { content: [{ type: 'text', text: wrapUpText(steps) }] } });
+    await sleep(120);
+    // Real claude stream-json carries the session's usage totals on the final
+    // `result` event (input_tokens / output_tokens / cache_*_input_tokens).
     out({
         type: 'result',
         subtype: 'success',
         session_id: sid,
         result: 'Completed (mock): ' + prompt + '. ' + steps.length + ' steps · no API spend.',
+        usage: { input_tokens: MOCK_TOKENS.input, output_tokens: MOCK_TOKENS.output },
     });
 }
 // codex exec --json format · thread.started → item.completed events → turn.completed
@@ -123,7 +241,10 @@ async function runCodex() {
     }
     if (/linear|github|jira|figma|mcp|issue|ticket/.test(lc)) {
         await sleep(120);
-        out({ type: 'item.completed', item: { type: 'mcp_tool_call', server: 'linear', tool: 'get_issue', arguments: { id: 'INFRA-247' } } });
+        out({
+            type: 'item.completed',
+            item: { type: 'mcp_tool_call', server: 'linear', tool: 'get_issue', arguments: { id: 'INFRA-247' } },
+        });
     }
     const steps = plannedSteps(prompt);
     for (const s of steps) {
@@ -150,12 +271,18 @@ async function runCodex() {
     }
     await sleep(120);
     out({ type: 'turn.completed', usage: { input_tokens: 1200, output_tokens: 340 } });
-    out({ type: 'item.completed', item: { type: 'agent_message', text: 'Completed (mock): ' + prompt } });
+    out({ type: 'item.completed', item: { type: 'agent_message', text: wrapUpText(steps) } });
 }
 // aider · plain-text stdout · "Applied edit to <p>" + "Running <cmd>"
 async function runAider() {
     process.stdout.write('Aider v0.x (mock)\n');
     const steps = plannedSteps(prompt);
+    // Real aider narrates BEFORE its edits/commands (its prose precedes the
+    // "Applied edit"/"Running" lines; nothing prose-shaped follows the last
+    // command — the adapter attributes post-Running lines to that command's
+    // output). Mock-currency: same order, so the say capture sees the finding.
+    await sleep(140);
+    process.stdout.write(wrapUpText(steps).replace(/^Wrote the change to/, 'I will write the change to') + '\n');
     for (const s of steps) {
         await sleep(170);
         if (s.tool === 'Bash')
@@ -166,12 +293,22 @@ async function runAider() {
             process.stdout.write(String(s.input.file_path) + '\n'); // read → plain mention
     }
     await sleep(120);
-    process.stdout.write('Done (mock): ' + prompt + '\n');
+    // Real aider prints a cost summary line at turn end; the adapter's token
+    // extraction parses exactly this "Tokens: Nk sent, N received" shape.
+    process.stdout.write('Tokens: 1.2k sent, 800 received. Cost: $0.0046 message, $0.0046 session.\n');
 }
-// gemini · JSON tool_use / tool_result (tool_id, tool_name, parameters)
+// gemini · JSON tool_use / tool_result (tool_id, tool_name, parameters).
+// Narration matches the REAL gemini-cli stream: `message` events with
+// role:'assistant' + delta:true chunks (verified against gemini-cli 0.39.1 —
+// assistant messages are ALWAYS delta'd; a `content` event type doesn't
+// exist). Mock-currency rule: the mock emits what the real CLI emits, or
+// mock runs silently exercise dead branches (this gap hid the no-say bug
+// that made every real gemini report degrade to the deterministic fallback).
 async function runGemini() {
     out({ type: 'session', session_id: 'mock-gem-' + Math.random().toString(36).slice(2, 8) });
     await sleep(120);
+    out({ type: 'message', role: 'assistant', content: 'Working on it (mock): ', delta: true });
+    out({ type: 'message', role: 'assistant', content: prompt.slice(0, 60), delta: true });
     const steps = plannedSteps(prompt);
     for (let i = 0; i < steps.length; i++) {
         const s = steps[i];
@@ -183,7 +320,19 @@ async function runGemini() {
         out({ type: 'tool_result', tool_id: id, output: s.result });
     }
     await sleep(120);
-    out({ type: 'content', text: 'Completed (mock): ' + prompt });
+    out({ type: 'message', role: 'assistant', content: wrapUpText(steps), delta: true });
+    // Real gemini carries token usage ONLY on the final success `result` event,
+    // under `stats` (the adapter reads input_tokens/output_tokens/cached).
+    out({
+        type: 'result',
+        status: 'success',
+        stats: {
+            total_tokens: MOCK_TOKENS.input + MOCK_TOKENS.output,
+            input_tokens: MOCK_TOKENS.input,
+            output_tokens: MOCK_TOKENS.output,
+            cached: 0,
+        },
+    });
 }
 // opencode · JSON tool_use with part:{tool,state:{input,output,status}}
 async function runOpencode() {
@@ -194,10 +343,16 @@ async function runOpencode() {
         out({ type: 'tool_use', part: { tool, state: { input: s.input, output: s.result, status: 'completed' } } });
     }
     await sleep(120);
+    // Real opencode carries token usage on step_finish events under
+    // part.tokens.{input,output,cache.{read,write}}; the adapter sums them.
+    out({
+        type: 'step_finish',
+        part: { tokens: { input: MOCK_TOKENS.input, output: MOCK_TOKENS.output, cache: { read: 0, write: 0 } } },
+    });
     // Real opencode carries narrative text in part.text (the adapter's summary
     // extraction and the aggregator's say capture both read that shape) — the
     // prior top-level `text` field was mock drift no real parser ever saw.
-    out({ type: 'text', part: { text: 'Completed (mock): ' + prompt } });
+    out({ type: 'text', part: { text: wrapUpText(steps) } });
 }
 async function main() {
     if (!prompt)

package/dist/infrastructure/orchestration/opencode-adapter.js

@@ -19,8 +19,9 @@ import { homedir } from 'os';
 import { join } from 'path';
 import { promisify } from 'util';
 import { ProgressAggregator } from './progress-aggregator.js';
-import { resolveAgentSpawn } from './mocks/resolve-agent-spawn.js';
+import { resolveAgentSpawn, isMockMode } from './mocks/resolve-agent-spawn.js';
 import { applyMemoryPrefix } from './memory-injector.js';
+import { detectOllama } from './detect-ollama.js';
 import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.js';
 import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
 const execFileAsync = promisify(execFile);
@@ -220,6 +221,22 @@ export function spawnOpenCode(prompt, options = {}) {
         }
     };
     const spawnEnv = { ...process.env, ...(options.env ?? {}) };
+    // Cost-bounded by default: when the user hasn't pinned a model and Ollama is
+    // serving one locally, route opencode to it (opencode lists it as
+    // `ollama/<model>`). This makes opencode a FREE, LOCAL vendor on a machine
+    // with Ollama — the same pattern proven on aider (aider-adapter.ts ~314) —
+    // so the "vendor-neutral + cost-bounded" promise isn't aider-only. Without
+    // it, opencode falls to its config default (e.g. a paid byteplus model),
+    // silently spending. Always overridable: --model in extraArgs, or
+    // CODEHERE_NO_LOCAL_OLLAMA=1 to opt out.
+    const _extra = options.extraArgs ?? [];
+    const _modelPinned = _extra.some((a) => a === '--model' || a.startsWith('--model='));
+    const _localArgs = [];
+    if (!_modelPinned && spawnEnv.CODEHERE_NO_LOCAL_OLLAMA !== '1') {
+        const ollama = detectOllama();
+        if (ollama.available && ollama.model)
+            _localArgs.push('--model', `ollama/${ollama.model}`);
+    }
     let child;
     try {
         // OpenCode's `run` expects the message as positional args, not stdin.
@@ -228,7 +245,7 @@ export function spawnOpenCode(prompt, options = {}) {
         // parseOpenCodeSessionIdByTitle for the why — opencode buffers the
         // ses_* id until LLM completion, so we can't capture it mid-stream).
         const titleTag = `${CODEHERE_TITLE_PREFIX}${sessionId}`;
-        const sp = resolveAgentSpawn('opencode', 'opencode', [...HEADLESS_FLAGS, '--title', titleTag, finalPrompt, ...(options.extraArgs ?? [])], finalPrompt);
+        const sp = resolveAgentSpawn('opencode', 'opencode', [...HEADLESS_FLAGS, '--title', titleTag, ..._localArgs, finalPrompt, ...(options.extraArgs ?? [])], finalPrompt);
         child = spawn(sp.command, sp.args, {
             cwd,
             env: spawnEnv,
@@ -268,6 +285,7 @@ export function spawnOpenCode(prompt, options = {}) {
     // CODEHERE_RECORD_CASSETTES=1, so zero overhead by default.
     const recorder = startRecording({ adapter: 'opencode', sessionId, prompt: finalPrompt, cwd });
     let stdoutBuf = '';
+    let eventsParsed = 0;
     child.stdout?.on('data', (chunk) => {
         const text = chunk.toString('utf-8');
         recorder.onStdout(text);
@@ -280,9 +298,13 @@ export function spawnOpenCode(prompt, options = {}) {
                 continue;
             try {
                 const data = JSON.parse(line);
+                eventsParsed++;
                 emit({ type: data.type ?? 'opencode_event', timestamp: Date.now(), data });
             }
             catch {
+                // Non-JSON output still counts as observed work — the no-op guard below
+                // must fire only when opencode produced NOTHING at all (refuter 2026-07-18).
+                eventsParsed++;
                 emit({ type: 'stdout', timestamp: Date.now(), data: { line } });
             }
         }
@@ -295,23 +317,63 @@ export function spawnOpenCode(prompt, options = {}) {
                 emit({ type: 'stderr', timestamp: Date.now(), data: { line } });
         }
     });
-    child.on('exit', (code, signal) => {
+    // 'close', not 'exit' — opencode buffers stdout until the LLM call completes,
+    // so the final burst can be delivered AFTER 'exit' fires. 'close' waits for
+    // all stdio to drain, which the zero-events guard below depends on (refuter
+    // 2026-07-18: checking in 'exit' could flip a true success to error).
+    child.on('close', (code, signal) => {
         recorder.onExit(code ?? -1, signal);
-        statusValue =
-            killRequested || signal !== null ? 'killed' : errorEmitted ? 'error' : code === 0 ? 'completed' : 'error';
-        if (aggregator.finalize(statusValue === 'completed' ? 'completed' : statusValue === 'killed' ? 'killed' : 'error')) {
-            stepsSnapshot = aggregator.steps.map((s) => ({ ...s }));
-            emit({ type: 'codehere:steps', timestamp: Date.now(), data: { steps: stepsSnapshot } });
-        }
-        if (statusValue === 'completed') {
+        // Flush a final line that arrived without a trailing newline — it would
+        // otherwise sit unparsed in stdoutBuf and read as "no output".
+        const remnant = stdoutBuf.trim();
+        if (remnant) {
+            stdoutBuf = '';
             try {
-                artifactsSnapshot = { ...extractArtifacts(snapshot, textAccum), usage: usageSnapshot };
-                emit({ type: 'codehere:artifacts', timestamp: Date.now(), data: artifactsSnapshot });
+                const data = JSON.parse(remnant);
+                eventsParsed++;
+                emit({ type: data.type ?? 'opencode_event', timestamp: Date.now(), data });
             }
             catch {
-                /* best-effort */
+                eventsParsed++;
+                emit({ type: 'stdout', timestamp: Date.now(), data: { line: remnant } });
             }
         }
+        // Trust the PROCESS's own exit code for success. The catch-all error-pattern
+        // scan above flips `errorEmitted` on any transient "rate limit"/"error" token
+        // anywhere in the stream — which falsely marked a SUCCESSFUL local-model run
+        // as a failure (opencode read+edited the file, said "I've added…", exited 0).
+        // For a trust product, lying that a success failed is the worst bug. So a
+        // clean exit (code 0, not killed) = completed; errorEmitted only carries the
+        // reason for a genuine non-zero failure.
+        statusValue = killRequested || signal !== null ? 'killed' : code === 0 ? 'completed' : 'error';
+        // BUG-8 (E2E 3.4) · the inverse lie: exit 0 with ZERO observed output lines
+        // means opencode did nothing observable. "Done" over a no-op misleads worse
+        // than an honest failure.
+        if (statusValue === 'completed' && eventsParsed === 0) {
+            statusValue = 'error';
+            emit({
+                type: 'error',
+                timestamp: Date.now(),
+                data: {
+                    message: 'opencode exited cleanly but reported no work at all (no events, no output). ' +
+                        'Usually a provider/model config issue — try `opencode run "say hi"` in this folder to see the real behavior.',
+                },
+            });
+        }
+        if (aggregator.finalize(statusValue === 'completed' ? 'completed' : statusValue === 'killed' ? 'killed' : 'error')) {
+            stepsSnapshot = aggregator.steps.map((s) => ({ ...s }));
+            emit({ type: 'codehere:steps', timestamp: Date.now(), data: { steps: stepsSnapshot } });
+        }
+        // Capture artifacts ALWAYS, not only on completion — a failed run that still
+        // edited files must report those files, never "no files changed" (the second
+        // half of the same lie). The honesty layer downstream needs the real diff.
+        try {
+            artifactsSnapshot = { ...extractArtifacts(snapshot, textAccum), usage: usageSnapshot };
+            emit({ type: 'codehere:artifacts', timestamp: Date.now(), data: artifactsSnapshot });
+        }
+        catch {
+            /* best-effort */
+        }
         emit({
             type: 'exit',
             timestamp: Date.now(),
@@ -390,6 +452,10 @@ export function spawnOpenCode(prompt, options = {}) {
                 // gemini adapter's choice (and is well above any LLM-tied internal
                 // timer opencode might have).
                 const timeoutMs = Number(process.env.CODEHERE_OPENCODE_LIST_TIMEOUT_MS) || 15000;
+                // S9 · never execute the real binary under mock — the session-id
+                // refinement is meaningless against the mock REPL anyway.
+                if (isMockMode())
+                    throw new Error('mock mode: skip real session list');
                 const { stdout: listOut } = await execFileAsync('opencode', ['session', 'list', '--format', 'json'], {
                     cwd,
                     env: spawnEnv,
@@ -410,7 +476,11 @@ export function spawnOpenCode(prompt, options = {}) {
             return new Promise((resolve, reject) => {
                 let stdout = '';
                 let stderr = '';
-                const followup = spawn('opencode', [...HEADLESS_FLAGS, ...resumeArgs, text], {
+                // S9 · route follow-ups through the mock seam too — under
+                // CODEHERE_MOCK=1 this hits the mock REPL, not real opencode.
+                // (Was a real-spend leak on reply; mirrors the codex fix.)
+                const sp2 = resolveAgentSpawn('opencode', 'opencode', [...HEADLESS_FLAGS, ...resumeArgs, text], text);
+                const followup = spawn(sp2.command, sp2.args, {
                     cwd,
                     env: spawnEnv,
                     stdio: ['ignore', 'pipe', 'pipe'],