codehere 0.6.0 → 0.6.2

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

@@ -22,14 +22,14 @@ import { buildGenericAdapter, loadAgentsConfig } from './generic-cli-adapter.js'
 import { buildConductorAdapter } from './conductor-adapter.js';
 import { seedAgentsConfig } from './agents-config-seed.js';
 import { AUDIT_FILE } from '../hooks/claude-sdk-hook.js';
-import { appendSpawned, appendCompleted, appendFinalReport, loadRecent } from './session-persistence.js';
+import { appendSpawned, appendCompleted, appendFinalReport, loadRecent, } from './session-persistence.js';
 import { generateFinalReport, printFinalReportToTerminal } from '../../application/use-cases/generate-final-report.js';
 import { mirrorSpawnedToThread, mirrorCompletedToThread } from '../storage/project-thread-mirror.js';
 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 { 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';
@@ -39,7 +39,13 @@ import { mirrorFailoverToThread } from '../storage/project-thread-mirror.js';
 // 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];
+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.
@@ -108,7 +114,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. */
@@ -142,16 +155,16 @@ export class SessionManager {
      *  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. */
+     *  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: 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" state instead
-      *  of leaving the UI showing "Generating report…" forever. */
+     *  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);
@@ -187,6 +200,7 @@ export class SessionManager {
         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.
@@ -297,7 +311,10 @@ export class SessionManager {
             // 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 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),
@@ -317,6 +334,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
@@ -388,29 +406,10 @@ export class SessionManager {
                 });
                 // 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);
-                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,
-                });
-                // Subscribe to the new session with the same failover logic
+                // 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;
@@ -456,14 +455,21 @@ export class SessionManager {
                             try {
                                 printFinalReportToTerminal(reportInput, report);
                             }
-                            catch { /* defensive */ }
+                            catch {
+                                /* defensive */
+                            }
                         }
                     })
-                        .catch(() => { });
+                        .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 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),
@@ -482,8 +488,36 @@ export class SessionManager {
                         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;
             }
@@ -501,13 +535,12 @@ export class SessionManager {
     /** Emitted when a failover offer is generated. The API layer listens
      *  to this to surface the banner in the web UI. */
     emitFailoverOffer(offer) {
-        // Store in a map that the API layer can poll — Slice E wires the
-        // /api/failover-offers endpoint to read from here.
         if (!this.failoverOffers) {
             this.failoverOffers = new Map();
         }
         const key = `${offer.session.sessionId}-${offer.target}`;
-        this.failoverOffers.set(key, offer);
+        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);
@@ -518,20 +551,20 @@ export class SessionManager {
         if (!this.failoverOffers)
             return [];
         const offers = [];
-        for (const [key, offer] of this.failoverOffers) {
+        for (const [key, { offer, createdAt }] of this.failoverOffers) {
             offers.push({
                 sessionId: offer.session.sessionId,
                 signal: offer.signal,
                 target: offer.target,
-                expiresAt: Date.now() + 60_000,
+                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. */
+     *  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)
@@ -565,32 +598,10 @@ export class SessionManager {
         });
         // Track the new session
         this.sessions.set(newSession.sessionId, newSession);
+        this.spawnOrder.push(newSession.sessionId);
         this.cwdBySession.set(newSession.sessionId, cwd);
-        // Session threading: record the parent-child relationship
-        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,
-        });
-        // Subscribe to the new session with the same failover logic
+        // Subscribe BEFORE persistence so exit events are never lost if the
+        // adapter exits synchronously.
         const unsubscribe = newSession.subscribe((event) => {
             if (event.type !== 'exit')
                 return;
@@ -636,14 +647,21 @@ export class SessionManager {
                     try {
                         printFinalReportToTerminal(reportInput, report);
                     }
-                    catch { /* defensive */ }
+                    catch {
+                        /* defensive */
+                    }
                 }
             })
-                .catch(() => { });
+                .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 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),
@@ -662,9 +680,34 @@ export class SessionManager {
                 clearInterval(t);
                 this.narrationTimers.delete(newSession.sessionId);
             }
-            this.startNarrationTimer(newSession);
+            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;
     }
@@ -698,7 +741,9 @@ export class SessionManager {
                 if (out)
                     this.narrationBySession.set(session.sessionId, out);
             })
-                .catch(() => { });
+                .catch(() => {
+                /* defensive — generateNarration never throws */
+            });
         }, intervalMs);
         this.narrationTimers.set(session.sessionId, timer);
     }
@@ -730,20 +775,52 @@ export class SessionManager {
         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". */
+     *  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());
     }
@@ -754,6 +831,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
@@ -879,5 +967,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

package/dist/infrastructure/protocols/cloud-sync.js

@@ -62,7 +62,7 @@ export function collectSessionMetadata() {
     }
     try {
         const content = readFileSync(SESSIONS_FILE, 'utf-8');
-        const lines = content.split('\n').filter(l => l.trim().length > 0);
+        const lines = content.split('\n').filter((l) => l.trim().length > 0);
         // Parse records and pair spawned + completed
         const spawnedMap = new Map();
         const completedMap = new Map();
@@ -89,9 +89,13 @@ export function collectSessionMetadata() {
             const completed = completedMap.get(id);
             const finalReport = finalReportMap.get(id);
             const status = completed
-                ? (completed.status === 'completed' ? 'done' : completed.status === 'failed' ? 'failed' : 'done')
+                ? completed.status === 'completed'
+                    ? 'done'
+                    : completed.status === 'failed'
+                        ? 'failed'
+                        : 'done'
                 : 'running';
-            const durationMs = completed?.durationMs ?? (Date.now() - spawned.startedAt);
+            const durationMs = completed?.durationMs ?? Date.now() - spawned.startedAt;
             const tools = completed?.steps?.length ?? 0;
             const files = completed?.artifacts?.filesChanged?.length ?? 0;
             const trustScore = extractTrustScore(completed?.artifacts);
@@ -151,7 +155,7 @@ export function startCloudSync(machineName) {
                 console.error(`  Cloud sync failed: ${res.status} ${body}`);
             }
             else {
-                const data = await res.json();
+                const data = (await res.json());
                 if (data.sessionsPushed && data.sessionsPushed > 0) {
                     console.log(`  Cloud sync: ${data.sessionsPushed} session(s) pushed`);
                 }
@@ -166,7 +170,7 @@ export function startCloudSync(machineName) {
             const res = await fetch(`${CLOUD_URL}?action=pull-tasks&machineId=${machineId}`);
             if (!res.ok)
                 return;
-            const data = await res.json();
+            const data = (await res.json());
             const tasks = data.tasks || [];
             for (const task of tasks) {
                 if (task.prompt) {