codehere 0.7.0 → 0.8.0

package/dist/application/use-cases/generate-final-report.js

@@ -1,107 +1,84 @@
 /**
- * Final Report — PM-UX Layer 3 · MVP (v0.5.0-alpha.3+).
+ * Final Report — the headline deliverable. At task exit, produce a plain-English
+ * summary of what the agent did.
  *
- * At task exit, generates a 3-paragraph plain-English summary of what the
- * agent did, what was touched, and what the user should look at. Prints to
- * stdout so the dogfood-while-building loop sees the artifact immediately.
+ * Engine (locked 2026-06-03, after the real dogfood found NO report on a real
+ * conductor run): REUSE THE AGENT SESSION. The agent already narrates what it
+ * did (kind:'say' steps — e.g. "Added subtract(a,b) to utils.js:5"); we use that
+ * directly. No fresh summarizer spawn.
  *
- * Provider strategy (MVP — try free first, fall back to paid):
- *   - Tries `claude-free --bare -p "<prompt>"` first. The `claude-free`
- *     wrapper is what actually routes through the FCC proxy at :8082
- *     (verified 2026-05-02 dogfood: plain `claude --bare` does NOT route
- *     through FCC — it hits paid Claude. The May 1 memory rule was wrong.)
- *   - Falls back to `claude --bare -p "<prompt>"` if `claude-free` is not
- *     installed (paid path; will fail gracefully if no credit).
- *   - If neither binary is installed, returns null silently (no report).
+ * Why the old path was replaced: it spawned a SEPARATE provider binary chain
+ * (`claude-free` → `claude`) to summarize. `claude-free` (the FCC/NIM proxy
+ * binary) is on PATH but its proxy was down → 30s hang → null; the `claude`
+ * fallback also returned null in the conductor exit-handler. Net: a completed
+ * real task showed "⚠ Final Report unavailable" — the headline deliverable
+ * missing. Reusing the agent's own words is cheaper, has full context, and can't
+ * be taken down by an external proxy.
  *
- * Env override: set CODEHERE_REPORT_BINARY=<binary-name> to force a
- * specific provider (e.g. for testing or non-default setups).
- *
- * Iterations 5-9 (2026-05-02) refuted the "we own the supervisory layer"
- * thesis. Final Report is the keystone delivery moment per the v3 chain
- * (claim_market_position) — it's the artifact the dogfood loop produces
- * that none of the surveyed competitors (ComposioHQ, Overstory, Praktor,
- * Claude Squad, AI-Agents-Orchestrator) advertise.
+ * Fallback (locked): when the agent left no usable summary (or it looks like a
+ * provider failure), build a DETERMINISTIC report from the recorded steps +
+ * artifacts. It states ONLY verified facts, says plainly that no written summary
+ * was available, and NEVER implies success — so a completed task always shows a
+ * deliverable, and it's honest about which kind it is (see `source`).
  */
