codehere 0.6.2 → 0.7.0

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

@@ -0,0 +1,233 @@
+/**
+ * Mock agent REPL · the synthetic subprocess codehere spawns under CODEHERE_MOCK=1
+ * INSTEAD of a real agent CLI. Zero API spend, zero rate limits — lets us build +
+ * dogfood the REAL execution path (spawn → tool calls → audit → artifacts → Final
+ * Report) and remote-control against a stand-in agent.
+ *
+ * Run as: node mock-agent-repl.js --agent <id> -p "<prompt>" [...ignored flags]
+ *
+ * Each agent emits its OWN CLI output format so the matching adapter parses it
+ * unchanged. claude-code → newline-delimited stream-json. (codex/aider/gemini/
+ * opencode formats added as their adapters get wired.)
+ *
+ * Honest scope: synthetic, deterministic-ish output derived from the prompt. It
+ * is NOT a real model — it produces plausible steps + a summary so the pipeline
+ * runs end-to-end. For replaying REAL captured runs, that's the cassette system.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join, isAbsolute, basename } from 'path';
+function argVal(flag) {
+    const i = process.argv.indexOf(flag);
+    return i >= 0 && i + 1 < process.argv.length ? process.argv[i + 1] : undefined;
+}
+/** The file the mock claims to edit — derived from the prompt, used for both
+ *  the emitted step AND the real on-disk edit so they stay consistent. */
+function targetFile(p) {
+    return /(\b[\w./-]+\.(ts|tsx|js|py|go|rs|md))\b/.exec(p)?.[1] || 'src/feature.ts';
+}
+/** CODEHERE_MOCK fidelity: actually apply a small, safe edit so the REAL
+ *  artifacts pipeline (git diff → trust score → Final Report → verify) has a
+ *  genuine change to report. The demo's "1 file changed · trust" stays honest —
+ *  it is a real diff on disk, just authored by the mock, not a model. */
+function materializeEdit(file) {
+    try {
+        const cwd = process.cwd();
+        let target = isAbsolute(file) ? file : join(cwd, file);
+        if (!target.startsWith(cwd))
+            target = join(cwd, basename(file)); // no traversal
+        const marker = `\n// codehere(mock): change applied for "${prompt.slice(0, 60).replace(/"/g, "'")}"\n`;
+        if (existsSync(target)) {
+            writeFileSync(target, readFileSync(target, 'utf-8') + marker);
+        }
+        else if (!file.includes('/')) {
+            writeFileSync(target, marker.trimStart()); // top-level only — never mkdir
+        }
+    }
+    catch {
+        /* best-effort — mock fidelity must never crash the run */
+    }
+}
+const agent = argVal('--agent') || 'claude-code';
+let prompt = argVal('--mock-prompt') || argVal('-p') || argVal('--prompt') || argVal('--message') || '';
+// Some agents (codex) pass the prompt via stdin, not an arg. Read it if no arg.
+function readStdin(timeoutMs = 1500) {
+    return new Promise((resolve) => {
+        let buf = '';
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            resolve(buf.trim());
+        };
+        if (process.stdin.isTTY)
+            return finish();
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', (c) => (buf += c));
+        process.stdin.on('end', finish);
+        setTimeout(finish, timeoutMs);
+    });
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const out = (o) => process.stdout.write(JSON.stringify(o) + '\n');
+// 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) {
+    const lc = p.toLowerCase();
+    const file = targetFile(p);
+    const steps = [
+        { tool: 'Read', input: { file_path: 'REPO_MAP.md' }, result: 'context loaded · 84 files indexed' },
+        { tool: 'Edit', input: { file_path: file }, result: '+' + (20 + (p.length % 90)) + ' lines · change applied' },
+    ];
+    if (/test|spec/.test(lc))
+        steps.push({ tool: 'Bash', input: { command: 'npm test' }, result: 'tests passed' });
+    else
+        steps.push({ tool: 'Bash', input: { command: 'npm run build' }, result: 'build clean' });
+    return steps;
+}
+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' });
+    await sleep(120);
+    out({ type: 'assistant', message: { content: [{ type: 'text', text: 'On it — ' + prompt }] } });
+    const steps = plannedSteps(prompt);
+    for (let i = 0; i < steps.length; i++) {
+        const s = steps[i];
+        const id = 'tu_' + i;
+        await sleep(180);
+        out({ type: 'assistant', message: { content: [{ type: 'tool_use', id, name: s.tool, input: s.input }] } });
+        await sleep(160);
+        out({
+            type: 'user',
+            message: { content: [{ type: 'tool_result', tool_use_id: id, content: s.result, is_error: false }] },
+        });
+    }
+    await sleep(140);
+    out({
+        type: 'result',
+        subtype: 'success',
+        session_id: sid,
+        result: 'Completed (mock): ' + prompt + '. ' + steps.length + ' steps · no API spend.',
+    });
+}
+// codex exec --json format · thread.started → item.completed events → turn.completed
+async function runCodex() {
+    const tid = 'mock-thread-' + Math.random().toString(36).slice(2, 8);
+    out({ type: 'thread.started', thread_id: tid });
+    await sleep(120);
+    // codex puts `item` at the TOP LEVEL of the event (sibling of type), not nested.
+    out({ type: 'item.completed', item: { type: 'agent_message', text: 'On it — ' + prompt } });
+    // Representative extra item types codex emits (so the timeline parser is exercised):
+    // a web_search when the task implies lookup, an mcp_tool_call when it implies an integration.
+    const lc = prompt.toLowerCase();
+    if (/search|find|research|look ?up|latest|docs?\b/.test(lc)) {
+        await sleep(120);
+        out({ type: 'item.completed', item: { type: 'web_search', query: prompt.slice(0, 60) } });
+    }
+    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' } } });
+    }
+    const steps = plannedSteps(prompt);
+    for (const s of steps) {
+        await sleep(170);
+        if (s.tool === 'Bash') {
+            out({
+                type: 'item.completed',
+                item: {
+                    type: 'command_execution',
+                    command: String(s.input.command),
+                    aggregated_output: s.result,
+                    exit_code: 0,
+                    status: 'completed',
+                },
+            });
+        }
+        else {
+            const kind = s.tool === 'Read' ? 'read' : 'update';
+            out({
+                type: 'item.completed',
+                item: { type: 'file_change', changes: [{ path: String(s.input.file_path), kind }] },
+            });
+        }
+    }
+    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 } });
+}
+// 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);
+    for (const s of steps) {
+        await sleep(170);
+        if (s.tool === 'Bash')
+            process.stdout.write('Running ' + String(s.input.command) + '\n' + s.result + '\n');
+        else if (s.tool === 'Edit')
+            process.stdout.write('Applied edit to ' + String(s.input.file_path) + '\n');
+        else
+            process.stdout.write(String(s.input.file_path) + '\n'); // read → plain mention
+    }
+    await sleep(120);
+    process.stdout.write('Done (mock): ' + prompt + '\n');
+}
+// gemini · JSON tool_use / tool_result (tool_id, tool_name, parameters)
+async function runGemini() {
+    out({ type: 'session', session_id: 'mock-gem-' + Math.random().toString(36).slice(2, 8) });
+    await sleep(120);
+    const steps = plannedSteps(prompt);
+    for (let i = 0; i < steps.length; i++) {
+        const s = steps[i];
+        const id = 'g' + i;
+        const name = s.tool === 'Read' ? 'read_file' : s.tool === 'Edit' ? 'edit_file' : 'run_shell_command';
+        await sleep(170);
+        out({ type: 'tool_use', tool_id: id, tool_name: name, parameters: s.input });
+        await sleep(150);
+        out({ type: 'tool_result', tool_id: id, output: s.result });
+    }
+    await sleep(120);
+    out({ type: 'content', text: 'Completed (mock): ' + prompt });
+}
+// opencode · JSON tool_use with part:{tool,state:{input,output,status}}
+async function runOpencode() {
+    const steps = plannedSteps(prompt);
+    for (const s of steps) {
+        const tool = s.tool === 'Read' ? 'read' : s.tool === 'Edit' ? 'edit' : 'bash';
+        await sleep(180);
+        out({ type: 'tool_use', part: { tool, state: { input: s.input, output: s.result, status: 'completed' } } });
+    }
+    await sleep(120);
+    out({ type: 'text', text: 'Completed (mock): ' + prompt });
+}
+async function main() {
+    if (!prompt)
+        prompt = (await readStdin()) || 'task';
+    // Apply the real on-disk edit before emitting the run so the artifacts
+    // extractor (which diffs at exit) sees a genuine change.
+    materializeEdit(targetFile(prompt));
+    switch (agent) {
+        case 'claude-code':
+        case 'claude':
+            await runClaudeCode();
+            break;
+        case 'codex':
+            await runCodex();
+            break;
+        case 'aider':
+            await runAider();
+            break;
+        case 'gemini':
+            await runGemini();
+            break;
+        case 'opencode':
+            await runOpencode();
+            break;
+        default:
+            // Other agents' formats land here as their adapters get wired.
+            process.stderr.write('mock-agent-repl: agent "' + agent + '" not yet mocked\n');
+            out({ type: 'result', subtype: 'success', result: 'mock stub for ' + agent });
+    }
+    process.exit(0);
+}
+void main();
+//# sourceMappingURL=mock-agent-repl.js.map

