codehere 0.8.0 → 1.0.2

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

@@ -1,524 +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';
-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);
-}
-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-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 };
-}
-/**
- * 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',
-    });
-    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 });
-        }
-        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,
-    });
-}
-/** 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})`,
-        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

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

@@ -1,172 +0,0 @@
-/**
- * Project thread reader — v0.6.0 M1 (UI-prep slice).
- *
- * Reads ~/.codehere/projects/<slug>/thread.jsonl files and reconstructs
- * the per-project thread state for API consumers (the new UI rendering
- * the persistent project thread shape).
- *
- * Reconstruction rules:
- *   - One file per project, identified by slug (sha1(cwd)[:12])
- *   - First line is `{_meta: 'project', ...}` — project header
- *   - Subsequent lines are `{_meta: 'project-update', ...}` (latest wins per
- *     field — Title agent uses this to set the title) OR `{type: 'task', ...}`
- *     (per-session entries; later entries with same sessionId override
- *     earlier — covers spawn entry → completion entry update)
- *
- * NOT in scope of this module:
- *   - Writing (handled by project-thread-mirror + project-thread-migration)
- *   - UI rendering (the new thread view will consume this reader's output)
- *   - Live SSE updates (polling is fine for the alpha; SSE in v0.6.x patch)
- */
-import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-const DEFAULT_PROJECTS_DIR = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'projects');
-/** List all known projects with summary stats. Cheap; no full task content. */
-export function listProjects(options) {
-    const root = options?.projectsDir ?? DEFAULT_PROJECTS_DIR;
-    if (!existsSync(root))
-        return [];
-    let stat;
-    try {
-        stat = statSync(root);
-    }
-    catch {
-        return [];
-    }
-    if (!stat.isDirectory())
-        return [];
-    const slugs = readdirSync(root).filter((entry) => {
-        const p = join(root, entry);
-        try {
-            return statSync(p).isDirectory();
-        }
-        catch {
-            return false;
-        }
-    });
-    const summaries = [];
-    for (const slug of slugs) {
-        // Pattern 4 — sidebar presence dots need agent attribution per project.
-        // Pull the full task list (lightweight — agent + startedAt only) so we
-        // can compute lastAgent + recentAgents (multi-agent stack). taskLimit:0
-        // would drop the data we need; fetch unbounded but discard the heavy
-        // fields (steps + artifacts) below.
-        const thread = readProjectThread(slug, { projectsDir: root });
-        if (thread) {
-            const agentChrono = thread.tasks
-                .filter((t) => typeof t.agent === 'string' && t.agent)
-                .sort((a, b) => b.startedAt - a.startedAt) // most-recent first
-                .map((t) => t.agent);
-            const lastAgent = agentChrono.length > 0 ? agentChrono[0] : null;
-            const seen = new Set();
-            const recentAgents = [];
-            for (const a of agentChrono) {
-                if (seen.has(a))
-                    continue;
-                seen.add(a);
-                recentAgents.push(a);
-                if (recentAgents.length >= 3)
-                    break;
-            }
-            summaries.push({
-                slug: thread.slug,
-                cwd: thread.cwd,
-                title: thread.title,
-                taskCount: thread.taskCount,
-                lastActivityAt: thread.lastActivityAt,
-                lastAgent,
-                recentAgents,
-            });
-        }
-    }
-    // Sort by recency (most recent first)
-    summaries.sort((a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0));
-    return summaries;
-}
-/** Read a single project thread by slug. Returns null if not found. */
-export function readProjectThread(slug, options) {
-    const root = options?.projectsDir ?? DEFAULT_PROJECTS_DIR;
-    const file = join(root, slug, 'thread.jsonl');
-    if (!existsSync(file))
-        return null;
-    let content;
-    try {
-        content = readFileSync(file, 'utf-8');
-    }
-    catch {
-        return null;
-    }
-    let cwd = null;
-    let title = null;
-    const tasksById = new Map();
-    for (const line of content.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        let rec;
-        try {
-            rec = JSON.parse(trimmed);
-        }
-        catch {
-            continue;
-        }
-        if (rec._meta === 'project') {
-            if (typeof rec.cwd === 'string')
-                cwd = rec.cwd;
-            if (typeof rec.title === 'string')
-                title = rec.title;
-        }
-        else if (rec._meta === 'project-update') {
-            if (typeof rec.title === 'string')
-                title = rec.title;
-            if (typeof rec.cwd === 'string' && cwd === null)
-                cwd = rec.cwd;
-        }
-        else if (rec.type === 'task' && typeof rec.sessionId === 'string') {
-            const existing = tasksById.get(rec.sessionId) ?? {
-                sessionId: rec.sessionId,
-                agent: '',
-                prompt: '',
-                cwd: '',
-                startedAt: 0,
-            };
-            // Merge fields — later entries override earlier (covers
-            // spawn → completion update pattern from forward-mirror)
-            for (const k of [
-                'agent',
-                'prompt',
-                'cwd',
-                'startedAt',
-                'status',
-                'durationMs',
-                'completedAt',
-                'steps',
-                'artifacts',
-            ]) {
-                if (rec[k] !== undefined) {
-                    existing[k] = rec[k];
-                }
-            }
-            tasksById.set(rec.sessionId, existing);
-        }
-    }
-    const tasks = [...tasksById.values()].sort((a, b) => a.startedAt - b.startedAt);
-    const lastActivityAt = tasks.reduce((acc, t) => {
-        const ts = t.completedAt ?? t.startedAt;
-        if (ts && (acc === null || ts > acc))
-            return ts;
-        return acc;
-    }, null);
-    const limit = options?.taskLimit;
-    const cappedTasks = limit === undefined ? tasks : limit === 0 ? [] : tasks.slice(-limit);
-    return {
-        slug,
-        cwd,
-        title,
-        taskCount: tasks.length,
-        tasks: cappedTasks,
-        lastActivityAt,
-    };
-}
-//# sourceMappingURL=project-thread-reader.js.map