-import { spawn } from 'child_process';
-import { isMockMode } from '../../infrastructure/orchestration/mocks/resolve-agent-spawn.js';
-import { mockFinalReport } from '../../infrastructure/orchestration/mocks/mock-synthesis.js';
-const PROMPT_TEMPLATE = (i) => `You are a PM reporting back to a developer about what their AI coding agent
-just did. Write 3 short paragraphs in plain English. No headers, no bullet
-lists, no markdown — just three paragraphs separated by blank lines.
-
-CRITICAL anti-hallucination rule: ground every claim in the structured data
-below. You CANNOT see the contents of files, the output of commands, or
-anything beyond what's listed under "Steps the agent took" and "Files
-changed". If the data doesn't show specific filenames, do NOT invent any.
-If a step ran a command but its output isn't shown to you, describe what
-the step ATTEMPTED, not what it found. Saying "I don't have the output to
-report on" is correct; making up plausible-sounding details is wrong and
-the developer will catch the lie.
-
-Paragraph 1: What the agent ATTEMPTED. Verb-led. Describe steps as listed.
-             Mention specific filenames ONLY if they appear in the data
-             below. 1-3 sentences.
-Paragraph 2: What was TOUCHED. Reference ONLY the "Files changed" list
-             below. If the list is empty AND "File tracking" says git is
-             available, say "No files were changed." If "File tracking" says
-             git is NOT available, say codehere could not track file changes
-             because this folder is not a git repository — do NOT say no files
-             were changed, because the agent may well have changed files
-             codehere cannot see. 1-2 sentences.
-Paragraph 3: What the developer should LOOK AT. If steps + files data show
-             nothing risky, say so explicitly ("nothing to verify; the
-             session was read-only" or similar). 1-2 sentences.
-
-Be specific where the data lets you. Don't pad. Don't editorialize. Don't
-praise the agent. Don't fabricate file names, line counts, or content
-descriptions you cannot derive from the data below.
-
-The task was: ${i.prompt}
-The agent used: ${i.agent}
-Duration: ${i.durationMs}ms
-Status: ${i.status}
-
-Steps the agent took:
-${i.steps.length ? i.steps.map((s) => `- ${s.label} (${s.state})`).join('\n') : '(no structured steps captured)'}
-
-File tracking: ${i.artifacts?.noGitTracking ? 'git NOT available (this folder is not a git repository — file changes cannot be tracked)' : 'git available'}
-
-Files changed:
-${i.artifacts?.files?.length
-    ? i.artifacts.files
-        .map((f) => `- ${f.path} (+${f.added}/-${f.removed}${f.trust !== undefined ? `, trust: ${f.trust}` : ''})`)
-        .join('\n')
-    : '(no file artifacts captured)'}
-
-Token usage: ${i.artifacts?.usage?.inputTokens ?? 0} in / ${i.artifacts?.usage?.outputTokens ?? 0} out
-
-Now write the 3 paragraphs, grounded ONLY in the data above.`;
-const REPORT_TIMEOUT_MS = 30_000;
-/** Provider chain: try free first, then paid. Override with CODEHERE_REPORT_BINARY. */
-function selectProviderBinary() {
-    const override = process.env.CODEHERE_REPORT_BINARY;
-    if (override)
-        return [override];
-    return ['claude-free', 'claude'];
-}
+const MAX_SUMMARY_CHARS = 1600;
 /**
- * UAT-003 — patterns that indicate the wrapped agent's session terminated
- * because of a network / auth / quota failure rather than a real task.
- * When we see these in the would-be summary text, we prepend a plain-English
- * recovery hint instead of letting the raw provider error echo through.
- *
- * Pre-fix: bare `exit` in REPL → Conductor spawned claude-code → real API
- * call failed with "All connection attempts failed Request ID: req_...";
- * Final Report quoted that text verbatim. Per Core Values #4 + #6, this is
- * unacceptable — the user sees a Request ID that means nothing.
+ * UAT-003 — patterns indicating the agent's own text is actually a network /
+ * auth / quota failure, not a real summary. Such "summaries" must NOT be shown
+ * as the report; they fall through to the deterministic fallback.
  */
 const NETWORK_FAILURE_PATTERNS = /(?:all connection attempts failed|ECONNREFUSED|ENOTFOUND|fetch failed|network error|request id:\s*req_|connection timed out|getaddrinfo)/i;
 function isLikelyNetworkFailureSummary(text) {
     return NETWORK_FAILURE_PATTERNS.test(text);
 }