package/dist/infrastructure/orchestration/mocks/mock-codex-app-server.js

@@ -0,0 +1,73 @@
+/**
+ * Mock codex app-server · speaks the real app-server JSON-RPC protocol
+ * (newline-delimited over stdio) so the codehere ControlSurface can be built +
+ * tested WITHOUT real codex (rate-limited until 2026-05-26) and zero API spend.
+ *
+ * Subset for remote-control inject: initialize · thread/start · turn/start
+ * (running turn emitting items) · turn/steer (inject mid-turn) · turn/interrupt.
+ * Schema source: `codex app-server generate-json-schema` (dumped 2026-05-25).
+ *
+ * Runs as a subprocess (node dist/.../mock-codex-app-server.js). Production code
+ * never imports it; only CODEHERE_MOCK spawns it.
+ */
+import { createInterface } from 'readline';
+const send = (o) => void process.stdout.write(JSON.stringify(o) + '\n');
+const reply = (id, result) => send({ jsonrpc: '2.0', id, result });
+const notify = (method, params) => send({ jsonrpc: '2.0', method, params });
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+let threadSeq = 0;
+let steeredText = null;
+const rl = createInterface({ input: process.stdin });
+rl.on('line', async (line) => {
+    const t = line.trim();
+    if (!t)
+        return;
+    let msg;
+    try {
+        msg = JSON.parse(t);
+    }
+    catch {
+        return;
+    }
+    const { id, method, params } = msg;
+    switch (method) {
+        case 'initialize':
+            reply(id, { userAgent: 'mock-codex-app-server/1.0', platformOs: 'mock', protocolVersion: '1' });
+            break;
+        case 'thread/start':
+            reply(id, { thread_id: 'mock-thread-' + ++threadSeq });
+            break;
+        case 'turn/start': {
+            reply(id, { accepted: true });
+            const prompt = String((params?.input ?? params?.prompt ?? 'task'));
+            await sleep(120);
+            notify('item.completed', { item: { type: 'agent_message', text: 'starting: ' + prompt.slice(0, 80) } });
+            // Real codex turns run for seconds; keep a window open so a mid-turn
+            // turn/steer (incl. from the web UI, which takes ~1-2s to fire) lands and
+            // gets reflected. Poll for a steer ~6s, then finish the turn.
+            for (let i = 0; i < 12; i++) {
+                await sleep(500);
+                if (steeredText) {
+                    notify('item.completed', { item: { type: 'agent_message', text: 'STEERED mid-turn: ' + steeredText } });
+                    steeredText = null;
+                }
+            }
+            notify('item.completed', {
+                item: { type: 'command_execution', command: 'npm test', exit_code: 0, status: 'completed' },
+            });
+            notify('turn.completed', { usage: { input_tokens: 900, output_tokens: 210 } });
+            break;
+        }
+        case 'turn/steer':
+            steeredText = String((params?.input ?? params?.text ?? params?.message ?? '(empty)'));
+            reply(id, { accepted: true });
+            break;
+        case 'turn/interrupt':
+            reply(id, { interrupted: true });
+            break;
+        default:
+            if (id !== undefined)
+                reply(id, { ok: true });
+    }
+});
+//# sourceMappingURL=mock-codex-app-server.js.map

