codehere 1.0.1 → 1.0.2

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

@@ -1,388 +0,0 @@
-/**
- * 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 } 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 single dedicated file the mock edits — claimed in the step AND written on
- *  disk, so they stay consistent. ALWAYS a mock-only file, NEVER an existing real
- *  source file. The prior version derived a path from the prompt and appended to
- *  it; when the daemon's cwd was a real repo and the prompt carried injected
- *  memory (which lists repo paths like `src/ui.ts`), it corrupted real tracked
- *  source. gitignored so it never rides along. */
-const MOCK_EDIT_FILE = 'codehere-mock-change.md';
-/** CODEHERE_MOCK fidelity: apply a small, safe on-disk edit so the run has a
- *  genuine change — WITHOUT touching real source. Writes only to the dedicated
- *  MOCK_EDIT_FILE. Note: that file is gitignored, so INSIDE a git repo the
- *  artifacts extractor (git ls-files --others --exclude-standard) won't count it
- *  — but verify-all runs the mock in a NON-git sandbox where file counts don't
- *  apply, and the polished demo uses seeded sessions, not live mock edits. */
-function materializeEdit() {
-    try {
-        const target = join(process.cwd(), MOCK_EDIT_FILE);
-        const header = '# codehere mock scratch — synthetic edits under CODEHERE_MOCK (safe to delete)\n\n';
-        const marker = `codehere(mock): change applied for "${prompt.slice(0, 60).replace(/"/g, "'")}"\n`;
-        writeFileSync(target, (existsSync(target) ? readFileSync(target, 'utf-8') : header) + marker);
-    }
-    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);
-    });
-}
-// 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) {
-    const lc = p.toLowerCase();
-    const file = MOCK_EDIT_FILE;
-    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;
-}
-/** 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 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];
-        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);
-    // 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
-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: 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')
-            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);
-    // 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).
-// 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];
-        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: '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() {
-    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);
-    // 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: wrapUpText(steps) } });
-}
-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();
-    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

@@ -1,73 +0,0 @@
-/**
- * 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

@@ -1,83 +0,0 @@
-/**
- * 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

@@ -1,37 +0,0 @@
-/**
- * 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