codehere 0.5.0-alpha.3 → 0.5.0-alpha.5

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

@@ -28,12 +28,28 @@ const PROMPT_TEMPLATE = (i) => `You are a PM reporting back to a developer about
 just did. Write 3 short paragraphs in plain English. No headers, no bullet
 lists, no markdown — just three paragraphs separated by blank lines.
 
-Paragraph 1: What the agent DID. Verb-led. Name files specifically. 1-3 sentences.
-Paragraph 2: What was TOUCHED. Files modified, line counts, anything that looks risky. 1-3 sentences.
-Paragraph 3: What the developer should LOOK AT. Open concerns, things to verify.
-             If everything looks clean, say so explicitly. 1-2 sentences.
+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.
 
-Be specific. Don't pad. Don't editorialize. Don't praise the agent.
+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, say "No files were changed."
+             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}
@@ -50,7 +66,7 @@ ${i.artifacts?.files?.length
 
 Token usage: ${i.artifacts?.usage?.inputTokens ?? 0} in / ${i.artifacts?.usage?.outputTokens ?? 0} out
 
-Now write the 3 paragraphs.`;
+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() {

package/dist/application/use-cases/generate-thread-title.js

@@ -0,0 +1,120 @@
+/**
+ * Hidden Title agent — v0.6.0 M9.
+ *
+ * Generates a 4-6 word title for a project thread from its first user prompt.
+ * Hidden = users don't pick it from any picker; fires automatically when the
+ * project thread gets its first task entry. The title surfaces in the browser
+ * tab + future thread switcher UI.
+ *
+ * Companion to generate-final-report.ts:
+ *   - Same provider chain pattern (claude-free → claude → graceful skip)
+ *   - Same single-shot, no streaming, returns string
+ *   - Different prompt (terse title generation, NOT 3-paragraph narrative)
+ *   - Cheaper budget (~50 tokens per title vs 200 per Final Report paragraph)
+ *
+ * Triggering: project-thread-mirror invokes this when seeding the project-meta
+ * header for a NEW project (i.e., this cwd's thread.jsonl didn't exist before).
+ * Idempotent: subsequent task entries do NOT regenerate the title.
+ *
+ * Cost: ~1 LLM call per NEW project (not per task). At a typical 1-2 new
+ * projects per week per user, the cost is negligible. FCC-routed when
+ * available; degrades silently to "(untitled)" when no provider responds.
+ */
+import { spawn } from 'child_process';
+const TITLE_TIMEOUT_MS = 15_000; // titles are short; abort fast if stuck
+const PROMPT_TEMPLATE = (firstPrompt, cwd) => `Generate a 4-6 word project title from this first user prompt.
+
+Project working directory: ${cwd}
+First prompt: ${firstPrompt}
+
+Rules:
+- 4 to 6 words MAX
+- No quotes, no punctuation, no trailing period
+- Title-case (e.g. "Auth Bug Fix Sprint")
+- Ground the title in the prompt + cwd ONLY. Do NOT invent project subject
+  matter you can't derive from the data above (e.g. don't infer "Thread
+  Interface Updates" from a "list files" prompt — say what the user
+  actually asked, not what you imagine the project is about).
+- If the prompt is too generic to title meaningfully, prefer naming the
+  cwd's last path segment (e.g. "Taste V0.6 Workspace") over invention.
+- Output ONLY the title — no preamble, no explanation
+
+Title:`;
+function selectProviderBinary() {
+    const override = process.env.CODEHERE_TITLE_BINARY;
+    if (override)
+        return [override];
+    return ['claude-free', 'claude'];
+}
+function tryProvider(binary, prompt) {
+    return new Promise((resolve) => {
+        let stdout = '';
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
+        const child = spawn(binary, ['--bare', '-p', prompt], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const timeout = setTimeout(() => {
+            child.kill('SIGTERM');
+            if (process.env.CODEHERE_DEBUG === '1') {
+                console.error(`[title-agent] ${binary} timeout after ${TITLE_TIMEOUT_MS}ms`);
+            }
+            finish(null);
+        }, TITLE_TIMEOUT_MS);
+        child.on('error', () => {
+            clearTimeout(timeout);
+            finish(null); // ENOENT etc. — silent fallback to next provider
+        });
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString('utf-8');
+        });
+        child.on('exit', (code) => {
+            clearTimeout(timeout);
+            if (code !== 0) {
+                finish(null);
+                return;
+            }
+            const title = sanitizeTitle(stdout);
+            if (!title) {
+                finish(null);
+                return;
+            }
+            finish(title);
+        });
+    });
+}
+/** Strip whitespace / quotes / trailing punctuation. Cap at 80 chars (safety). */
+function sanitizeTitle(raw) {
+    const lines = raw.split('\n').map((l) => l.trim()).filter(Boolean);
+    if (lines.length === 0)
+        return '';
+    let title = lines[lines.length - 1]; // last non-empty line is the answer
+    // Strip surrounding quotes
+    title = title.replace(/^["'`]+|["'`]+$/g, '');
+    // Strip trailing punctuation
+    title = title.replace(/[.!?,;:]+$/, '');
+    // Cap at 80 chars
+    if (title.length > 80)
+        title = title.slice(0, 77) + '...';
+    return title.trim();
+}
+/**
+ * Generate a thread title from the first user prompt + cwd context.
+ * Returns the title string, or null if no provider is reachable.
+ * Never throws — failure modes return null.
+ */
+export async function generateThreadTitle(firstPrompt, cwd) {
+    const prompt = PROMPT_TEMPLATE(firstPrompt, cwd);
+    for (const binary of selectProviderBinary()) {
+        const result = await tryProvider(binary, prompt);
+        if (result)
+            return result;
+    }
+    return null;
+}
+//# sourceMappingURL=generate-thread-title.js.map

package/dist/index.js

@@ -14,6 +14,7 @@ import { Command } from 'commander';
 import { config } from 'dotenv';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { homedir } from 'os';
 import { executeSetupCommand } from './presentation/cli/commands/setup-command.js';
 import { executeInitCommand } from './presentation/cli/commands/init-command.js';
 import { executeMemoryCommand } from './presentation/cli/commands/memory-command.js';
@@ -428,6 +429,43 @@ program
         }
     };
     try {
+        // v0.6.0 M1+M7 — migrate sessions.jsonl → ~/.codehere/projects/<slug>/thread.jsonl
+        // on daemon start. Idempotent: skips projects whose thread.jsonl already exists,
+        // so this is safe to run on every boot. Opt-out via CODEHERE_DISABLE_THREAD_MIGRATION=1.
+        // Failures are non-blocking — back-compat to v0.5 sessions.jsonl is preserved.
+        if (process.env.CODEHERE_DISABLE_THREAD_MIGRATION !== '1') {
+            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'),
+                });
+                if (result.threadsWritten > 0) {
+                    console.log(colors.dim(`  v0.6 migration: created ${result.threadsWritten} project thread(s) from ${result.sessionsProcessed} sessions (${result.durationMs}ms)`));
+                }
+            }
+            catch (err) {
+                console.warn(colors.dim(`  v0.6 migration skipped: ${err instanceof Error ? err.message : String(err)}`));
+            }
+        }
+        // v0.6.0 follow-up — backfill missing titles for projects that the
+        // M9 Title agent never fired on (migration-seeded ones). Runs in the
+        // background so daemon startup isn't blocked by ~5 LLM calls.
+        // Idempotent + best-effort. Same env-var gate as M9 itself.
+        if (process.env.CODEHERE_DISABLE_TITLE_AGENT !== '1') {
+            void (async () => {
+                try {
+                    const { backfillThreadTitles } = await import('./infrastructure/storage/project-thread-title-backfill.js');
+                    const r = await backfillThreadTitles();
+                    if (r.titlesGenerated > 0 && process.env.CODEHERE_DEBUG === '1') {
+                        console.log(colors.dim(`  v0.6 title backfill: titled ${r.titlesGenerated}/${r.scanned} project(s) in ${r.durationMs}ms`));
+                    }
+                }
+                catch {
+                    /* best-effort — silent on failure */
+                }
+            })();
+        }
         const { startMCPServer } = await import('./infrastructure/protocols/mcp-server-impl.js');
         const server = startMCPServer({ port, host });
         // Wait for the server to either start listening or fail. The default