package/dist/infrastructure/orchestration/mocks/mock-synthesis.js

@@ -0,0 +1,83 @@
+/**
+ * Mock synthesis · the CODEHERE_MOCK stand-in for the three LLM "narrator"
+ * calls (Final Report, mid-task narration, thread title).
+ *
+ * The agent-spawn seam (resolve-agent-spawn.ts) already mocks the coding agents
+ * themselves. But the Final Report / narration / title are SEPARATE `claude`
+ * subprocess calls, so under CODEHERE_MOCK they would still hit a real model (or
+ * fail) and the headline deliverable would be missing in a demo. These builders
+ * produce deterministic, grounded text from the run's own data — zero API spend
+ * — so the whole flow (incl. the Final Report + verify cross-check) runs under
+ * mock end-to-end.
+ *
+ * Honest scope: this is demo/dev output, only active when CODEHERE_MOCK=1. It is
+ * grounded in the real (mock) run's steps + artifacts so the verifier still
+ * cross-checks it the same way it checks a real report.
+ */
+function stepVerbs(steps) {
+    const labels = steps
+        .filter((s) => s.kind !== 'say')
+        .map((s) => s.label)
+        .filter(Boolean);
+    if (labels.length === 0)
+        return 'started the task but recorded no structured steps';
+    if (labels.length <= 3)
+        return labels.join(', then ');
+    return `${labels.slice(0, 3).join(', ')}, and ${labels.length - 3} more step${labels.length - 3 === 1 ? '' : 's'}`;
+}
+/** Build the "files" paragraph so it stays consistent with what the verifier
+ *  checks against artifacts — same truth rules as the real prompt template. */
+function filesParagraph(artifacts) {
+    const files = artifacts?.files ?? [];
+    if (artifacts?.noGitTracking) {
+        return 'codehere could not track file changes here because this folder is not a git repository, so there is no per-file diff to show.';
+    }
+    if (files.length === 0) {
+        return 'No files were changed.';
+    }
+    const list = files
+        .map((f) => `${f.path} (+${f.added}/-${f.removed}${typeof f.trust === 'number' ? `, trust ${f.trust}` : ''})`)
+        .join('; ');
+    return `The agent touched ${files.length} file${files.length === 1 ? '' : 's'}: ${list}.`;
+}
+export function mockFinalReport(input) {
+    const p1 = `Working on "${input.prompt.slice(0, 120)}", the ${input.agent} agent ${stepVerbs(input.steps)}.`;
+    const p2 = filesParagraph(input.artifacts);
+    const files = input.artifacts?.files ?? [];
+    const tests = input.artifacts?.tests;
+    let p3;
+    if (tests) {
+        p3 = `Tests ran with ${tests.passed} passing${tests.failed ? ` and ${tests.failed} failing` : ''} — ${tests.failed ? 'look at the failures before relying on this' : 'a quick glance at the changed lines is still worth it'}.`;
+    }
+    else if (files.length > 0) {
+        p3 = `Open ${files[0].path} and confirm the change does what you asked before relying on it.`;
+    }
+    else {
+        p3 = 'Nothing to verify on disk; this looks like a read-only session.';
+    }
+    return { summary: `${p1}\n\n${p2}\n\n${p3}`, generatedAt: Date.now(), durationMs: 8 };
+}
+export function mockNarration(input) {
+    const recent = input.steps
+        .filter((s) => s.kind !== 'say')
+        .slice(-2)
+        .map((s) => s.label)
+        .filter(Boolean);
+    const summary = recent.length > 0
+        ? `The agent is working through it — most recently: ${recent.join(', then ')}.`
+        : 'The agent is getting started on your task.';
+    return { summary, durationMs: 5 };
+}
+export function mockTitle(firstPrompt, cwd) {
+    const words = firstPrompt
+        .replace(/[^a-zA-Z0-9 ]/g, ' ')
+        .split(/\s+/)
+        .filter(Boolean)
+        .slice(0, 6);
+    if (words.length >= 2) {
+        return words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+    }
+    const seg = cwd.split('/').filter(Boolean).pop() || 'Project';
+    return seg.replace(/[-_]/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()) + ' Workspace';
+}
+//# sourceMappingURL=mock-synthesis.js.map

