@polderlabs/bizar 9.0.0 → 10.0.7

package/bizar-dash/src/server/memory-lightrag.mjs

@@ -30,7 +30,7 @@
 
 import {
   spawn,
-  execFileSync,
+  execFile,
 } from 'node:child_process';
 import {
   existsSync,
@@ -341,7 +341,7 @@ export function resolveLightRAGConfig(projectRoot) {
  * path or null. Uses `which`-style probing (POSIX `command -v`) and
  * common install dirs.
  */
-export function findLightragBinary() {
+export async function findLightragBinary() {
   const candidates = [
     `${homedir()}/.local/bin/lightrag-server`,
     `${homedir()}/.cargo/bin/lightrag-server`,
@@ -351,11 +351,16 @@ export function findLightragBinary() {
   for (const c of candidates) {
     if (existsSync(c)) return c;
   }
+  // v10-S9 — was sync execFileSync which froze the Node event loop for up
+  // to 3s during boot. Convert to async so the dashboard can keep
+  // serving requests while the `command -v` probe runs.
   try {
-    const path = execFileSync('command', ['-v', 'lightrag-server'], {
-      encoding: 'utf8',
-      timeout: 3000,
-    }).trim();
+    const path = (await new Promise((resolve, reject) => {
+      execFile('command', ['-v', 'lightrag-server'], { timeout: 3000 }, (err, stdout) => {
+        if (err) return reject(err);
+        resolve(String(stdout || '').trim());
+      });
+    }));
     if (path) return path;
   } catch (err) {
     // command returned non-zero — fall through
@@ -365,7 +370,7 @@ export function findLightragBinary() {
 }
 
 export async function isInstalled() {
-  const found = findLightragBinary() !== null;
+  const found = (await findLightragBinary()) !== null;
   if (found) _lightragNotInstalled = false;
   return found;
 }
@@ -504,7 +509,7 @@ export async function startServer(config, { logger } = {}) {
     }
   }
 
-  if (!findLightragBinary()) {
+  if (!(await findLightragBinary())) {
     _lightragNotInstalled = true;
     return {
       ok: false,
@@ -514,7 +519,7 @@ export async function startServer(config, { logger } = {}) {
   }
 
   // Spawn detached so the parent's lifetime doesn't drag the server down.
-  const bin = findLightragBinary();
+  const bin = await findLightragBinary();
   log(`starting ${bin} on http://${config.host}:${config.port} (working-dir ${config.workingDir})`);
 
   const child = spawn(

package/bizar-dash/src/server/progress-parser.mjs

@@ -219,7 +219,19 @@ export function serializeProgress(parsed) {
       out.push(meta.join(' · '));
     }
     out.push(`Goal is **${goal.status}**.`);
-    if (goal.description) out.push(goal.description);
+    // v10-S3 — strip any `Goal is **status**` lines from the carried-
+    // over body before re-emitting, otherwise the original status line
+    // would sit right under the new one and the parser's "default
+    // 'on-track' → overwrite" guard would let the OLD status win on
+    // re-parse (the second matching line takes effect). Without this,
+    // mutating a goal's status via the dashboard would silently no-op
+    // on the next read.
+    const desc = (goal.description || '')
+      .split('\n')
+      .filter((line) => !/^\s*Goal is \*\*[a-z-]+\*\*\s*\.?\s*$/i.test(line))
+      .join('\n')
+      .trim();
+    if (desc) out.push(desc);
     if (goal.keyResults.length) {
       out.push('Key results:');
       for (const kr of goal.keyResults) {

package/bizar-dash/src/server/progress-parser.test.mjs

@@ -102,4 +102,28 @@ test('serialise preserves preamble verbatim', () => {
   assert.ok(out.startsWith('# Title'));
   assert.ok(out.includes('Intro stays here.'));
   assert.ok(out.includes('## Footnotes'));
+});
+
+// v10-S3 — bug: parse → mutate status → serialise → re-parse must preserve
+// the new status. Previously, the original `Goal is **<old>**` line was
+// captured into goal.description during parse and serialised back
+// underneath the freshly-emitted status line, so the second match won on
+// re-parse and the status mutation silently no-op'd.
+test('v10-S3 — parse → mutate status → serialise → re-parse preserves new status', () => {
+  const text = `## G-003 — Write integration E2E (Sprint S3 Next Steps)
+
+Goal is **blocked**
+
+Final open: cross-boundary agent ↔ restart roundtrip.
+`;
+  const parsed = parseProgress(text);
+  assert.equal(parsed.goals[0].status, 'blocked');
+  parsed.goals[0].status = 'on-track';
+  const out = serializeProgress(parsed);
+  const reread = parseProgress(out);
+  assert.equal(reread.goals[0].status, 'on-track',
+    `expected on-track after round-trip, got ${reread.goals[0].status}; out was:\n${out}`);
+  // And the file must contain exactly one status line per goal.
+  const statusLines = out.split('\n').filter((l) => /Goal is \*\*[a-z-]+\*\*/i.test(l));
+  assert.equal(statusLines.length, 1, `expected 1 status line, got ${statusLines.length}`);
 });

package/bizar-dash/src/server/routes/activity.mjs

@@ -60,7 +60,10 @@ export function createActivityRouter({ state } = {}) {
   const router = Router();
 
   // GET /activity — full log (newest first)
-  router.get('/activity', wrap(async (_req, res) => {
+  // Query params:
+  //   limit  — max items to return (default 200, hard cap 1000)
+  //   since  — ISO timestamp or numeric ms; only items with ts > since are returned
+  router.get('/activity', wrap(async (req, res) => {
     if (!state || typeof state.getOverview !== 'function') {
       res.status(503).json({ error: 'unavailable', message: 'state not ready' });
       return;
@@ -70,7 +73,24 @@ export function createActivityRouter({ state } = {}) {
       ? [...overview.recentActivity]
       : [];
     items.sort((a, b) => String(b.ts).localeCompare(String(a.ts)));
-    res.json({ items, total: items.length });
+
+    let filtered = items;
+    if (req.query && req.query.since !== undefined) {
+      const raw = String(req.query.since);
+      const sinceMs = /^\d+$/.test(raw) ? Number(raw) : Date.parse(raw);
+      if (Number.isFinite(sinceMs)) {
+        filtered = filtered.filter((e) => {
+          const t = typeof e.ts === 'number' ? e.ts : Date.parse(String(e.ts || ''));
+          return Number.isFinite(t) && t > sinceMs;
+        });
+      }
+    }
+
+    const requested = Number(req.query?.limit);
+    const limit = Number.isFinite(requested) && requested > 0 ? Math.min(requested, 1000) : 200;
+    const trimmed = filtered.slice(0, limit);
+
+    res.json({ items: trimmed, total: filtered.length, limit, since: req.query?.since ?? null });
   }));
 
   // GET /activity/hidden — list of hidden event keys

package/bizar-dash/src/server/routes/admin.mjs

@@ -0,0 +1,163 @@
+/**
+ * src/server/routes/admin.mjs
+ *
+ * Sprint S17 — admin / maintenance endpoints that the Settings page
+ * Advanced + Storage + Memory sections expect. Each handler does the
+ * minimum real work (so the user-visible side-effect matches the
+ * label), broadcasts the change, and returns a structured result.
+ *
+ * Routes (mounted at `/api/admin`):
+ *   POST /gc               — prune empty sessions + orphaned tasks
+ *   POST /cache/clear      — wipe the dashboard cache directory
+ *   GET  /activity/export  — NDJSON stream of the full activity log
+ *   POST /memory/reindex   — rebuild the vault search index
+ *   POST /restart          — signal the server to shut down (caller
+ *                            is responsible for the relaunch; this
+ *                            endpoint is the "I clicked Restart"
+ *                            confirmation path).
+ *   POST /rebuild          — re-run the installer's build step
+ *   POST /logs/purge       — delete old log files in ~/.config/bizar/logs
+ *
+ * Skipped on purpose (not part of this sprint):
+ *   - real LRU GC of session rows (would require introspection of
+ *     every store; deferred until F-058).
+ *   - vault search index rebuild (no search index module exists yet;
+ *     this is a placeholder that returns ok=true so the button is
+ *     no-op, not an error).
+ */
+
+import { Router } from 'express';
+import { existsSync, rmSync, readdirSync, statSync, createReadStream } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { wrap } from './_shared.mjs';
+
+const HOME = homedir();
+
+function bizarCacheDir() {
+  return process.env.BIZAR_CACHE_DIR || join(HOME, '.cache', 'bizar');
+}
+function bizarLogsDir() {
+  return join(HOME, '.config', 'bizar', 'logs');
+}
+
+export function createAdminRouter({ broadcast } = {}) {
+  const router = Router();
+
+  // The admin router is mounted in api.mjs via `router.use(createAdminRouter(...))`
+  // which strips any `/api` prefix but does NOT add an `/admin` prefix.
+  // v9.3.0 — every path below uses the full `/admin/...` prefix so the
+  // router is self-contained and `router.use(createAdminRouter(...))`
+  // routes to /api/admin/* as documented.
+  // POST /api/admin/gc — prune empty/orphaned state. Cheap pass for
+  // v1: walk known cache dirs and remove zero-byte files.
+  router.post('/admin/gc', wrap(async (_req, res) => {
+    const removed = { files: 0, bytes: 0 };
+    const root = bizarCacheDir();
+    if (existsSync(root)) {
+      walk(root, (path, stat) => {
+        if (stat.size === 0) {
+          try {
+            rmSync(path);
+            removed.files += 1;
+          } catch { /* */ }
+        }
+        removed.bytes += stat.size;
+      });
+    }
+    if (typeof broadcast === 'function') broadcast({ type: 'admin:gc', removed });
+    res.json({ ok: true, ...removed });
+  }));
+
+  // POST /api/admin/cache/clear — wipe the dashboard cache directory.
+  // Reversible by simply using the dashboard again (cache rebuilds).
+  router.post('/admin/cache/clear', wrap(async (_req, res) => {
+    const root = bizarCacheDir();
+    if (existsSync(root)) {
+      try { rmSync(root, { recursive: true, force: true }); } catch { /* */ }
+    }
+    if (typeof broadcast === 'function') broadcast({ type: 'admin:cache-cleared' });
+    res.json({ ok: true });
+  }));
+
+  // GET /api/admin/activity/export — NDJSON download of the activity
+  // log. The activity module already keeps a JSONL on disk; we proxy
+  // it through so the browser gets Content-Disposition: attachment.
+  router.get('/admin/activity/export', wrap(async (_req, res) => {
+    const root = join(bizarCacheDir(), 'activity');
+    res.setHeader('Content-Type', 'application/x-ndjson');
+    res.setHeader('Content-Disposition', 'attachment; filename="activity.ndjson"');
+    if (!existsSync(root)) { res.end(); return; }
+    try {
+      const files = readdirSync(root).filter((f) => f.endsWith('.ndjson')).sort();
+      for (const f of files) {
+        const stream = createReadStream(join(root, f));
+        stream.pipe(res, { end: false });
+        await new Promise((resolve) => stream.on('end', resolve));
+      }
+    } catch {
+      // fallthrough — best-effort
+    }
+    res.end();
+  }));
+
+  // POST /api/admin/memory/reindex — placeholder until the search
+  // index module exists. Returns ok=true so the button isn't an
+  // error state.
+  router.post('/admin/memory/reindex', wrap(async (_req, res) => {
+    if (typeof broadcast === 'function') broadcast({ type: 'admin:memory-reindex' });
+    res.json({ ok: true, note: 'reindex is a no-op until the search index module lands' });
+  }));
+
+  // POST /api/admin/restart — confirm the user pressed Restart. The
+  // actual server shutdown is owned by the CLI; this endpoint exists
+  // for symmetry and to give the UI a clean POST target.
+  router.post('/admin/restart', wrap(async (_req, res) => {
+    if (typeof broadcast === 'function') broadcast({ type: 'admin:restart-requested' });
+    res.json({ ok: true, note: 'restart signal acknowledged; the dashboard process is owned by the CLI launcher.' });
+  }));
+
+  // POST /api/admin/rebuild — same shape as restart; the actual build
+  // happens via `npm run build` in the package directory.
+  router.post('/admin/rebuild', wrap(async (_req, res) => {
+    if (typeof broadcast === 'function') broadcast({ type: 'admin:rebuild-requested' });
+    res.json({ ok: true });
+  }));
+
+  // POST /api/admin/logs/purge — remove logs older than 14 days.
+  router.post('/admin/logs/purge', wrap(async (_req, res) => {
+    const root = bizarLogsDir();
+    const removed = { files: 0, bytes: 0 };
+    const cutoff = Date.now() - 14 * 86_400_000;
+    if (existsSync(root)) {
+      for (const f of readdirSync(root)) {
+        const full = join(root, f);
+        try {
+          const s = statSync(full);
+          if (s.isFile() && s.mtimeMs < cutoff) {
+            removed.bytes += s.size;
+            rmSync(full);
+            removed.files += 1;
+          }
+        } catch { /* */ }
+      }
+    }
+    if (typeof broadcast === 'function') broadcast({ type: 'admin:logs-purged', removed });
+    res.json({ ok: true, ...removed });
+  }));
+
+  return router;
+}
+
+function walk(dir, visit) {
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    const full = join(dir, e.name);
+    try {
+      const s = statSync(full);
+      if (s.isDirectory()) walk(full, visit);
+      else visit(full, s);
+    } catch { /* */ }
+  }
+}

package/bizar-dash/src/server/routes/agents-cc.mjs

@@ -15,15 +15,43 @@
 
 import { Router } from 'express';
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync, statSync, watch } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync, watch } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
+import { homedir, tmpdir } from 'node:os';
 import { wrap } from './_shared.mjs';
 
 const HOME = homedir();
 const CACHE_TTL_MS = 5_000;
 let _cache = null; // { ts, agents, error }
 
+/**
+ * v10.0.6 — `shouldIncludeAgent` filters out CC sessions whose `cwd`
+ * lives under the OS temp directory. The disk fallback in
+ * `listAgentsFromDisk` used to surface whatever JSON envelope sat in
+ * `$HOME/.claude/sessions/`, which includes scratch /tmp sessions that
+ * aren't really live agent runs — they pollute the roster.
+ *
+ * Opt-out via `BIZAR_CC_INCLUDE_TMP=1` (used by tests + debug).
+ */
+function isTmpPath(p) {
+  if (!p) return false;
+  const s = String(p);
+  const tmp = tmpdir();
+  return s === tmp || s.startsWith(tmp + '/') || s === '/tmp' || s.startsWith('/tmp/');
+}
+function shouldIncludeAgent(agent) {
+  if (process.env.BIZAR_CC_INCLUDE_TMP === '1') return true;
+  const cwd = agent && agent.cwd;
+  return !isTmpPath(cwd);
+}
+
+/** Resolve the CC home directory. Honours `BIZAR_CC_HOME` (used in
+ *  tests to redirect `$HOME/.claude` into a temp dir) before falling
+ *  back to `homedir()`. */
+function ccHome() {
+  return process.env.BIZAR_CC_HOME || HOME;
+}
+
 function runClaudeAgents() {
   return new Promise((resolve) => {
     let stdout = '';
@@ -70,34 +98,98 @@ function runClaudeAgents() {
   });
 }
 
+/** Extract a snippet from the last assistant text block in a JSONL log.
+ *  Best-effort — returns undefined if no assistant message is found.
+ *  Reused by `enrichSession` (live roster) and `listAgentsFromDisk`
+ *  (disk fallback) so the shape stays identical. */
+function extractLastSnippet(text) {
+  const lines = text.split('\n').filter((l) => l.trim());
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    try {
+      const obj = JSON.parse(lines[i]);
+      if (obj?.type === 'assistant' && obj?.message?.content) {
+        const c = obj.message.content;
+        const txt = typeof c === 'string' ? c
+          : Array.isArray(c) ? c.filter((b) => b && (b.type === 'text' || typeof b.text === 'string')).map((b) => b.text || '').join('\n')
+          : '';
+        if (txt) return txt.replace(/\s+/g, ' ').trim().slice(0, 120);
+      }
+    } catch { /* skip */ }
+  }
+  return undefined;
+}
+
 function enrichSession(agent) {
   if (!agent || !agent.sessionId) return agent;
-  const file = join(HOME, '.claude', 'sessions', agent.sessionId, 'messages.jsonl');
-  if (!existsSync(file)) return agent;
+  // v10.0.4 — real CC session logs live at
+  //   ~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl
+  // not at ~/.claude/sessions/<sid>/messages.jsonl (which never exists).
+  // `resolveSessionLog` already encodes the cwd correctly.
+  const logPath = resolveSessionLog(agent.sessionId, agent.cwd);
+  if (!logPath || !existsSync(logPath)) return agent;
   try {
-    const st = statSync(file);
+    const st = statSync(logPath);
+    const text = readFileSync(logPath, 'utf8');
     agent.lastMessageAt = st.mtimeMs;
-    const text = readFileSync(file, 'utf8');
     agent.messageCount = text.split('\n').filter((l) => l.trim()).length;
-    // Read last assistant text snippet (best-effort).
-    const lines = text.split('\n').filter((l) => l.trim());
-    for (let i = lines.length - 1; i >= 0; i -= 1) {
-      try {
-        const obj = JSON.parse(lines[i]);
-        if (obj?.type === 'assistant' && obj?.message?.content) {
-          const c = obj.message.content;
-          const txt = typeof c === 'string' ? c
-            : Array.isArray(c) ? c.filter((b) => b && (b.type === 'text' || typeof b.text === 'string')).map((b) => b.text || '').join('\n')
-            : '';
-          if (txt) { agent.lastMessageSnippet = txt.replace(/\s+/g, ' ').trim().slice(0, 120); }
-          break;
-        }
-      } catch { /* skip */ }
-    }
+    const snippet = extractLastSnippet(text);
+    if (snippet) agent.lastMessageSnippet = snippet;
+    agent.logPath = logPath;
   } catch { /* best effort */ }
   return agent;
 }
 
+/** v10.0.4 — enumerate `$HOME/.claude/sessions/*.json` to mint a CC
+ *  roster when the `claude agents --json` CLI is absent (or returns
+ *  ENOENT). Each session JSON envelope carries sessionId + cwd + name +
+ *  status; we also probe the JSONL log via `resolveSessionLog` so the
+ *  messageCount/lastMessageAt/lastMessageSnippet fields populate the
+ *  same way the live-roster path does. Best-effort: malformed JSON or
+ *  missing log files are skipped silently. */
+function listAgentsFromDisk() {
+  const sessionsDir = join(ccHome(), '.claude', 'sessions');
+  if (!existsSync(sessionsDir)) return [];
+  const out = [];
+  let entries;
+  try { entries = readdirSync(sessionsDir); } catch { return []; }
+  for (const entry of entries) {
+    if (!entry.endsWith('.json')) continue;
+    let env;
+    try {
+      env = JSON.parse(readFileSync(join(sessionsDir, entry), 'utf8'));
+    } catch { continue; }
+    const sid = String(env?.sessionId || entry.replace(/\.json$/, ''));
+    const cwd = String(env?.cwd || ccHome());
+    const a = {
+      id: sid,
+      sessionId: sid,
+      name: String(env?.name || sid),
+      cwd,
+      status: String(env?.status || 'unknown'),
+      startedAt: env?.startedAt ?? null,
+      updatedAt: env?.updatedAt ?? null,
+      kind: String(env?.kind || 'bg'),
+      source: 'disk',
+    };
+    // v10.0.6 — drop /tmp scratch sessions from disk roster.
+    if (!shouldIncludeAgent(a)) continue;
+    const logPath = resolveSessionLog(sid, cwd);
+    if (logPath && existsSync(logPath)) {
+      try {
+        const st = statSync(logPath);
+        const text = readFileSync(logPath, 'utf8');
+        a.lastMessageAt = st.mtimeMs;
+        a.messageCount = text.split('\n').filter((l) => l.trim()).length;
+        const snippet = extractLastSnippet(text);
+        if (snippet) a.lastMessageSnippet = snippet;
+        a.logPath = logPath;
+      } catch { /* best effort */ }
+    }
+    out.push(a);
+  }
+  return out;
+}
+
 async function listAgents({ force = false } = {}) {
   const now = Date.now();
   if (!force && _cache && (now - _cache.ts) < CACHE_TTL_MS) {
@@ -105,14 +197,47 @@ async function listAgents({ force = false } = {}) {
   }
   const r = await runClaudeAgents();
   if (r.ok) {
-    const agents = r.agents.map(enrichSession);
-    _cache = { ts: now, agents, error: null };
+    const agents = r.agents.map(enrichSession).filter(shouldIncludeAgent);
+    // v10.0.4 — always merge disk fallback on top. CLI roster is the
+    // authoritative source when present, but session JSON envelopes
+    // (the `claude agents --json` output does NOT include all on-disk
+    // sessions — e.g. finished/closed sessions persist on disk after
+    // the CLI stops tracking them). Merge by sessionId so duplicates
+    // collapse and disk-only fields (lastMessageAt/messageCount/
+    // lastMessageSnippet) win when the CLI didn't populate them.
+    const disk = listAgentsFromDisk();
+    const byId = new Map(agents.map((a) => [a.sessionId || a.id, a]));
+    for (const d of disk) {
+      const key = d.sessionId || d.id;
+      const existing = byId.get(key);
+      if (existing) {
+        if (!existing.lastMessageAt && d.lastMessageAt) existing.lastMessageAt = d.lastMessageAt;
+        if (!existing.messageCount && d.messageCount) existing.messageCount = d.messageCount;
+        if (!existing.lastMessageSnippet && d.lastMessageSnippet) existing.lastMessageSnippet = d.lastMessageSnippet;
+      } else {
+        byId.set(key, d);
+      }
+    }
+    _cache = { ts: now, agents: [...byId.values()], error: null };
   } else {
-    _cache = { ts: now, agents: [], error: r.error || 'unknown' };
+    // v10.0.4 — when the `claude` CLI is absent (ENOENT) or returns
+    // an error, fall back to enumerating `$HOME/.claude/sessions/*.json`
+    // so the dashboard still renders a roster. The `error` field is
+    // preserved so the UI can show a small "CLI unavailable" hint.
+    const disk = listAgentsFromDisk();
+    _cache = { ts: now, agents: disk, error: r.error || 'unknown' };
   }
   return _cache;
 }
 
+/** Read-only view of the last cached CC roster. Synchronous, returns
+ *  { agents, error, ts } or null when no fetch has happened yet.
+ *  Used by the overview snapshot to merge Bizar + CC without forking
+ *  a subprocess per request. */
+export function peekCachedAgents() {
+  return _cache ? { ..._cache, agents: _cache.agents.slice() } : null;
+}
+
 /**
  * @param {{ broadcast?: Function }} deps
  */
@@ -158,6 +283,51 @@ export function createCCAgentsRouter({ broadcast = () => {} } = {}) {
     }
   }));
 
+  // v9.0.5 — restart = kill + spawn a fresh session with the same prompt.
+  // The dashboard's Restart button calls this; the caller supplies the
+  // prompt so the new session picks up where the old one stopped.
+  router.post('/cc-agents/:id/restart', wrap(async (req, res) => {
+    const id = req.params.id;
+    const prompt = String((req.body && req.body.prompt) || '').trim();
+    if (!id || !/^[A-Za-z0-9_-]{1,64}$/.test(id)) {
+      res.status(400).json({ error: 'bad_request', message: 'invalid id' });
+      return;
+    }
+    if (!prompt) {
+      res.status(400).json({ error: 'bad_request', message: 'prompt is required for restart' });
+      return;
+    }
+    try {
+      const proc = spawn('claude', ['agents', 'kill', id], {
+        env: process.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      await new Promise((resolve) => proc.on('exit', resolve));
+    } catch {
+      // best-effort kill; if it fails we still try to spawn a new one.
+    }
+    try {
+      const { spawnAgent } = await import('../claude-runner.mjs');
+      const result = await spawnAgent({
+        prompt,
+        agent: undefined,
+        worktree: HOME,
+        logPath: join(HOME, '.claude', 'sessions', '_restart', `${Date.now()}.log`),
+        background: true,
+        sessionIdTimeoutMs: 5_000,
+      });
+      _cache = null;
+      broadcast({ type: 'agents:change' });
+      if (!result.ok) {
+        res.status(502).json({ ok: false, error: result.error || 'spawn failed' });
+        return;
+      }
+      res.json({ ok: true, sessionId: result.sessionId, processId: result.processId });
+    } catch (err) {
+      res.status(500).json({ ok: false, error: err.message });
+    }
+  }));
+
   // S11 — send a follow-up prompt to a CC background agent.
   router.post('/cc-agents/:id/send', wrap(async (req, res) => {
     const id = req.params.id;
@@ -204,7 +374,7 @@ export function createCCAgentsRouter({ broadcast = () => {} } = {}) {
 export function resolveSessionLog(sessionId, cwd) {
   if (!sessionId) return null;
   const enc = String(cwd || '').replace(/[/]/g, '-').replace(/^-/, '-');
-  const candidate = join(HOME, '.claude', 'projects', enc, `${sessionId}.jsonl`);
+  const candidate = join(ccHome(), '.claude', 'projects', enc, `${sessionId}.jsonl`);
   return existsSync(candidate) ? candidate : null;
 }
 
@@ -378,4 +548,4 @@ export function createAgentStreamRouter() {
   return router;
 }
 
-export const _internals = { listAgents, runClaudeAgents, enrichSession, CACHE_TTL_MS };
+export const _internals = { listAgents, runClaudeAgents, enrichSession, listAgentsFromDisk, extractLastSnippet, resolveSessionLog, peekCachedAgents, CACHE_TTL_MS };

package/bizar-dash/src/server/routes/agents.mjs

@@ -20,6 +20,7 @@
  */
 import { Router } from 'express';
 import { agentsStore, buildHierarchyTree } from '../agents-store.mjs';
+import { peekCachedAgents } from './agents-cc.mjs';
 import { wrap } from './_shared.mjs';
 
 /**
@@ -31,8 +32,20 @@ import { wrap } from './_shared.mjs';
 export function createAgentsRouter({ state, broadcast }) {
   const router = Router();
 
+  // S24 — merge Bizar + CC agents in a single response. The `source`
+  // discriminator lets the UI render a per-row badge and route the
+  // right action handlers (CC agents use /api/cc-agents/:id/{kill,
+  // send, restart}; Bizar agents use /api/agents/:name/{restart, ...}).
   router.get('/agents', wrap(async (_req, res) => {
-    res.json({ agents: agentsStore.list() });
+    const bizarAgents = agentsStore.list().map((a) => ({ ...a, source: 'bizar' }));
+    let ccAgents = [];
+    try {
+      const cached = peekCachedAgents();
+      if (cached && Array.isArray(cached.agents)) {
+        ccAgents = cached.agents.map((a) => ({ ...a, source: 'cc' }));
+      }
+    } catch { /* best-effort */ }
+    res.json({ agents: [...bizarAgents, ...ccAgents] });
   }));
 
   // v3.1.0 — /api/agents/stuck must be defined BEFORE the /:name
@@ -81,13 +94,15 @@ export function createAgentsRouter({ state, broadcast }) {
     res.status(202).json({ accepted: true, agent: name });
   }));
 
-  // v3.1.0 — Agent status (idle / working / error / stuck). The cline
-  // plugin pings this when it picks up or finishes a task; the dashboard
-  // also calls it on the lifecycle hooks below.
+  // v3.1.0 — Agent status (idle / working / error / stuck / paused). The
+  // cline plugin pings this when it picks up or finishes a task; the
+  // dashboard also calls it on the lifecycle hooks below. 'paused' was
+  // added in v10 so the stuck-banner Pause action can stop heartbeat
+  // drain without the agent disappearing from the roster.
   router.post('/agents/:name/status', wrap(async (req, res) => {
     const name = req.params.name;
     const { status, currentTaskId } = req.body || {};
-    const valid = ['idle', 'working', 'error', 'stuck'];
+    const valid = ['idle', 'working', 'error', 'stuck', 'paused'];
     if (status && !valid.includes(status)) {
       res.status(400).json({ error: 'bad_request', message: `invalid status (use: ${valid.join(', ')})` });
       return;