codehere 0.6.0-alpha.1 → 0.6.1

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

@@ -28,6 +28,12 @@ import { mirrorSpawnedToThread, mirrorCompletedToThread } from '../storage/proje
 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, resolveChain } 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
@@ -102,7 +108,14 @@ function parseEtime(s) {
     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. */
@@ -132,6 +145,21 @@ export class SessionManager {
     narrationBySession = new Map();
     narrationTimers = new Map();
     narrationStepsAtLastFire = 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) {
@@ -158,12 +186,18 @@ export class SessionManager {
         if (!scan.allowed) {
             throw new Error(scan.blockReason || 'pre-prompt scan blocked the spawn');
         }
-        const session = adapter.spawn(prompt, options);
+        // 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.
-        const cwd = options?.cwd ?? process.cwd();
         this.cwdBySession.set(session.sessionId, cwd);
         appendSpawned({
             id: session.sessionId,
@@ -182,6 +216,20 @@ export class SessionManager {
             startedAt: session.startedAt,
         });
         const unsubscribe = session.subscribe((event) => {
+            // ── 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;
@@ -248,7 +296,28 @@ export class SessionManager {
                 }
             })
                 .catch(() => {
-                // generateFinalReport never throws by contract; defensive only.
+                // 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);
@@ -256,6 +325,7 @@ export class SessionManager {
                 clearInterval(t);
                 this.narrationTimers.delete(session.sessionId);
             }
+            this.evictOldCompleted();
             unsubscribe();
         });
         // v0.6 M3 — PM Narrator. Mid-task plain-English summaries fired
@@ -267,6 +337,357 @@ export class SessionManager {
         this.startNarrationTimer(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 chain = resolveChain(config?.chain);
+        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);
+                // 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) => {
+                    if (event.type !== 'exit')
+                        return;
+                    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,
+                    });
+                    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,
+                            });
+                            try {
+                                printFinalReportToTerminal(reportInput, report);
+                            }
+                            catch { /* defensive */ }
+                        }
+                    })
+                        .catch(() => { });
+                    // 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);
+                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}`;
+        const expiresAt = Date.now() + 60_000;
+        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 [key, { 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);
+        // Subscribe BEFORE persistence so exit events are never lost if the
+        // adapter exits synchronously.
+        const unsubscribe = newSession.subscribe((event) => {
+            if (event.type !== 'exit')
+                return;
+            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,
+            });
+            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,
+                    });
+                    try {
+                        printFinalReportToTerminal(reportInput, report);
+                    }
+                    catch { /* defensive */ }
+                }
+            })
+                .catch(() => { });
+            // 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);
+        return newSession;
+    }
     /** v0.6 M3 — periodic narration loop per session. */
     startNarrationTimer(session) {
         if (process.env.CODEHERE_DISABLE_NARRATOR === '1')
@@ -320,16 +741,61 @@ export class SessionManager {
     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. */
+      *  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.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());
     }
@@ -340,6 +806,17 @@ export class SessionManager {
         session.kill();
         return true;
     }
+    /** Graceful shutdown: kill all running sessions and clear all timers. */
+    shutdown() {
+        for (const [id, timer] of this.narrationTimers) {
+            clearInterval(timer);
+        }
+        this.narrationTimers.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
@@ -465,5 +942,19 @@ export class SessionManager {
     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);
 }
 //# sourceMappingURL=session-manager.js.map