codehere 0.5.0-alpha.5 → 0.5.0-alpha.6

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

@@ -22,7 +22,7 @@ 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';
 // ── Agent registry ─────────────────────────────────────────────────────────────
@@ -105,6 +105,11 @@ 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
@@ -124,6 +129,7 @@ export class SessionManager {
         // 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 +193,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);
                     }
@@ -213,6 +230,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',
         });
     }

package/dist/infrastructure/protocols/mcp-server-impl.js

@@ -30,6 +30,8 @@ import { SessionManager, availableAgents, readinessForAllAgents, getAdapter, all
 import { isAbsolute } from 'path';
 import { readCrossToolAgents } from '../storage/cross-tool-agents.js';
 import { listProjects, readProjectThread } from '../storage/project-thread-reader.js';
+import { mirrorReplyToThread } from '../storage/project-thread-mirror.js';
+import { randomUUID } from 'crypto';
 import { installAgent } from '../orchestration/agent-installer.js';
 import { detectReadiness } from '../orchestration/readiness.js';
 // ── Tool definitions ─────────────────────────────────────────────────────────
@@ -653,6 +655,7 @@ export function startMCPServer(options = {}) {
                     // in completedAtBySession map (populated when exit event fires).
                     const completedAt = manager.getCompletedAt(s.sessionId);
                     const finalReport = manager.getFinalReport(s.sessionId);
+                    const cwd = manager.getCwd(s.sessionId);
                     return {
                         sessionId: s.sessionId,
                         prompt: s.prompt,
@@ -666,6 +669,10 @@ export function startMCPServer(options = {}) {
                         // Iter 12 — surface canAppendMessage so the UI knows whether to
                         // render the reply input or a disabled "follow-up unsupported" state.
                         canAppendMessage: s.canAppendMessage === true,
+                        // v0.6.x Slack-shape spike — surface cwd so the dashboard's
+                        // "Continue thread" intake button can find the most recent
+                        // in-memory session for the current folder.
+                        ...(cwd !== undefined ? { cwd } : {}),
                         provenance: 'spawned',
                     };
                 });
@@ -743,7 +750,32 @@ export function startMCPServer(options = {}) {
                                 res.end(JSON.stringify({ error: 'text is required' }));
                                 return;
                             }
+                            const replyStartedAt = Date.now();
                             const out = await session.appendMessage(text);
+                            const replyCompletedAt = Date.now();
+                            // v0.6.x — forward-mirror the reply turn into the project thread
+                            // so /threads sees follow-ups as visible chronological turns
+                            // (not just the original spawn). Best-effort: mirror failures
+                            // never break the reply path.
+                            try {
+                                const replyCwd = manager.getCwd(sessionId);
+                                if (replyCwd) {
+                                    mirrorReplyToThread({
+                                        parentSessionId: sessionId,
+                                        replySessionId: randomUUID(),
+                                        agent: session.agent,
+                                        prompt: text,
+                                        cwd: replyCwd,
+                                        startedAt: replyStartedAt,
+                                        completedAt: replyCompletedAt,
+                                        durationMs: out.durationMs,
+                                        result: out.result,
+                                    });
+                                }
+                            }
+                            catch {
+                                /* mirror is best-effort */
+                            }
                             res.writeHead(200, { 'Content-Type': 'application/json' });
                             res.end(JSON.stringify({ sessionId, ...out }));
                         }

package/dist/infrastructure/protocols/ui-page.js

@@ -515,12 +515,14 @@ ${SHARED_STYLES}
   <a href="/" class="nav-link">Tasks</a>
   <a href="/threads" class="nav-link">Threads</a>
   <a href="/history" class="nav-link active">History</a>
-  <span style="color:var(--fg-40);font-family:var(--mono);font-size:11px;">
-    <span id="live-dot" class="dot"></span><span id="conn">connecting</span>
-  </span>
 </nav>
 
-<div class="tagline" style="margin-top:90px">One feed. Every agent. Every action.</div>
+<div class="tagline" style="margin-top:90px">
+  One feed. Every agent. Every action.
+  <span class="conn-inline" style="margin-left:12px;font-family:var(--mono);font-size:10px;color:var(--fg-40);">
+    <span id="live-dot" class="dot"></span><span id="conn">connecting</span>
+  </span>
+</div>
 
 <div class="status">
   <div class="stat">
@@ -865,6 +867,17 @@ ${SHARED_STYLES}
   }
   .intake button.spawn:hover { filter: brightness(1.05); }
   .intake button.spawn[disabled] { opacity: 0.45; cursor: default; }
