@monoes/monomindcli 1.10.11 → 1.10.13

package/.claude/commands/monomind/adr.md

@@ -0,0 +1,11 @@
+---
+description: Draft an Architecture Decision Record from accumulated decision markers in this session's prompts
+---
+
+Run the hook handler's adr-draft action to scan `.monomind/decisions.jsonl` for the last 7 days of decision markers (e.g. "let's go with X", "we chose Y", "decision: Z") and produce an ADR template in `docs/adrs/`.
+
+```bash
+node "$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs" adr-draft
+```
+
+After running, open the generated `docs/adrs/ADR-NNNN-YYYY-MM-DD-session-decisions.md`, fill in the Context and Consequences sections, and change Status to Accepted/Rejected.

package/.claude/helpers/hook-handler.cjs

@@ -62,6 +62,8 @@ function getMonographSuggestions(taskText, limit) {
     try {
       // BM25 ranks better than degree for keyword relevance; tie-break by deg.
       // File/Function/Class outrank Section so navigable nodes win.
+      // Filter out anonymous lambdas, arrow expressions, and other unnamed
+      // garbage that the AST extraction picks up but isn't navigable.
       rows = db.prepare(
         "SELECT n.id, n.name, n.label, n.file_path AS file, " +
         "bm25(nodes_fts) AS bm25_score, " +
@@ -71,6 +73,8 @@ function getMonographSuggestions(taskText, limit) {
         "FROM nodes_fts f JOIN nodes n ON f.rowid = n.rowid " +
         "WHERE nodes_fts MATCH ? AND n.file_path IS NOT NULL AND n.file_path != '' " +
         "AND n.label NOT IN ('Concept') " +
+        "AND n.name NOT LIKE '(%' AND n.name NOT LIKE '%=>%' AND n.name != 'function' " +
+        "AND length(n.name) >= 3 " +
         "ORDER BY label_rank DESC, bm25_score ASC, deg DESC LIMIT ?"
       ).all(ftsQuery, lim);
     } catch (e) {
@@ -157,6 +161,33 @@ function _recordGraphTelemetry(event) {
   } catch (e) { /* non-fatal */ }
 }
 
+// Re-inject graph god nodes after compaction so the LLM doesn't lose its spatial map.
+function _injectCompactGraphMap() {
+  try {
+    var db = _openMonographDb();
+    if (!db) return;
+    try {
+      var nodeC = db.prepare("SELECT COUNT(*) AS c FROM nodes").get().c;
+      var gods = db.prepare(
+        "SELECT n.name, n.label, n.file_path, " +
+        "(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg " +
+        "FROM nodes n " +
+        "WHERE n.label NOT IN ('Concept') AND n.file_path IS NOT NULL AND n.file_path != '' " +
+        "AND n.name NOT LIKE '(%' AND n.name NOT LIKE '%=>%' AND length(n.name) >= 3 " +
+        "ORDER BY deg DESC LIMIT 8"
+      ).all();
+      if (gods.length > 0) {
+        console.log('[COMPACT_GRAPH] ' + nodeC + ' nodes available. Top spatial anchors:');
+        for (var ci = 0; ci < gods.length; ci++) {
+          var g = gods[ci];
+          console.log('  · ' + g.name + ' [' + g.label + '] — ' + g.file_path + ' (deg ' + g.deg + ')');
+        }
+        console.log('  Use mcp__monomind__monograph_suggest first when navigating.');
+      }
+    } finally { try { db.close(); } catch (_) {} }
+  } catch (e) {}
+}
+
 // ── Loop drift detection ───────────────────────────────────────────────────────
 // Record tool call signatures per session, warn when the same call recurs ≥3×.
 function _recordToolCall(signature) {
@@ -1130,6 +1161,7 @@ const handlers = {
         if (clean.length >= 3) {
           var hits = getMonographSuggestions(clean, 5);
           if (hits.length > 0) {
+            _recordGraphTelemetry('graph_assist_search');
             console.log('[MONOGRAPH_HIT] Graph has ' + hits.length + ' file(s) for "' + clean.slice(0, 40) + '" — consider monograph_query instead of shell grep:');
             for (var j = 0; j < hits.length; j++) {
               var h = hits[j];
@@ -1154,7 +1186,6 @@ const handlers = {
       var clean = pattern.replace(/[\\^$.*+?()\[\]{}|]/g, ' ').trim();
       if (clean.length < 3) return;
 
-      // Loop drift detection
       var sig = (toolName || 'Search') + ':' + clean.slice(0, 60);
       var count = _recordToolCall(sig);
       if (count >= 3) {
@@ -1162,6 +1193,9 @@ const handlers = {
       }
       var suggestions = getMonographSuggestions(clean, 5);
       if (suggestions.length === 0) return;
+      // Successful intercept — count as a "graph assist" so the ratio reflects
+      // server-side wins, not just LLM-initiated MCP calls.
+      _recordGraphTelemetry('graph_assist_search');
       console.log('[MONOGRAPH_HIT] Graph already knows ' + suggestions.length + ' file(s) matching "' + clean.slice(0, 40) + '":');
       for (var i = 0; i < suggestions.length; i++) {
         var s = suggestions[i];
@@ -1183,6 +1217,7 @@ const handlers = {
       if (n.importedBy.length > 0) parts.push('imported-by: ' + n.importedBy.slice(0, 4).join(', '));
       if (n.imports.length > 0)    parts.push('imports: '    + n.imports.slice(0, 4).join(', '));
       if (parts.length === 0) return;
+      _recordGraphTelemetry('graph_assist_neighbors');
       console.log('[MONOGRAPH_NEIGHBORS] ' + parts.join(' · '));
     } catch (e) { /* non-fatal */ }
   },
@@ -2080,11 +2115,9 @@ const handlers = {
   },
 
   'compact-manual': async () => {
-    // Consolidate intelligence before compaction so patterns survive
     if (intelligence && intelligence.consolidate) {
       try { await runWithTimeout(function() { return intelligence.consolidate(); }, 'intelligence.consolidate()'); } catch (e) { /* non-fatal */ }
     }
-    // Save current routing context for post-compact restore
     try {
       var lastRoute = path.join(CWD, '.monomind', 'last-route.json');
       if (fs.existsSync(lastRoute)) {
@@ -2092,11 +2125,11 @@ const handlers = {
         console.log('[COMPACT_CONTEXT] Last route: ' + route.agent + ' (' + (route.confidence != null ? (route.confidence * 100).toFixed(0) : '?') + '%)');
       }
     } catch (e) { /* non-fatal */ }
+    _injectCompactGraphMap();
     console.log('[COMPACT] Manual compaction — intelligence consolidated, context preserved');
   },
 
   'compact-auto': async () => {
-    // Same consolidation for auto-compact
     if (intelligence && intelligence.consolidate) {
       try { await runWithTimeout(function() { return intelligence.consolidate(); }, 'intelligence.consolidate()'); } catch (e) { /* non-fatal */ }
     }
@@ -2107,6 +2140,7 @@ const handlers = {
         console.log('[COMPACT_CONTEXT] Last route: ' + route.agent + ' (' + (route.confidence != null ? (route.confidence * 100).toFixed(0) : '?') + '%)');
       }
     } catch (e) { /* non-fatal */ }
+    _injectCompactGraphMap();
     console.log('[COMPACT] Auto compaction — intelligence consolidated, context preserved');
     console.log('GOLDEN RULE: 1 message = all parallel operations');
   },
@@ -2199,6 +2233,62 @@ const handlers = {
     console.log('[OK] Agent registered');
   },
 
+  // Draft an ADR from accumulated decision markers in .monomind/decisions.jsonl.
+  // Usage: node hook-handler.cjs adr-draft   (or via /adr slash command)
+  'adr-draft': () => {
+    var jsonl = path.join(CWD, '.monomind', 'decisions.jsonl');
+    if (!fs.existsSync(jsonl)) {
+      console.log('[ADR] No decisions recorded yet. Type prompts containing markers like "let\'s go with X", "we chose Y", "decision: Z" to populate the log.');
+      return;
+    }
+    var lines = fs.readFileSync(jsonl, 'utf-8').trim().split('\n').filter(Boolean);
+    if (lines.length === 0) {
+      console.log('[ADR] decisions.jsonl is empty.');
+      return;
+    }
+    // Group decisions captured in the last 7 days
+    var cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    var recent = lines.map(function(l) { try { return JSON.parse(l); } catch (_) { return null; } })
+                       .filter(function(d) { return d && d.ts >= cutoff; });
+    if (recent.length === 0) {
+      console.log('[ADR] No decisions in the last 7 days. Older entries: ' + lines.length + '.');
+      return;
+    }
+
+    var adrsDir = path.join(CWD, 'docs', 'adrs');
+    try { fs.mkdirSync(adrsDir, { recursive: true }); } catch (_) {}
+    // Pick next ADR number
+    var existing = [];
+    try { existing = fs.readdirSync(adrsDir).filter(function(f) { return /^ADR-\d{4}/.test(f); }); } catch (_) {}
+    var nextNum = existing.length + 1;
+    var num = String(nextNum).padStart(4, '0');
+    var stamp = new Date().toISOString().slice(0,10);
+    var slug = 'session-decisions';
+    var fname = 'ADR-' + num + '-' + stamp + '-' + slug + '.md';
+    var outPath = path.join(adrsDir, fname);
+
+    var body = '# ADR-' + num + ': Session decisions (' + stamp + ')\n\n' +
+               '**Status:** Proposed\n**Date:** ' + stamp + '\n\n' +
+               '## Context\n\n' +
+               'During recent sessions, the following decision markers were captured ' +
+               'from user prompts. Each excerpt is the surrounding sentence at the time.\n\n' +
+               '## Decisions\n\n';
+    for (var i = 0; i < recent.length; i++) {
+      var d = recent[i];
+      var date = new Date(d.ts).toISOString().slice(0,16).replace('T',' ');
+      body += '### ' + (i + 1) + '. ' + date + '\n\n';
+      for (var j = 0; j < d.excerpts.length; j++) {
+        body += '> ' + d.excerpts[j].trim() + '\n\n';
+      }
+      if (d.prompt) body += '_Prompt:_ ' + d.prompt.slice(0, 200) + (d.prompt.length > 200 ? '…' : '') + '\n\n';
+    }
+    body += '## Consequences\n\n_(fill in after review)_\n\n' +
+            '## Status\n\nProposed — awaiting human review and refinement.\n';
+    fs.writeFileSync(outPath, body);
+    console.log('[ADR_DRAFT] Wrote ' + recent.length + ' decision(s) to ' + outPath);
+    console.log('  Edit the file to fill in Context and Consequences, then change Status to Accepted/Rejected.');
+  },
+
   'status': () => {
     console.log('[OK] Status check');
   },

package/.claude/helpers/statusline.cjs

@@ -720,21 +720,27 @@ function getHookLatency() {
   } catch { return null; }
 }
 
-// Graph usage telemetry — ratio of monograph_* vs Grep/Glob, plus $ saved
+// Graph usage telemetry — counts ALL graph wins (MCP calls + silent assists)
+// vs greps that got no graph help. "graph %" reflects how often the graph
+// actually touched the LLM's flow, not just how often the LLM invoked MCP.
 function getGraphUsage() {
   const usagePath = path.join(CWD, '.monomind', 'metrics', 'graph-usage.json');
   try {
     if (!fs.existsSync(usagePath)) return null;
     const d = JSON.parse(fs.readFileSync(usagePath, 'utf-8'));
-    const monograph = d.monograph_call || 0;
-    const search = (d.grep_call || 0) + (d.glob_call || 0)
-                 + (d.bash_grep_call || 0) + (d.bash_find_call || 0);
-    const total = monograph + search;
+    const graphWins =
+        (d.monograph_call || 0)           // LLM-initiated MCP monograph tool call
+      + (d.preresolve_hit || 0)           // route hook injected pre-resolved files
+      + (d.graph_assist_search || 0)      // pre-search / pre-bash injected hits
+      + (d.graph_assist_neighbors || 0);  // post-read neighbor footer
+    const searches = (d.grep_call || 0) + (d.glob_call || 0)
+                   + (d.bash_grep_call || 0) + (d.bash_find_call || 0);
+    const total = graphWins + searches;
     if (total === 0) return null;
     return {
-      monograph,
-      search,
-      pct: Math.round((monograph / total) * 100),
+      graphWins,
+      searches,
+      pct: Math.round((graphWins / total) * 100),
       dollarsSaved: d.dollars_saved || 0,
     };
   } catch { return null; }

package/dist/src/init/statusline-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"statusline-generator.d.ts","sourceRoot":"","sources":["../../../src/init/statusline-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CA4qCrE;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CA8BnE"}
+{"version":3,"file":"statusline-generator.d.ts","sourceRoot":"","sources":["../../../src/init/statusline-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CA8qCrE;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CA8BnE"}

package/dist/src/init/statusline-generator.js

@@ -849,18 +849,20 @@ function getHookLatency() {
   } catch { return null; }
 }
 
-// Graph usage telemetry — ratio of monograph_* vs Grep/Glob/Bash-grep, + $ saved
+// Graph usage telemetry — counts ALL graph wins (MCP calls + silent assists)
+// vs greps that got no graph help.
 function getGraphUsage() {
   const usagePath = path.join(CWD, '.monomind', 'metrics', 'graph-usage.json');
   try {
     if (!fs.existsSync(usagePath)) return null;
     const d = JSON.parse(fs.readFileSync(usagePath, 'utf-8'));
-    const monograph = d.monograph_call || 0;
-    const search = (d.grep_call || 0) + (d.glob_call || 0)
-                 + (d.bash_grep_call || 0) + (d.bash_find_call || 0);
-    const total = monograph + search;
+    const graphWins = (d.monograph_call || 0) + (d.preresolve_hit || 0)
+                    + (d.graph_assist_search || 0) + (d.graph_assist_neighbors || 0);
+    const searches = (d.grep_call || 0) + (d.glob_call || 0)
+                   + (d.bash_grep_call || 0) + (d.bash_find_call || 0);
+    const total = graphWins + searches;
     if (total === 0) return null;
-    return { monograph: monograph, search: search, pct: Math.round((monograph / total) * 100), dollarsSaved: d.dollars_saved || 0 };
+    return { graphWins: graphWins, searches: searches, pct: Math.round((graphWins / total) * 100), dollarsSaved: d.dollars_saved || 0 };
   } catch { return null; }
 }
 

package/dist/src/init/statusline-generator.js.map

@@ -1 +1 @@
-{"version":3,"file":"statusline-generator.js","sourceRoot":"","sources":["../../../src/init/statusline-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAAoB;IAC3D,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC;IAC5C,OAAO;;;;;;;;;;;;;;;;;;;;;;;eAuBM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkpCvB,CAAC;AACF,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,OAAoB;IACzD,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;QAChC,OAAO,sCAAsC,CAAC;IAChD,CAAC;IAED,OAAO;;;;;;;;;;;;;;;;;;;;;;;;CAwBR,CAAC;AACF,CAAC"}
+{"version":3,"file":"statusline-generator.js","sourceRoot":"","sources":["../../../src/init/statusline-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAAoB;IAC3D,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC;IAC5C,OAAO;;;;;;;;;;;;;;;;;;;;;;;eAuBM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAopCvB,CAAC;AACF,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,OAAoB;IACzD,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;QAChC,OAAO,sCAAsC,CAAC;IAChD,CAAC;IAED,OAAO;;;;;;;;;;;;;;;;;;;;;;;;CAwBR,CAAC;AACF,CAAC"}

package/dist/src/ui/server.mjs

@@ -2128,6 +2128,70 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
       return;
     }
 
+    // ------------------------------------------------- Monograph
+    // GET /api/monograph — node/edge counts, top god nodes, type distribution.
+    // (Distinct from /api/graph which serves session/journal graph data.)
+    // Reads .monomind/monograph.db via sqlite3 CLI to avoid bundling better-sqlite3.
+    if (req.method === 'GET' && url === '/api/monograph') {
+      try {
+        const dbPath = path.join(projectDir || process.cwd(), '.monomind', 'monograph.db');
+        if (!fs.existsSync(dbPath)) {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ exists: false }));
+          return;
+        }
+        const { execSync } = await import('child_process');
+        // Pipe SQL via stdin to avoid shell quoting issues with single-quoted SQL strings.
+        const runSql = (sql, timeout = 5000) => {
+          try {
+            return execSync(`sqlite3 -json "${dbPath}"`,
+              { encoding: 'utf-8', timeout: timeout, input: sql + ';' });
+          } catch (e) { return '[]'; }
+        };
+        const counts = JSON.parse(runSql(
+          "SELECT (SELECT COUNT(*) FROM nodes) AS nodes, (SELECT COUNT(*) FROM edges) AS edges;"
+        ) || '[{}]')[0] || { nodes: 0, edges: 0 };
+        // Compute degree in one pass via GROUP BY (much faster than per-row subquery).
+        const gods = JSON.parse(runSql(
+          "WITH deg(node_id, d) AS (" +
+          "  SELECT source_id, COUNT(*) FROM edges GROUP BY source_id " +
+          "  UNION ALL " +
+          "  SELECT target_id, COUNT(*) FROM edges GROUP BY target_id" +
+          "), totals AS (" +
+          "  SELECT node_id, SUM(d) AS deg FROM deg GROUP BY node_id" +
+          ") " +
+          "SELECT n.name, n.label, n.file_path, t.deg " +
+          "FROM nodes n JOIN totals t ON t.node_id = n.id " +
+          "WHERE n.label NOT IN ('Concept') " +
+          "AND n.file_path IS NOT NULL AND n.file_path != '' " +
+          "AND n.name NOT LIKE '(%' AND length(n.name) >= 3 " +
+          "ORDER BY t.deg DESC LIMIT 20",
+          10000
+        ) || '[]');
+        const types = JSON.parse(runSql(
+          "SELECT label, COUNT(*) AS count FROM nodes GROUP BY label ORDER BY count DESC LIMIT 12"
+        ) || '[]');
+        const relations = JSON.parse(runSql(
+          "SELECT relation, COUNT(*) AS count FROM edges GROUP BY relation ORDER BY count DESC"
+        ) || '[]');
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          exists: true,
+          nodes: counts.nodes,
+          edges: counts.edges,
+          godNodes: gods,
+          typeDistribution: types,
+          relationDistribution: relations,
+          updatedAt: fs.statSync(dbPath).mtime,
+        }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: String(err) }));
+      }
+      return;
+    }
+
     // ------------------------------------------------- Org management
     // GET /api/orgs — list all saved org configs
     if (req.method === 'GET' && url === '/api/orgs') {