@@ -597,6 +635,41 @@ program
         r.end();
     });
 });
+// ── migrate-threads — v0.6.0 schema migration sessions.jsonl → projects/<slug>/thread.jsonl
+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('--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)
+    .action(async (options) => {
+    const { migrate, dryRun, rollback } = await import('./infrastructure/storage/project-thread-migration.js');
+    if (options.rollback) {
+        const r = rollback(options.target);
+        console.log(`Rollback: removed ${r.removedDirs} project dir(s) from ${options.target}`);
+        console.log(`Source ${options.source} untouched.`);
+        return;
+    }
+    const fn = options.dryRun ? dryRun : migrate;
+    const label = options.dryRun ? 'DRY RUN' : 'MIGRATION';
+    const result = fn({
+        sourceJsonl: options.source,
+        targetDir: options.target,
+        skipTempDirs: !options.keepTempDirs,
+    });
+    console.log(`=== ${label} ===`);
+    console.log(`  source:                  ${options.source}`);
+    console.log(`  target:                  ${options.target}`);
+    console.log(`  sessions processed:      ${result.sessionsProcessed}`);
+    console.log(`  threads ${options.dryRun ? 'would write' : 'written'}:   ${result.threadsWritten}`);
+    console.log(`  threads skipped (exist): ${result.threadsSkippedExisting}`);
+    console.log(`  unknown-cwd sessions:    ${result.unknownCwdSessions}`);
+    console.log(`  abandoned sessions:      ${result.abandonedSessions}`);
+    console.log(`  temp-dir sessions skipped: ${result.tempDirSessionsSkipped}`);
+    console.log(`  duration:                ${result.durationMs}ms`);
+});
 // ── scan-tool (called by Claude Code hooks system, not users directly) ───────
 program
     .command('scan-tool', { hidden: true }) // hidden from --help (May 2 cut: internal hook handler, called by Claude Code via stdin)

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

@@ -266,6 +266,65 @@ export function spawnAider(prompt, options = {}) {
                 }
             }, 3000);
         },
