codehere 0.5.0-alpha.5 → 0.6.0-alpha.1

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

@@ -22,9 +22,12 @@ 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, 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';
 // ── 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
@@ -47,19 +50,25 @@ const REGISTRY = [
 // 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() }));
+    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) => {
-        if (a.checkReadiness)
-            return a.checkReadiness();
-        // Fallback for adapters that haven't implemented checkReadiness yet: treat
-        // "installed" as "ready", "not installed" as "needs_install without hint".
-        const installed = a.isInstalled();
-        return installed
-            ? { id: a.id, label: a.label, state: 'ready', installed: true }
-            : { id: a.id, label: a.label, state: 'needs_install', installed: false };
+        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) {
@@ -105,11 +114,24 @@ export class SessionManager {
      *  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();
     spawn(prompt, agentId = 'claude-code', options) {
         const adapter = getAdapter(agentId);
         if (!adapter) {
@@ -118,12 +140,31 @@ export class SessionManager {
         if (!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');
+        }
         const session = adapter.spawn(prompt, options);
         this.sessions.set(session.sessionId, session);
         // 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,
             agent: session.agent,
@@ -187,6 +228,17 @@ export class SessionManager {
                     // 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,
+                    });
                     try {
                         printFinalReportToTerminal(reportInput, report);
                     }
@@ -198,10 +250,61 @@ export class SessionManager {
                 .catch(() => {
                 // generateFinalReport never throws by contract; defensive only.
             });
+            // 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);
+            }
             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);
         return session;
     }
+    /** 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(() => { });
+        }, intervalMs);
+        this.narrationTimers.set(session.sessionId, timer);
+    }
+    /** 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;
@@ -213,6 +316,10 @@ export class SessionManager {
     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);
+    }
     /** 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

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

@@ -46,6 +46,27 @@ export function appendCompleted(rec) {
         /* best-effort */
     }
 }
+/**
+ * v0.6.x — persist a Final Report so it survives daemon restart.
+ *
+ * Pre-fix: Final Reports lived only in SessionManager.finalReportBySession
+ * (in-memory Map) and were lost on every daemon bounce. Founder hit this
+ * 2026-05-03 after a Mac restart: completed sessions showed
+ * "Generating report…" forever because there was no on-disk record + no
+ * "report-unavailable" state in the UI.
+ *
+ * Append-only: Final Report fires AFTER the CompletedRecord (generateFinalReport
+ * is async post-exit), so it gets its own record type. Reader merges by id.
+ */
+export function appendFinalReport(rec) {
+    try {
+        ensureDir();
+        appendFileSync(SESSIONS_FILE, JSON.stringify({ t: 'finalReport', ...rec }) + '\n', 'utf-8');
+    }
+    catch {
+        /* best-effort */
+    }
+}
 /**
  * Walk the session log backward, pair spawned+completed records by id, return
  * the most recent `limit` completed pairs sorted newest-first.
@@ -67,6 +88,9 @@ export function loadRecent(limit = 20) {
     }
     const spawned = new Map();
     const completed = [];
+    /** v0.6.x — Final Reports keyed by sessionId. Last write wins
+     *  (rare in practice; reports fire once per session). */
+    const finalReports = new Map();
     for (const line of content.split('\n')) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -82,6 +106,8 @@ export function loadRecent(limit = 20) {
             spawned.set(rec.id, rec);
         else if (rec.t === 'completed')
             completed.push(rec);
+        else if (rec.t === 'finalReport')
+            finalReports.set(rec.id, rec);
     }
     const merged = [];
     // Walk completed in reverse so we return newest-first
@@ -90,6 +116,7 @@ export function loadRecent(limit = 20) {
         const s = spawned.get(c.id);
         if (!s)
             continue; // orphan completed (shouldn't happen but harmless)
+        const fr = finalReports.get(c.id);
         merged.push({
             sessionId: s.id,
             agent: s.agent,
@@ -113,6 +140,7 @@ export function loadRecent(limit = 20) {
             completedAt: c.completedAt,
             steps: c.steps,
             artifacts: c.artifacts,
+            ...(fr ? { finalReport: { summary: fr.summary, generatedAt: fr.generatedAt, durationMs: fr.durationMs } } : {}),
             provenance: 'persisted',
         });
     }