+  /* v0.6.x Slack-shape spike — alternative submit that routes the prompt as a
+     reply to the most-recent task in the current cwd, exercising the existing
+     appendMessage path. Lets a single intake feel like an ongoing conversation
+     when the user wants continuity, while preserving "Assign" as the explicit
+     new-task path. Disabled when no thread exists for the current cwd. */
+  .intake button.continue-thread {
+    background: rgba(255,154,118,0.10); color: var(--accent); font-weight: 600;
+    border-color: rgba(255,154,118,0.3);
+  }
+  .intake button.continue-thread:hover:not([disabled]) { background: rgba(255,154,118,0.18); }
+  .intake button.continue-thread[disabled] { opacity: 0.4; cursor: default; }
   .intake .hint { margin-left: auto; color: var(--fg-40); font-family: var(--mono); font-size: 11px; }
 
   /* ── Setup panel (onboarding — appears when a non-ready agent is picked) ───
@@ -1233,11 +1246,12 @@ ${SHARED_STYLES}
   <div class="intake-row">
     <select id="agent" title="Auto-pick agent · codehere routes. Override below."><option value="">Auto-pick agent</option></select>
     <input type="text" id="cwd" class="cwd" placeholder="folder" spellcheck="false" />
-    <button class="spawn" id="spawn">Assign</button>
+    <button class="continue-thread" id="continue-thread" type="button" disabled title="Send as a reply to the most recent task in this folder (Slack-shape spike)">Continue thread</button>
+    <button class="spawn" id="spawn">Assign new</button>
   </div>
   <div class="setup-panel" id="setup-panel" data-state=""></div>
   <div class="intake-row" style="margin-top:6px">
-    <span class="hint" style="margin-left:auto">⌘ + Enter</span>
+    <span class="hint" style="margin-left:auto">⌘+Enter = Assign new · ⌘+Shift+Enter = Continue thread</span>
   </div>
 </div>
 
@@ -2085,13 +2099,22 @@ ${SHARED_STYLES}
     // Iter 12 — prose summary (3 paragraphs, plain English) prepended above
     // the artifact list. Non-technical users see prose first; raw artifact
     // detail (files/tests/tokens) below as supporting context.
-    function renderArtifacts(artifacts, finalReport, status) {
+    function renderArtifacts(artifacts, finalReport, status, completedAt) {
       // Show the block if either prose summary OR artifacts exist OR if a
       // completed task is still generating its report (placeholder state).
       const isCompleted = status === 'completed' || status === 'killed' || status === 'error';
       const hasContent = artifacts || finalReport;
-      const isAwaitingReport = isCompleted && !finalReport;
-      if (!hasContent && !isAwaitingReport) { finalReportEl.style.display = 'none'; return; }
+      // v0.6.x — bound the "Generating report…" placeholder to the actual
+      // generation window. Final Report typically returns within 30s; after
+      // 90s post-completion with no report, the report either failed silently
+      // or the daemon was restarted (in-memory finalReportBySession Map gets
+      // wiped). Either way, "Generating report…" forever is dishonest.
+      const REPORT_WAIT_BUDGET_MS = 90_000;
+      const sinceCompleted = completedAt ? Date.now() - completedAt : 0;
+      const stillWaitingForReport = isCompleted && !finalReport && sinceCompleted < REPORT_WAIT_BUDGET_MS;
+      const reportTimedOut = isCompleted && !finalReport && sinceCompleted >= REPORT_WAIT_BUDGET_MS;
+      const isAwaitingReport = stillWaitingForReport;
+      if (!hasContent && !isAwaitingReport && !reportTimedOut) { finalReportEl.style.display = 'none'; return; }
       finalReportEl.style.display = 'block';
       const files = Array.isArray(artifacts?.files) ? artifacts.files : [];
       const tests = artifacts?.tests;
@@ -2106,10 +2129,13 @@ ${SHARED_STYLES}
           paragraphs.map(p => '<p>' + escape(p.trim()) + '</p>').join('') +
           '</div>';
       } else if (isAwaitingReport) {
-        // Placeholder — task done, report still generating (or provider failed silently).
-        // After ~30s with no report, the placeholder persists. Iter 13 will replace
-        // with explicit "report unavailable — start FCC proxy or set ANTHROPIC_API_KEY".
         html += '<div class="fr-summary fr-summary-pending"><p>Generating report…</p></div>';
+      } else if (reportTimedOut) {
+        // Honest message instead of perpetual "Generating report…". Most
+        // common cause: daemon restarted (Final Report is in-memory only,
+        // doesn't persist to disk yet — v0.6.x cleanup item). Less common:
+        // the report provider (claude-free / claude) failed silently.
+        html += '<div class="fr-summary fr-summary-pending"><p>Final Report unavailable for this session. (Most often this means the daemon restarted — reports aren\\'t persisted yet. Re-spawn to get a fresh one.)</p></div>';
       }
       if (files.length > 0) {
         html += '<div class="fr-files">' + files.map(f => {
@@ -2147,7 +2173,7 @@ ${SHARED_STYLES}
     // Render Final Report block if there's anything to show (prose summary,
     // artifacts, or "generating…" placeholder for a freshly-completed session).
     if (session.artifacts || session.finalReport || session.status === 'completed' || session.status === 'killed' || session.status === 'error') {
-      renderArtifacts(session.artifacts, session.finalReport, session.status);
+      renderArtifacts(session.artifacts, session.finalReport, session.status, session.completedAt);
     }
 
     // Persisted sessions have no live event stream and no subprocess to kill.
@@ -2164,7 +2190,7 @@ ${SHARED_STYLES}
 
         // Layer 2/3 synthetic events — handle before renderEvent (so they don't leak into the raw log)
         if (event.type === 'codehere:steps') { renderSteps(event.data?.steps); return; }
-        if (event.type === 'codehere:artifacts') { renderArtifacts(event.data, undefined, session.status); return; }
+        if (event.type === 'codehere:artifacts') { renderArtifacts(event.data, undefined, session.status, session.completedAt); return; }
 
         // Any structured error flips the status pill immediately — don't wait for
         // the subprocess to exit. Many CLIs print a logical error to stdout and
@@ -2234,10 +2260,95 @@ ${SHARED_STYLES}
   }
 
   spawnBtn.addEventListener('click', assignTask);
+
+  // v0.6.x Slack-shape spike — Continue thread button + Cmd+Shift+Enter.
+  // Routes the prompt as a reply to the most recent in-memory session for
+  // the current cwd via the existing /api/task/:id/message endpoint.
+  // Disabled when no eligible session exists; auto-refresh state every 5s
+  // alongside the existing tasks polling.
+  const continueBtn = document.getElementById('continue-thread');
+  let continueTargetSessionId = null;
+
+  function findContinueTarget(spawnedList, cwd) {
+    if (!cwd) return null;
+    const eligible = (spawnedList || []).filter(s => s.cwd === cwd && s.canAppendMessage === true);
+    if (eligible.length === 0) return null;
+    eligible.sort((a, b) => b.startedAt - a.startedAt);
+    return eligible[0];
+  }
+
+  function refreshContinueAvailability() {
+    const cwd = cwdInput.value.trim();
+    if (!cwd) {
+      continueTargetSessionId = null;
+      continueBtn.disabled = true;
+      continueBtn.title = 'Set a folder first to continue its thread';
+      return;
+    }
+    fetch('/api/tasks').then(r => r.json()).then(d => {
+      const target = findContinueTarget(d.spawned, cwd);
+      if (target) {
+        continueTargetSessionId = target.sessionId;
+        continueBtn.disabled = false;
+        const promptPreview = (target.prompt || '').slice(0, 40);
+        continueBtn.title = 'Reply to last task in this folder: "' + promptPreview + (target.prompt && target.prompt.length > 40 ? '…' : '') + '" (' + target.agent + ')';
+      } else {
+        continueTargetSessionId = null;
+        continueBtn.disabled = true;
+        continueBtn.title = 'No live session for this folder. Use Assign new instead.';
+      }
+    }).catch(() => {});
+  }
+
+  async function continueThread() {
+    const prompt = promptEl.value.trim();
+    if (!prompt) return;
+    if (!continueTargetSessionId) { alert('No live session for this folder. Use Assign new instead.'); return; }
+    const targetId = continueTargetSessionId;
+    continueBtn.disabled = true;
+    const originalText = continueBtn.textContent;
+    continueBtn.textContent = '...';
+    try {
+      const res = await fetch('/api/task/' + encodeURIComponent(targetId) + '/message', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ text: prompt }),
+      });
+      const data = await res.json();
+      if (!res.ok) { alert('Failed: ' + (data.error || res.status)); return; }
+      promptEl.value = '';
+      // Scroll the existing card into view; existing 5s polling refreshes content.
+      const card = document.querySelector('[data-session-id="' + targetId + '"]');
+      if (card) card.scrollIntoView({ behavior: 'smooth', block: 'start' });
+    } catch (e) {
+      alert('Network error: ' + (e && e.message ? e.message : e));
+    } finally {
+      continueBtn.disabled = false;
+      continueBtn.textContent = originalText;
+      // Re-check availability (target may have settled differently)
+      refreshContinueAvailability();
+    }
+  }
+
+  continueBtn.addEventListener('click', continueThread);
+  cwdInput.addEventListener('input', refreshContinueAvailability);
+  cwdInput.addEventListener('change', refreshContinueAvailability);
+
   promptEl.addEventListener('keydown', (e) => {
-    if ((e.metaKey || e.ctrlKey) && e.key === 'Enter') { e.preventDefault(); assignTask(); }
+    if ((e.metaKey || e.ctrlKey) && e.key === 'Enter') {
+      e.preventDefault();
+      if (e.shiftKey) {
+        continueThread();
+      } else {
+        assignTask();
+      }
+    }
   });
 
+  // Refresh continue-target availability alongside the existing tasks polling
+  setInterval(refreshContinueAvailability, 5000);
+  refreshContinueAvailability();
+
   // ── Observed sessions (F1d) ──────────────────────────────────────────
   function shortId(id) { return String(id || '').slice(0, 8); }
 
@@ -2371,7 +2482,7 @@ ${SHARED_STYLES}
       for (const s of (d.spawned || d.sessions || [])) {
         const entry = sessions.get(s.sessionId);
         if (entry && entry.renderArtifacts) {
-          entry.renderArtifacts(s.artifacts, s.finalReport, s.status);
+          entry.renderArtifacts(s.artifacts, s.finalReport, s.status, s.completedAt);
         }
       }
     }).catch(() => { /* fine */ });
