@monoes/monomindcli 1.6.0

package/dist/src/ui/server.mjs

@@ -0,0 +1,909 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { collectAll, getWatchPaths, collectProject, collectSessions, collectSwarm, collectAgents, collectTokens, collectHooks, collectKnowledge, collectMetrics, collectMemory, collectMemoryFiles, collectSystem } from './collector.mjs';
+
+const JSONL_SIZE_CAP = 10 * 1024 * 1024; // 10 MB — skip files larger than this in /api/graph
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// ─── Session JSONL parser ────────────────────────────────────────────────────
+function categorizeTool(name) {
+  if (['Read','Write','Edit','MultiEdit','Glob','Grep','LS'].includes(name)) return 'file';
+  if (name === 'Bash') return 'bash';
+  if (['Agent','Task'].includes(name)) return 'agent';
+  if (name.startsWith('mcp__monobrain__memory') || name.startsWith('mcp__monobrain__agentdb')) return 'memory';
+  if (['WebFetch','WebSearch'].includes(name)) return 'web';
+  if (name === 'TodoWrite' || name === 'TodoRead') return 'task';
+  if (name === 'Skill') return 'skill';
+  if (name === 'ToolSearch') return 'search';
+  if (name.startsWith('mcp__')) return 'mcp';
+  return 'other';
+}
+
+function parseSessionLines(lines) {
+  const events = [];
+  let agentDepth = 0;
+  const toolMap = new Map(); // id → tool event index
+
+  for (const line of lines) {
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    const type = entry.type;
+    const ts = entry.timestamp || null;
+    const uuid = entry.uuid || null;
+
+    if (type === 'user') {
+      const content = entry.message?.content;
+      let text = '';
+      if (typeof content === 'string') text = content;
+      else if (Array.isArray(content)) {
+        text = content.filter(b => b && b.type === 'text').map(b => b.text).join('');
+      }
+      if (text && text.length > 0) {
+        events.push({ kind: 'user', text: text.slice(0, 500), uuid, ts });
+      }
+    } else if (type === 'assistant') {
+      const content = entry.message?.content || [];
+      for (const block of (Array.isArray(content) ? content : [])) {
+        if (!block || typeof block !== 'object') continue;
+        if (block.type === 'thinking') {
+          events.push({ kind: 'thinking', text: (block.thinking || '').slice(0, 200), uuid, ts });
+        } else if (block.type === 'text') {
+          const t = (block.text || '').trim();
+          if (t) events.push({ kind: 'text', text: t.slice(0, 600), uuid, ts });
+        } else if (block.type === 'tool_use') {
+          const cat = categorizeTool(block.name);
+          const label = buildToolLabel(block.name, block.input || {});
+          const idx = events.length;
+          const ev = { kind: 'tool', name: block.name, cat, label, id: block.id, uuid, ts };
+          if (cat === 'agent') {
+            ev.subagent = block.input?.subagent_type || block.input?.description || '?';
+            ev.background = !!block.input?.run_in_background;
+          }
+          events.push(ev);
+          if (block.id) toolMap.set(block.id, idx);
+        }
+      }
+    } else if (type === 'tool') {
+      const content = entry.message?.content || [];
+      for (const block of (Array.isArray(content) ? content : [])) {
+        if (!block || block.type !== 'tool_result') continue;
+        const resultText = Array.isArray(block.content)
+          ? block.content.filter(b => b && b.type === 'text').map(b => b.text).join('').slice(0, 400)
+          : String(block.content || '').slice(0, 400);
+        const isError = !!block.is_error;
+        const toolIdx = toolMap.get(block.tool_use_id);
+        events.push({ kind: 'tool_result', tool_use_id: block.tool_use_id, text: resultText, isError, toolIdx, uuid, ts });
+      }
+    }
+  }
+  return events;
+}
+
+function buildToolLabel(name, input) {
+  if (name === 'Read') return input.file_path ? `Read ${path.basename(input.file_path)}` : 'Read';
+  if (name === 'Write') return input.file_path ? `Write ${path.basename(input.file_path)}` : 'Write';
+  if (name === 'Edit') return input.file_path ? `Edit ${path.basename(input.file_path)}` : 'Edit';
+  if (name === 'Bash') return (input.description || input.command || 'Bash').slice(0, 60);
+  if (name === 'Grep') return `Grep ${(input.pattern || '').slice(0, 30)}`;
+  if (name === 'Glob') return `Glob ${(input.pattern || '').slice(0, 30)}`;
+  if (name === 'Agent' || name === 'Task') return `→ ${input.subagent_type || input.description || 'agent'}`;
+  if (name === 'WebFetch') return `Fetch ${(input.url || '').slice(0, 50)}`;
+  if (name === 'WebSearch') return `Search ${(input.query || '').slice(0, 40)}`;
+  if (name === 'Skill') return `Skill: ${input.skill || '?'}`;
+  if (name.startsWith('mcp__monobrain__memory')) return name.replace('mcp__monobrain__memory_', 'mem:');
+  if (name.startsWith('mcp__')) return name.replace('mcp__monobrain__', '⬡ ').replace('mcp__', '⬡ ').slice(0, 40);
+  return name.slice(0, 40);
+}
+
+// ─── Section collectors (for /api/section lazy load) ────────────────────────
+function buildSectionData(name, dir) {
+  const d = path.resolve(dir);
+  switch (name) {
+    case 'sessions': return { sessions: collectSessions(d) };
+    case 'swarm':    return { swarm: collectSwarm(d), agents: collectAgents(d) };
+    case 'agents':   return { agents: collectAgents(d) };
+    case 'tokens':   return { tokens: collectTokens(d) };
+    case 'hooks':    return { hooks: collectHooks(d) };
+    case 'knowledge':return { knowledge: collectKnowledge(d) };
+    case 'metrics':  return { metrics: collectMetrics(d) };
+    case 'system':   return { system: collectSystem() };
+    case 'memory': {
+      const s = collectSessions(d);
+      return { sessions: { palace: s.palace }, memory: collectMemory(d) };
+    }
+    case 'overview': return { project: collectProject(d), system: collectSystem() };
+    default: return {};
+  }
+}
+
+// Map file path fragment → affected section names
+function pathToSections(filename) {
+  if (!filename) return null;
+  const f = filename.toLowerCase();
+  if (f.includes('swarm'))                          return ['swarm'];
+  if (f.includes('token'))                          return ['tokens'];
+  if (f.includes('registry') || f.includes('registrations')) return ['agents'];
+  if (f.includes('route') || f.includes('worker-dispatch'))  return ['hooks'];
+  if (f.includes('chunk') || f.includes('skills')) return ['knowledge'];
+  if (f.includes('memory.db') || f.includes('memory.graph') || f.includes('hnsw.index') ||
+      f.includes('ruvector.db') || f.includes('ranked-context') ||
+      (f.includes('/memory/') && f.endsWith('.md'))) return ['memory', 'sessions'];
+  if (f.includes('palace') || f.includes('drawers') || f.includes('identity')) return ['memory', 'sessions'];
+  if (f.includes('ddd') || f.includes('learning') || f.includes('audit')) return ['metrics'];
+  if (f.endsWith('.jsonl') || f.includes('sessions')) return ['sessions'];
+  return ['sessions', 'swarm', 'agents', 'tokens', 'hooks'];
+}
+
+// SSE client registry
+const sseClients = new Set();
+
+// Server state
+let running = false;
+let currentPort = null;
+let currentUrl = null;
+let activeServer = null;
+const activeWatchers = [];
+
+/**
+ * Broadcasts a data payload to all connected SSE clients.
+ * Silently removes clients that have disconnected.
+ */
+function broadcast(data) {
+  const msg = `data: ${JSON.stringify(data)}\n\n`;
+  for (const client of sseClients) {
+    try {
+      client.write(msg);
+    } catch {
+      sseClients.delete(client);
+    }
+  }
+}
+
+/**
+ * Opens a URL in the default browser, cross-platform.
+ */
+async function openUrl(url) {
+  const { exec } = await import('child_process');
+  const cmd =
+    process.platform === 'darwin'
+      ? `open "${url}"`
+      : process.platform === 'win32'
+      ? `start "${url}"`
+      : `xdg-open "${url}"`;
+  exec(cmd);
+}
+
+/**
+ * Attempts to bind the HTTP server to a port, trying up to 10 increments
+ * if the initial port is already in use.
+ */
+function bindServer(server, port) {
+  return new Promise((resolve, reject) => {
+    const maxTries = 10;
+    let attempt = 0;
+
+    function tryPort(p) {
+      server.listen(p, '127.0.0.1', () => resolve(p));
+      server.once('error', (err) => {
+        if (err.code === 'EADDRINUSE' && attempt < maxTries) {
+          attempt += 1;
+          server.removeAllListeners('error');
+          tryPort(p + 1);
+        } else {
+          reject(err);
+        }
+      });
+    }
+
+    tryPort(port);
+  });
+}
+
+/**
+ * Starts the monomind live dashboard HTTP server.
+ *
+ * @param {object} [options]
+ * @param {number}  [options.port=4242]        - Preferred port. Tries up to port+10 on collision.
+ * @param {string}  [options.projectDir]       - Root of the project to collect data from.
+ * @param {boolean} [options.openBrowser=true] - Whether to open the dashboard in the default browser.
+ * @returns {Promise<{port: number, url: string, server: http.Server}>}
+ */
+export async function startServer({ port = 4242, projectDir, openBrowser = true } = {}) {
+  const server = http.createServer(async (req, res) => {
+    const url = req.url.split('?')[0];
+
+    // ------------------------------------------------------------------ GET /
+    if (req.method === 'GET' && url === '/') {
+      const htmlPath = path.join(__dirname, 'dashboard.html');
+      try {
+        const html = fs.readFileSync(htmlPath, 'utf8');
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(html);
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end(`Failed to load dashboard.html: ${err.message}`);
+      }
+      return;
+    }
+
+    // --------------------------------------------------------- GET /api/data
+    if (req.method === 'GET' && url === '/api/data') {
+      try {
+        const qs = new URL(req.url, 'http://localhost').searchParams;
+        const dir = qs.get('dir') || projectDir;
+        const snapshot = await collectAll(dir);
+        res.writeHead(200, {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+          'Cache-Control': 'no-cache',
+        });
+        res.end(JSON.stringify(snapshot));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+    // ------------------------------------------------------ GET /api/session
+    if (req.method === 'GET' && url === '/api/session') {
+      const qs = new URL(req.url, 'http://localhost').searchParams;
+      const file = qs.get('file');
+      const limit = Math.min(parseInt(qs.get('limit') || '600', 10), 3000);
+      if (!file) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'missing file param' }));
+        return;
+      }
+      try {
+        const raw = fs.readFileSync(file, 'utf8');
+        const allLines = raw.split('\n').filter(Boolean);
+        const lines = allLines.slice(-limit);
+        const events = parseSessionLines(lines);
+        res.writeHead(200, {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+          'Cache-Control': 'no-cache',
+        });
+        res.end(JSON.stringify({ events, total: allLines.length, shown: lines.length }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+    // ------------------------------------------------------- GET /api/palace
+    if (req.method === 'GET' && url === '/api/palace') {
+      try {
+        const qs = new URL(req.url, 'http://localhost').searchParams;
+        const dir = qs.get('dir') || projectDir;
+        const d = path.resolve(dir || process.cwd());
+        const palaceDir = path.join(d, '.monomind', 'palace');
+
+        let drawers = [];
+        try {
+          const raw = fs.readFileSync(path.join(palaceDir, 'drawers.jsonl'), 'utf8');
+          drawers = raw.split('\n').filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+        } catch {}
+
+        let identity = null;
+        try { identity = fs.readFileSync(path.join(palaceDir, 'identity.md'), 'utf8'); } catch {}
+
+        let kg = [];
+        try { const raw = fs.readFileSync(path.join(palaceDir, 'kg.json'), 'utf8'); kg = JSON.parse(raw); } catch {}
+
+        res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', 'Cache-Control': 'no-cache' });
+        res.end(JSON.stringify({ drawers, identity, kg }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+    // ------------------------------------------------------- GET /api/memory-files
+    if (req.method === 'GET' && url === '/api/memory-files') {
+      try {
+        const qs = new URL(req.url, 'http://localhost').searchParams;
+        const dir = qs.get('dir') || projectDir;
+        const d = path.resolve(dir || process.cwd());
+        const homeDir = os.homedir();
+        const slug = d.replace(/\//g, '-');
+        const memDir = path.join(homeDir, '.claude', 'projects', slug, 'memory');
+
+        let files = [];
+        try { files = fs.readdirSync(memDir).filter(f => f.endsWith('.md') && f !== 'MEMORY.md'); } catch {}
+
+        const memories = files.map(fname => {
+          const fp = path.join(memDir, fname);
+          let stat = null; try { stat = fs.statSync(fp); } catch {}
+          let raw = ''; try { raw = fs.readFileSync(fp, 'utf8').replace(/\r\n/g, '\n'); } catch {}
+          // Parse frontmatter — escHtml ordering: bold replace runs on already-escaped content (safe)
+          let name = fname.replace('.md', ''), description = '', type = 'project', body = raw;
+          const fm = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+          if (fm) {
+            body = fm[2].trim();
+            for (const line of fm[1].split('\n')) {
+              const m = line.match(/^(\w+):\s*(.+)$/);
+              if (m) {
+                if (m[1] === 'name') name = m[2].trim();
+                if (m[1] === 'description') description = m[2].trim();
+                if (m[1] === 'type') type = m[2].trim();
+              }
+            }
+          }
+          return { filename: fname, name, description, type, body, mtime: stat ? stat.mtimeMs : null };
+        }).sort((a, b) => (b.mtime || 0) - (a.mtime || 0));
+
+        res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', 'Cache-Control': 'no-cache' });
+        res.end(JSON.stringify({ memories, memDir }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+    // ------------------------------------------------------- PUT /api/memory-file
+    if (req.method === 'PUT' && url === '/api/memory-file') {
+      let body = '';
+      req.on('data', chunk => { body += chunk; });
+      req.on('end', () => {
+        try {
+          const qs = new URL(req.url, 'http://localhost').searchParams;
+          const d = path.resolve(qs.get('dir') || projectDir || process.cwd());
+          const slug = d.replace(/\//g, '-');
+          const memDir = path.join(os.homedir(), '.claude', 'projects', slug, 'memory');
+          const { filename, content } = JSON.parse(body);
+          if (!filename || filename.includes('..') || !filename.endsWith('.md') || filename.includes('/')) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid filename' }));
+            return;
+          }
+          const fp = path.join(memDir, filename);
+          if (!fp.startsWith(memDir + path.sep) && fp !== memDir) {
+            res.writeHead(403, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Access denied' }));
+            return;
+          }
+          fs.mkdirSync(memDir, { recursive: true });
+          fs.writeFileSync(fp, content || '', 'utf8');
+          res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+          res.end(JSON.stringify({ ok: true }));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+      });
+      return;
+    }
+
+    // ------------------------------------------------------- DELETE /api/memory-file
+    if (req.method === 'DELETE' && url === '/api/memory-file') {
+      let body = '';
+      req.on('data', chunk => { body += chunk; });
+      req.on('end', () => {
+        try {
+          const qs = new URL(req.url, 'http://localhost').searchParams;
+          const d = path.resolve(qs.get('dir') || projectDir || process.cwd());
+          const slug = d.replace(/\//g, '-');
+          const memDir = path.join(os.homedir(), '.claude', 'projects', slug, 'memory');
+          const { filename } = JSON.parse(body);
+          if (!filename || filename.includes('..') || !filename.endsWith('.md') || filename.includes('/')) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid filename' }));
+            return;
+          }
+          const fp = path.join(memDir, filename);
+          if (!fp.startsWith(memDir + path.sep) && fp !== memDir) {
+            res.writeHead(403, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Access denied' }));
+            return;
+          }
+          fs.unlinkSync(fp);
+          res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+          res.end(JSON.stringify({ ok: true }));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+      });
+      return;
+    }
+
+    // ------------------------------------------------------- DELETE /api/knowledge-chunk
+    if (req.method === 'DELETE' && url === '/api/knowledge-chunk') {
+      let body = '';
+      req.on('data', chunk => { body += chunk; });
+      req.on('end', () => {
+        try {
+          const qs = new URL(req.url, 'http://localhost').searchParams;
+          const d = path.resolve(qs.get('dir') || projectDir || process.cwd());
+          const chunksFile = path.join(d, '.monomind', 'knowledge', 'chunks.jsonl');
+          const { chunkId } = JSON.parse(body);
+          if (!chunkId || typeof chunkId !== 'string') {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid chunkId' }));
+            return;
+          }
+          if (!fs.existsSync(chunksFile)) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'chunks.jsonl not found' }));
+            return;
+          }
+          const entries = fs.readFileSync(chunksFile, 'utf8').split('\n').filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+          const before = entries.length;
+          const filtered = entries.filter(e => e.chunkId !== chunkId);
+          if (filtered.length === before) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Chunk not found' }));
+            return;
+          }
+          fs.writeFileSync(chunksFile, filtered.map(e => JSON.stringify(e)).join('\n') + (filtered.length ? '\n' : ''), 'utf8');
+          res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+          res.end(JSON.stringify({ ok: true, removed: before - filtered.length }));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+      });
+      return;
+    }
+
+    // ------------------------------------------------------- PUT /api/knowledge-chunk
+    if (req.method === 'PUT' && url === '/api/knowledge-chunk') {
+      let body = '';
+      req.on('data', chunk => { body += chunk; });
+      req.on('end', () => {
+        try {
+          const qs = new URL(req.url, 'http://localhost').searchParams;
+          const d = path.resolve(qs.get('dir') || projectDir || process.cwd());
+          const chunksFile = path.join(d, '.monomind', 'knowledge', 'chunks.jsonl');
+          const { chunkId, text } = JSON.parse(body);
+          if (!chunkId || typeof chunkId !== 'string' || typeof text !== 'string') {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid chunkId or text' }));
+            return;
+          }
+          if (!fs.existsSync(chunksFile)) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'chunks.jsonl not found' }));
+            return;
+          }
+          const entries = fs.readFileSync(chunksFile, 'utf8').split('\n').filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+          const idx = entries.findIndex(e => e.chunkId === chunkId);
+          if (idx === -1) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Chunk not found' }));
+            return;
+          }
+          entries[idx] = { ...entries[idx], text };
+          fs.writeFileSync(chunksFile, entries.map(e => JSON.stringify(e)).join('\n') + '\n', 'utf8');
+          res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+          res.end(JSON.stringify({ ok: true }));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+      });
+      return;
+    }
+
+    // ------------------------------------------------------- GET /api/graphify-report
+    if (req.method === 'GET' && url === '/api/graphify-report') {
+      try {
+        const qs = new URL(req.url, 'http://localhost').searchParams;
+        const dir = qs.get('dir') || projectDir;
+        const d = path.resolve(dir || process.cwd());
+        const reportPath = path.join(d, '.monomind', 'graph', 'GRAPH_REPORT.md');
+        const graphPath = path.join(d, '.monomind', 'graph', 'graph.json');
+
+        let content = null, exists = false, stats = null, enriched = null;
+        try { content = fs.readFileSync(reportPath, 'utf-8'); exists = true; } catch {}
+        try {
+          const s = fs.statSync(graphPath);
+          if (s.size < 5 * 1024 * 1024) {
+            const g = JSON.parse(fs.readFileSync(graphPath, 'utf-8'));
+            const nodes = Array.isArray(g.nodes) ? g.nodes.length : 0;
+            const edgeArr = Array.isArray(g.edges) ? g.edges : (Array.isArray(g.links) ? g.links : []);
+            const edges = edgeArr.length;
+            stats = { nodes, edges, size: s.size, mtime: s.mtimeMs };
+          } else {
+            stats = { size: s.size, mtime: s.mtimeMs, tooLarge: true };
+          }
+        } catch {}
+        // Include enriched metadata if available (same 5MB size cap as graph.json)
+        const enrichedPath = path.join(d, '.monomind', 'graph', 'graph.enriched.json');
+        try {
+          const es = fs.statSync(enrichedPath);
+          if (es.size < 5 * 1024 * 1024) {
+            const em = JSON.parse(fs.readFileSync(enrichedPath, 'utf-8'));
+            enriched = { enrichedAt: em.enrichedAt, enrichedNodes: em.metrics?.enrichedNodes,
+              resolvedCallEdges: em.metrics?.resolvedCallEdges, pageRankComputed: em.metrics?.pageRankComputed, size: es.size };
+          } else {
+            enriched = { size: es.size, tooLarge: true };
+          }
+          if (stats) stats.enriched = enriched;
+        } catch {}
+
+        res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', 'Cache-Control': 'no-cache' });
+        res.end(JSON.stringify({ exists, content, stats, reportPath, enriched }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+    // -------------------------------------------------- GET /api/graphify-graph
+    if (req.method === 'GET' && url === '/api/graphify-graph') {
+      try {
+        const qs = new URL(req.url, 'http://localhost').searchParams;
+        const dir = qs.get('dir') || projectDir;
+        const d = path.resolve(dir || process.cwd());
+        const graphPath = path.join(d, '.monomind', 'graph', 'graph.json');
+        let nodes = [], edges = [], tooLarge = false;
+        try {
+          const s = fs.statSync(graphPath);
+          if (s.size < 50 * 1024 * 1024) {
+            const g = JSON.parse(fs.readFileSync(graphPath, 'utf-8'));
+            const rawNodes = Array.isArray(g.nodes) ? g.nodes : [];
+            const rawEdges = Array.isArray(g.edges) ? g.edges : (Array.isArray(g.links) ? g.links : []);
+            // Filter to internal nodes (project symbols with a known source file)
+            const internalNodes = rawNodes.filter(n => n.sourceFile && n.sourceFile !== '');
+            const internalIds = new Set(internalNodes.map(n => n.id));
+            // Compute degree: count edges that touch any internal node (measures real-world connectivity)
+            const degree = new Map();
+            for (const n of internalNodes) degree.set(n.id, 0);
+            for (const e of rawEdges) {
+              if (internalIds.has(e.source)) degree.set(e.source, (degree.get(e.source) || 0) + 1);
+              if (internalIds.has(e.target)) degree.set(e.target, (degree.get(e.target) || 0) + 1);
+            }
+            // Top 120 internal nodes by degree
+            const topNodes = [...internalNodes]
+              .sort((a, b) => (degree.get(b.id) || 0) - (degree.get(a.id) || 0))
+              .slice(0, 120);
+            const topIds = new Set(topNodes.map(n => n.id));
+            nodes = topNodes.map(n => ({ id: n.id, label: n.label || n.id, type: n.type, degree: degree.get(n.id) || 0 }));
+            edges = rawEdges
+              .filter(e => topIds.has(e.source) && topIds.has(e.target))
+              .sort((a, b) => ((degree.get(b.source) || 0) + (degree.get(b.target) || 0)) - ((degree.get(a.source) || 0) + (degree.get(a.target) || 0)))
+              .slice(0, 500)
+              .map(e => ({ source: e.source, target: e.target, relation: e.relation || e.type }));
+          } else {
+            tooLarge = true;
+          }
+        } catch (e) { if (e.code !== 'ENOENT') throw e; }
+        res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', 'Cache-Control': 'no-cache' });
+        res.end(JSON.stringify({ nodes, edges, tooLarge }));
+      } catch (err) {
+        res.writeHead(500); res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+    // -------------------------------------------------- POST /api/graphify-build
+    if (req.method === 'POST' && url === '/api/graphify-build') {
+      try {
+        const qs = new URL(req.url, 'http://localhost').searchParams;
+        const dir = qs.get('dir') || projectDir;
+        const d = path.resolve(dir || process.cwd());
+        const outputDir = path.join(d, '.monomind', 'graph');
+
+        // Start build in background, respond immediately so UI can show progress state
+        res.writeHead(202, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+        res.end(JSON.stringify({ status: 'building', dir: d, outputDir }));
+
+        (async () => {
+          try {
+            const { buildGraph } = await import('@monoes/graph');
+            const r = await buildGraph(d, { codeOnly: true, outputDir });
+            console.log(`[graph] built for ${d}: ${r.filesProcessed} files`);
+            // Run enrichment after build
+            try {
+              const { enrichGraph } = await import('file://' + new URL('../graph/enrich.mjs', import.meta.url).pathname);
+              const er = await enrichGraph(d, { graphDir: outputDir });
+              console.log(`[graph] enriched: ${er.metrics.enrichedNodes}/${er.metrics.totalNodes} nodes, PageRank: ${er.metrics.pageRankComputed}`);
+            } catch (ee) { console.error('[graph] enrichment failed:', ee.message); }
+          } catch (e) { console.error(`[graph] build failed for ${d}:`, e.message); }
+        })();
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+
+    // ------------------------------------------------------- GET /api/graph
+    if (req.method === 'GET' && url === '/api/graph') {
+      try {
+        const qs = new URL(req.url, 'http://localhost').searchParams;
+        const dir = qs.get('dir') || projectDir;
+        const d = path.resolve(dir || process.cwd());
+
+        // Find session files — sort by mtime descending before processing
+        const homeDir = os.homedir();
+        const slug = d.replace(/\//g, '-');
+        const sessionsDir = fs.existsSync(path.join(homeDir, '.claude', 'projects', slug))
+          ? path.join(homeDir, '.claude', 'projects', slug)
+          : path.join(d, '.claude', 'sessions');
+
+        let sessionFiles = [];
+        try {
+          sessionFiles = fs.readdirSync(sessionsDir)
+            .filter(f => f.endsWith('.jsonl'))
+            .map(f => ({ f, mtime: (() => { try { return fs.statSync(path.join(sessionsDir, f)).mtimeMs; } catch { return 0; } })() }))
+            .sort((a, b) => b.mtime - a.mtime)
+            .map(({ f }) => f);
+        } catch {}
+
+        // Parse each session: count tool categories + agent type spawns
+        const TOOL_CAT = name => {
+          if (['Read','Write','Edit','MultiEdit','Glob','Grep','LS'].includes(name)) return 'file';
+          if (name === 'Bash') return 'bash';
+          if (['Agent','Task'].includes(name)) return 'agent';
+          if (name.startsWith('mcp__monobrain__memory') || name.startsWith('mcp__monobrain__agentdb')) return 'memory';
+          if (['WebFetch','WebSearch'].includes(name)) return 'web';
+          if (name === 'Skill') return 'skill';
+          return 'other';
+        };
+
+        const nodes = [];
+        const edges = [];
+        const agentTypeNodes = {}; // subagent_type → node id
+
+        for (const fname of sessionFiles) {
+          const sid = fname.replace('.jsonl','');
+          const fp = path.join(sessionsDir, fname);
+          let stat = null;
+          try { stat = fs.statSync(fp); } catch { continue; }
+
+          // Skip files over size cap to avoid memory spikes on large sessions
+          if (stat.size > JSONL_SIZE_CAP) {
+            nodes.push({ id: sid, type: 'session', label: sid.slice(0,8), turns: 0, totalTools: 0,
+              toolCounts: {}, cost: 0, mtime: stat.mtimeMs, size: stat.size, agentSpawns: {}, truncated: true });
+            continue;
+          }
+
+          const toolCounts = {};
+          const agentSpawns = {}; // subagent_type → count
+          let turns = 0, totalCost = 0;
+
+          try {
+            const raw = fs.readFileSync(fp, 'utf8').replace(/\r\n/g, '\n');
+            const lines = raw.split('\n').filter(Boolean);
+            for (const line of lines) {
+              let e; try { e = JSON.parse(line); } catch { continue; }
+              if (e.type === 'user') turns++;
+              if (e.type === 'assistant') {
+                for (const block of (e.message?.content || [])) {
+                  if (!block || block.type !== 'tool_use') continue;
+                  const cat = TOOL_CAT(block.name);
+                  toolCounts[cat] = (toolCounts[cat] || 0) + 1;
+                  if (cat === 'agent') {
+                    const sub = block.input?.subagent_type || block.input?.description || '?';
+                    agentSpawns[sub] = (agentSpawns[sub] || 0) + 1;
+                  }
+                }
+              }
+              if (e.costUSD) totalCost += e.costUSD;
+            }
+          } catch {}
+
+          const totalTools = Object.values(toolCounts).reduce((a,b)=>a+b,0);
+          nodes.push({
+            id: sid, type: 'session', label: sid.slice(0,8),
+            turns, totalTools, toolCounts,
+            cost: totalCost, mtime: stat.mtimeMs, size: stat.size,
+            agentSpawns
+          });
+
+          // Create/link agent type nodes
+          for (const [subType, count] of Object.entries(agentSpawns)) {
+            const nodeId = 'agent::' + subType;
+            if (!agentTypeNodes[subType]) {
+              agentTypeNodes[subType] = true;
+              nodes.push({ id: nodeId, type: 'agenttype', label: subType, totalSpawns: 0 });
+            }
+            const aNode = nodes.find(n => n.id === nodeId);
+            if (aNode) aNode.totalSpawns = (aNode.totalSpawns || 0) + count;
+            edges.push({ source: sid, target: nodeId, weight: count, label: String(count) });
+          }
+        }
+
+        res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', 'Cache-Control': 'no-cache' });
+        res.end(JSON.stringify({ nodes, edges }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+    // ------------------------------------------------------- GET /api/section
+    if (req.method === 'GET' && url === '/api/section') {
+      try {
+        const qs = new URL(req.url, 'http://localhost').searchParams;
+        const name = qs.get('name') || '';
+        const dir = qs.get('dir') || projectDir;
+        const full = qs.get('full') === '1';
+        let partial = buildSectionData(name, dir || process.cwd());
+        // For full knowledge request, include all chunks
+        if (name === 'knowledge' && full) {
+          const chunksPath = path.join(path.resolve(dir || process.cwd()), '.monomind', 'knowledge', 'chunks.jsonl');
+          let allChunks = [];
+          try {
+            const raw = fs.readFileSync(chunksPath, 'utf8');
+            allChunks = raw.split('\n').filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+          } catch {}
+          partial = { knowledge: { ...partial.knowledge, allChunks } };
+        }
+        res.writeHead(200, {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+          'Cache-Control': 'no-cache',
+        });
+        res.end(JSON.stringify(partial));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+    // ------------------------------------------------------- GET /api/stream
+    if (req.method === 'GET' && url === '/api/stream') {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+        'Access-Control-Allow-Origin': '*',
+        'X-Accel-Buffering': 'no',
+      });
+
+      // Keep the connection alive with periodic comments
+      const keepAlive = setInterval(() => {
+        try {
+          res.write(': ping\n\n');
+        } catch {
+          clearInterval(keepAlive);
+        }
+      }, 20_000);
+
+      sseClients.add(res);
+
+      req.on('close', () => {
+        clearInterval(keepAlive);
+        sseClients.delete(res);
+      });
+
+      // Send the initial snapshot immediately
+      try {
+        const snapshot = await collectAll(projectDir);
+        res.write(`data: ${JSON.stringify(snapshot)}\n\n`);
+      } catch (err) {
+        res.write(`data: ${JSON.stringify({ error: err.message })}\n\n`);
+      }
+      return;
+    }
+
+    // ---------------------------------------------------- GET /favicon.ico
+    if (req.method === 'GET' && url === '/favicon.ico') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    // ------------------------------------------------------------------ 404
+    res.writeHead(404, { 'Content-Type': 'text/plain' });
+    res.end('Not found');
+  });
+
+  // Bind to available port
+  const boundPort = await bindServer(server, port);
+  const url = `http://localhost:${boundPort}`;
+
+  // ---------------------------------------------------------------- Watchers
+  let debounceTimer = null;
+  let pendingSections = new Set();
+
+  function scheduleRefresh(event, filename) {
+    const sections = pathToSections(filename);
+    if (sections) sections.forEach(s => pendingSections.add(s));
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      const changed = pendingSections.size > 0
+        ? Array.from(pendingSections)
+        : ['sessions', 'swarm', 'agents', 'tokens', 'hooks', 'memory', 'knowledge', 'metrics'];
+      pendingSections.clear();
+      broadcast({ kind: 'changed', sections: changed });
+    }, 500);
+  }
+
+  // Watch .monomind directory
+  const monomindDir = path.join(projectDir || process.cwd(), '.monomind');
+  if (fs.existsSync(monomindDir)) {
+    try {
+      const w = fs.watch(monomindDir, { recursive: true }, scheduleRefresh);
+      activeWatchers.push(w);
+    } catch {
+      // Directory may not support recursive watch on all platforms — ignore
+    }
+  }
+
+  // Watch .claude/sessions/ if present
+  const claudeSessionsDir = path.join(projectDir || process.cwd(), '.claude', 'sessions');
+  if (fs.existsSync(claudeSessionsDir)) {
+    try {
+      const w = fs.watch(claudeSessionsDir, { recursive: true }, scheduleRefresh);
+      activeWatchers.push(w);
+    } catch {
+      // Ignore unsupported watch
+    }
+  }
+
+  // Update module-level state
+  running = true;
+  currentPort = boundPort;
+  currentUrl = url;
+  activeServer = server;
+
+  // --------------------------------------------------------- Graceful shutdown
+  function shutdown() {
+    for (const w of activeWatchers) {
+      try {
+        w.close();
+      } catch {
+        // Already closed
+      }
+    }
+    activeWatchers.length = 0;
+
+    // Close all SSE connections
+    for (const client of sseClients) {
+      try {
+        client.end();
+      } catch {
+        // Already ended
+      }
+    }
+    sseClients.clear();
+
+    server.close(() => {
+      running = false;
+      currentPort = null;
+      currentUrl = null;
+      activeServer = null;
+    });
+  }
+
+  process.once('SIGTERM', shutdown);
+  process.once('SIGINT', shutdown);
+
+  // ---------------------------------------------------------- Auto-open
+  if (openBrowser) {
+    openUrl(url).catch(() => {
+      // Non-fatal: browser open failure should not crash the server
+    });
+  }
+
+  return { port: boundPort, url, server };
+}
+
+/**
+ * Returns the current server status.
+ */
+export function getServerStatus() {
+  return {
+    running,
+    port: currentPort,
+    url: currentUrl,
+    clientCount: sseClients.size,
+  };
+}