codehere 1.0.1 → 1.0.2

package/dist/infrastructure/storage/project-thread-mirror.js

@@ -1,671 +0,0 @@
-/**
- * Project thread forward-mirror — writes new sessions to per-project
- * thread.jsonl alongside sessions.jsonl during normal daemon operation.
- *
- * v0.6.0 M1+M7 — companion to project-thread-migration.ts:
- *   - Migration handles HISTORICAL data (sessions.jsonl → projects/<slug>/thread.jsonl)
- *   - This handles NEW data (every spawn + completion writes to BOTH)
- *
- * Without this, the project threads created by migration are a one-time
- * snapshot. With this, every new session lands in both formats and the
- * project thread stays current as users work. UI restructure (next milestone)
- * then renders thread.jsonl as the primary view.
- *
- * Write pattern matches session-persistence.ts:
- *   - Append-only (no rewrites; lock-free single writer)
- *   - Best-effort (failures don't break the spawn path)
- *   - Each session writes TWO entries over its lifetime:
- *     1. On spawn:    { type: 'task', sessionId, agent, prompt, cwd, startedAt, status: 'running' }
- *     2. On complete: { type: 'task', sessionId, status, durationMs, completedAt, steps, artifacts }
- *   - Reader reconstructs by sessionId (later entry overrides earlier) — same
- *     shape as project-thread-migration.ts output.
- *
- * Filtering matches migration defaults:
- *   - Temp dirs (/tmp, /var/folders, /private/var/folders, /private/tmp) skipped
- *   - NULL cwd → 'unknown' bucket
- *
- * Iter 13 — built after v0.5.0-alpha.4 ship. Previously the only way new
- * sessions reached thread.jsonl was to re-run migration; this closes the gap.
- */
-import { existsSync, mkdirSync, appendFileSync, readFileSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { createHash } from 'crypto';
-import { execFileSync } from 'child_process';
-import { normalizeRemote } from './project-thread-reader.js';
-const PROJECTS_DIR = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'projects');
-/** Match migration module's defaults. Same regex set kept in sync. */
-const TEMP_DIR_PATTERNS = [/^\/tmp\//, /^\/var\/folders\//, /^\/private\/var\/folders\//, /^\/private\/tmp\//];
-function isTempDir(cwd) {
-    if (!cwd)
-        return false;
-    return TEMP_DIR_PATTERNS.some((re) => re.test(cwd));
-}
-function slugForCwd(cwd) {
-    if (!cwd)
-        return 'unknown';
-    return createHash('sha1').update(cwd).digest('hex').slice(0, 12);
-}
-/**
- * Detect the git remote for a cwd → normalized `host/org/repo` (project
- * identity). Best-effort + fast: a short-timeout `git remote get-url origin`,
- * silent on not-a-repo / no-remote / git-missing. Called at most once per
- * project (write-time seed + the daemon-start backfill), never on a read poll.
- */
-function detectRemote(cwd) {
-    if (!cwd)
-        return null;
-    try {
-        const out = execFileSync('git', ['-C', cwd, 'remote', 'get-url', 'origin'], {
-            encoding: 'utf-8',
-            timeout: 2000,
-            stdio: ['ignore', 'pipe', 'ignore'],
-        });
-        return normalizeRemote(out.trim());
-    }
-    catch {
-        return null;
-    }
-}
-function ensureProjectDir(slug) {
-    const dir = join(PROJECTS_DIR, slug);
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    return dir;
-}
-function appendThreadEntry(slug, entry) {
-    // Returns true if this write SEEDED the file (first time creation), false otherwise.
-    // Caller (mirrorSpawnedToThread) uses this signal to fire the hidden Title agent.
-    try {
-        const dir = ensureProjectDir(slug);
-        const file = join(dir, 'thread.jsonl');
-        let seeded = false;
-        if (!existsSync(file)) {
-            const meta = JSON.stringify({
-                _meta: 'project',
-                slug,
-                cwd: null, // populated by migration; forward-mirror writes the cwd in each task entry
-                sessionCount: 0,
-                title: null, // populated by hidden Title agent (v0.6.0 M9) on first task entry
-                migratedFrom: 'forward-mirror',
-                migratedAt: Date.now(),
-            });
-            appendFileSync(file, meta + '\n', 'utf-8');
-            seeded = true;
-        }
-        appendFileSync(file, JSON.stringify(entry) + '\n', 'utf-8');
-        return seeded;
-    }
-    catch {
-        // Best-effort. Mirror failures must never break the spawn or completion
-        // path — sessions.jsonl is the canonical store; thread.jsonl is derived.
-        return false;
-    }
-}
-/** Append a project-meta update line (used by Title agent to set the title).
- *  Returns true on successful write, false on any fs failure. Title-agent
- *  callers ignore the return (best-effort); renameProject surfaces it as a
- *  500 to the HTTP layer so users don't see "renamed" when nothing landed. */
-function appendMetaUpdate(slug, partial) {
-    try {
-        const dir = ensureProjectDir(slug);
-        const file = join(dir, 'thread.jsonl');
-        if (!existsSync(file))
-            return false; // can't update what doesn't exist
-        appendFileSync(file, JSON.stringify({ _meta: 'project-update', slug, ...partial, updatedAt: Date.now() }) + '\n', 'utf-8');
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Returns true if any prior project-update line for this slug carries
- * userOverride:true. Used by the async Title agent (and the periodic backfill)
- * to skip overwriting a title the user has manually set.
- *
- * The race this guards: spawn fires Title agent in background → user renames
- * before LLM returns → Title agent's later write would clobber the manual
- * rename because the reader takes the latest title. With this check, the
- * Title agent reads its own outcome moments before writing and bails if the
- * user got there first. Best-effort; on read failure returns false (Title
- * agent proceeds) — same posture as every other appendThreadEntry caller.
- */
-/**
- * Derive a clean Title-Cased name from a working directory path. Used as the
- * immediate seed title (so the sidebar never shows blank / placeholder during
- * the LLM call) and as the permanent fallback when the Title agent returns
- * null / garbage. Examples:
- *   /Users/x/code/codehere       → "Codehere"
- *   /Users/x/work/auth_service   → "Auth Service"
- *   /Users/x/code/some-cool-thing → "Some Cool Thing"
- *   /                            → "Project"
- */
-export function titleFromCwd(cwd) {
-    if (!cwd)
-        return 'Project';
-    const segments = cwd.split('/').filter(Boolean);
-    const last = segments[segments.length - 1];
-    if (!last)
-        return 'Project';
-    // Replace separators with spaces, title-case each word, cap at 6 words
-    const words = last
-        .replace(/[._-]+/g, ' ')
-        .replace(/([a-z])([A-Z])/g, '$1 $2') // camelCase split
-        .split(/\s+/)
-        .filter(Boolean)
-        .slice(0, 6)
-        .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase());
-    return words.join(' ') || 'Project';
-}
-/**
- * One-shot backfill for legacy garbage project titles (Bug A4 retroactive).
- *
- * The original A4 fix (rejected garbage titles + cwd fallback) only applied
- * to NEW projects. Existing thread.jsonl files written before the fix can
- * still carry titles like "Request ID: req_abc123…" or "I cannot generate…"
- * sitting in the latest project-update record. Those show up in the sidebar
- * forever until the user manually renames.
- *
- * Walks every ~/.codehere/projects/<slug>/thread.jsonl, reads the latest
- * project-update title, runs the same garbage detection used at write time.
- * If garbage, appends a new project-update with the cwd-derived fallback
- * title plus `_backfilled: true` marker so re-runs are no-ops.
- *
- * Manual overrides (set via Pattern 10 inline rename) are NEVER touched —
- * hasManualOverride guards the rewrite.
- *
- * Best-effort: any per-project failure logs to stderr (when CODEHERE_DEBUG=1)
- * and continues. Returns the count of titles rewritten.
- */
-export async function backfillProjectTitles() {
-    let scanned = 0;
-    let rewritten = 0;
-    if (!existsSync(PROJECTS_DIR))
-        return { scanned, rewritten };
-    // Lazy-load sanitizeTitle to avoid a static import cycle (use-case → infra).
-    const { sanitizeTitle } = await import('../../application/use-cases/generate-thread-title.js');
-    let entries;
-    try {
-        const { readdirSync } = await import('fs');
-        entries = readdirSync(PROJECTS_DIR);
-    }
-    catch {
-        return { scanned, rewritten };
-    }
-    for (const slug of entries) {
-        // Skip non-slug-shaped names + hidden files
-        if (!/^[a-f0-9]{12}$|^unknown$/.test(slug))
-            continue;
-        scanned++;
-        try {
-            const file = join(PROJECTS_DIR, slug, 'thread.jsonl');
-            if (!existsSync(file))
-                continue;
-            if (hasManualOverride(slug))
-                continue; // Never overwrite user renames
-            const content = readFileSync(file, 'utf-8');
-            const lines = content.split('\n').filter((l) => l.trim());
-            // Find the latest project-update + the most recent task cwd (for fallback)
-            let latestTitle = null;
-            let latestCwd = null;
-            let alreadyBackfilled = false;
-            for (const line of lines) {
-                try {
-                    const rec = JSON.parse(line);
-                    if (rec._meta === 'project-update' && typeof rec.title === 'string') {
-                        latestTitle = rec.title;
-                        if (rec._backfilled === true)
-                            alreadyBackfilled = true;
-                        else
-                            alreadyBackfilled = false;
-                    }
-                    if (rec.type === 'task' && typeof rec.cwd === 'string' && rec.cwd) {
-                        latestCwd = rec.cwd;
-                    }
-                }
-                catch {
-                    /* skip malformed line */
-                }
-            }
-            if (alreadyBackfilled)
-                continue; // idempotent — already cleaned
-            if (!latestTitle)
-                continue; // nothing to check
-            // Run the same garbage detection sanitizeTitle uses at write time.
-            // sanitizeTitle returns '' for garbage; non-empty means clean.
-            const cleaned = sanitizeTitle(latestTitle);
-            if (cleaned)
-                continue; // title is fine
-            // Garbage — write a new project-update with cwd-derived fallback.
-            const fallback = titleFromCwd(latestCwd);
-            const ok = appendMetaUpdate(slug, {
-                title: fallback,
-                cwd: latestCwd,
-                _backfilled: true,
-            });
-            if (ok) {
-                rewritten++;
-                if (process.env.CODEHERE_DEBUG === '1') {
-                    console.error(`[backfill] ${slug}: "${latestTitle.slice(0, 40)}" › "${fallback}"`);
-                }
-            }
-        }
-        catch {
-            /* per-project failure → continue */
-        }
-    }
-    return { scanned, rewritten };
-}
-/**
- * One-time backfill of the git remote into _meta for projects that predate
- * write-time detection (or whose seed-time detection found none). Idempotent:
- * any project carrying a non-null remote OR a `_remoteChecked` marker is
- * skipped, so this runs the git probe at most once per project across the
- * daemon's lifetime. Best-effort; per-project failures continue.
- *
- * Wired at daemon start alongside backfillProjectTitles. Returns the count of
- * projects for which a real remote was detected.
- */
-export async function backfillProjectRemotes() {
-    let scanned = 0;
-    let detected = 0;
-    if (!existsSync(PROJECTS_DIR))
-        return { scanned, detected };
-    let entries;
-    try {
-        const { readdirSync } = await import('fs');
-        entries = readdirSync(PROJECTS_DIR);
-    }
-    catch {
-        return { scanned, detected };
-    }
-    for (const slug of entries) {
-        if (!/^[a-f0-9]{12}$|^unknown$/.test(slug))
-            continue;
-        scanned++;
-        try {
-            const file = join(PROJECTS_DIR, slug, 'thread.jsonl');
-            if (!existsSync(file))
-                continue;
-            const content = readFileSync(file, 'utf-8');
-            const lines = content.split('\n').filter((l) => l.trim());
-            let alreadyChecked = false;
-            let haveRemote = false;
-            let latestCwd = null;
-            for (const line of lines) {
-                try {
-                    const rec = JSON.parse(line);
-                    if (rec._meta === 'project' || rec._meta === 'project-update') {
-                        if (rec._remoteChecked === true)
-                            alreadyChecked = true;
-                        if (typeof rec.remote === 'string' && rec.remote)
-                            haveRemote = true;
-                        if (typeof rec.cwd === 'string' && rec.cwd && !latestCwd)
-                            latestCwd = rec.cwd;
-                    }
-                    if (rec.type === 'task' && typeof rec.cwd === 'string' && rec.cwd)
-                        latestCwd = rec.cwd;
-                }
-                catch {
-                    /* skip malformed line */
-                }
-            }
-            if (alreadyChecked || haveRemote)
-                continue; // idempotent — already settled
-            const remote = detectRemote(latestCwd);
-            // Stamp _remoteChecked even on a null result so we never re-probe a
-            // remote-less project. The reader ignores a null remote (keeps it null).
-            const ok = appendMetaUpdate(slug, { remote: remote ?? null, _remoteChecked: true });
-            if (ok && remote) {
-                detected++;
-                if (process.env.CODEHERE_DEBUG === '1') {
-                    console.error(`[backfill-remote] ${slug}: ${remote}`);
-                }
-            }
-        }
-        catch {
-            /* per-project failure → continue */
-        }
-    }
-    return { scanned, detected };
-}
-/**
- * One-shot reconciliation for stale-running tasks (Bug: project-thread.jsonl
- * entries can stay in `status: 'running'` forever when the daemon dies
- * mid-task or the subprocess crashes without a clean completion event).
- *
- * The visible failure mode (per dogfood screenshots May 6): the threads
- * view shows RUNNING pills on 3-day-old tasks. With Pattern 8's peach-
- * accent running pill, the page reads as "codehere doesn't know what
- * state its own sessions are in" — a credibility bomb.
- *
- * Walks every ~/.codehere/projects/<slug>/thread.jsonl, reconstructs each
- * session's latest task state by sessionId, and for any session whose
- * latest state is `running` AND startedAt > 60 minutes ago, appends a
- * synthetic completion record marking it `crashed` with `_reconciled: true`.
- *
- * Idempotent — sessions already carrying `_reconciled: true` are skipped.
- * Preserves history (append-only, never rewrites prior lines).
- *
- * Best-effort: per-project failures log to stderr (CODEHERE_DEBUG=1) and
- * continue. Returns count of sessions reconciled.
- */
-export async function reconcileStaleProjectTasks(options) {
-    const STALE_AFTER_MS = options?.staleAfterMs ?? 60 * 60 * 1000; // 60 minutes
-    const now = Date.now();
-    let scanned = 0;
-    let reconciled = 0;
-    if (!existsSync(PROJECTS_DIR))
-        return { scanned, reconciled };
-    let entries;
-    try {
-        const { readdirSync } = await import('fs');
-        entries = readdirSync(PROJECTS_DIR);
-    }
-    catch {
-        return { scanned, reconciled };
-    }
-    for (const slug of entries) {
-        if (!/^[a-f0-9]{12}$|^unknown$/.test(slug))
-            continue;
-        scanned++;
-        try {
-            const file = join(PROJECTS_DIR, slug, 'thread.jsonl');
-            if (!existsSync(file))
-                continue;
-            const content = readFileSync(file, 'utf-8');
-            const lines = content.split('\n').filter((l) => l.trim());
-            const bySession = new Map();
-            for (const line of lines) {
-                try {
-                    const rec = JSON.parse(line);
-                    if (rec.type !== 'task' || typeof rec.sessionId !== 'string')
-                        continue;
-                    const cur = bySession.get(rec.sessionId) ?? {
-                        sessionId: rec.sessionId,
-                        status: '',
-                        startedAt: 0,
-                        reconciled: false,
-                    };
-                    if (typeof rec.status === 'string')
-                        cur.status = rec.status;
-                    if (typeof rec.startedAt === 'number' && rec.startedAt > 0)
-                        cur.startedAt = rec.startedAt;
-                    if (rec._reconciled === true)
-                        cur.reconciled = true;
-                    bySession.set(rec.sessionId, cur);
-                }
-                catch {
-                    /* skip malformed line */
-                }
-            }
-            // Find stale-running candidates and append synthetic completions.
-            for (const state of bySession.values()) {
-                if (state.status !== 'running')
-                    continue;
-                if (state.reconciled)
-                    continue; // already cleaned
-                if (state.startedAt <= 0)
-                    continue; // safety: no time data
-                if (now - state.startedAt < STALE_AFTER_MS)
-                    continue;
-                // appendThreadEntry returns `seeded` (first-write flag), not a
-                // success signal. For an already-seeded file, the return is always
-                // false on both success and failure. Best-effort approach: count
-                // optimistically — write failures are rare and bounded by the
-                // function's own try/catch.
-                appendThreadEntry(slug, {
-                    type: 'task',
-                    sessionId: state.sessionId,
-                    status: 'crashed',
-                    completedAt: now,
-                    durationMs: now - state.startedAt,
-                    _reconciled: true,
-                });
-                reconciled++;
-                if (process.env.CODEHERE_DEBUG === '1') {
-                    const ageMin = Math.round((now - state.startedAt) / 60000);
-                    console.error(`[reconcile] ${slug}/${state.sessionId.slice(0, 8)} stale running for ${ageMin}m › crashed`);
-                }
-            }
-        }
-        catch {
-            /* per-project failure → continue */
-        }
-    }
-    return { scanned, reconciled };
-}
-export function hasManualOverride(slug) {
-    try {
-        const file = join(PROJECTS_DIR, slug, 'thread.jsonl');
-        if (!existsSync(file))
-            return false;
-        const content = readFileSync(file, 'utf-8');
-        for (const line of content.split('\n')) {
-            const t = line.trim();
-            if (!t)
-                continue;
-            try {
-                const rec = JSON.parse(t);
-                if (rec._meta === 'project-update' && rec.userOverride === true)
-                    return true;
-            }
-            catch {
-                // skip malformed line
-            }
-        }
-        return false;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * v0.6.x — user-initiated rename. The Title agent generates a title from the
- * first prompt, but project intent drifts (e.g. /agent dir gets titled "Scan
- * Auth File" forever even after 100+ unrelated tasks). This gives the user a
- * mechanism to override that title without re-firing the LLM-based agent.
- *
- * Returns { ok: false, error } on validation/fs failure so the HTTP layer can
- * surface a meaningful 4xx instead of a silent best-effort write. Note: this
- * is the only project-update path that returns errors — Title agent
- * appendMetaUpdate is silent because LLM hiccups are normal.
- */
-export function renameProject(slug, newTitle) {
-    // Validate slug shape — guards against path traversal in case the caller
-    // doesn't sanitize the URL parameter (HTTP layer validates this too, defense in depth).
-    if (!/^([a-f0-9]{12}|unknown)$/.test(slug)) {
-        return { ok: false, error: 'Invalid project slug' };
-    }
-    // Validate title — strip whitespace, enforce length and single-line.
-    const trimmed = newTitle.trim();
-    if (!trimmed)
-        return { ok: false, error: 'Title cannot be empty' };
-    if (trimmed.length > 100)
-        return { ok: false, error: 'Title too long (max 100 chars)' };
-    if (/[\n\r]/.test(trimmed))
-        return { ok: false, error: 'Title cannot contain newlines' };
-    // Verify project exists — appendMetaUpdate is silent on missing files but
-    // we want a clean 404 path for the HTTP caller.
-    const file = join(PROJECTS_DIR, slug, 'thread.jsonl');
-    if (!existsSync(file))
-        return { ok: false, error: 'Project not found' };
-    // userOverride:true tells the async Title agent + periodic backfill to skip
-    // writing for this slug — see hasManualOverride() above. Without this flag,
-    // a slow LLM call from spawn-time can land AFTER the user's rename and
-    // clobber it (the reader takes the latest project-update title).
-    if (!appendMetaUpdate(slug, { title: trimmed, userOverride: true })) {
-        return { ok: false, error: 'Write failed' };
-    }
-    return { ok: true };
-}
-/**
- * Archive (soft-delete) or restore a task. Append-only and audit-safe: writes an
- * `{_meta:'archived', sessionId, archived}` event to the thread (latest wins).
- * The task record is NEVER deleted — the proof stays; the room just hides it from
- * the active list. Restore = the same event with archived:false.
- */
-export function setTaskArchived(slug, sessionId, archived) {
-    if (!/^([a-f0-9]{12}|unknown)$/.test(slug))
-        return { ok: false, error: 'Invalid project slug' };
-    if (!sessionId || typeof sessionId !== 'string' || sessionId.length > 200 || /[\n\r]/.test(sessionId)) {
-        return { ok: false, error: 'Invalid sessionId' };
-    }
-    const file = join(PROJECTS_DIR, slug, 'thread.jsonl');
-    if (!existsSync(file))
-        return { ok: false, error: 'Project not found' };
-    try {
-        appendFileSync(file, JSON.stringify({ _meta: 'archived', slug, sessionId, archived: !!archived, updatedAt: Date.now() }) + '\n', 'utf-8');
-        return { ok: true };
-    }
-    catch {
-        return { ok: false, error: 'Write failed' };
-    }
-}
-/**
- * Mirror a spawn event to the project thread. Skips temp-dir cwds (matches
- * migration defaults) so test-artifact dirs don't pollute the project list.
- *
- * If this spawn is the FIRST task in a brand-new project (i.e., thread.jsonl
- * just got seeded), fire the hidden Title agent (v0.6.0 M9) in the background
- * to generate a 4-6 word title from the first user prompt. The title appears
- * in the project-meta as a 'project-update' record; readers take the latest
- * value. Title generation is best-effort and silent on failure.
- */
-export function mirrorSpawnedToThread(rec) {
-    if (isTempDir(rec.cwd))
-        return;
-    const slug = slugForCwd(rec.cwd);
-    const seeded = appendThreadEntry(slug, {
-        type: 'task',
-        sessionId: rec.sessionId,
-        agent: rec.agent,
-        prompt: rec.prompt,
-        cwd: rec.cwd,
-        startedAt: rec.startedAt,
-        status: 'running',
-        ...(rec.batchId ? { batchId: rec.batchId } : {}),
-        ...(rec.parentSessionId ? { parentSessionId: rec.parentSessionId } : {}),
-    });
-    if (seeded) {
-        // Seed an immediate cwd-derived title so the sidebar never shows a blank
-        // / placeholder while the LLM call is in flight (or if it fails entirely).
-        // The Title agent can later overwrite this with a richer prompt-derived
-        // title; user manual rename always wins over both.
-        if (!hasManualOverride(slug)) {
-            const fallback = titleFromCwd(rec.cwd);
-            appendMetaUpdate(slug, { title: fallback, cwd: rec.cwd });
-        }
-        // Detect + cache the git remote ONCE at project creation. Project identity
-        // (and clone-collapse in listProjects) reads this from _meta — no git
-        // shell-out on the hot read path. Only written when a remote is found;
-        // remote-less / non-repo projects are settled by the daemon-start backfill.
-        const remote = detectRemote(rec.cwd);
-        if (remote)
-            appendMetaUpdate(slug, { remote, _remoteChecked: true });
-        if (process.env.CODEHERE_DISABLE_TITLE_AGENT !== '1') {
-            // Fire Title agent in background; do not block the spawn path. Lazy-import
-            // to avoid loading the LLM module on every spawn when not needed.
-            void (async () => {
-                try {
-                    const { generateThreadTitle } = await import('../../application/use-cases/generate-thread-title.js');
-                    const title = await generateThreadTitle(rec.prompt, rec.cwd);
-                    // Last-moment manual-override check: between spawn and now (LLM call
-                    // can take seconds), user may have already renamed. Don't clobber.
-                    // Also: if Title agent returned null (garbage rejected, provider
-                    // unreachable, refusal), keep the cwd-derived fallback already seeded
-                    // above — never write `(untitled)` or empty.
-                    if (title && !hasManualOverride(slug)) {
-                        appendMetaUpdate(slug, { title, cwd: rec.cwd });
-                    }
-                }
-                catch {
-                    // best-effort — cwd fallback already seeded
-                }
-            })();
-        }
-    }
-}
-/**
- * Mirror a completion event to the project thread. Same skip rules as spawn.
- * Reader reconstructs by sessionId — this entry's fields override the spawn
- * entry's where they overlap (status flips from 'running' to actual final).
- */
-export function mirrorCompletedToThread(rec) {
-    if (isTempDir(rec.cwd))
-        return;
-    const slug = slugForCwd(rec.cwd);
-    appendThreadEntry(slug, {
-        type: 'task',
-        sessionId: rec.sessionId,
-        status: rec.status,
-        durationMs: rec.durationMs,
-        completedAt: rec.completedAt,
-        steps: rec.steps,
-        artifacts: rec.artifacts,
-    });
-}
-/**
- * Persist a generated Final Report summary to the project thread. The report is
- * produced ASYNC after the session exits, so mirrorCompletedToThread already ran
- * without it — this second append fills finalReport in. The reader merges task
- * records by sessionId field-by-field, so this partial entry layers onto the
- * existing completion record. Without it the summary lives only in the in-memory
- * cache + sessions.jsonl: the conversation view loses it on a daemon restart, and
- * a cross-agent hand-off reads "(no summary recorded)" instead of the real work.
- */
-export function mirrorFinalReportToThread(rec) {
-    if (isTempDir(rec.cwd))
-        return;
-    const slug = slugForCwd(rec.cwd);
-    appendThreadEntry(slug, {
-        type: 'task',
-        sessionId: rec.sessionId,
-        finalReport: { summary: rec.summary, ...(rec.source ? { source: rec.source } : {}) },
-    });
-}
-/** Label map for raw error codes → user-facing text. */
-const FAILOVER_LABELS = {
-    rate_limit: 'hit a rate limit',
-    quota_exceeded: 'exhausted its quota',
-    credit_low: 'ran low on credits',
-    error: 'encountered an error',
-};
-export function mirrorFailoverToThread(rec) {
-    if (isTempDir(rec.cwd))
-        return;
-    const slug = slugForCwd(rec.cwd);
-    const reasonLabel = FAILOVER_LABELS[rec.reason] ?? 'became unavailable';
-    const fromLabel = rec.fromAgent;
-    const toLabel = rec.toAgent;
-    appendThreadEntry(slug, {
-        type: 'task',
-        sessionId: rec.sessionId,
-        agent: 'system',
-        prompt: `Switched from ${fromLabel} to ${toLabel} (${reasonLabel}) — warm restart with context, not a state transfer`,
-        status: 'completed',
-        startedAt: Date.now(),
-        completedAt: Date.now(),
-        durationMs: 0,
-    });
-}
-export function mirrorReplyToThread(rec) {
-    if (isTempDir(rec.cwd))
-        return;
-    const slug = slugForCwd(rec.cwd);
-    appendThreadEntry(slug, {
-        type: 'task',
-        sessionId: rec.replySessionId,
-        parentSessionId: rec.parentSessionId,
-        agent: rec.agent,
-        prompt: rec.prompt,
-        cwd: rec.cwd,
-        startedAt: rec.startedAt,
-        completedAt: rec.completedAt,
-        durationMs: rec.durationMs,
-        status: 'completed',
-        ...(rec.result ? { result: rec.result } : {}),
-    });
-}
-//# sourceMappingURL=project-thread-mirror.js.map