codehere 0.7.0 → 0.8.0

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

@@ -15,33 +15,30 @@
  * 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';
+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 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) {
+/** 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 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
-        }
+        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 */
@@ -74,7 +71,7 @@ const out = (o) => process.stdout.write(JSON.stringify(o) + '\n');
 // 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 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' },
@@ -197,14 +194,17 @@ async function runOpencode() {
         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 });
+    // 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 } });
 }
 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));
+    materializeEdit();
     switch (agent) {
         case 'claude-code':
         case 'claude':

package/dist/infrastructure/orchestration/progress-aggregator.js

@@ -169,6 +169,14 @@ export class ProgressAggregator {
     // real gap surfaced by the mock harness). Build a step on the terminal
     // (status==='completed') event so opencode is a first-class agent.
     ingestOpencode(type, data) {
+        // OpenCode's narrative text rides `text` events with part.text (the same
+        // shape the adapter's summary extraction reads) — cross-vendor say capture
+        // per the v1 spec, so opencode's Final Report stops degrading to the
+        // deterministic fallback.
+        if (type === 'text') {
+            const part = (data.part ?? {});
+            return this.pushSay(String(part.text ?? ''));
+        }
         if (type !== 'tool_use')
             return false;
         const part = (data.part ?? {});
@@ -213,6 +221,24 @@ export class ProgressAggregator {
         const idx = this._steps.push({ label, state, startedAt: Date.now() }) - 1;
         return idx;
     }
+    /** The agent's own narration as a kind:'say' step — the "watch it work"
+     *  signal AND what the Final Report engine reuses as the summary. Cross-
+     *  vendor by decision of the v1 spec (the room thread is "tool steps woven
+     *  with the agent's plain-English narration" — for every agent, not just
+     *  claude/aider). Same 500-char cap as the original claude capture. */
+    pushSay(text) {
+        const said = String(text ?? '').trim();
+        if (!said)
+            return false;
+        this._steps.push({
+            kind: 'say',
+            label: said.length > 500 ? said.slice(0, 500) + '\\u2026' : said,
+            state: 'done',
+            startedAt: Date.now(),
+            completedAt: Date.now(),
+        });
+        return true;
+    }
     ingestClaude(type, data) {
         if (type === 'assistant') {
             const msg = (data.message ?? {});
@@ -322,6 +348,12 @@ export class ProgressAggregator {
                 return true;
             }
         }
+        // Gemini's narrative text rides `content` events — same cross-vendor say
+        // capture as claude/aider/codex (v1 spec: narration woven into the thread,
+        // and the Final Report engine reuses it as the summary).
+        if (type === 'content' && typeof data.text === 'string') {
+            return this.pushSay(data.text);
+        }
         return false;
     }
     /**
@@ -642,12 +674,15 @@ export class ProgressAggregator {
             });
             return true;
         }
-        // NOTE (mock-currency 2026-06-02): codex `agent_message` is intentionally NOT
-        // captured here — a prior decision (pm-layers.test.ts "just chatter, not a
-        // step") drops it. This is INCONSISTENT with ingestClaude/ingestAider, which
-        // DO capture agent narration as kind:'say' (per #45 + A1 "watch it work").
-        // Resolving that inconsistency is a product taste call → flagged for Ega in
-        // mock-currency-2026-06-02.md, not changed unilaterally by the autonomous loop.
+        // agent_message = codex's own narration. Captured as kind:'say' since the
+        // v1 spec settled the taste call that used to be flagged here (pm-layers
+        // "just chatter" decision): the room thread is "tool steps woven with the
+        // agent's plain-English narration" for EVERY vendor, and the Final Report
+        // engine reuses 'say' steps as the summary — without this, codex always
+        // degraded to the deterministic fallback.
+        if (itemType === 'agent_message') {
+            return this.pushSay(String(item.text ?? ''));
+        }
         return false;
     }
 }

package/dist/infrastructure/orchestration/session-manager.js

@@ -20,6 +20,7 @@ import { OpenCodeAdapter } from './opencode-adapter.js';
 import { GeminiAdapter } from './gemini-adapter.js';
 import { buildGenericAdapter, loadAgentsConfig } from './generic-cli-adapter.js';
 import { buildConductorAdapter } from './conductor-adapter.js';
+import { recordTurnToWorkingMemory } from './memory-injector.js';
 import { seedAgentsConfig } from './agents-config-seed.js';
 import { AUDIT_FILE } from '../hooks/claude-sdk-hook.js';
 import { appendSpawned, appendCompleted, appendFinalReport, loadRecent, } from './session-persistence.js';
@@ -308,7 +309,22 @@ export class SessionManager {
                         summary: report.summary,
                         generatedAt: report.generatedAt,
                         durationMs: report.durationMs,
+                        source: report.source,
                     });
+                    // Shared-room hand-off: record this turn's outcome to the project's
+                    // working memory so the NEXT agent spawned here reads it (closes the
+                    // loop with applyMemoryPrefix). Best-effort; only initialized projects.
+                    try {
+                        recordTurnToWorkingMemory(cwd, {
+                            agent: session.agent,
+                            prompt: session.prompt,
+                            summary: report.summary,
+                            files: session.artifacts?.files?.length,
+                        });
+                    }
+                    catch {
+                        /* memory write must never break the run */
+                    }
                     try {
                         printFinalReportToTerminal(reportInput, report);
                     }
@@ -473,6 +489,7 @@ export class SessionManager {
                                 summary: report.summary,
                                 generatedAt: report.generatedAt,
                                 durationMs: report.durationMs,
+                                source: report.source,
                             });
                             try {
                                 printFinalReportToTerminal(reportInput, report);
@@ -669,6 +686,7 @@ export class SessionManager {
                         summary: report.summary,
                         generatedAt: report.generatedAt,
                         durationMs: report.durationMs,
+                        source: report.source,
                     });
                     try {
                         printFinalReportToTerminal(reportInput, report);

package/dist/infrastructure/orchestration/session-persistence.js

@@ -151,7 +151,7 @@ export function loadSessionById(idOrPrefix) {
             steps: c.steps,
             artifacts: c.artifacts,
             ...(c.turns ? { turns: c.turns } : {}),
-            ...(fr ? { finalReport: { summary: fr.summary, generatedAt: fr.generatedAt, durationMs: fr.durationMs } } : {}),
+            ...(fr ? { finalReport: { summary: fr.summary, generatedAt: fr.generatedAt, durationMs: fr.durationMs, source: fr.source } } : {}),
             ...(failoverFrom ? { failoverFrom } : {}),
             ...(failoverTo ? { failoverTo } : {}),
             ...(failoverReason ? { failoverReason } : {}),
@@ -222,7 +222,7 @@ export function loadRecent(limit = 20) {
         steps: c.steps,
         artifacts: c.artifacts,
         ...(c.turns ? { turns: c.turns } : {}),
-        ...(fr ? { finalReport: { summary: fr.summary, generatedAt: fr.generatedAt, durationMs: fr.durationMs } } : {}),
+        ...(fr ? { finalReport: { summary: fr.summary, generatedAt: fr.generatedAt, durationMs: fr.durationMs, source: fr.source } } : {}),
         ...((c.failoverFrom ?? s.failoverFrom) ? { failoverFrom: c.failoverFrom ?? s.failoverFrom } : {}),
         ...((c.failoverTo ?? s.failoverTo) ? { failoverTo: c.failoverTo ?? s.failoverTo } : {}),
         ...((c.failoverReason ?? s.failoverReason) ? { failoverReason: c.failoverReason ?? s.failoverReason } : {}),

package/dist/infrastructure/protocols/cloud-sync.js

@@ -16,8 +16,8 @@ import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir, hostname } from 'os';
 const CLOUD_URL = 'https://codehere.uk/api/sync';
-const TOKEN_PATH = join(homedir(), '.codehere', 'cloud-token');
-const SESSIONS_FILE = join(homedir(), '.codehere', 'sessions.jsonl');
+const TOKEN_PATH = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'cloud-token');
+const SESSIONS_FILE = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'sessions.jsonl');
 // Lazy-loaded session manager — imported once to avoid circular deps
 let _sessionManager = null;
 async function getSessionManager() {

package/dist/infrastructure/protocols/mcp-server-impl.js

@@ -46,6 +46,8 @@ import { begin as oauthBegin, complete as oauthComplete, getProvider as getOAuth
 import { saveToken, clearToken, connectionStatus } from '../context/oauth-store.js';
 import { SessionManager, availableAgents, readinessForAllAgents, getAdapter, allAdapters, } from '../orchestration/session-manager.js';
 import { isAbsolute } from 'path';
+import { findProjectRoot } from '../orchestration/memory-injector.js';
+import { scaffoldProjectAt } from '../../presentation/cli/commands/init-command.js';
 import { readCrossToolAgents } from '../storage/cross-tool-agents.js';
 import { listProjects, readProjectThread } from '../storage/project-thread-reader.js';
 import { mirrorReplyToThread, renameProject } from '../storage/project-thread-mirror.js';
@@ -444,7 +446,9 @@ export function startMCPServer(options = {}) {
         // Health check
         if (req.method === 'GET' && req.url === '/health') {
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ status: 'ok', server: 'codehere-mcp', version: getVersion(), tools: TOOLS.length }));
+            // `mock` lets a no-spend tool (verify-all) confirm a daemon is mock BEFORE
+            // attaching — so it can refuse to drive a LIVE daemon while claiming "no spend".
+            res.end(JSON.stringify({ status: 'ok', server: 'codehere-mcp', version: getVersion(), tools: TOOLS.length, mock: process.env.CODEHERE_MOCK === '1' }));
             return;
         }
         // v2 Task-Centric PM UI (primary — served at /)
@@ -543,7 +547,7 @@ export function startMCPServer(options = {}) {
         // Tails sessions.jsonl and pushes "change" events so the /v2 UI can
         // re-fetch task state instantly instead of waiting 8s for the next poll.
         // Same pattern as /events (audit log tail) but for sessions.
-        const SESSIONS_FILE = join(homedir(), '.codehere', 'sessions.jsonl');
+        const SESSIONS_FILE = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'sessions.jsonl');
         if (req.method === 'GET' && req.url === '/api/events/sessions') {
             res.writeHead(200, {
                 'Content-Type': 'text/event-stream',
@@ -1209,6 +1213,66 @@ export function startMCPServer(options = {}) {
             }
             return;
         }
+        // ── v1 project-memory routes (the room's init nudge) ─────────────────────
+        // Found by the stranger walk: web-only users never run `codehere init`, so
+        // the spec's "agent remembers the project" half of nothing-lost silently
+        // doesn't apply. Status reports the SAME readiness the injector acts on
+        // (shared findProjectRoot); init runs the SAME hardened scaffold the CLI
+        // does (shared scaffoldProjectAt — symlink defenses included).
+        if (req.method === 'GET' && req.url?.startsWith('/api/memory/status')) {
+            try {
+                const u = new URL(req.url, `http://${req.headers.host || '127.0.0.1'}`);
+                const cwd = u.searchParams.get('cwd') || '';
+                if (!cwd || !isAbsolute(cwd) || cwd.includes('\0')) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'cwd (absolute path) required' }));
+                    return;
+                }
+                const root = findProjectRoot(cwd);
+                const ready = !!root && existsSync(join(root, '.codehere', 'memory', 'working'));
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ready, projectRoot: root }));
+            }
+            catch (e) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'memory_status_failed', detail: String(e) }));
+            }
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/api/memory/init') {
+            (async () => {
+                try {
+                    const body = await readBody(req, res);
+                    let cwd = '';
+                    try {
+                        cwd = String(JSON.parse(body || '{}').cwd || '');
+                    }
+                    catch {
+                        /* falls through to the validation below */
+                    }
+                    if (!cwd || !isAbsolute(cwd) || cwd.includes('\0') || !existsSync(cwd) || !statSync(cwd).isDirectory()) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'cwd (absolute path to an existing directory) required' }));
+                        return;
+                    }
+                    const r = scaffoldProjectAt(cwd);
+                    if (!r.ok) {
+                        res.writeHead(409, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, reason: r.reason }));
+                        return;
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, created: r.created.length, skipped: r.skipped.length, refused: r.refused.length + r.refusedDirs.length }));
+                }
+                catch (e) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'memory_init_failed', detail: String(e) }));
+                }
+            })().catch(() => {
+                /* handled above — keep the route from rejecting unhandled */
+            });
+            return;
+        }
         // ── v0.6.0 M1 project thread routes ──────────────────────────────────────
         // GET /api/projects           — list all known projects (slug, cwd, title, taskCount, lastActivityAt)
         // GET /api/projects/:slug     — single project thread (meta + tasks merged by sessionId)