codehere 0.5.0-alpha.4 → 0.5.0-alpha.6

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

@@ -448,6 +448,24 @@ program
                 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

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/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 = {

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

@@ -22,8 +22,9 @@ import { buildGenericAdapter, loadAgentsConfig } from './generic-cli-adapter.js'
 import { buildConductorAdapter } from './conductor-adapter.js';
 import { seedAgentsConfig } from './agents-config-seed.js';
 import { AUDIT_FILE } from '../hooks/claude-sdk-hook.js';
-import { appendSpawned, appendCompleted, loadRecent } from './session-persistence.js';
+import { appendSpawned, appendCompleted, appendFinalReport, loadRecent } from './session-persistence.js';
 import { generateFinalReport, printFinalReportToTerminal } from '../../application/use-cases/generate-final-report.js';
+import { mirrorSpawnedToThread, mirrorCompletedToThread } from '../storage/project-thread-mirror.js';
 // ── Agent registry ─────────────────────────────────────────────────────────────
 // All backends codehere can spawn. Order here drives the default UI dropdown
 // order. Built-in adapters first; user-config-driven ones appended from
@@ -104,6 +105,11 @@ export class SessionManager {
      *  Surfaced May 2 by the cold-start dogfood — `duration: NaNs` in /api/tasks
      *  for completed-but-not-yet-restarted sessions. Bug 2 sister-fix. */
     completedAtBySession = new Map();
+    /** v0.6.x Slack-shape spike — cwd per session. The "Continue thread" intake
+     * button needs to find the most recent in-memory session for the current
+     * cwd; cwd isn't on the TaskSession interface and adapters don't all expose
+     * it, so we track it here at spawn time. */
+    cwdBySession = new Map();
     /** PM-UX Layer 3 · Final Report cache (iteration 11 MVP, UI-integration iter 12).
      *  Populated when generateFinalReport resolves in the exit handler. Web UI
      *  reads via getFinalReport() through the /api/tasks serializer so non-technical
@@ -123,6 +129,7 @@ export class SessionManager {
         // leaves an audit trail of what was attempted. Subscribe to exit so we can
         // capture the final status + steps + artifacts when the session settles.
         const cwd = options?.cwd ?? process.cwd();
+        this.cwdBySession.set(session.sessionId, cwd);
         appendSpawned({
             id: session.sessionId,
             agent: session.agent,
@@ -130,6 +137,15 @@ export class SessionManager {
             cwd,
             startedAt: session.startedAt,
         });
+        // v0.6.0 M1+M7 — forward-mirror to per-project thread.jsonl alongside
+        // sessions.jsonl. Best-effort; mirror failures don't break the spawn path.
+        mirrorSpawnedToThread({
+            sessionId: session.sessionId,
+            agent: session.agent,
+            prompt,
+            cwd,
+            startedAt: session.startedAt,
+        });
         const unsubscribe = session.subscribe((event) => {
             if (event.type !== 'exit')
                 return;
@@ -147,6 +163,16 @@ export class SessionManager {
                 steps: session.steps ? [...session.steps] : undefined,
                 artifacts: session.artifacts,
             });
+            // v0.6.0 M1+M7 — forward-mirror completion to project thread.
+            mirrorCompletedToThread({
+                sessionId: session.sessionId,
+                cwd,
+                status: session.status,
+                durationMs: Number(data?.durationMs ?? completedAt - session.startedAt),
+                completedAt,
+                steps: session.steps ? [...session.steps] : undefined,
+                artifacts: session.artifacts,
+            });
             // PM-UX Layer 3 · Final Report MVP. Fire-and-forget; the report appears
             // in the terminal a few seconds after exit. Failure modes return null
             // silently (claude CLI not installed, timeout, non-zero exit). No SSE,
@@ -167,6 +193,17 @@ export class SessionManager {
                     // Cache for web UI consumption via /api/tasks (iter 12 — non-technical
                     // users live in the web UI, not the terminal).
                     this.finalReportBySession.set(session.sessionId, report);
+                    // v0.6.x — persist to disk so the report survives daemon restart.
+                    // Pre-fix: founder's Mac restart 2026-05-03 left a session card
+                    // showing "Generating report…" forever because reports lived only
+                    // in this in-memory Map. Append-only finalReport record paired
+                    // with the existing spawned/completed records by sessionId.
+                    appendFinalReport({
+                        id: session.sessionId,
+                        summary: report.summary,
+                        generatedAt: report.generatedAt,
+                        durationMs: report.durationMs,
+                    });
                     try {
                         printFinalReportToTerminal(reportInput, report);
                     }
@@ -193,6 +230,10 @@ export class SessionManager {
     getCompletedAt(sessionId) {
         return this.completedAtBySession.get(sessionId);
     }
+    /** v0.6.x Slack-shape spike — return cwd for an in-memory session. */
+    getCwd(sessionId) {
+        return this.cwdBySession.get(sessionId);
+    }
     /** PM-UX Layer 3 · prose Final Report for an in-memory exited session.
      *  Returns undefined while generation is in flight OR if the provider chain
      *  failed (no claude-free, no claude, no credit, etc). The web UI reads this

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

@@ -46,6 +46,27 @@ export function appendCompleted(rec) {
         /* best-effort */
     }
 }
+/**
+ * v0.6.x — persist a Final Report so it survives daemon restart.
+ *
+ * Pre-fix: Final Reports lived only in SessionManager.finalReportBySession
+ * (in-memory Map) and were lost on every daemon bounce. Founder hit this
+ * 2026-05-03 after a Mac restart: completed sessions showed
+ * "Generating report…" forever because there was no on-disk record + no
+ * "report-unavailable" state in the UI.
+ *
+ * Append-only: Final Report fires AFTER the CompletedRecord (generateFinalReport
+ * is async post-exit), so it gets its own record type. Reader merges by id.
+ */
+export function appendFinalReport(rec) {
+    try {
+        ensureDir();
+        appendFileSync(SESSIONS_FILE, JSON.stringify({ t: 'finalReport', ...rec }) + '\n', 'utf-8');
+    }
+    catch {
+        /* best-effort */
+    }
+}
 /**
  * Walk the session log backward, pair spawned+completed records by id, return
  * the most recent `limit` completed pairs sorted newest-first.
@@ -67,6 +88,9 @@ export function loadRecent(limit = 20) {
     }
     const spawned = new Map();
     const completed = [];
+    /** v0.6.x — Final Reports keyed by sessionId. Last write wins
+     *  (rare in practice; reports fire once per session). */
+    const finalReports = new Map();
     for (const line of content.split('\n')) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -82,6 +106,8 @@ export function loadRecent(limit = 20) {
             spawned.set(rec.id, rec);
         else if (rec.t === 'completed')
             completed.push(rec);
+        else if (rec.t === 'finalReport')
+            finalReports.set(rec.id, rec);
     }
     const merged = [];
     // Walk completed in reverse so we return newest-first
@@ -90,6 +116,7 @@ export function loadRecent(limit = 20) {
         const s = spawned.get(c.id);
         if (!s)
             continue; // orphan completed (shouldn't happen but harmless)
+        const fr = finalReports.get(c.id);
         merged.push({
             sessionId: s.id,
             agent: s.agent,
@@ -113,6 +140,7 @@ export function loadRecent(limit = 20) {
             completedAt: c.completedAt,
             steps: c.steps,
             artifacts: c.artifacts,
+            ...(fr ? { finalReport: { summary: fr.summary, generatedAt: fr.generatedAt, durationMs: fr.durationMs } } : {}),
             provenance: 'persisted',
         });
     }