+        canAppendMessage: true,
+        /**
+         * v0.6.0 — Slice 2 of REPL persistence. Aider has no per-session UUID
+         * (unlike claude-code's session_id or codex's thread_id); it persists chat
+         * history to ./.aider.chat.history.md in the cwd. `--restore-chat-history`
+         * reads that file before processing the new --message, giving multi-turn
+         * continuity scoped to the cwd.
+         *
+         * Limitation: aider is single-cwd-single-session. Two concurrent aider
+         * sessions in the same cwd would collide on the same history file. Same
+         * limitation aider's own users have when running it interactively;
+         * codehere doesn't make it worse.
+         *
+         * Same shape as the other appendMessage implementations: one-shot Q&A,
+         * returns assistant text + duration, no streaming.
+         */
+        appendMessage(text) {
+            const startedAt = Date.now();
+            return new Promise((resolve, reject) => {
+                let stdout = '';
+                let stderr = '';
+                const followup = spawn('aider', ['--restore-chat-history', '--message', text, ...HEADLESS_FLAGS], {
+                    cwd,
+                    env: spawnEnv,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                followup.on('error', (err) => reject(err));
+                followup.stdout?.on('data', (chunk) => {
+                    stdout += chunk.toString('utf-8');
+                });
+                followup.stderr?.on('data', (chunk) => {
+                    stderr += chunk.toString('utf-8');
+                });
+                followup.on('exit', (code) => {
+                    if (code !== 0) {
+                        reject(new Error(`aider --restore-chat-history exited ${code}: ${stderr.slice(0, 300)}`));
+                        return;
+                    }
+                    // Aider's --no-stream + --no-pretty output is plain text; the
+                    // assistant's reply lands as a top-level paragraph after any
+                    // tool-execution lines. Strip aider's own prefix lines (Added,
+                    // Tokens, Cost, Applied, etc.) and keep the conversational body.
+                    const stripped = stdout
+                        .split('\n')
+                        .filter((l) => {
+                        const t = l.trim();
+                        if (!t)
+                            return false;
+                        if (/^(Added|Removed|Tokens?:|Cost:|Applied|Creating|Running|Commit|Aider|Model:|Main model:|Weak model:)/i.test(t))
+                            return false;
+                        return true;
+                    })
+                        .join('\n')
+                        .trim();
+                    const result = stripped || '(aider returned no conversational output)';
+                    resolve({ result, durationMs: Date.now() - startedAt });
+                });
+            });
+        },
     };
 }
 export const AiderAdapter = {

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

@@ -221,6 +221,12 @@ export function spawnClaudeCode(prompt, options = {}) {
     }
     // ── stdout: newline-delimited JSON from `--output-format stream-json` ────────
     let stdoutBuf = '';
+    // Iter 13 — capture the claude-internal session_id from the init event so
+    // appendMessage can use `--resume <session-id>` (reliable) instead of `-c`
+    // (which picks "most recent in cwd" and can collide with other concurrent
+    // claude sessions OR with conversations containing thinking blocks the
+    // headless API can't replay).
+    let claudeSessionId;
     child.stdout?.on('data', (chunk) => {
         stdoutBuf += chunk.toString('utf-8');
         let idx;
@@ -231,6 +237,12 @@ export function spawnClaudeCode(prompt, options = {}) {
                 continue;
             try {
                 const data = JSON.parse(line);
+                if (claudeSessionId === undefined &&
+                    data.type === 'system' &&
+                    data.subtype === 'init' &&
+                    typeof data.session_id === 'string') {
+                    claudeSessionId = data.session_id;
+                }
                 emit({ type: data.type ?? 'message', timestamp: Date.now(), data });
             }
             catch {
@@ -319,20 +331,31 @@ export function spawnClaudeCode(prompt, options = {}) {
             }, 3000);
         },
         /**
-         * Iter 12 — follow-up message to a completed session. Spawns a fresh
-         * `claude -p "<text>" -c` in the same cwd, which uses Claude Code's
-         * native -c flag to continue the most recent conversation in that dir.
+         * Iter 12 (with iter-13 fix) — follow-up message to a completed session.
+         *
+         * Iter 12 used `claude -p "<text>" -c` which picks "most recent
+         * conversation in current directory". Iter 13 dogfood proved this
+         * fragile: in a cwd with multiple concurrent claude sessions OR with
+         * conversations containing thinking blocks, -c either picks the wrong
+         * session or hits an API-replay error ("Invalid signature in thinking
+         * block"). Fix: capture the claude session_id from this session's init
+         * event (above) and use `--resume <session-id>` for follow-ups —
+         * unambiguous and replay-safe.
          *
-         * Scope: one-shot Q&A. No streaming, no event piping into the parent
-         * emitter. Returns the assistant's response text. Iter 13 may upgrade
-         * to a true thread-streaming model if the dogfood signal warrants.
+         * Scope: still one-shot Q&A. No streaming. Returns assistant's response
+         * text. If we never captured a session_id (init event never fired —
+         * shouldn't happen in healthy claude runs), reject explicitly.
          */
         appendMessage(text) {
             const startedAt = Date.now();
             return new Promise((resolve, reject) => {
+                if (!claudeSessionId) {
+                    reject(new Error('Cannot reply: original claude session_id was never captured (init event missed)'));
+                    return;
+                }
                 let stdout = '';
                 let stderr = '';
-                const followup = spawn('claude', ['-p', text, '-c', ...HEADLESS_FLAGS], {
+                const followup = spawn('claude', ['-p', text, '--resume', claudeSessionId, ...HEADLESS_FLAGS], {
                     cwd,
                     env: spawnEnv,
                     stdio: ['ignore', 'pipe', 'pipe'],

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

@@ -187,6 +187,11 @@ export function spawnCodex(prompt, options = {}) {
             },
         };
     }
+    // v0.6.0 — capture codex's thread_id from the `thread.started` event so
+    // appendMessage() can use `codex exec resume <thread_id> <prompt>` for
+    // multi-turn continuity. Same pattern as claude-code-adapter capturing
+    // session_id from the init event for `claude --resume`.
+    let codexThreadId;
     let stdoutBuf = '';
     child.stdout?.on('data', (chunk) => {
         stdoutBuf += chunk.toString('utf-8');
@@ -198,6 +203,11 @@ export function spawnCodex(prompt, options = {}) {
                 continue;
             try {
                 const data = JSON.parse(line);
+                if (codexThreadId === undefined &&
+                    data.type === 'thread.started' &&
+                    typeof data.thread_id === 'string') {
+                    codexThreadId = data.thread_id;
+                }
                 emit({ type: data.type ?? 'codex_event', timestamp: Date.now(), data });
             }
             catch {
@@ -277,6 +287,72 @@ export function spawnCodex(prompt, options = {}) {
                 }
             }, 3000);
         },
+        canAppendMessage: true,
+        /**
+         * v0.6.0 — Slice 1 of REPL persistence. Spawns `codex exec resume <thread_id>`
+         * with the follow-up prompt via stdin (codex exec resume accepts `-` to read
+         * prompt from stdin per `codex exec resume --help`). Re-uses the original
+         * thread context so this is a true continuation, not a fresh session.
+         *
+         * Same shape as claude-code's appendMessage:
+         *   - One-shot Q&A (no streaming reply yet)
+         *   - Returns assistant text + duration
+         *   - Rejects if thread_id wasn't captured (init event missed)
+         *
+         * Founder hit codex usage cap at smoke time; the real-error path is
+         * exercised by the rate-limit fingerprint that lands in stderr/JSONL.
+         */
+        appendMessage(text) {
+            const startedAt = Date.now();
+            return new Promise((resolve, reject) => {
+                if (!codexThreadId) {
+                    reject(new Error('Cannot reply: codex thread_id was never captured (thread.started event missed)'));
+                    return;
+                }
+                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, '-'], {
+                    cwd,
+                    env: spawnEnv,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                followup.stdin?.write(text);
+                followup.stdin?.end();
+                followup.on('error', (err) => reject(err));
+                followup.stdout?.on('data', (chunk) => {
+                    stdout += chunk.toString('utf-8');
+                });
+                followup.stderr?.on('data', (chunk) => {
+                    stderr += chunk.toString('utf-8');
+                });
+                followup.on('exit', (code) => {
+                    if (code !== 0) {
+                        reject(new Error(`codex exec resume exited ${code}: ${stderr.slice(0, 300)}`));
+                        return;
+                    }
+                    // Parse JSONL — extract assistant message text from item.completed
+                    // events of type agent_message (same shape codex emits during the
+                    // initial exec; reuse the textAccum logic).
+                    const lines = stdout.split('\n').filter((l) => l.trim());
+                    const fragments = [];
+                    for (const line of lines) {
+                        try {
+                            const obj = JSON.parse(line);
+                            if (obj.type === 'item.completed' && obj.item?.type === 'agent_message' && obj.item.text) {
+                                fragments.push(obj.item.text);
+                            }
+                        }
+                        catch {
+                            /* non-JSON line — skip */
+                        }
+                    }
+                    const result = fragments.join('\n').trim() || '(codex returned no agent_message text)';
+                    resolve({ result, durationMs: Date.now() - startedAt });
+                });
+            });
+        },
     };
 }
 export const CodexAdapter = {

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

@@ -323,7 +323,17 @@ function spawnConductor(prompt, options, lookup) {
         get artifacts() {
             return artifactsSnapshot;
         },
-        canAppendMessage: false, // v0.4-alpha doesn't support mid-session redirection
+        // v0.6.0 — Slice 3 of REPL persistence. Conductor inherits appendMessage
+        // capability from whichever specialist it routed to. With all 5 external
+        // adapters wired in Slices 1-2c, this becomes true for every routing
+        // decision. Follow-ups stay with the SAME specialist that handled the
+        // original turn — no re-routing mid-thread (intentional: the user's reply
+        // is part of an ongoing exchange with that specific specialist, not a
+        // fresh classification opportunity).
+        canAppendMessage: specialistSession.canAppendMessage === true,
+        appendMessage: specialistSession.appendMessage
+            ? (text) => specialistSession.appendMessage(text)
+            : undefined,
         subscribe(handler) {
             for (const e of buffer)
                 handler(e);

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

@@ -354,6 +354,64 @@ export function spawnGemini(prompt, options = {}) {
                     sendSignal('SIGKILL');
             }, 3000);
         },
+        canAppendMessage: true,
+        /**
+         * v0.6.0 — Slice 2b of REPL persistence. Gemini's --resume flag accepts
+         * either a numeric INDEX (per-cwd ordinal of past sessions) or the literal
+         * string "latest" — NOT the session_id UUID that the init JSONL event
+         * emits. UUID→index mapping requires --list-sessions which has its own
+         * race condition (indices shift as sessions are added/deleted).
+         *
+         * For the v0.6 cut we use --resume latest. Limitation: if the user spawns
+         * another gemini session in this cwd between the original spawn and this
+         * follow-up, the follow-up routes to the wrong session. Same caveat as
+         * opencode's --continue. Acceptable for the typical reply-within-minutes
+         * flow; the rigorous UUID→index helper is queued for v0.6.x.
+         */
+        appendMessage(text) {
+            const startedAt = Date.now();
+            return new Promise((resolve, reject) => {
+                let stdout = '';
+                let stderr = '';
+                const followup = spawn('gemini', ['-p', text, '--resume', 'latest', ...HEADLESS_FLAGS], {
+                    cwd,
+                    env: spawnEnv,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                followup.on('error', (err) => reject(err));
+                followup.stdout?.on('data', (chunk) => {
+                    stdout += chunk.toString('utf-8');
+                });
+                followup.stderr?.on('data', (chunk) => {
+                    stderr += chunk.toString('utf-8');
+                });
+                followup.on('exit', (code) => {
+                    if (code !== 0) {
+                        reject(new Error(`gemini --resume latest exited ${code}: ${stderr.slice(0, 300)}`));
+                        return;
+                    }
+                    // Parse stream-json — extract assistant message text from 'message'
+                    // events with role='assistant'. Same source codex/claude-code use.
+                    const fragments = [];
+                    for (const line of stdout.split('\n')) {
+                        const trimmed = line.trim();
+                        if (!trimmed)
+                            continue;
+                        try {
+                            const obj = JSON.parse(trimmed);
+                            if (obj.type === 'message' && obj.role === 'assistant' && typeof obj.content === 'string') {
+                                fragments.push(obj.content);
+                            }
+                        }
+                        catch {
+                            /* non-JSON — skip */
+                        }
+                    }
+                    const result = fragments.join('\n').trim() || '(gemini returned no assistant message)';
+                    resolve({ result, durationMs: Date.now() - startedAt });
+                });
+            });
+        },
     };
 }
 export const GeminiAdapter = {

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

@@ -245,6 +245,68 @@ export function spawnOpenCode(prompt, options = {}) {
                 }
             }, 3000);
         },
+        canAppendMessage: true,
+        /**
+         * v0.6.0 — Slice 2c of REPL persistence. OpenCode's `run --format json`
+         * output is fully buffered until the LLM call completes; the session ID
+         * (ses_*) is not observable mid-stream like claude-code's session_id or
+         * codex's thread_id. The cleanest available alternative is `-c/--continue`
+         * which targets the last session.
+         *
+         * Limitation: same as gemini's --resume latest — if the user spawns
+         * another opencode session in this cwd between the original spawn and the
+         * follow-up, the follow-up routes to the wrong session. Acceptable for
+         * the typical reply-within-minutes flow; the rigorous version (capture
+         * session ID via post-spawn `opencode session list` filtered by --title
+         * tag) is queued for v0.6.x.
+         *
+         * Output parsing: `--format json` here uses the same JSONL event shape as
+         * the spawn path; we extract assistant message text from `text` events.
+         */
+        appendMessage(text) {
+            const startedAt = Date.now();
+            return new Promise((resolve, reject) => {
+                let stdout = '';
+                let stderr = '';
+                const followup = spawn('opencode', [...HEADLESS_FLAGS, '--continue', text], {
+                    cwd,
+                    env: spawnEnv,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                followup.on('error', (err) => reject(err));
+                followup.stdout?.on('data', (chunk) => {
+                    stdout += chunk.toString('utf-8');
+                });
+                followup.stderr?.on('data', (chunk) => {
+                    stderr += chunk.toString('utf-8');
+                });
+                followup.on('exit', (code) => {
+                    if (code !== 0) {
+                        reject(new Error(`opencode --continue exited ${code}: ${stderr.slice(0, 300)}`));
+                        return;
+                    }
+                    // Parse JSONL — extract assistant text from `text` events
+                    // (same shape spawn() consumes via textAccum logic above).
+                    const fragments = [];
+                    for (const line of stdout.split('\n')) {
+                        const trimmed = line.trim();
+                        if (!trimmed)
+                            continue;
+                        try {
+                            const obj = JSON.parse(trimmed);
+                            if (obj.type === 'text' && obj.part?.text) {
+                                fragments.push(obj.part.text);
+                            }
+                        }
+                        catch {
+                            /* non-JSON — skip */
+                        }
+                    }
+                    const result = fragments.join('\n').trim() || '(opencode returned no text events)';
+                    resolve({ result, durationMs: Date.now() - startedAt });
+                });
+            });
+        },
     };
 }
 export const OpenCodeAdapter = {