@@ -2440,24 +2551,10 @@ ${SHARED_STYLES}
   html, body { height: 100%; }
   body { margin: 0; background: var(--bg); color: var(--fg); font-family: var(--sans); font-size: 13px; line-height: 1.55; -webkit-font-smoothing: antialiased; }
 
-  /* ── Floating nav (matches dashboard exactly) ───────────────────────── */
-  .floating-nav {
-    position: fixed; top: 16px; left: 50%; transform: translateX(-50%);
-    z-index: 100;
-    display: flex; align-items: center; gap: 4px;
-    padding: 6px 10px;
-    background: rgba(20,20,22,0.85); backdrop-filter: blur(20px); -webkit-backdrop-filter: blur(20px);
-    border: 1px solid var(--border);
-    border-radius: 999px;
-    font-family: var(--mono); font-size: 11.5px;
-  }
-  .floating-nav .logo { color: var(--accent); padding: 4px 10px; text-decoration: none; }
-  .floating-nav .nav-link {
-    color: var(--fg-50); padding: 4px 10px; border-radius: 999px;
-    text-decoration: none;
-  }
-  .floating-nav .nav-link:hover { color: var(--fg); background: rgba(255,255,255,0.05); }
-  .floating-nav .nav-link.active { color: var(--fg); background: rgba(255,154,118,0.10); }
+  /* Floating nav inherits from SHARED_STYLES (no override here — keeps the
+     active-state look identical to / and /history. Founder caught
+     2026-05-03 that the local override gave /threads a different orange-bg
+     active state, fragmenting the design system across pages.) */
 
   /* ── Slack-shape shell (3-column — channels | thread | members) ─────── */
   .shell.slack-shape {

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

@@ -156,4 +156,37 @@ export function mirrorCompletedToThread(rec) {
         artifacts: rec.artifacts,
     });
 }
