codehere 0.8.0 → 1.0.2

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

@@ -1,1091 +0,0 @@
-/**
- * In-memory registry of active task sessions + audit-log derived observation.
- *
- * Two kinds of session surfaced to the UI:
- *   1. spawned   — started via codehere.spawn; we own the subprocess, can kill.
- *   2. observed  — derived from the audit log. Claude Code sessions running
- *                  in the user's terminals, IDE, or elsewhere on this machine.
- *                  codehere didn't start them and can't kill them, but shows
- *                  them so the dashboard reflects reality from first load.
- *
- * Durable state lives in the audit log (F0). On daemon restart, spawned
- * sessions are gone but observed ones remain (they're re-derived from the log).
- */
-import { existsSync, readFileSync } from 'fs';
-import { execFileSync } from 'child_process';
-import { ClaudeCodeAdapter } from './claude-code-adapter.js';
-import { CodexAdapter } from './codex-adapter.js';
-import { AiderAdapter } from './aider-adapter.js';
-import { OpenCodeAdapter } from './opencode-adapter.js';
-import { GeminiAdapter } from './gemini-adapter.js';
-import { buildGenericAdapter, loadAgentsConfig } from './generic-cli-adapter.js';
-import { buildConductorAdapter } from './conductor-adapter.js';
-import { recordTurnToWorkingMemory } from './memory-injector.js';
-import { seedAgentsConfig } from './agents-config-seed.js';
-import { AUDIT_FILE } from '../hooks/claude-sdk-hook.js';
-import { appendSpawned, appendCompleted, appendFinalReport, loadRecent, } from './session-persistence.js';
-import { generateFinalReport, printFinalReportToTerminal } from '../../application/use-cases/generate-final-report.js';
-import { mirrorSpawnedToThread, mirrorCompletedToThread } from '../storage/project-thread-mirror.js';
-import { scanPromptBeforeSpawn } from '../hooks/pre-prompt-scan.js';
-import { generateNarration } from '../../application/use-cases/generate-narration.js';
-import { randomUUID } from 'crypto';
-import { classifyFailoverEligibility } from './failover-classifier.js';
-import { resolveFailoverTarget, toAvailability } from './failover-policy.js';
-import { loadFailoverConfig } from './failover-config.js';
-import { enrichPromptWithPackSync, compileSessionPackSync, persistContextPack } from './graphify-context.js';
-import { buildFailoverHandoff, enrichPromptWithHandoff } from './context-handoff.js';
-import { mirrorFailoverToThread } 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
-// ~/.codehere/agents.yaml (generic-cli-adapter). isInstalled() gates visibility
-// so an adapter registering for an un-installed CLI is harmless.
-const BUILTIN_REGISTRY = [
-    ClaudeCodeAdapter,
-    CodexAdapter,
-    AiderAdapter,
-    OpenCodeAdapter,
-    GeminiAdapter,
-];
-// Seed the default agents.yaml if this user has never configured one, so Gemini
-// / Cursor / Pi / Antigravity / Goose appear in the registry pre-wired. They
-// stay hidden in the UI until isInstalled() flips to true. Idempotent.
-seedAgentsConfig();
-const REGISTRY = [
-    ...BUILTIN_REGISTRY,
-    // User-configurable adapters — "plug any CLI" escape hatch, seeded with
-    // popular CLI agents above. Users can add/edit/remove entries freely.
-    ...loadAgentsConfig().map(buildGenericAdapter),
-];
-// F6 Conductor — the meta-agent. Registered LAST so it sees the full registry
-// at lookup time. The lookup function is closed over `REGISTRY` so it always
-// returns the current populated array (including any future user adapters).
-// Conductor is appended to the same array so UIs that iterate REGISTRY see it.
-REGISTRY.push(buildConductorAdapter(() => REGISTRY));
-export function availableAgents() {
-    return REGISTRY.map((a) => ({
-        id: a.id,
-        label: a.label,
-        installed: a.isInstalled(),
-        ...(a.description ? { description: a.description } : {}),
-    }));
-}
-/** Per-agent readiness across the full registry. Powers the setup-aware UI. */
-export function readinessForAllAgents() {
-    return REGISTRY.map((a) => {
-        const base = a.checkReadiness
-            ? a.checkReadiness()
-            : a.isInstalled()
-                ? { id: a.id, label: a.label, state: 'ready', installed: true }
-                : { id: a.id, label: a.label, state: 'needs_install', installed: false };
-        // v0.6 S5 — mirror the adapter's "when to use me" description into the
-        // readiness payload so the dashboard dropdown can surface it as a
-        // plain-English hover tooltip without a separate API call.
-        return a.description ? { ...base, description: a.description } : base;
-    });
-}
-export function getAdapter(id) {
-    return REGISTRY.find((a) => a.id === id);
-}
-export function allAdapters() {
-    return REGISTRY;
-}
-export function agentProcessPatterns() {
-    return REGISTRY.map((a) => ({
-        regex: a.processPattern,
-        agent: a.id,
-        label: a.label,
-    }));
-}
-const DEFAULT_OBSERVED_WINDOW_MS = 10 * 60 * 1000; // 10 minutes
-function parseEtime(s) {
-    // ps etime formats: "MM:SS", "HH:MM:SS", "D-HH:MM:SS"
-    let rest = s;
-    let days = 0;
-    if (rest.includes('-')) {
-        const [d, r] = rest.split('-');
-        days = parseInt(d, 10) || 0;
-        rest = r;
-    }
-    const parts = rest.split(':').map((p) => parseInt(p, 10) || 0);
-    if (parts.length === 2)
-        return parts[0] * 60 + parts[1];
-    if (parts.length === 3)
-        return days * 86400 + parts[0] * 3600 + parts[1] * 60 + parts[2];
-    return 0;
-}
-export class SessionManager {
-    /** Max completed sessions kept in memory. Older sessions are evicted to
-     *  prevent unbounded memory growth in the internal tracking maps. The data
-     *  survives on disk via sessions.jsonl + thread.jsonl. */
-    static MAX_COMPLETED_SESSIONS = 100;
-    sessions = new Map();
-    /** Spawn order FIFO — used to evict oldest completed sessions when the cap
-     *  is reached. Pushed on spawn, referenced by evictOldCompleted(). */
-    spawnOrder = [];
-    /** Read-only sessions replayed from ~/.codehere/sessions.jsonl on daemon start.
-     *  These subprocesses are long-dead; we surface them so the user doesn't lose
-     *  their Final reports across restarts. */
-    persistedCache = loadRecent(20);
-    /** When a spawned session exits, we capture the completion timestamp here
-     *  so the API layer can show duration on still-in-memory sessions (the
-     *  TaskSession interface intentionally has no completedAt; only PersistedSession
-     *  does, so anything reading session.completedAt got undefined pre-fix).
-     *  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
-     *  users see the prose summary without opening a terminal. */
-    finalReportBySession = new Map();
-    /** v0.6 M3 · PM Narrator. Mid-task plain-English summaries cached per
-     *  session so the API can serve the latest narration without re-running
-     *  the LLM call on every frontend poll. Latest-only — older narrations
-     *  are overwritten when a new one fires. Per claim_user_persona HIGH:
-     *  non-technical users read narration, not tool calls. */
-    narrationBySession = new Map();
-    narrationTimers = new Map();
-    narrationStepsAtLastFire = new Map();
-    /** Stall watchdog (dogfood 2026-05-27 #1): a spawned agent can hang with no
-     *  output and sit "running" forever (opencode did exactly this). We track the
-     *  timestamp of the last event from each session and, if a running session
-     *  goes silent past the stall window, kill it and record an honest reason so
-     *  the UI shows "stopped — no response", never a fake "running" or a normal row. */
-    stallTimers = new Map();
-    lastActivityBySession = new Map();
-    stalledBySession = new Map();
-    /** Stores active failover offers keyed by sessionId+target. API layer
-     *  reads these via getFailoverOffers() for the /api/failover-offers endpoint. */
-    failoverOffers;
-    /** Tracks the failover error code per session so acceptFailover can emit
-     *  the correct reason in the thread event. Populated by handleFailover. */
-    failoverReasonBySession = new Map();
-    /** Session threading — tracks which session continued as which after failover.
-     *  continuedAsBySession: original → new session ID
-     *  continuedFromBySession: new → original session ID */
-    continuedAsBySession = new Map();
-    continuedFromBySession = new Map();
-    /** Final Report failure tracking — when generateFinalReport rejects, we
-     *  record it so the API can return a definitive "failed" status instead
-     *  of leaving the UI showing "Generating report…" forever. */
-    failedReportBySession = new Set();
-    spawn(prompt, agentId = 'claude-code', options) {
-        const adapter = getAdapter(agentId);
-        if (!adapter) {
-            throw new Error(`Unknown agent: ${agentId}. Registered: ${REGISTRY.map((a) => a.id).join(', ')}`);
-        }
-        // CODEHERE_MOCK spawns a synthetic agent (mock REPL), so the real CLI need
-        // not be installed — bypass the readiness gate. Makes the mock harness truly
-        // zero-dependency (dogfood/dev without any agent CLI installed).
-        const mockMode = process.env.CODEHERE_MOCK === '1' || process.env.CODEHERE_MOCK === 'true';
-        if (!mockMode && !adapter.isInstalled()) {
-            throw new Error(`Agent ${adapter.label} (${adapter.id}) is not installed on this machine`);
-        }
-        // Cross-vendor pre-prompt scan (task #110, slice 1). Closes the gap
-        // the FAQ now claims as "v0.5.x → v0.6 track": every adapter — not
-        // just claude-code — gets a safety scan on the user's prompt before
-        // spawn. Catches API-key paste, prompt-injection patterns, etc.
-        // Always writes one audit entry (synthetic toolName 'pre_prompt');
-        // refuses spawn ONLY when getHookMode() === 'block' AND the prompt
-        // has critical/high findings. Other modes (advisory/log-only/off)
-        // log + proceed.
-        const preScanSessionId = randomUUID();
-        const scan = scanPromptBeforeSpawn({
-            sessionId: preScanSessionId,
-            agent: agentId,
-            prompt,
-            cwd: options?.cwd,
-        });
-        if (!scan.allowed) {
-            throw new Error(scan.blockReason || 'pre-prompt scan blocked the spawn');
-        }
-        // P1 — graphify-ts structural memory: enrich prompt with compact context
-        // pack so the agent starts with a verified knowledge graph of the workspace.
-        // Respects CODEHERE_GRAPHIFY env var (auto|force|off, default=auto).
-        // Synchronous call — degrades to original prompt if graphify fails.
-        const cwd = options?.cwd ?? process.cwd();
-        const enrichedPrompt = enrichPromptWithPackSync(prompt, cwd);
-        const session = adapter.spawn(enrichedPrompt, options);
-        this.sessions.set(session.sessionId, session);
-        this.spawnOrder.push(session.sessionId);
-        // Persistence: write the spawned record immediately so a daemon crash still
-        // leaves an audit trail of what was attempted. Subscribe to exit so we can
-        // capture the final status + steps + artifacts when the session settles.
-        this.cwdBySession.set(session.sessionId, cwd);
-        appendSpawned({
-            id: session.sessionId,
-            agent: session.agent,
-            prompt,
-            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,
-        });
-        this.lastActivityBySession.set(session.sessionId, Date.now());
-        const unsubscribe = session.subscribe((event) => {
-            // Any event = the agent is alive. Reset the stall clock. (watchdog)
-            this.lastActivityBySession.set(session.sessionId, Date.now());
-            // ── Failover check — intercept rate-limit / quota errors before exit ──
-            // Adapters emit 'codehere:error' (structured: { code, message, recovery })
-            // or 'error' (spawn-level: { message }). Both need classification.
-            if (event.type === 'error' || event.type === 'codehere:error') {
-                const err = event.data;
-                if (err?.code && err?.message) {
-                    const signal = classifyFailoverEligibility(session.agent, err.code, err.message);
-                    if (signal) {
-                        const newSession = this.handleFailover(session, signal);
-                        if (newSession)
-                            return; // auto-spawned — keep listening on new session
-                    }
-                }
-            }
-            if (event.type !== 'exit')
-                return;
-            const data = event.data;
-            const completedAt = Date.now();
-            // Surface completedAt to API consumers reading the still-in-memory
-            // session (Bug 2 sister-fix, May 2). Without this, /api/tasks shows
-            // status=completed but no completedAt → NaN duration in the UI.
-            this.completedAtBySession.set(session.sessionId, completedAt);
-            appendCompleted({
-                id: session.sessionId,
-                status: session.status,
-                durationMs: Number(data?.durationMs ?? completedAt - session.startedAt),
-                completedAt,
-                steps: session.steps ? [...session.steps] : undefined,
-                artifacts: session.artifacts,
-                stalledReason: this.stalledBySession.get(session.sessionId)?.reason,
-            });
-            // 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,
-            // no UI integration in this MVP — terminal output only so the dogfood
-            // loop sees the artifact immediately. See `generate-final-report.ts`.
-            const reportInput = {
-                sessionId: session.sessionId,
-                prompt: session.prompt,
-                agent: session.agent,
-                status: session.status,
-                durationMs: completedAt - session.startedAt,
-                steps: session.steps ? [...session.steps] : [],
-                artifacts: session.artifacts,
-            };
-            generateFinalReport(reportInput)
-                .then((report) => {
-                if (report) {
-                    // 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,
-                        source: report.source,
-                    });
-                    // Shared-room hand-off: record this turn's outcome to the project's
-                    // working memory so the NEXT agent spawned here reads it (closes the
-                    // loop with applyMemoryPrefix). Best-effort; only initialized projects.
-                    try {
-                        recordTurnToWorkingMemory(cwd, {
-                            agent: session.agent,
-                            prompt: session.prompt,
-                            summary: report.summary,
-                            files: session.artifacts?.files?.length,
-                        });
-                    }
-                    catch {
-                        /* memory write must never break the run */
-                    }
-                    try {
-                        printFinalReportToTerminal(reportInput, report);
-                    }
-                    catch {
-                        // Don't let a print failure crash the daemon.
-                    }
-                }
-            })
-                .catch(() => {
-                // generateFinalReport rejected — record it so the UI can show
-                // "Report unavailable" instead of "Generating report…" forever.
-                this.failedReportBySession.add(session.sessionId);
-            });
-            // P1 — persist context pack at session exit for cross-session handoff (P2).
-            // Fire-and-forget: graphify-ts may not be installed, graph may be empty,
-            // or pack compilation may fail. All degrade silently.
-            void Promise.resolve().then(() => {
-                try {
-                    const stepsStr = session.steps
-                        ?.map((s) => `${s.label}: ${s.output || s.state}`)
-                        .filter(Boolean)
-                        .join('\n') ?? '';
-                    const pack = compileSessionPackSync(cwd, {
-                        prompt: session.prompt,
-                        artifacts: JSON.stringify(session.artifacts, null, 2),
-                        steps: stepsStr,
-                        agent: session.agent,
-                    });
-                    if (pack)
-                        persistContextPack(pack, cwd);
-                }
-                catch {
-                    // Silent degradation — context pack is enrichment, not the primary path.
-                }
-            });
-            // v0.6 M3 — clean up the narration timer for this session.
-            const t = this.narrationTimers.get(session.sessionId);
-            if (t) {
-                clearInterval(t);
-                this.narrationTimers.delete(session.sessionId);
-            }
-            // Watchdog: session settled on its own — stop watching it.
-            this.clearStallTimer(session.sessionId);
-            this.evictOldCompleted();
-            unsubscribe();
-        });
-        // v0.6 M3 — PM Narrator. Mid-task plain-English summaries fired
-        // every 30s while the session is running. Heuristic: only fire if
-        // the step count grew by ≥3 since the last narration (otherwise
-        // we'd narrate the same state with new words). Fire-and-forget;
-        // failures (no claude binary, timeout, malformed output) silently
-        // skip — narration is enrichment, not the primary surface.
-        this.startNarrationTimer(session);
-        this.startStallWatchdog(session);
-        return session;
-    }
-    /** Tracks which agents have already been tried for a given prompt during
-     *  a failover chain. Maps sessionId → set of agent ids already attempted. */
-    failoverTriedBySession = new Map();
-    /** v0.6.x failover — emit a failover offer when an adapter hits a
-     *  rate-limit / quota error. The offer is surfaced via the API layer
-     *  (Slice E) and optionally auto-spawned (Slice D). Returns the new
-     *  session if auto-spawn was triggered, undefined otherwise. */
-    handleFailover(session, signal) {
-        const config = loadFailoverConfig();
-        const tried = this.failoverTriedBySession.get(session.sessionId) ?? new Set();
-        tried.add(signal.fromAgent);
-        this.failoverTriedBySession.set(session.sessionId, tried);
-        const adapters = allAdapters();
-        const available = toAvailability(adapters, (a) => {
-            return a.id !== signal.fromAgent && a.isInstalled();
-        });
-        const target = resolveFailoverTarget({
-            failedAgent: signal.fromAgent,
-            alreadyTried: Array.from(tried),
-            available,
-            preferredChain: config?.chain,
-        });
-        if (!target)
-            return undefined;
-        const targetAdapter = getAdapter(target);
-        if (!targetAdapter || !targetAdapter.isInstalled())
-            return undefined;
-        // Auto-failover: spawn on the next agent in the chain
-        const autoFailover = config?.autoFailover ?? true;
-        if (autoFailover) {
-            // Spawn replacement session on the next agent, preserving prompt + cwd
-            const cwd = this.cwdBySession.get(session.sessionId) ?? process.cwd();
-            // P2 — build handoff context for continuity across agent swap
-            const handoff = buildFailoverHandoff(cwd, {
-                failedAgent: session.agent,
-                failedPrompt: session.prompt,
-            });
-            // Enrich prompt with handoff if available (P2)
-            const promptWithHandoff = handoff
-                ? enrichPromptWithHandoff(session.prompt, {
-                    packId: handoff.packId,
-                    agent: session.agent,
-                    prompt: session.prompt,
-                    status: 'failed',
-                    timestamp: handoff.timestamp,
-                    nodeCount: handoff.nodeCount,
-                    edgeCount: handoff.edgeCount,
-                    task: handoff.task,
-                    payloadPreview: handoff.payloadPreview,
-                })
-                : session.prompt;
-            try {
-                const newSession = targetAdapter.spawn(promptWithHandoff, {
-                    cwd,
-                    env: process.env,
-                    preferSubscription: true,
-                });
-                // Track this new session in the same way
-                this.sessions.set(newSession.sessionId, newSession);
-                this.spawnOrder.push(newSession.sessionId);
-                this.cwdBySession.set(newSession.sessionId, cwd);
-                this.lastActivityBySession.set(newSession.sessionId, Date.now());
-                // Subscribe BEFORE persistence so exit events are never lost if the
-                // adapter exits synchronously (command not found, instant crash, etc).
-                const unsubscribe = newSession.subscribe((event) => {
-                    this.lastActivityBySession.set(newSession.sessionId, Date.now());
-                    if (event.type !== 'exit')
-                        return;
-                    this.clearStallTimer(newSession.sessionId);
-                    const data = event.data;
-                    const completedAt = Date.now();
-                    this.completedAtBySession.set(newSession.sessionId, completedAt);
-                    appendCompleted({
-                        id: newSession.sessionId,
-                        status: newSession.status,
-                        durationMs: Number(data?.durationMs ?? completedAt - newSession.startedAt),
-                        completedAt,
-                        steps: newSession.steps ? [...newSession.steps] : undefined,
-                        artifacts: newSession.artifacts,
-                        stalledReason: this.stalledBySession.get(newSession.sessionId)?.reason,
-                    });
-                    mirrorCompletedToThread({
-                        sessionId: newSession.sessionId,
-                        cwd,
-                        status: newSession.status,
-                        durationMs: Number(data?.durationMs ?? completedAt - newSession.startedAt),
-                        completedAt,
-                        steps: newSession.steps ? [...newSession.steps] : undefined,
-                        artifacts: newSession.artifacts,
-                    });
-                    const reportInput = {
-                        sessionId: newSession.sessionId,
-                        prompt: newSession.prompt,
-                        agent: newSession.agent,
-                        status: newSession.status,
-                        durationMs: completedAt - newSession.startedAt,
-                        steps: newSession.steps ? [...newSession.steps] : [],
-                        artifacts: newSession.artifacts,
-                    };
-                    generateFinalReport(reportInput)
-                        .then((report) => {
-                        if (report) {
-                            this.finalReportBySession.set(newSession.sessionId, report);
-                            appendFinalReport({
-                                id: newSession.sessionId,
-                                summary: report.summary,
-                                generatedAt: report.generatedAt,
-                                durationMs: report.durationMs,
-                                source: report.source,
-                            });
-                            try {
-                                printFinalReportToTerminal(reportInput, report);
-                            }
-                            catch {
-                                /* defensive */
-                            }
-                        }
-                    })
-                        .catch(() => {
-                        /* defensive */
-                    });
-                    // P1 — persist context pack at failover-replacement session exit.
-                    void Promise.resolve().then(() => {
-                        try {
-                            const stepsStr = newSession.steps
-                                ?.map((s) => `${s.label}: ${s.output || s.state}`)
-                                .filter(Boolean)
-                                .join('\n') ?? '';
-                            const pack = compileSessionPackSync(cwd, {
-                                prompt: newSession.prompt,
-                                artifacts: JSON.stringify(newSession.artifacts, null, 2),
-                                steps: stepsStr,
-                                agent: newSession.agent,
-                            });
-                            if (pack)
-                                persistContextPack(pack, cwd);
-                        }
-                        catch {
-                            // Silent degradation — context pack is enrichment, not primary path.
-                        }
-                    });
-                    const t = this.narrationTimers.get(newSession.sessionId);
-                    if (t) {
-                        clearInterval(t);
-                        this.narrationTimers.delete(newSession.sessionId);
-                    }
-                    this.evictOldCompleted();
-                    unsubscribe();
-                });
-                // Persistence + threading — safe after subscribe because the exit
-                // handler is already registered. These can run even if the session
-                // already exited (spawned record still useful, exit handler handles
-                // the completion).
-                appendSpawned({
-                    id: newSession.sessionId,
-                    agent: newSession.agent,
-                    prompt: promptWithHandoff,
-                    cwd,
-                    startedAt: newSession.startedAt,
-                });
-                mirrorSpawnedToThread({
-                    sessionId: newSession.sessionId,
-                    agent: newSession.agent,
-                    prompt: promptWithHandoff,
-                    cwd,
-                    startedAt: newSession.startedAt,
-                });
-                mirrorFailoverToThread({
-                    sessionId: newSession.sessionId,
-                    fromAgent: signal.fromAgent,
-                    toAgent: target,
-                    reason: signal.errorCode,
-                    cwd,
-                });
-                this.continuedAsBySession.set(session.sessionId, newSession.sessionId);
-                this.continuedFromBySession.set(newSession.sessionId, session.sessionId);
-                this.startNarrationTimer(newSession);
-                this.startStallWatchdog(newSession);
-                return newSession;
-            }
-            catch {
-                // Spawn failed — fall through to offer-only mode
-                return undefined;
-            }
-        }
-        // Offer-only mode: signal the API layer to present a failover banner
-        // (Slice E handles the actual UI surfacing)
-        this.emitFailoverOffer({ session, signal, target });
-        this.failoverReasonBySession.set(session.sessionId, signal.errorCode);
-        return undefined;
-    }
-    /** Emitted when a failover offer is generated. The API layer listens
-     *  to this to surface the banner in the web UI. */
-    emitFailoverOffer(offer) {
-        if (!this.failoverOffers) {
-            this.failoverOffers = new Map();
-        }
-        const key = `${offer.session.sessionId}-${offer.target}`;
-        this.failoverOffers.set(key, { offer, createdAt: Date.now() });
-        // Auto-expire offers after 60 seconds to keep the map bounded
-        setTimeout(() => {
-            this.failoverOffers?.delete(key);
-        }, 60_000);
-    }
-    /** Get all active failover offers for the API layer. */
-    getFailoverOffers() {
-        if (!this.failoverOffers)
-            return [];
-        const offers = [];
-        for (const [, { offer, createdAt }] of this.failoverOffers) {
-            offers.push({
-                sessionId: offer.session.sessionId,
-                signal: offer.signal,
-                target: offer.target,
-                expiresAt: createdAt + 60_000,
-            });
-        }
-        return offers;
-    }
-    /** v0.6.x P0 — user-initiated failover accept. Spawns a replacement
-     *  session on the target agent, preserving the original prompt + cwd.
-     *  P2 — injects handoff context for cross-agent continuity.
-     *  Returns the new session or undefined if the target is unavailable. */
-    acceptFailover(sessionId, targetAgent) {
-        const session = this.sessions.get(sessionId);
-        if (!session)
-            return undefined;
-        const targetAdapter = getAdapter(targetAgent);
-        if (!targetAdapter || !targetAdapter.isInstalled())
-            return undefined;
-        const cwd = this.cwdBySession.get(sessionId) ?? process.cwd();
-        // P2 — build handoff context for continuity across agent swap
-        const handoff = buildFailoverHandoff(cwd, {
-            failedAgent: session.agent,
-            failedPrompt: session.prompt,
-        });
-        const promptWithHandoff = handoff
-            ? enrichPromptWithHandoff(session.prompt, {
-                packId: handoff.packId,
-                agent: session.agent,
-                prompt: session.prompt,
-                status: 'failed',
-                timestamp: handoff.timestamp,
-                nodeCount: handoff.nodeCount,
-                edgeCount: handoff.edgeCount,
-                task: handoff.task,
-                payloadPreview: handoff.payloadPreview,
-            })
-            : session.prompt;
-        const newSession = targetAdapter.spawn(promptWithHandoff, {
-            cwd,
-            env: process.env,
-            preferSubscription: true,
-        });
-        // Track the new session
-        this.sessions.set(newSession.sessionId, newSession);
-        this.spawnOrder.push(newSession.sessionId);
-        this.cwdBySession.set(newSession.sessionId, cwd);
-        this.lastActivityBySession.set(newSession.sessionId, Date.now());
-        // Subscribe BEFORE persistence so exit events are never lost if the
-        // adapter exits synchronously.
-        const unsubscribe = newSession.subscribe((event) => {
-            this.lastActivityBySession.set(newSession.sessionId, Date.now());
-            if (event.type !== 'exit')
-                return;
-            this.clearStallTimer(newSession.sessionId);
-            const data = event.data;
-            const completedAt = Date.now();
-            this.completedAtBySession.set(newSession.sessionId, completedAt);
-            appendCompleted({
-                id: newSession.sessionId,
-                status: newSession.status,
-                durationMs: Number(data?.durationMs ?? completedAt - newSession.startedAt),
-                completedAt,
-                steps: newSession.steps ? [...newSession.steps] : undefined,
-                artifacts: newSession.artifacts,
-                stalledReason: this.stalledBySession.get(newSession.sessionId)?.reason,
-            });
-            mirrorCompletedToThread({
-                sessionId: newSession.sessionId,
-                cwd,
-                status: newSession.status,
-                durationMs: Number(data?.durationMs ?? completedAt - newSession.startedAt),
-                completedAt,
-                steps: newSession.steps ? [...newSession.steps] : undefined,
-                artifacts: newSession.artifacts,
-            });
-            const reportInput = {
-                sessionId: newSession.sessionId,
-                prompt: newSession.prompt,
-                agent: newSession.agent,
-                status: newSession.status,
-                durationMs: completedAt - newSession.startedAt,
-                steps: newSession.steps ? [...newSession.steps] : [],
-                artifacts: newSession.artifacts,
-            };
-            generateFinalReport(reportInput)
-                .then((report) => {
-                if (report) {
-                    this.finalReportBySession.set(newSession.sessionId, report);
-                    appendFinalReport({
-                        id: newSession.sessionId,
-                        summary: report.summary,
-                        generatedAt: report.generatedAt,
-                        durationMs: report.durationMs,
-                        source: report.source,
-                    });
-                    try {
-                        printFinalReportToTerminal(reportInput, report);
-                    }
-                    catch {
-                        /* defensive */
-                    }
-                }
-            })
-                .catch(() => {
-                /* defensive */
-            });
-            // P1 — persist context pack at accept-failover replacement session exit.
-            void Promise.resolve().then(() => {
-                try {
-                    const stepsStr = newSession.steps
-                        ?.map((s) => `${s.label}: ${s.output || s.state}`)
-                        .filter(Boolean)
-                        .join('\n') ?? '';
-                    const pack = compileSessionPackSync(cwd, {
-                        prompt: newSession.prompt,
-                        artifacts: JSON.stringify(newSession.artifacts, null, 2),
-                        steps: stepsStr,
-                        agent: newSession.agent,
-                    });
-                    if (pack)
-                        persistContextPack(pack, cwd);
-                }
-                catch {
-                    // Silent degradation — context pack is enrichment, not primary path.
-                }
-            });
-            const t = this.narrationTimers.get(newSession.sessionId);
-            if (t) {
-                clearInterval(t);
-                this.narrationTimers.delete(newSession.sessionId);
-            }
-            this.evictOldCompleted();
-            unsubscribe();
-        });
-        // Persistence + threading — safe after subscribe because the exit
-        // handler is already registered.
-        this.continuedAsBySession.set(sessionId, newSession.sessionId);
-        this.continuedFromBySession.set(newSession.sessionId, sessionId);
-        appendSpawned({
-            id: newSession.sessionId,
-            agent: newSession.agent,
-            prompt: promptWithHandoff,
-            cwd,
-            startedAt: newSession.startedAt,
-        });
-        mirrorSpawnedToThread({
-            sessionId: newSession.sessionId,
-            agent: newSession.agent,
-            prompt: promptWithHandoff,
-            cwd,
-            startedAt: newSession.startedAt,
-        });
-        mirrorFailoverToThread({
-            sessionId: newSession.sessionId,
-            fromAgent: session.agent,
-            toAgent: targetAgent,
-            reason: this.failoverReasonBySession.get(session.sessionId) ?? 'error',
-            cwd,
-        });
-        this.startNarrationTimer(newSession);
-        this.startStallWatchdog(newSession);
-        return newSession;
-    }
-    /** v0.6 M3 — periodic narration loop per session. */
-    startNarrationTimer(session) {
-        if (process.env.CODEHERE_DISABLE_NARRATOR === '1')
-            return;
-        this.narrationStepsAtLastFire.set(session.sessionId, 0);
-        const intervalMs = Number(process.env.CODEHERE_NARRATOR_INTERVAL_MS ?? 30_000);
-        const minStepDelta = Number(process.env.CODEHERE_NARRATOR_MIN_STEPS ?? 3);
-        const timer = setInterval(() => {
-            // Skip if session has settled.
-            if (session.status !== 'running')
-                return;
-            const steps = session.steps ?? [];
-            const lastFireSteps = this.narrationStepsAtLastFire.get(session.sessionId) ?? 0;
-            if (steps.length - lastFireSteps < minStepDelta)
-                return;
-            // Mark BEFORE the async call to prevent double-firing if the LLM
-            // is slow.
-            this.narrationStepsAtLastFire.set(session.sessionId, steps.length);
-            const elapsedMs = Date.now() - session.startedAt;
-            void generateNarration({
-                sessionId: session.sessionId,
-                prompt: session.prompt,
-                agent: session.agent,
-                elapsedMs,
-                steps: [...steps],
-            })
-                .then((out) => {
-                if (out)
-                    this.narrationBySession.set(session.sessionId, out);
-            })
-                .catch(() => {
-                /* defensive — generateNarration never throws */
-            });
-        }, intervalMs);
-        this.narrationTimers.set(session.sessionId, timer);
-    }
-    /** Stall watchdog (dogfood 2026-05-27 #1). Polls a running session; if no
-     *  event has arrived within the stall window, kills it and records an honest
-     *  reason. Cross-agent — opencode hung, but any adapter can. Timings are
-     *  env-overridable so the mock harness + tests can drive it fast. Disable
-     *  entirely with CODEHERE_DISABLE_WATCHDOG=1. */
-    startStallWatchdog(session) {
-        if (process.env.CODEHERE_DISABLE_WATCHDOG === '1')
-            return;
-        const stallMs = Number(process.env.CODEHERE_STALL_TIMEOUT_MS ?? 180_000);
-        const pollMs = Number(process.env.CODEHERE_STALL_POLL_MS ?? 15_000);
-        if (!(stallMs > 0) || !(pollMs > 0))
-            return;
-        const timer = setInterval(() => {
-            if (session.status !== 'running') {
-                this.clearStallTimer(session.sessionId);
-                return;
-            }
-            const last = this.lastActivityBySession.get(session.sessionId) ?? session.startedAt;
-            const silentMs = Date.now() - last;
-            if (silentMs < stallMs)
-                return;
-            const reason = `Stopped after no response for ${Math.round(silentMs / 1000)}s — the agent hung without finishing.`;
-            this.stalledBySession.set(session.sessionId, { reason, stalledAt: Date.now() });
-            this.clearStallTimer(session.sessionId);
-            try {
-                session.kill();
-            }
-            catch {
-                // kill is best-effort; the recorded stall reason + 'killed' status is
-                // what the UI reads, so a kill that throws still surfaces honestly.
-            }
-        }, pollMs);
-        this.stallTimers.set(session.sessionId, timer);
-    }
-    clearStallTimer(sessionId) {
-        const t = this.stallTimers.get(sessionId);
-        if (t) {
-            clearInterval(t);
-            this.stallTimers.delete(sessionId);
-        }
-    }
-    /** Watchdog verdict for a session — the honest "why it stopped" reason when
-     *  the stall watchdog killed it, or undefined if it settled on its own.
-     *  The API layer surfaces this so the dashboard never shows a hung task as a
-     *  normal row. */
-    getStallReason(sessionId) {
-        return this.stalledBySession.get(sessionId)?.reason;
-    }
-    /** v0.6 M3 — latest narration for a session, or undefined. */
-    getNarration(sessionId) {
-        return this.narrationBySession.get(sessionId);
-    }
-    /** Persisted (read-only) sessions from prior daemon runs. Cached at boot. */
-    listPersisted() {
-        return this.persistedCache;
-    }
-    /** Completion timestamp for an in-memory session, if it has exited.
-     *  Returns undefined if the session is still running OR was never spawned
-     *  through this manager. Bug 2 sister-fix (May 2): TaskSession itself has
-     *  no completedAt field; this method lets the API layer compute durations. */
-    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);
-    }
-    /** Session threading — which session did this one continue from (after failover)? */
-    getContinuedFrom(sessionId) {
-        return this.continuedFromBySession.get(sessionId);
-    }
-    /** Session threading — which session did this one continue as (after failover)? */
-    getContinuedAs(sessionId) {
-        return this.continuedAsBySession.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
-     *  through the /api/tasks serializer to render the prose summary inline. */
-    getFinalReport(sessionId) {
-        return this.finalReportBySession.get(sessionId);
-    }
-    /** Returns true if Final Report generation explicitly failed for this session.
-     *  Lets the API distinguish "not yet" from "never coming". */
-    hasFailedReport(sessionId) {
-        return this.failedReportBySession.has(sessionId);
-    }
-    get(sessionId) {
-        return this.sessions.get(sessionId);
-    }
-    /** Evict the oldest completed sessions when the in-memory cap is reached.
-     *  Prevents unbounded memory growth in the internal tracking maps. The
-     *  data survives on disk via sessions.jsonl + thread.jsonl. */
-    evictOldCompleted() {
-        const completed = [];
-        for (const id of this.spawnOrder) {
-            const at = this.completedAtBySession.get(id);
-            if (at !== undefined)
-                completed.push({ id, completedAt: at });
-        }
-        if (completed.length <= SessionManager.MAX_COMPLETED_SESSIONS)
-            return;
-        const toEvict = completed.slice(0, completed.length - SessionManager.MAX_COMPLETED_SESSIONS);
-        const evictSet = new Set(toEvict.map((e) => e.id));
-        for (const id of evictSet) {
-            const t = this.narrationTimers.get(id);
-            if (t) {
-                clearInterval(t);
-                this.narrationTimers.delete(id);
-            }
-            this.clearStallTimer(id);
-            this.lastActivityBySession.delete(id);
-            this.stalledBySession.delete(id);
-            this.sessions.delete(id);
-            this.completedAtBySession.delete(id);
-            this.cwdBySession.delete(id);
-            this.finalReportBySession.delete(id);
-            this.narrationBySession.delete(id);
-            this.failoverReasonBySession.delete(id);
-            this.continuedAsBySession.delete(id);
-            this.continuedFromBySession.delete(id);
-            this.failedReportBySession.delete(id);
-            this.failoverTriedBySession.delete(id);
-        }
-    }
-    list() {
-        return Array.from(this.sessions.values());
-    }
-    kill(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session)
-            return false;
-        session.kill();
-        return true;
-    }
-    /** Graceful shutdown: kill all running sessions and clear all timers. */
-    shutdown() {
-        for (const [, timer] of this.narrationTimers) {
-            clearInterval(timer);
-        }
-        this.narrationTimers.clear();
-        for (const [, timer] of this.stallTimers) {
-            clearInterval(timer);
-        }
-        this.stallTimers.clear();
-        for (const session of this.sessions.values()) {
-            if (session.status === 'running')
-                session.kill();
-        }
-    }
-    /**
-     * Active Claude Code sessions on this machine, derived from the audit log.
-     * A session is "active" if any tool call from it was recorded within the
-     * last `maxAgeMs` milliseconds. Returns most-recent first.
-     *
-     * Note: codehere-spawned sessions may also appear here because they produce
-     * audit entries just like any other Claude Code session. The UI distinguishes
-     * by provenance.
-     */
-    listObserved(maxAgeMs = DEFAULT_OBSERVED_WINDOW_MS) {
-        if (!existsSync(AUDIT_FILE))
-            return [];
-        const now = Date.now();
-        const cutoff = now - maxAgeMs;
-        const byId = new Map();
-        let content;
-        try {
-            content = readFileSync(AUDIT_FILE, 'utf-8');
-        }
-        catch {
-            return [];
-        }
-        const lines = content.split('\n');
-        // Walk backwards — most recent lines first — and stop early when we
-        // pass the window. Audit log appends chronologically.
-        for (let i = lines.length - 1; i >= 0; i--) {
-            const line = lines[i].trim();
-            if (!line)
-                continue;
-            let entry;
-            try {
-                entry = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (!entry.sessionId)
-                continue;
-            const ts = typeof entry.timestamp === 'number'
-                ? entry.timestamp
-                : entry.timestamp
-                    ? Date.parse(String(entry.timestamp))
-                    : 0;
-            if (!ts)
-                continue;
-            if (ts < cutoff)
-                break; // past the window; older entries can't qualify
-            const existing = byId.get(entry.sessionId);
-            if (existing) {
-                existing.eventCount += 1;
-                if (ts < existing.firstEventAt)
-                    existing.firstEventAt = ts;
-            }
-            else {
-                byId.set(entry.sessionId, {
-                    sessionId: entry.sessionId,
-                    firstEventAt: ts,
-                    lastEventAt: ts,
-                    eventCount: 1,
-                    recentTool: entry.toolName,
-                    provenance: 'observed',
-                });
-            }
-        }
-        return Array.from(byId.values()).sort((a, b) => b.lastEventAt - a.lastEventAt);
-    }
-    /**
-     * Agent processes running on this machine right now.
-     * Enumerates via `ps`, filters to known agent executables, returns most
-     * recently started first. This is the primary F1d surface — it reflects
-     * "what AI agents are alive on your machine" independent of whether
-     * they've produced audit events yet.
-     */
-    listActiveAgents() {
-        let out;
-        try {
-            out = execFileSync('ps', ['-A', '-o', 'pid,tty,etime,args'], {
-                encoding: 'utf-8',
-                timeout: 2000,
-            });
-        }
-        catch {
-            return [];
-        }
-        const agents = [];
-        const lines = out.trim().split('\n').slice(1); // drop header
-        for (const line of lines) {
-            const m = line.trim().match(/^(\d+)\s+(\S+)\s+(\S+)\s+(.+)$/);
-            if (!m)
-                continue;
-            const [, pidStr, tty, etime, args] = m;
-            // Skip ourselves — the codehere daemon would otherwise show up repeatedly
-            if (/\bcodehere\b|\bch\s+start\b/.test(args))
-                continue;
-            // Skip the audit tailer from other codehere commands
-            if (/scan-tool|codehere-audit/.test(args))
-                continue;
-            let matched = null;
-            for (const p of agentProcessPatterns()) {
-                if (p.regex.test(args)) {
-                    matched = { agent: p.agent, label: p.label };
-                    break;
-                }
-            }
-            if (!matched)
-                continue;
-            const uptimeSeconds = parseEtime(etime);
-            const startedAt = Date.now() - uptimeSeconds * 1000;
-            agents.push({
-                pid: parseInt(pidStr, 10),
-                tty,
-                agent: matched.agent,
-                label: matched.label,
-                args: args.length > 200 ? args.slice(0, 200) + '…' : args,
-                startedAt,
-                uptimeSeconds,
-                provenance: 'detected',
-            });
-        }
-        return agents.sort((a, b) => b.startedAt - a.startedAt);
-    }
-    static _instance;
-    static getInstance() {
-        return (this._instance ??= new SessionManager());
-    }
-    /** @internal Resets the singleton for test isolation. */
-    static __testOnlyReset() {
-        this._instance = undefined;
-    }
-}
-// ── Test seam ─────────────────────────────────────────────────────────────────
-// Avoids refactoring the module-level REGISTRY const to DI. Usage:
-//   import { __testOnlyRegisterAdapter, SessionManager } from '...';
-//   __testOnlyRegisterAdapter(mockAdapter);
-//   SessionManager.__testOnlyReset();
-//   const sm = SessionManager.getInstance();
-/** @internal Exported for testing only — allows mock adapter injection. */
-export function __testOnlyRegisterAdapter(adapter) {
-    REGISTRY.push(adapter);
-}
-/** @internal Resets REGISTRY to BUILTIN_REGISTRY for test isolation.
- *  Call before __testOnlyRegisterAdapter to avoid adapter accumulation. */
-export function __testOnlyResetRegistry() {
-    REGISTRY.length = 0;
-    REGISTRY.push(...BUILTIN_REGISTRY);
-}
-//# sourceMappingURL=session-manager.js.map