package/dist/infrastructure/orchestration/mocks/resolve-agent-spawn.js

@@ -0,0 +1,37 @@
+/**
+ * Mock spawn seam · the ONE place adapters route through to get mocked.
+ *
+ * When CODEHERE_MOCK=1, resolveAgentSpawn() swaps the real agent binary for the
+ * mock REPL subprocess (node mock-agent-repl.js --agent <id> ...same args). The
+ * adapter's spawn/parse path is otherwise untouched — it parses the mock's
+ * output exactly as it would the real CLI's. Zero API spend, zero rate limits.
+ *
+ * Off by default: without the env var it returns the real binary + args verbatim,
+ * so production behavior is unchanged.
+ */
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+export function isMockMode() {
+    return process.env.CODEHERE_MOCK === '1' || process.env.CODEHERE_MOCK === 'true';
+}
+const mockReplPath = () => join(dirname(fileURLToPath(import.meta.url)), 'mock-agent-repl.js');
+/**
+ * @param agentId  stable adapter id (e.g. 'claude-code', 'codex') — tells the
+ *                 mock which CLI output format to emit.
+ * @param realBin  the real binary the adapter would spawn (e.g. 'claude').
+ * @param args     the args the adapter would pass.
+ * @returns        { command, args } to hand to child_process.spawn().
+ */
+export function resolveAgentSpawn(agentId, realBin, args, prompt) {
+    if (!isMockMode())
+        return { command: realBin, args, mocked: false };
+    // Pass the prompt explicitly (agents take it differently: -p / --message /
+    // stdin / positional) so the mock doesn't have to guess where it is.
+    const promptArgs = prompt ? ['--mock-prompt', prompt] : [];
+    return {
+        command: process.execPath, // node
+        args: [mockReplPath(), '--agent', agentId, ...promptArgs, ...args],
+        mocked: true,
+    };
+}
+//# sourceMappingURL=resolve-agent-spawn.js.map

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