+/**
+ * v0.6.x — mirror a successful appendMessage() reply to the project thread.
+ *
+ * Pre-fix: only initial spawn + completion wrote to thread.jsonl. Reply turns
+ * (the `/api/task/:id/message` endpoint, the dashboard reply box, and the new
+ * /threads reply bar) updated only the in-memory session. Result: /threads
+ * showed the original spawn but every follow-up turn was invisible. Founder
+ * flagged it 2026-05-03 as a v0.6.x cleanup item.
+ *
+ * Schema choice: write a single complete `{type: 'task', sessionId: <new>,
+ * parentSessionId: <orig>, ...}` entry rather than splitting spawn+complete.
+ * appendMessage is synchronous-from-caller's-POV (no streaming), so the whole
+ * turn is known when this fires. The reader's sessionId merge logic surfaces
+ * each reply as its own chronological row on /threads.
+ */
+export function mirrorReplyToThread(rec) {
+    if (isTempDir(rec.cwd))
+        return;
+    const slug = slugForCwd(rec.cwd);
+    appendThreadEntry(slug, {
+        type: 'task',
+        sessionId: rec.replySessionId,
+        parentSessionId: rec.parentSessionId,
+        agent: rec.agent,
+        prompt: rec.prompt,
+        cwd: rec.cwd,
+        startedAt: rec.startedAt,
+        completedAt: rec.completedAt,
+        durationMs: rec.durationMs,
+        status: 'completed',
+        ...(rec.result ? { result: rec.result } : {}),
+    });
+}
 //# sourceMappingURL=project-thread-mirror.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehere",
-  "version": "0.5.0-alpha.5",
+  "version": "0.5.0-alpha.6",
   "description": "A PM for your AI coding agents. Delegate, orchestrate, and audit Claude Code, Codex, Aider, OpenCode, Gemini, and any user-configured CLI agent from one local web UI — every AI action traced, every file scored, every spawn warmed with project memory.",
   "main": "dist/index.js",
   "type": "module",