+/**
+ * ENGINE: the agent's own narration. kind:'say' steps are the words the agent
+ * already emitted (reasoning + wrap-up). Joined newest-context-last, they ARE
+ * the summary — no extra spawn. Returns null if the agent said nothing usable.
+ */
+function extractAgentSummary(steps) {
+    const says = steps
+        .filter((s) => s.kind === 'say' && typeof s.label === 'string' && s.label.trim().length > 0)
+        .map((s) => s.label.trim());
+    if (!says.length)
+        return null;
+    const text = says.join('\n\n').slice(0, MAX_SUMMARY_CHARS);
+    // Too short to be a real summary (e.g. a one-word ack) → let the fallback give facts.
+    return text.length >= 12 ? text : null;
+}
+/**
+ * FALLBACK: deterministic, honest. Facts only, from steps + artifacts. Says
+ * plainly that no written summary was available. Never implies success.
+ */
+function buildDeterministicReport(input) {
+    const files = input.artifacts?.files ?? [];
+    const toolSteps = input.steps.filter((s) => s.kind !== 'say');
+    const noGit = input.artifacts?.noGitTracking;
+    const agentName = input.agent === 'conductor' ? 'the agent codehere chose' : input.agent;
+    const parts = [
+        `No plain-English summary was available for this run — ${agentName} didn't leave a written summary, and codehere doesn't fabricate one. Here are the recorded facts.`,
+        `The session ran ${input.steps.length} step${input.steps.length === 1 ? '' : 's'}` +
+            (toolSteps.length
+                ? ` (${toolSteps.slice(0, 5).map((s) => s.label).join(', ')}${toolSteps.length > 5 ? ', …' : ''})`
+                : '') +
+            `.`,
+    ];
+    if (noGit) {
+        parts.push(`This folder isn't a git repository, so codehere couldn't track which files changed — check the working tree yourself.`);
+    }
+    else if (files.length) {
+        parts.push(`Files changed: ` +
+            files
+                .map((f) => `${f.path} (+${f.added}/-${f.removed}${f.trust !== undefined ? `, trust ${f.trust}` : ''})`)
+                .join('; ') +
+            `.`);
+    }
+    else {
+        parts.push(`No files were changed.`);
+    }
+    return { summary: parts.join('\n\n'), generatedAt: Date.now(), durationMs: 0, source: 'deterministic' };
+}
 function buildErrorRecoveryReport(input, durationMs) {
-    // Tailor the hint to the specific failure shape we can detect from input.
     const agentName = input.agent === 'conductor' ? 'the agent codehere chose' : input.agent;
     return {
         summary: `The ${agentName} session ended without completing the task. ` +
@@ -112,114 +89,32 @@ function buildErrorRecoveryReport(input, durationMs) {
             `codehere couldn't confirm any file changes from this attempt.`,
         generatedAt: Date.now(),
         durationMs,
+        source: 'error-recovery',
     };
 }
 /**
- * Generate a Final Report. Returns null if no provider is reachable.
- * Never throws — failure modes return null + log a debug line.
- *
- * UAT-003 — when the input.status is 'error', we skip the LLM call entirely
- * and return a deterministic recovery hint. Saves tokens on a known-failed
- * task AND gives the user a plain-English next step instead of waiting for
- * a possibly-unhelpful LLM summary.
+ * Generate a Final Report. Reuses the agent's own summary; falls back to a
+ * deterministic, honest facts report. A completed task ALWAYS gets a report
+ * (never null for non-error terminal states) — no external dependency.
  */
 export async function generateFinalReport(input) {
-    // CODEHERE_MOCK — synthesize a grounded report with zero API so the full
-    // demo flow (incl. this headline deliverable + the verify cross-check) runs
-    // under mock. Errors still get the deterministic recovery report below.
-    if (isMockMode() && input.status !== 'error') {
-        return mockFinalReport(input);
-    }
-    // Short-circuit on errored sessions — don't waste tokens summarizing nothing.
+    // No mock short-circuit: under CODEHERE_MOCK the SAME engine runs, so the
+    // narration gap is reproduced faithfully — claude/aider (emit `say`) get a
+    // rich agent-summary; codex/gemini/opencode (no `say`) get the honest
+    // deterministic report, exactly as on a real run. (A prior mock-only
+    // short-circuit synthesized a report from steps for every agent, hiding the
+    // cross-vendor gap — you couldn't dogfood "codex's report is thin" under mock.)
+    // Errored session — deterministic recovery hint, no summarization of nothing.
     if (input.status === 'error') {
         return buildErrorRecoveryReport(input, 0);
     }
-    const prompt = PROMPT_TEMPLATE(input);
-    for (const binary of selectProviderBinary()) {
-        const result = await tryProvider(binary, prompt, input.sessionId);
-        if (result) {
-            // Defense-in-depth: even on 'completed' status, if the generated
-            // summary leaks a provider network-failure string (e.g., the wrapped
-            // agent exited 0 but its assistant text was an error message), wrap
-            // the summary with a recovery preamble.
-            if (isLikelyNetworkFailureSummary(result.summary)) {
-                return {
-                    summary: `Couldn't reach the provider cleanly — the agent's session text looks like a network or auth failure.\n\n` +
-                        `What to try: check your internet, run \`codehere health\`, or rerun in a minute. ` +
-                        `If it persists, switch agents from the dropdown.\n\n` +
-                        `— Raw agent message —\n${result.summary}`,
-                    generatedAt: result.generatedAt,
-                    durationMs: result.durationMs,
-                };
-            }
-            return result;
-        }
+    // ENGINE: reuse the agent's own narration (no fresh spawn).
+    const agentSummary = extractAgentSummary(input.steps);
+    if (agentSummary && !isLikelyNetworkFailureSummary(agentSummary)) {
+        return { summary: agentSummary, generatedAt: Date.now(), durationMs: 0, source: 'agent-summary' };
     }
-    return null;
-}
-function tryProvider(binary, prompt, sessionId) {
-    const startedAt = Date.now();
-    return new Promise((resolve) => {
-        let stdout = '';
-        let stderr = '';
-        let settled = false;
-        const finish = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve(result);
-        };
-        // Provider args per-binary:
-        //   - `claude-free` (FCC proxy binary) needs `--bare` to skip session
-        //     setup that the proxy doesn't implement.
-        //   - Standard `claude` (the Claude Code Max CLI) MUST NOT use `--bare`
-        //     because `--bare` explicitly rejects OAuth and keychain auth — and
-        //     Claude Code Max users authenticate via OAuth. With `--bare`, the
-        //     fallback path returned empty silently, no Final Report ever
-        //     reached the UI, and the dashboard showed `✓ Final Report` on a
-        //     missing artifact. (May 21, 2026 — root cause of CRIT #1.)
-        const args = binary === 'claude-free' ? ['--bare', '-p', prompt] : ['-p', prompt];
-        const child = spawn(binary, args, {
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        const timeout = setTimeout(() => {
-            child.kill('SIGTERM');
-            if (process.env.CODEHERE_DEBUG === '1') {
-                console.error(`[final-report] ${binary} timeout after ${REPORT_TIMEOUT_MS}ms for ${sessionId}`);
-            }
-            finish(null);
-        }, REPORT_TIMEOUT_MS);
-        child.on('error', (err) => {
-            clearTimeout(timeout);
-            // ENOENT = binary not installed. Silent fallback to next provider in chain.
-            if (process.env.CODEHERE_DEBUG === '1') {
-                console.error(`[final-report] ${binary} unavailable: ${err.message}`);
-            }
-            finish(null);
-        });
-        child.stdout?.on('data', (chunk) => {
-            stdout += chunk.toString('utf8');
-        });
-        child.stderr?.on('data', (chunk) => {
-            stderr += chunk.toString('utf8');
-        });
-        child.on('exit', (code) => {
-            clearTimeout(timeout);
-            if (code !== 0) {
-                if (process.env.CODEHERE_DEBUG === '1') {
-                    console.error(`[final-report] ${binary} exited ${code}: ${stderr.slice(0, 200)}`);
-                }
-                finish(null);
-                return;
-            }
-            const summary = stdout.trim();
-            if (!summary) {
-                finish(null);
-                return;
-            }
-            finish({ summary, generatedAt: Date.now(), durationMs: Date.now() - startedAt });
-        });
-    });
+    // FALLBACK: deterministic, honest — always a deliverable, never a fake ✓.
+    return buildDeterministicReport(input);
 }
 /**
  * Pretty-print to terminal. Used by session-manager when a spawned task exits.

package/dist/application/use-cases/narrator-prompt-template.js

@@ -79,7 +79,7 @@ Write the paragraph now. Do not preface with "Update:" or anything similar.
 Plain prose. No "I'm currently…" — narrate the AGENT, not yourself.
 `;
 function templateFile() {
-    return join(homedir(), '.codehere', 'narrator-prompt.md');
+    return join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'narrator-prompt.md');
 }
 /** Read the user-customized template if present and valid. Falls back to
  *  baked-in default on missing file, parse failure, or missing required

package/dist/index.js

@@ -661,8 +661,8 @@ program
             try {
                 const { migrate } = await import('./infrastructure/storage/project-thread-migration.js');
                 const result = migrate({
-                    sourceJsonl: join(homedir(), '.codehere/sessions.jsonl'),
-                    targetDir: join(homedir(), '.codehere/projects'),
+                    sourceJsonl: join(process.env.CODEHERE_HOME || homedir(), '.codehere/sessions.jsonl'),
+                    targetDir: join(process.env.CODEHERE_HOME || homedir(), '.codehere/projects'),
                 });
                 if (result.threadsWritten > 0) {
                     console.log(colors.dim(`  v0.6 migration: created ${result.threadsWritten} project thread(s) from ${result.sessionsProcessed} sessions (${result.durationMs}ms)`));
@@ -765,8 +765,12 @@ program
                     console.log(colors.dim(`  version: ${existing.version}`));
                 }
                 newline();
-                console.log(colors.dim('  Opening browser...'));
-                await openBrowser();
+                // Honor --no-open here too — found via the v1 stranger walk: a second
+                // `start --no-open` against a running daemon popped a browser anyway.
+                if (shouldOpen) {
+                    console.log(colors.dim('  Opening browser...'));
+                    await openBrowser();
+                }
                 process.exit(0);
             }
             console.error(error(`Port ${port} is in use by another process.`));
@@ -947,8 +951,8 @@ program
 program
     .command('migrate-threads', { hidden: true }) // hidden from --help (v0.6.0 internal — auto-runs on daemon start once wired)
     .description('Migrate sessions.jsonl into per-project thread.jsonl files (v0.6.0 schema)')
-    .option('--source <path>', 'Source sessions.jsonl', `${homedir()}/.codehere/sessions.jsonl`)
-    .option('--target <dir>', 'Target projects dir', `${homedir()}/.codehere/projects`)
+    .option('--source <path>', 'Source sessions.jsonl', `${process.env.CODEHERE_HOME || homedir()}/.codehere/sessions.jsonl`)
+    .option('--target <dir>', 'Target projects dir', `${process.env.CODEHERE_HOME || homedir()}/.codehere/projects`)
     .option('--dry-run', 'Report what migrate WOULD do, write nothing', false)
     .option('--rollback', 'Remove the projects dir; sessions.jsonl untouched', false)
     .option('--keep-temp-dirs', 'Include /tmp + /var/folders cwds (default skips them)', false)

package/dist/infrastructure/cost/budget-config.js

@@ -29,7 +29,7 @@ const DEFAULT_CONFIG = {
     warnAtPct: 70,
 };
 function configFile() {
-    return join(homedir(), '.codehere', 'budget.yaml');
+    return join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'budget.yaml');
 }
 /** Parse a tiny subset of YAML — `key: value` pairs, # comments, blank lines.
  *  No nesting, no lists, no multi-line. Same approach as permissions-config:

package/dist/infrastructure/cost/spend-aggregator.js

@@ -25,7 +25,7 @@ import { join } from 'path';
 /** Resolved at call time, not module load, so test setups that swap $HOME
  *  after import still get a fresh path on each invocation. */
 function sessionsFile() {
-    return join(homedir(), '.codehere', 'sessions.jsonl');
+    return join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'sessions.jsonl');
 }
 /** USD per million OUTPUT tokens at the agent's typical 2026 tier. Input is
  *  estimated at 1/5 of output rate (Anthropic + OpenAI both publish ~5x

package/dist/infrastructure/hooks/claude-sdk-hook.js

@@ -396,8 +396,14 @@ export function calculateRiskScore(findings) {
 /**
  * Audit log path — defaults to ~/.codehere/audit/hook-events.jsonl.
  * Override at process start with CODEHERE_AUDIT_FILE env var (used by tests, optional for users).
+ * Honors CODEHERE_HOME like sessions/config/threads — found via the v1 stranger
+ * walk: an "isolated" daemon (verify-all's :3779, the walk's scratch home) was
+ * writing mock audit entries into the REAL ~/.codehere/audit while verify-all
+ * printed "Real ~/.codehere untouched" (the footer showed 162 entries · 51
+ * agents in a brand-new home — all of them pollution from past mock runs).
  */
-export const AUDIT_FILE = process.env.CODEHERE_AUDIT_FILE || join(homedir(), '.codehere', 'audit', 'hook-events.jsonl');
+export const AUDIT_FILE = process.env.CODEHERE_AUDIT_FILE ||
+    join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'audit', 'hook-events.jsonl');
 const GENESIS_PREV_HASH = '0'.repeat(64);
 /**
  * Canonicalize an audit entry for hashing. We sort keys alphabetically and

package/dist/infrastructure/orchestration/agents-config-seed.js

@@ -15,7 +15,7 @@
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { join, dirname } from 'path';
-const CONFIG_PATH = join(homedir(), '.codehere', 'agents.yaml');
+const CONFIG_PATH = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'agents.yaml');
 const DEFAULT_YAML = `# codehere — pluggable agent adapters
 #
 # Built-in adapters (no configuration needed — just install the CLI):

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

@@ -342,7 +342,10 @@ export function spawnAider(prompt, options = {}) {
             return new Promise((resolve, reject) => {
                 let stdout = '';
                 let stderr = '';
-                const followup = spawn('aider', ['--restore-chat-history', '--message', text, ...HEADLESS_FLAGS], {
+                // Route follow-ups through the mock seam too — under CODEHERE_MOCK=1 this
+                // hits the mock REPL, not real aider. (Was a real-spend leak.)
+                const sp2 = resolveAgentSpawn('aider', 'aider', ['--restore-chat-history', '--message', text, ...HEADLESS_FLAGS], text);
+                const followup = spawn(sp2.command, sp2.args, {
                     cwd,
                     env: spawnEnv,
                     stdio: ['ignore', 'pipe', 'pipe'],

package/dist/infrastructure/orchestration/cassette-recorder.js

@@ -38,7 +38,7 @@ const NULL_RECORDER = {
 export function startRecording(opts) {
     if (process.env[ENV_FLAG] !== '1')
         return NULL_RECORDER;
-    const outDir = opts.outDir ?? join(homedir(), '.codehere', 'cassettes', opts.adapter);
+    const outDir = opts.outDir ?? join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'cassettes', opts.adapter);
     const scenario = `organic-${opts.sessionId.slice(0, 8)}`;
     const stamp = new Date().toISOString().replace(/[:.]/g, '-');
     const path = join(outDir, `${scenario}-${stamp}.jsonl`);

package/dist/infrastructure/orchestration/claude-code-adapter.js

@@ -384,7 +384,11 @@ export function spawnClaudeCode(prompt, options = {}) {
                 }
                 let stdout = '';
                 let stderr = '';
-                const followup = spawn('claude', ['-p', text, '--resume', claudeSessionId, ...HEADLESS_FLAGS], {
+                // Route follow-ups through the mock seam too — under CODEHERE_MOCK=1 this
+                // hits the mock REPL, not the real binary. (Was a real-spend leak:
+                // appendMessage spawned `claude` directly regardless of mock mode.)
+                const sp2 = resolveAgentSpawn('claude-code', 'claude', ['-p', text, '--resume', claudeSessionId, ...HEADLESS_FLAGS], text);
+                const followup = spawn(sp2.command, sp2.args, {
                     cwd,
                     env: spawnEnv,
                     stdio: ['ignore', 'pipe', 'pipe'],

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

@@ -456,15 +456,10 @@ export function spawnCodex(prompt, options = {}) {
                 let stdout = '';
                 let stderr = '';
                 // codex exec resume <SESSION_ID> -  → reads prompt from stdin
-                const followup = spawn('codex', [
-                    'exec',
-                    '--json',
-                    '--skip-git-repo-check',
-                    '--dangerously-bypass-approvals-and-sandbox',
-                    'resume',
-                    codexThreadId,
-                    '-',
-                ], {
+                // Route follow-ups through the mock seam too — under CODEHERE_MOCK=1 this
+                // hits the mock REPL, not real codex. (Was a real-spend leak.)
+                const sp2 = resolveAgentSpawn('codex', 'codex', ['exec', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox', 'resume', codexThreadId, '-'], text);
+                const followup = spawn(sp2.command, sp2.args, {
                     cwd,
                     env: spawnEnv,
                     stdio: ['pipe', 'pipe', 'pipe'],

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

@@ -53,9 +53,15 @@ const ROUTING_RULES = [
         reason: 'targeted fixes favor Aider',
     },
     {
-        triggers: ['scaffold', 'generate', 'create new', 'bootstrap', 'set up'],
-        preferred: ['opencode', 'claude-code', 'codex'],
-        reason: 'greenfield generation favors OpenCode',
+        // Narrowed 2026-06-02 (root-cause fix for "randomly uses opencode"): bare
+        // 'generate'/'set up' are far too common ("generate a report", "set up the
+        // config") and were silently routing ordinary tasks to opencode. AND
+        // claude-code now leads — opencode has NO mid-stream visibility (buffered
+        // output), so it must never be the surprise default for a "watch it work"
+        // product; it stays available via the explicit agent picker.
+        triggers: ['scaffold', 'bootstrap', 'create a new project', 'greenfield', 'new project from scratch'],
+        preferred: ['claude-code', 'codex', 'opencode'],
+        reason: 'greenfield scaffolding — claude-code default (visible); opencode opt-in only',
     },
     {
         triggers: ['add tests', 'write tests', 'test coverage', 'unit test', 'integration test'],

package/dist/infrastructure/orchestration/failover-config.js

@@ -23,7 +23,7 @@ import { readFileSync, existsSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import { validateFailoverChain } from './failover-policy.js';
-const GLOBAL_CONFIG_PATH = join(homedir(), '.codehere', 'config.json');
+const GLOBAL_CONFIG_PATH = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'config.json');
 /**
  * Load failover configuration from ~/.codehere/config.json.
  * Returns undefined if the config file does not exist or has no failover section.

package/dist/infrastructure/orchestration/generic-cli-adapter.js

@@ -38,8 +38,8 @@ import { randomUUID } from 'crypto';
 import { ProgressAggregator } from './progress-aggregator.js';
 import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
 import { applyMemoryPrefix } from './memory-injector.js';
-const CONFIG_PATH = join(homedir(), '.codehere', 'agents.yaml');
-const CONFIG_PATH_JSON = join(homedir(), '.codehere', 'agents.json');
+const CONFIG_PATH = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'agents.yaml');
+const CONFIG_PATH_JSON = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'agents.json');
 /** Minimal YAML parser for the narrow shape above. Intentionally NOT a full YAML
  *  parser — avoids dragging in a dep. Handles: `key: value`, lists with `- key: val`,
  *  nested lists of simple strings via `[a, b]`, comments after `#`. Errors loud.

package/dist/infrastructure/orchestration/graphify-context.js

@@ -185,24 +185,29 @@ export function loadRecentContextPack(cwd) {
  * Returns the original prompt if graphify-ts fails or is unavailable.
  *
  * Respects CODEHERE_GRAPHIFY env var:
- *   - unset or "auto" (default): compile on spawn if graph doesn't exist
- *   - "force": always compile, even if pack exists
- *   - "off": skip entirely
+ *   - unset or "auto" (default): enrich ONLY from a pre-existing graph/pack;
+ *     NEVER compile on the spawn hot path (root-cause fix 2026-06-02 for
+ *     "every task calls graphify" — `npx graphify-ts pack` was shelling out
+ *     synchronously on every spawn, slowing crucial tasks + prepending a
+ *     verbose context blob the user never asked for).
+ *   - "force": compile a fresh pack on spawn (explicit opt-in for the cost).
+ *   - "off": skip entirely.
  */
 export function enrichPromptWithPackSync(prompt, cwd, { force = false } = {}) {
     const mode = process.env.CODEHERE_GRAPHIFY ?? 'auto';
     if (mode === 'off')
         return prompt;
-    // Check for existing pack to avoid recompiling on every spawn
-    const existingPack = loadRecentContextPack(cwd);
-    const graphPath = getGraphPath(cwd);
-    const graphExists = existsSync(graphPath);
-    if (!force && existingPack && graphExists) {
-        // Reuse existing pack — just enrich the prompt with a compact reference
-        const reference = `[graphify-ts context pack: ${existingPack.nodeCount} nodes, ${existingPack.edgeCount} edges, pack=${existingPack.packId}]`;
-        return `[graphify context: ${reference} — agent should call retrieve() for full pack]\n\n${prompt}`;
-    }
-    // Compile a fresh pack
+    const forceCompile = force || mode === 'force';
+    // 'auto' must NEVER touch the user's prompt — not by compiling (npx subprocess
+    // on the hot path) AND not by prepending an existing pack's "[graphify context:
+    // …]" reference blob. That blob leaked into the visible prompt, the Final
+    // Report summary, and the conversation ("On it — [graphify context: 1017
+    // nodes…]") — user-reported 2026-06-02 with a graph present. Structural
+    // context enrichment is now 'force'-only opt-in; a normal task gets a clean prompt.
+    if (!forceCompile)
+        return prompt;
+    // Compile a fresh pack (force only)
+    // Compile a fresh pack (force only)
     const pack = compileContextPackSync(prompt, cwd, { task: 'explain', budget: 2500 });
     if (!pack) {
         return prompt;

package/dist/infrastructure/orchestration/memory-injector.js

@@ -29,7 +29,7 @@
  * AGENTS.md / session.md). Same byte-equality-based detection pattern as
  * memory-command.ts (per feedback_implementation_patterns_v05.md Pattern #1).
  */
-import { existsSync, readFileSync, realpathSync } from 'fs';
+import { existsSync, readFileSync, realpathSync, writeFileSync } from 'fs';
 import { join, dirname, resolve } from 'path';
 const DEFAULT_MAX_TOKENS = 3000;
 const DEFAULT_MAX_LESSONS = 10;
@@ -279,8 +279,11 @@ export function buildMemoryPrefix(projectRoot, options = {}) {
  *
  * Stops at the filesystem root. Symlink-following on read is the right
  * asymmetry per ADR-012 (the symlink defense applies to writes, not reads).
+ *
+ * Exported for the daemon's /api/memory/status route (the room's init nudge
+ * must report the SAME readiness the injector itself would act on).
  */
-function findProjectRoot(startPath) {
+export function findProjectRoot(startPath) {
     let current;
     try {
         current = realpathSync(resolve(startPath));
@@ -329,4 +332,49 @@ export function applyMemoryPrefix(prompt, cwd, options) {
         record: { included: r.included, tokens: r.tokens, truncated: r.truncated },
     };
 }
+/**
+ * Write-back side of the shared-room hand-off: append a finished turn's outcome
+ * to the project's `working/session.md` so the NEXT agent spawned in this
+ * project reads it via buildMemoryPrefix() — closing the loop ("agents take
+ * turns in a shared room, each building on the last").
+ *
+ * Resolves the SAME project root as the read path (findProjectRoot), so it only
+ * writes when the project is codehere-initialized — it never creates `.codehere/`
+ * in an uninitialized repo. The scratch is capped (the injector also budgets it).
+ * Best-effort: a memory-write failure must never break a run.
+ */
+export function recordTurnToWorkingMemory(cwd, entry) {
+    try {
+        const projectRoot = findProjectRoot(cwd);
+        if (projectRoot === null)
+            return; // not a codehere-initialized project
+        const dir = join(projectRoot, '.codehere', 'memory', 'working');
+        if (!existsSync(dir))
+            return;
+        const p = join(dir, 'session.md');
+        const HEADER = '# Working session log - codehere auto-records each agent turn so the next one picks up here\n';
+        const agent = (entry.agent || 'agent').replace(/\s+/g, ' ').trim().slice(0, 40);
+        const prompt = (entry.prompt || '').replace(/\s+/g, ' ').trim().slice(0, 120);
+        const summary = (entry.summary || '').replace(/\s+/g, ' ').trim().slice(0, 600);
+        const files = entry.files ? ` - ${entry.files} file${entry.files === 1 ? '' : 's'} changed` : '';
+        const block = `\n## ${agent}${prompt ? ' - ' + prompt : ''}${files}\n${summary || '(no written summary)'}\n`;
+        let cur = '';
+        try {
+            cur = existsSync(p) ? readFileSync(p, 'utf8') : '';
+        }
+        catch {
+            cur = '';
+        }
+        if (!cur.trim() || looksLikeInitSeed(cur, 'session'))
+            cur = HEADER;
+        cur += block;
+        const CAP = 8000;
+        if (cur.length > CAP)
+            cur = HEADER + cur.slice(cur.length - (CAP - HEADER.length));
+        writeFileSync(p, cur, 'utf8');
+    }
+    catch {
+        /* never break a run on a memory-write failure */
+    }
+}
 //# sourceMappingURL=memory-injector.js.map