@@ -13,11 +13,13 @@
 import { spawn, execFile, execFileSync } from 'child_process';
 import { EventEmitter } from 'events';
 import { randomUUID } from 'crypto';
+import { startRecording } from './cassette-recorder.js';
 import { existsSync } from 'fs';
 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 { applyMemoryPrefix } from './memory-injector.js';
 import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.js';
 import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
@@ -150,8 +152,18 @@ export function spawnOpenCode(prompt, options = {}) {
         // { input: {...}, output, status, ... } } } (verified via deepwiki +
         // takopi cheatsheet). Same post-hoc visibility surface as Codex/Aider/
         // Gemini — no synchronous block until upstream pre-tool hooks land.
+        //
+        // v0.7 CRIT-2 fix — only mirror on state.status === 'completed' to
+        // avoid double-firing (state transitions running → completed both arrive
+        // as tool_use events; mirroring twice doubles audit entries + trust
+        // scans). Per docs/contracts/opencode.md, status is canonical.
         if (event.type === 'tool_use') {
             const part = event.data?.part;
+            // CRIT-2 guard: skip in-flight running state. Only audit on terminal.
+            const status = part?.state?.status;
+            if (status && status !== 'completed') {
+                return;
+            }
             const rawTool = String(part?.tool ?? 'tool').toLowerCase();
             // Normalize to Claude-cased tool names so /history filter chips group
             // cross-vendor (a bash call from claude-code and opencode show under
@@ -216,7 +228,8 @@ 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}`;
-        child = spawn('opencode', [...HEADLESS_FLAGS, '--title', titleTag, finalPrompt, ...(options.extraArgs ?? [])], {
+        const sp = resolveAgentSpawn('opencode', 'opencode', [...HEADLESS_FLAGS, '--title', titleTag, finalPrompt, ...(options.extraArgs ?? [])], finalPrompt);
+        child = spawn(sp.command, sp.args, {
             cwd,
             env: spawnEnv,
             stdio: ['ignore', 'pipe', 'pipe'],
@@ -251,9 +264,14 @@ export function spawnOpenCode(prompt, options = {}) {
             },
         };
     }
+    // Organic cassette recording (S2b · capture-first plan) · no-op unless
+    // CODEHERE_RECORD_CASSETTES=1, so zero overhead by default.
+    const recorder = startRecording({ adapter: 'opencode', sessionId, prompt: finalPrompt, cwd });
     let stdoutBuf = '';
     child.stdout?.on('data', (chunk) => {
-        stdoutBuf += chunk.toString('utf-8');
+        const text = chunk.toString('utf-8');
+        recorder.onStdout(text);
+        stdoutBuf += text;
         let idx;
         while ((idx = stdoutBuf.indexOf('\n')) >= 0) {
             const line = stdoutBuf.slice(0, idx).trim();
@@ -271,12 +289,14 @@ export function spawnOpenCode(prompt, options = {}) {
     });
     child.stderr?.on('data', (chunk) => {
         const text = chunk.toString('utf-8');
+        recorder.onStderr(text);
         for (const line of text.split('\n')) {
             if (line.trim())
                 emit({ type: 'stderr', timestamp: Date.now(), data: { line } });
         }
     });
     child.on('exit', (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')) {