@vohongtho.infotech/code-intel 1.0.0 → 1.0.1

package/dist/index.js

@@ -6,12 +6,13 @@ import { SEMRESATTRS_DEPLOYMENT_ENVIRONMENT, SEMRESATTRS_SERVICE_NAME } from '@o
 import { trace, context, SpanStatusCode } from '@opentelemetry/api';
 import winston from 'winston';
 import DailyRotateFile from 'winston-daily-rotate-file';
-import fs25, { existsSync } from 'fs';
+import fs26, { existsSync } from 'fs';
 import path32 from 'path';
 import os13 from 'os';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
 import { Parser, Language, Query } from 'web-tree-sitter';
+import { Database, Connection } from '@ladybugdb/core';
 import { execSync } from 'child_process';
 import Database2 from 'better-sqlite3';
 import bcrypt from 'bcrypt';
@@ -24,7 +25,6 @@ import 'events';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { Database, Connection } from '@ladybugdb/core';
 import express from 'express';
 import compression from 'compression';
 import cors from 'cors';
@@ -56,6 +56,135 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/graph/knowledge-graph.ts
+var knowledge_graph_exports = {};
+__export(knowledge_graph_exports, {
+  createKnowledgeGraph: () => createKnowledgeGraph
+});
+function createKnowledgeGraph() {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const edgesByKind = /* @__PURE__ */ new Map();
+  const edgesFromNode = /* @__PURE__ */ new Map();
+  const edgesToNode = /* @__PURE__ */ new Map();
+  function indexEdge(edge) {
+    let kindSet = edgesByKind.get(edge.kind);
+    if (!kindSet) {
+      kindSet = /* @__PURE__ */ new Set();
+      edgesByKind.set(edge.kind, kindSet);
+    }
+    kindSet.add(edge.id);
+    let fromSet = edgesFromNode.get(edge.source);
+    if (!fromSet) {
+      fromSet = /* @__PURE__ */ new Set();
+      edgesFromNode.set(edge.source, fromSet);
+    }
+    fromSet.add(edge.id);
+    let toSet = edgesToNode.get(edge.target);
+    if (!toSet) {
+      toSet = /* @__PURE__ */ new Set();
+      edgesToNode.set(edge.target, toSet);
+    }
+    toSet.add(edge.id);
+  }
+  function unindexEdge(edge) {
+    edgesByKind.get(edge.kind)?.delete(edge.id);
+    edgesFromNode.get(edge.source)?.delete(edge.id);
+    edgesToNode.get(edge.target)?.delete(edge.id);
+  }
+  return {
+    addNode(node) {
+      nodes.set(node.id, node);
+    },
+    addEdge(edge) {
+      edges.set(edge.id, edge);
+      indexEdge(edge);
+    },
+    getNode(id) {
+      return nodes.get(id);
+    },
+    getEdge(id) {
+      return edges.get(id);
+    },
+    *findEdgesByKind(kind) {
+      const ids = edgesByKind.get(kind);
+      if (!ids) return;
+      for (const id of ids) {
+        const edge = edges.get(id);
+        if (edge) yield edge;
+      }
+    },
+    *findEdgesFrom(sourceId) {
+      const ids = edgesFromNode.get(sourceId);
+      if (!ids) return;
+      for (const id of ids) {
+        const edge = edges.get(id);
+        if (edge) yield edge;
+      }
+    },
+    *findEdgesTo(targetId) {
+      const ids = edgesToNode.get(targetId);
+      if (!ids) return;
+      for (const id of ids) {
+        const edge = edges.get(id);
+        if (edge) yield edge;
+      }
+    },
+    removeNodeCascade(id) {
+      const fromEdges = edgesFromNode.get(id);
+      if (fromEdges) {
+        for (const edgeId of [...fromEdges]) {
+          const edge = edges.get(edgeId);
+          if (edge) {
+            unindexEdge(edge);
+            edges.delete(edgeId);
+          }
+        }
+      }
+      const toEdges = edgesToNode.get(id);
+      if (toEdges) {
+        for (const edgeId of [...toEdges]) {
+          const edge = edges.get(edgeId);
+          if (edge) {
+            unindexEdge(edge);
+            edges.delete(edgeId);
+          }
+        }
+      }
+      edgesFromNode.delete(id);
+      edgesToNode.delete(id);
+      nodes.delete(id);
+    },
+    removeEdge(id) {
+      const edge = edges.get(id);
+      if (edge) {
+        unindexEdge(edge);
+        edges.delete(id);
+      }
+    },
+    *allNodes() {
+      yield* nodes.values();
+    },
+    *allEdges() {
+      yield* edges.values();
+    },
+    get size() {
+      return { nodes: nodes.size, edges: edges.size };
+    },
+    clear() {
+      nodes.clear();
+      edges.clear();
+      edgesByKind.clear();
+      edgesFromNode.clear();
+      edgesToNode.clear();
+    }
+  };
+}
+var init_knowledge_graph = __esm({
+  "src/graph/knowledge-graph.ts"() {
+  }
+});
+
 // src/graph/id-generator.ts
 function generateNodeId(kind, filePath, qualifiedName) {
   return `${kind}:${filePath}:${qualifiedName}`;
@@ -68,6 +197,64 @@ var init_id_generator = __esm({
   }
 });
 
+// src/storage/schema.ts
+function getCreateNodeTableDDL(tableName) {
+  return `CREATE NODE TABLE IF NOT EXISTS ${tableName} (
+  id STRING,
+  name STRING,
+  file_path STRING,
+  start_line INT64,
+  end_line INT64,
+  exported BOOLEAN,
+  content STRING,
+  metadata STRING,
+  PRIMARY KEY (id)
+)`;
+}
+function getCreateEdgeTableDDL() {
+  const uniqueTables = ALL_NODE_TABLES;
+  const fromToPairs = [];
+  for (const from of uniqueTables) {
+    for (const to of uniqueTables) {
+      fromToPairs.push(`FROM ${from} TO ${to}`);
+    }
+  }
+  return [`CREATE REL TABLE GROUP IF NOT EXISTS code_edges (
+  ${fromToPairs.join(",\n  ")},
+  kind STRING,
+  weight DOUBLE,
+  label STRING
+)`];
+}
+var NODE_TABLE_MAP, ALL_NODE_TABLES;
+var init_schema = __esm({
+  "src/storage/schema.ts"() {
+    NODE_TABLE_MAP = {
+      file: "file_nodes",
+      directory: "dir_nodes",
+      function: "func_nodes",
+      class: "class_nodes",
+      interface: "iface_nodes",
+      method: "method_nodes",
+      constructor: "ctor_nodes",
+      variable: "var_nodes",
+      property: "prop_nodes",
+      struct: "struct_nodes",
+      enum: "enum_nodes",
+      trait: "trait_nodes",
+      namespace: "ns_nodes",
+      module: "mod_nodes",
+      type_alias: "type_nodes",
+      constant: "const_nodes",
+      route: "route_nodes",
+      cluster: "cluster_nodes",
+      flow: "flow_nodes",
+      vulnerability: "vuln_nodes"
+    };
+    ALL_NODE_TABLES = [...new Set(Object.values(NODE_TABLE_MAP))];
+  }
+});
+
 // src/observability/tracing.ts
 var tracing_exports = {};
 __export(tracing_exports, {
@@ -344,8 +531,8 @@ var init_logger = __esm({
           transports.push(new winston.transports.Console());
           if (!isProduction) {
             try {
-              if (!fs25.existsSync(_Logger.LOG_DIR)) {
-                fs25.mkdirSync(_Logger.LOG_DIR, { recursive: true });
+              if (!fs26.existsSync(_Logger.LOG_DIR)) {
+                fs26.mkdirSync(_Logger.LOG_DIR, { recursive: true });
               }
               transports.push(
                 new DailyRotateFile({
@@ -1961,7 +2148,7 @@ var init_parse_phase = __esm({
           const batch = filePaths.slice(i, i + CONCURRENCY);
           await Promise.all(batch.map(async (filePath) => {
             try {
-              const source = await fs25.promises.readFile(filePath, "utf-8");
+              const source = await fs26.promises.readFile(filePath, "utf-8");
               context2.fileCache.set(filePath, source);
             } catch {
             }
@@ -2575,6 +2762,65 @@ var init_embedder = __esm({
   }
 });
 
+// src/storage/db-manager.ts
+var db_manager_exports = {};
+__export(db_manager_exports, {
+  DbManager: () => DbManager
+});
+var DbManager;
+var init_db_manager = __esm({
+  "src/storage/db-manager.ts"() {
+    DbManager = class {
+      db = null;
+      conn = null;
+      dbPath;
+      readOnly;
+      constructor(dbPath, readOnly = false) {
+        this.dbPath = dbPath;
+        this.readOnly = readOnly;
+      }
+      async init() {
+        if (!this.readOnly) {
+          fs26.mkdirSync(path32.dirname(this.dbPath), { recursive: true });
+        }
+        this.db = new Database(this.dbPath, 0, true, this.readOnly);
+        await this.db.init();
+        this.conn = new Connection(this.db);
+        await this.conn.init();
+      }
+      async query(cypher) {
+        if (!this.conn) throw new Error("Database not initialized");
+        const result = await this.conn.query(cypher);
+        const qr = Array.isArray(result) ? result[0] : result;
+        const rows = await qr.getAll();
+        qr.close();
+        return rows;
+      }
+      async execute(cypher) {
+        if (!this.conn) throw new Error("Database not initialized");
+        const result = await this.conn.query(cypher);
+        const qr = Array.isArray(result) ? result[0] : result;
+        qr.close();
+      }
+      close() {
+        try {
+          this.conn?.closeSync();
+        } catch {
+        }
+        try {
+          this.db?.closeSync();
+        } catch {
+        }
+        this.conn = null;
+        this.db = null;
+      }
+      get isOpen() {
+        return this.conn !== null;
+      }
+    };
+  }
+});
+
 // src/multi-repo/group-registry.ts
 var group_registry_exports = {};
 __export(group_registry_exports, {
@@ -2593,23 +2839,23 @@ function groupFile(name) {
 }
 function loadGroup(name) {
   try {
-    return JSON.parse(fs25.readFileSync(groupFile(name), "utf-8"));
+    return JSON.parse(fs26.readFileSync(groupFile(name), "utf-8"));
   } catch {
     return null;
   }
 }
 function saveGroup(group) {
-  fs25.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs25.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
+  fs26.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs26.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
 }
 function listGroups() {
   const groups = [];
   try {
-    for (const file of fs25.readdirSync(GROUPS_DIR)) {
+    for (const file of fs26.readdirSync(GROUPS_DIR)) {
       if (!file.endsWith(".json") || file.endsWith(".sync.json")) continue;
       try {
         const g = JSON.parse(
-          fs25.readFileSync(path32.join(GROUPS_DIR, file), "utf-8")
+          fs26.readFileSync(path32.join(GROUPS_DIR, file), "utf-8")
         );
         groups.push(g);
       } catch {
@@ -2621,16 +2867,16 @@ function listGroups() {
 }
 function deleteGroup(name) {
   try {
-    fs25.unlinkSync(groupFile(name));
+    fs26.unlinkSync(groupFile(name));
   } catch {
   }
   try {
-    fs25.unlinkSync(path32.join(GROUPS_DIR, `${name}.sync.json`));
+    fs26.unlinkSync(path32.join(GROUPS_DIR, `${name}.sync.json`));
   } catch {
   }
 }
 function groupExists(name) {
-  return fs25.existsSync(groupFile(name));
+  return fs26.existsSync(groupFile(name));
 }
 function addMember(groupName, member) {
   const group = loadGroup(groupName);
@@ -2656,8 +2902,8 @@ function removeMember(groupName, groupPath) {
   return group;
 }
 function saveSyncResult(result) {
-  fs25.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs25.writeFileSync(
+  fs26.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs26.writeFileSync(
     path32.join(GROUPS_DIR, `${result.groupName}.sync.json`),
     JSON.stringify(result, null, 2) + "\n"
   );
@@ -2665,7 +2911,7 @@ function saveSyncResult(result) {
 function loadSyncResult(groupName) {
   try {
     return JSON.parse(
-      fs25.readFileSync(path32.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
+      fs26.readFileSync(path32.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
     );
   } catch {
     return null;
@@ -2678,6 +2924,86 @@ var init_group_registry = __esm({
   }
 });
 
+// src/multi-repo/graph-from-db.ts
+var graph_from_db_exports = {};
+__export(graph_from_db_exports, {
+  loadGraphFromDB: () => loadGraphFromDB
+});
+function parseRow(row, kind) {
+  return {
+    id: String(row["id"] ?? ""),
+    kind,
+    name: String(row["name"] ?? ""),
+    filePath: String(row["file_path"] ?? ""),
+    startLine: row["start_line"] != null ? Number(row["start_line"]) : void 0,
+    endLine: row["end_line"] != null ? Number(row["end_line"]) : void 0,
+    exported: row["exported"] != null ? Boolean(row["exported"]) : void 0,
+    content: row["content"] ? String(row["content"]) : void 0,
+    metadata: row["metadata"] ? (() => {
+      try {
+        return JSON.parse(String(row["metadata"]));
+      } catch {
+        return void 0;
+      }
+    })() : void 0
+  };
+}
+async function loadGraphFromDB(graph, db) {
+  for (const table of ALL_NODE_TABLES) {
+    const kind = TABLE_TO_KIND2[table];
+    if (!kind) continue;
+    let rows = [];
+    try {
+      rows = await db.query(`MATCH (n:${table}) RETURN n.id, n.name, n.file_path, n.start_line, n.end_line, n.exported, n.content, n.metadata`);
+    } catch {
+      continue;
+    }
+    for (const row of rows) {
+      const node = parseRow({
+        id: row["n.id"],
+        name: row["n.name"],
+        file_path: row["n.file_path"],
+        start_line: row["n.start_line"],
+        end_line: row["n.end_line"],
+        exported: row["n.exported"],
+        content: row["n.content"],
+        metadata: row["n.metadata"]
+      }, kind);
+      if (node.id && node.name) graph.addNode(node);
+    }
+  }
+  try {
+    const edgeRows = await db.query(
+      `MATCH (a)-[e:code_edges]->(b) RETURN a.id, b.id, e.kind, e.weight, e.label`
+    );
+    for (const row of edgeRows) {
+      const sourceId = String(row["a.id"] ?? "");
+      const targetId = String(row["b.id"] ?? "");
+      const kind = String(row["e.kind"] ?? "");
+      if (!sourceId || !targetId || !kind) continue;
+      const edge = {
+        id: `${sourceId}::${kind}::${targetId}`,
+        source: sourceId,
+        target: targetId,
+        kind,
+        weight: row["e.weight"] != null ? Number(row["e.weight"]) : void 0,
+        label: row["e.label"] ? String(row["e.label"]) : void 0
+      };
+      graph.addEdge(edge);
+    }
+  } catch {
+  }
+}
+var TABLE_TO_KIND2;
+var init_graph_from_db = __esm({
+  "src/multi-repo/graph-from-db.ts"() {
+    init_schema();
+    TABLE_TO_KIND2 = Object.fromEntries(
+      Object.entries(NODE_TABLE_MAP).map(([kind, table]) => [table, kind])
+    );
+  }
+});
+
 // src/health/dead-code.ts
 function detectDeadCode(graph) {
   const results = [];
@@ -4000,7 +4326,7 @@ var init_secret_scanner = __esm({
         const ignorePatterns = [...options?.ignorePatterns ?? []];
         if (options?.workspaceRoot) {
           try {
-            const raw = fs25.readFileSync(path32.join(options.workspaceRoot, ".codeintelignore"), "utf-8");
+            const raw = fs26.readFileSync(path32.join(options.workspaceRoot, ".codeintelignore"), "utf-8");
             for (const line of raw.split("\n")) {
               const trimmed = line.trim();
               if (trimmed && !trimmed.startsWith("#")) ignorePatterns.push(trimmed);
@@ -4288,10 +4614,10 @@ var init_codes = __esm({
   }
 });
 function secureMkdir(dir) {
-  fs25.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
+  fs26.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
   if (process.platform !== "win32") {
     try {
-      fs25.chmodSync(dir, SECURE_DIR_MODE);
+      fs26.chmodSync(dir, SECURE_DIR_MODE);
     } catch {
     }
   }
@@ -4299,17 +4625,17 @@ function secureMkdir(dir) {
 function secureChmodFile(file) {
   if (process.platform === "win32") return;
   try {
-    fs25.chmodSync(file, SECURE_FILE_MODE);
+    fs26.chmodSync(file, SECURE_FILE_MODE);
   } catch {
   }
 }
 function tightenDbFiles(dir) {
   if (process.platform === "win32") return;
-  if (!fs25.existsSync(dir)) return;
-  for (const name of fs25.readdirSync(dir)) {
+  if (!fs26.existsSync(dir)) return;
+  for (const name of fs26.readdirSync(dir)) {
     if (name.endsWith(".db") || name.endsWith(".db-wal") || name.endsWith(".db-shm")) {
       try {
-        fs25.chmodSync(path32.join(dir, name), SECURE_FILE_MODE);
+        fs26.chmodSync(path32.join(dir, name), SECURE_FILE_MODE);
       } catch {
       }
     }
@@ -4647,8 +4973,8 @@ function decryptSecrets(encrypted) {
   return JSON.parse(plaintext.toString("utf8"));
 }
 function loadSecrets(secretsPath = getSecretsPath()) {
-  if (!fs25.existsSync(secretsPath)) return {};
-  const blob = fs25.readFileSync(secretsPath);
+  if (!fs26.existsSync(secretsPath)) return {};
+  const blob = fs26.readFileSync(secretsPath);
   return decryptSecrets(blob);
 }
 function getSecret(key, secretsPath = getSecretsPath()) {
@@ -4669,11 +4995,18 @@ function getSessionTtlMs() {
   const hours = parseInt(process.env["CODE_INTEL_SESSION_TTL_HOURS"] ?? "8", 10);
   return (isNaN(hours) ? 8 : hours) * 60 * 60 * 1e3;
 }
-function createSession(user) {
+function createSession(user, rememberMe = false) {
   const sessionId = v4();
-  const expiresAt = Date.now() + getSessionTtlMs();
-  sessionStore.set(sessionId, { userId: user.id, username: user.username, role: user.role, expiresAt });
-  return sessionId;
+  const ttlMs = rememberMe ? REMEMBER_ME_TTL_MS : getSessionTtlMs();
+  const expiresAt = Date.now() + ttlMs;
+  sessionStore.set(sessionId, {
+    userId: user.id,
+    username: user.username,
+    role: user.role,
+    expiresAt,
+    ttlMs
+  });
+  return { sessionId, ttlMs };
 }
 function getSession(sessionId) {
   const entry = sessionStore.get(sessionId);
@@ -4682,10 +5015,9 @@ function getSession(sessionId) {
     sessionStore.delete(sessionId);
     return null;
   }
-  const ttlMs = getSessionTtlMs();
   const remaining = entry.expiresAt - Date.now();
-  if (remaining < ttlMs * 0.75) {
-    entry.expiresAt = Date.now() + ttlMs;
+  if (remaining < entry.ttlMs * 0.75) {
+    entry.expiresAt = Date.now() + entry.ttlMs;
   }
   return entry;
 }
@@ -4705,7 +5037,7 @@ function authMiddleware(req, res, next) {
     const session = getSession(sessionId);
     if (session) {
       req.user = { id: session.userId, username: session.username, role: session.role, authMethod: "session" };
-      res.setHeader("Set-Cookie", buildSessionCookie(sessionId));
+      res.setHeader("Set-Cookie", buildSessionCookie(sessionId, session.ttlMs));
       next();
       return;
     }
@@ -4875,9 +5207,9 @@ function parseCookies(cookieHeader) {
   }
   return result;
 }
-function buildSessionCookie(sessionId) {
+function buildSessionCookie(sessionId, ttlMs) {
   const isProduction = process.env["NODE_ENV"] === "production";
-  const maxAge = Math.floor(getSessionTtlMs() / 1e3);
+  const maxAge = Math.floor((ttlMs ?? getSessionTtlMs()) / 1e3);
   const parts = [
     `${SESSION_COOKIE_NAME}=${encodeURIComponent(sessionId)}`,
     `HttpOnly`,
@@ -4894,7 +5226,7 @@ function clearSessionCookie() {
 async function verifyPassword(plain, hash) {
   return bcrypt.compare(plain, hash);
 }
-var sessionStore, SESSION_COOKIE_NAME, ROLE_RANK;
+var sessionStore, SESSION_COOKIE_NAME, REMEMBER_ME_TTL_MS, ROLE_RANK;
 var init_middleware = __esm({
   "src/auth/middleware.ts"() {
     init_users_db();
@@ -4902,6 +5234,7 @@ var init_middleware = __esm({
     init_secret_store();
     sessionStore = /* @__PURE__ */ new Map();
     SESSION_COOKIE_NAME = "code_intel_session";
+    REMEMBER_ME_TTL_MS = 12 * 60 * 60 * 1e3;
     ROLE_RANK = {
       viewer: 1,
       "repo-owner": 2,
@@ -4982,236 +5315,64 @@ var init_websocket_server = __esm({
       wss;
       clients = /* @__PURE__ */ new Set();
       constructor(httpServer) {
-        this.wss = new WebSocketServer({ server: httpServer, path: "/ws" });
-        this.wss.on("connection", (ws, req) => {
-          const user = verifyWebSocketHandshake(req);
-          if (!user) {
-            logger_default.warn("[ws] rejected unauthenticated connection");
-            ws.close(4401, "Unauthorized");
-            return;
-          }
-          logger_default.info(`[ws] client connected: ${user.username}`);
-          this.clients.add(ws);
-          ws.on("close", () => {
-            this.clients.delete(ws);
-            logger_default.info(`[ws] client disconnected: ${user.username}`);
-          });
-          ws.on("error", (err) => {
-            logger_default.warn("[ws] client error:", err.message);
-            this.clients.delete(ws);
-          });
-        });
-        this.wss.on("error", (err) => {
-          logger_default.warn("[ws] server error:", err.message);
-        });
-      }
-      /** Broadcast a message to all authenticated connected clients. */
-      broadcast(msg) {
-        const payload = JSON.stringify(msg);
-        let sent = 0;
-        for (const client of this.clients) {
-          if (client.readyState === WebSocket.OPEN) {
-            client.send(payload);
-            sent++;
-          }
-        }
-        logger_default.info(`[ws] broadcast \u2192 ${sent} client(s)`);
-      }
-      get clientCount() {
-        return this.clients.size;
-      }
-      close() {
-        for (const client of this.clients) {
-          try {
-            client.close();
-          } catch {
-          }
-        }
-        this.clients.clear();
-        this.wss.close();
-      }
-    };
-  }
-});
-
-// src/graph/knowledge-graph.ts
-function createKnowledgeGraph() {
-  const nodes = /* @__PURE__ */ new Map();
-  const edges = /* @__PURE__ */ new Map();
-  const edgesByKind = /* @__PURE__ */ new Map();
-  const edgesFromNode = /* @__PURE__ */ new Map();
-  const edgesToNode = /* @__PURE__ */ new Map();
-  function indexEdge(edge) {
-    let kindSet = edgesByKind.get(edge.kind);
-    if (!kindSet) {
-      kindSet = /* @__PURE__ */ new Set();
-      edgesByKind.set(edge.kind, kindSet);
-    }
-    kindSet.add(edge.id);
-    let fromSet = edgesFromNode.get(edge.source);
-    if (!fromSet) {
-      fromSet = /* @__PURE__ */ new Set();
-      edgesFromNode.set(edge.source, fromSet);
-    }
-    fromSet.add(edge.id);
-    let toSet = edgesToNode.get(edge.target);
-    if (!toSet) {
-      toSet = /* @__PURE__ */ new Set();
-      edgesToNode.set(edge.target, toSet);
-    }
-    toSet.add(edge.id);
-  }
-  function unindexEdge(edge) {
-    edgesByKind.get(edge.kind)?.delete(edge.id);
-    edgesFromNode.get(edge.source)?.delete(edge.id);
-    edgesToNode.get(edge.target)?.delete(edge.id);
-  }
-  return {
-    addNode(node) {
-      nodes.set(node.id, node);
-    },
-    addEdge(edge) {
-      edges.set(edge.id, edge);
-      indexEdge(edge);
-    },
-    getNode(id) {
-      return nodes.get(id);
-    },
-    getEdge(id) {
-      return edges.get(id);
-    },
-    *findEdgesByKind(kind) {
-      const ids = edgesByKind.get(kind);
-      if (!ids) return;
-      for (const id of ids) {
-        const edge = edges.get(id);
-        if (edge) yield edge;
-      }
-    },
-    *findEdgesFrom(sourceId) {
-      const ids = edgesFromNode.get(sourceId);
-      if (!ids) return;
-      for (const id of ids) {
-        const edge = edges.get(id);
-        if (edge) yield edge;
-      }
-    },
-    *findEdgesTo(targetId) {
-      const ids = edgesToNode.get(targetId);
-      if (!ids) return;
-      for (const id of ids) {
-        const edge = edges.get(id);
-        if (edge) yield edge;
+        this.wss = new WebSocketServer({ server: httpServer, path: "/ws" });
+        this.wss.on("connection", (ws, req) => {
+          const user = verifyWebSocketHandshake(req);
+          if (!user) {
+            logger_default.warn("[ws] rejected unauthenticated connection");
+            ws.close(4401, "Unauthorized");
+            return;
+          }
+          logger_default.info(`[ws] client connected: ${user.username}`);
+          this.clients.add(ws);
+          ws.on("close", () => {
+            this.clients.delete(ws);
+            logger_default.info(`[ws] client disconnected: ${user.username}`);
+          });
+          ws.on("error", (err) => {
+            logger_default.warn("[ws] client error:", err.message);
+            this.clients.delete(ws);
+          });
+        });
+        this.wss.on("error", (err) => {
+          logger_default.warn("[ws] server error:", err.message);
+        });
       }
-    },
-    removeNodeCascade(id) {
-      const fromEdges = edgesFromNode.get(id);
-      if (fromEdges) {
-        for (const edgeId of [...fromEdges]) {
-          const edge = edges.get(edgeId);
-          if (edge) {
-            unindexEdge(edge);
-            edges.delete(edgeId);
+      /** Broadcast a message to all authenticated connected clients. */
+      broadcast(msg) {
+        const payload = JSON.stringify(msg);
+        let sent = 0;
+        for (const client of this.clients) {
+          if (client.readyState === WebSocket.OPEN) {
+            client.send(payload);
+            sent++;
           }
         }
+        logger_default.info(`[ws] broadcast \u2192 ${sent} client(s)`);
       }
-      const toEdges = edgesToNode.get(id);
-      if (toEdges) {
-        for (const edgeId of [...toEdges]) {
-          const edge = edges.get(edgeId);
-          if (edge) {
-            unindexEdge(edge);
-            edges.delete(edgeId);
+      get clientCount() {
+        return this.clients.size;
+      }
+      close() {
+        for (const client of this.clients) {
+          try {
+            client.close();
+          } catch {
           }
         }
+        this.clients.clear();
+        this.wss.close();
       }
-      edgesFromNode.delete(id);
-      edgesToNode.delete(id);
-      nodes.delete(id);
-    },
-    removeEdge(id) {
-      const edge = edges.get(id);
-      if (edge) {
-        unindexEdge(edge);
-        edges.delete(id);
-      }
-    },
-    *allNodes() {
-      yield* nodes.values();
-    },
-    *allEdges() {
-      yield* edges.values();
-    },
-    get size() {
-      return { nodes: nodes.size, edges: edges.size };
-    },
-    clear() {
-      nodes.clear();
-      edges.clear();
-      edgesByKind.clear();
-      edgesFromNode.clear();
-      edgesToNode.clear();
-    }
-  };
-}
+    };
+  }
+});
 
 // src/graph/index.ts
+init_knowledge_graph();
 init_id_generator();
 
-// src/storage/schema.ts
-var NODE_TABLE_MAP = {
-  file: "file_nodes",
-  directory: "dir_nodes",
-  function: "func_nodes",
-  class: "class_nodes",
-  interface: "iface_nodes",
-  method: "method_nodes",
-  constructor: "ctor_nodes",
-  variable: "var_nodes",
-  property: "prop_nodes",
-  struct: "struct_nodes",
-  enum: "enum_nodes",
-  trait: "trait_nodes",
-  namespace: "ns_nodes",
-  module: "mod_nodes",
-  type_alias: "type_nodes",
-  constant: "const_nodes",
-  route: "route_nodes",
-  cluster: "cluster_nodes",
-  flow: "flow_nodes",
-  vulnerability: "vuln_nodes"
-};
-var ALL_NODE_TABLES = [...new Set(Object.values(NODE_TABLE_MAP))];
-function getCreateNodeTableDDL(tableName) {
-  return `CREATE NODE TABLE IF NOT EXISTS ${tableName} (
-  id STRING,
-  name STRING,
-  file_path STRING,
-  start_line INT64,
-  end_line INT64,
-  exported BOOLEAN,
-  content STRING,
-  metadata STRING,
-  PRIMARY KEY (id)
-)`;
-}
-function getCreateEdgeTableDDL() {
-  const uniqueTables = ALL_NODE_TABLES;
-  const fromToPairs = [];
-  for (const from of uniqueTables) {
-    for (const to of uniqueTables) {
-      fromToPairs.push(`FROM ${from} TO ${to}`);
-    }
-  }
-  return [`CREATE REL TABLE GROUP IF NOT EXISTS code_edges (
-  ${fromToPairs.join(",\n  ")},
-  kind STRING,
-  weight DOUBLE,
-  label STRING
-)`];
-}
-
 // src/graph/lazy-knowledge-graph.ts
+init_schema();
 init_logger();
 Object.fromEntries(
   Object.entries(NODE_TABLE_MAP).map(([kind, table]) => [table, kind])
@@ -6189,7 +6350,7 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
 ]);
 function loadIgnorePatterns(workspaceRoot) {
   try {
-    const raw = fs25.readFileSync(path32.join(workspaceRoot, ".codeintelignore"), "utf-8");
+    const raw = fs26.readFileSync(path32.join(workspaceRoot, ".codeintelignore"), "utf-8");
     const extras = /* @__PURE__ */ new Set();
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -6213,7 +6374,7 @@ var scanPhase = {
     function walk(dir) {
       let entries;
       try {
-        entries = fs25.readdirSync(dir, { withFileTypes: true });
+        entries = fs26.readdirSync(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -6230,7 +6391,7 @@ var scanPhase = {
           if (!extensions.has(ext)) continue;
           const fullPath = path32.join(dir, name);
           try {
-            const stat = fs25.statSync(fullPath);
+            const stat = fs26.statSync(fullPath);
             if (stat.size > MAX_FILE_SIZE_BYTES) continue;
           } catch {
             continue;
@@ -6452,8 +6613,8 @@ var LLMGovernanceLogger = class {
         ...entry
       };
       const logPath = this.getLogPath();
-      fs25.mkdirSync(path32.dirname(logPath), { recursive: true });
-      fs25.appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
+      fs26.mkdirSync(path32.dirname(logPath), { recursive: true });
+      fs26.appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
     } catch {
     }
   }
@@ -6463,7 +6624,7 @@ var LLMGovernanceLogger = class {
    */
   readLog(limit = 100) {
     try {
-      const raw = fs25.readFileSync(this.getLogPath(), "utf-8");
+      const raw = fs26.readFileSync(this.getLogPath(), "utf-8");
       const lines = raw.split("\n").filter((l) => l.trim().length > 0).slice(-limit);
       return lines.map((l) => JSON.parse(l));
     } catch {
@@ -6854,7 +7015,7 @@ init_embedder();
 async function hybridSearch(graph, query, limit, options = {}) {
   const { vectorDbPath, bm25Limit = 50, vectorLimit = 50, bm25Results: precomputedBm25 } = options;
   const bm25Promise = precomputedBm25 ? Promise.resolve(precomputedBm25) : Promise.resolve(textSearch(graph, query, bm25Limit));
-  const hasVectorDb = Boolean(vectorDbPath && fs25.existsSync(vectorDbPath));
+  const hasVectorDb = Boolean(vectorDbPath && fs26.existsSync(vectorDbPath));
   if (!hasVectorDb) {
     const bm25Results2 = await bm25Promise;
     return {
@@ -6919,6 +7080,41 @@ function nodeToDoc(node) {
     (node.content ?? "").slice(0, 1e3)
   ].join(" ");
 }
+function heapTopK(scores, k) {
+  if (k <= 0) return [];
+  const heap = [];
+  function heapifyUp(i) {
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (heap[parent][1] > heap[i][1]) {
+        [heap[parent], heap[i]] = [heap[i], heap[parent]];
+        i = parent;
+      } else break;
+    }
+  }
+  function heapifyDown(i) {
+    const n = heap.length;
+    while (true) {
+      let smallest = i;
+      const l = 2 * i + 1, r = 2 * i + 2;
+      if (l < n && heap[l][1] < heap[smallest][1]) smallest = l;
+      if (r < n && heap[r][1] < heap[smallest][1]) smallest = r;
+      if (smallest === i) break;
+      [heap[smallest], heap[i]] = [heap[i], heap[smallest]];
+      i = smallest;
+    }
+  }
+  for (const [nodeId, score] of scores) {
+    if (heap.length < k) {
+      heap.push([nodeId, score]);
+      heapifyUp(heap.length - 1);
+    } else if (score > heap[0][1]) {
+      heap[0] = [nodeId, score];
+      heapifyDown(0);
+    }
+  }
+  return heap.sort((a, b) => b[1] - a[1]);
+}
 var Bm25Index = class {
   constructor(dbPath) {
     this.dbPath = dbPath;
@@ -6971,10 +7167,10 @@ var Bm25Index = class {
         postings.push({ nodeId, tf: count });
       }
     }
-    fs25.mkdirSync(path32.dirname(this.dbPath), { recursive: true });
+    fs26.mkdirSync(path32.dirname(this.dbPath), { recursive: true });
     for (const f of [this.dbPath, `${this.dbPath}-shm`, `${this.dbPath}-wal`]) {
       try {
-        if (fs25.existsSync(f)) fs25.unlinkSync(f);
+        if (fs26.existsSync(f)) fs26.unlinkSync(f);
       } catch {
       }
     }
@@ -7012,7 +7208,7 @@ var Bm25Index = class {
    * Called once on `serve` startup.
    */
   load() {
-    if (!fs25.existsSync(this.dbPath)) return;
+    if (!fs26.existsSync(this.dbPath)) return;
     const db = new Database2(this.dbPath, { readonly: true });
     try {
       const getMeta = db.prepare("SELECT value FROM bm25_meta WHERE key = ?");
@@ -7046,8 +7242,13 @@ var Bm25Index = class {
   }
   // ── Search ──────────────────────────────────────────────────────────────────
   /**
-   * BM25 search. LIMIT pushdown: scores only the posting lists for query terms,
-   * then partial-sorts to return only the top `limit` results.
+   * BM25 search.
+   *
+   * Performance strategy:
+   *  1. Skip ultra-high-df terms (df/N > 0.6) — near-zero IDF, dominate posting
+   *     lists for common words like "function", "return", "export" in large repos.
+   *  2. Min-heap top-K selection — O(n log k) instead of full O(n log n) sort.
+   *     For k=10 and n=30,000 candidates this is ~10× faster than Array.sort.
    */
   search(query, limit) {
     if (!this._loaded || this.invertedIndex.size === 0) return [];
@@ -7060,6 +7261,7 @@ var Bm25Index = class {
       const postings = this.invertedIndex.get(term);
       if (!postings) continue;
       const df = postings.length;
+      if (N > 100 && df / N > 0.6) continue;
       const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
       for (const { nodeId, tf } of postings) {
         const dl = this.docLengths.get(nodeId) ?? avgdl;
@@ -7067,10 +7269,9 @@ var Bm25Index = class {
         scores.set(nodeId, (scores.get(nodeId) ?? 0) + score);
       }
     }
-    const entries = [...scores.entries()];
-    entries.sort((a, b) => b[1] - a[1]);
-    const topK = entries.slice(0, limit);
-    return topK.map(([nodeId, score]) => {
+    if (scores.size === 0) return [];
+    const topEntries = heapTopK(scores, limit);
+    return topEntries.map(([nodeId, score]) => {
       const meta = this.nodeMeta.get(nodeId);
       return {
         nodeId,
@@ -7089,7 +7290,7 @@ var Bm25Index = class {
    * Works even if `load()` was not called (reads affected terms directly from DB).
    */
   updateNodes(nodes) {
-    if (!fs25.existsSync(this.dbPath)) return;
+    if (!fs26.existsSync(this.dbPath)) return;
     if (nodes.length === 0) return;
     const changedIds = new Set(nodes.map((n) => n.id));
     const newTermFreqs = /* @__PURE__ */ new Map();
@@ -7165,56 +7366,15 @@ var Bm25Index = class {
 function getBm25DbPath(workspaceRoot) {
   return path32.join(workspaceRoot, ".code-intel", "bm25.db");
 }
-var DbManager = class {
-  db = null;
-  conn = null;
-  dbPath;
-  readOnly;
-  constructor(dbPath, readOnly = false) {
-    this.dbPath = dbPath;
-    this.readOnly = readOnly;
-  }
-  async init() {
-    if (!this.readOnly) {
-      fs25.mkdirSync(path32.dirname(this.dbPath), { recursive: true });
-    }
-    this.db = new Database(this.dbPath, 0, true, this.readOnly);
-    await this.db.init();
-    this.conn = new Connection(this.db);
-    await this.conn.init();
-  }
-  async query(cypher) {
-    if (!this.conn) throw new Error("Database not initialized");
-    const result = await this.conn.query(cypher);
-    const qr = Array.isArray(result) ? result[0] : result;
-    const rows = await qr.getAll();
-    qr.close();
-    return rows;
-  }
-  async execute(cypher) {
-    if (!this.conn) throw new Error("Database not initialized");
-    const result = await this.conn.query(cypher);
-    const qr = Array.isArray(result) ? result[0] : result;
-    qr.close();
-  }
-  close() {
-    try {
-      this.conn?.closeSync();
-    } catch {
-    }
-    try {
-      this.db?.closeSync();
-    } catch {
-    }
-    this.conn = null;
-    this.db = null;
-  }
-  get isOpen() {
-    return this.conn !== null;
-  }
-};
+
+// src/storage/index.ts
+init_db_manager();
+init_schema();
+
+// src/storage/csv-writer.ts
+init_schema();
 function writeNodeCSVs(graph, outputDir) {
-  fs25.mkdirSync(outputDir, { recursive: true });
+  fs26.mkdirSync(outputDir, { recursive: true });
   const header = "id,name,file_path,start_line,end_line,exported,content,metadata\n";
   const tableBuffers = /* @__PURE__ */ new Map();
   const tableFilePaths = /* @__PURE__ */ new Map();
@@ -7242,12 +7402,12 @@ function writeNodeCSVs(graph, outputDir) {
     );
   }
   for (const [table, lines] of tableBuffers) {
-    fs25.writeFileSync(tableFilePaths.get(table), lines.join(""), "utf-8");
+    fs26.writeFileSync(tableFilePaths.get(table), lines.join(""), "utf-8");
   }
   return tableFilePaths;
 }
 function writeEdgeCSV(graph, outputDir) {
-  fs25.mkdirSync(outputDir, { recursive: true });
+  fs26.mkdirSync(outputDir, { recursive: true });
   const header = "from_id,to_id,kind,weight,label\n";
   const groups = /* @__PURE__ */ new Map();
   for (const edge of graph.allEdges()) {
@@ -7273,7 +7433,7 @@ function writeEdgeCSV(graph, outputDir) {
   }
   const result = [];
   for (const group of groups.values()) {
-    fs25.writeFileSync(group.filePath, group.lines.join(""), "utf-8");
+    fs26.writeFileSync(group.filePath, group.lines.join(""), "utf-8");
     result.push({ fromTable: group.from, toTable: group.to, filePath: group.filePath });
   }
   return result;
@@ -7290,6 +7450,9 @@ function escapeNewlines(s) {
   if (!s.includes("\n") && !s.includes("\r")) return s;
   return s.replace(/\r/g, "\\r").replace(/\n/g, "\\n");
 }
+
+// src/storage/graph-loader.ts
+init_schema();
 async function loadGraphToDB(graph, dbManager) {
   for (const table of ALL_NODE_TABLES) {
     await dbManager.execute(getCreateNodeTableDDL(table));
@@ -7301,7 +7464,7 @@ async function loadGraphToDB(graph, dbManager) {
     } catch {
     }
   }
-  const tmpDir = fs25.mkdtempSync(path32.join(os13.tmpdir(), "code-intel-csv-"));
+  const tmpDir = fs26.mkdtempSync(path32.join(os13.tmpdir(), "code-intel-csv-"));
   try {
     const nodeTableFiles = writeNodeCSVs(graph, tmpDir);
     const edgeGroups = writeEdgeCSV(graph, tmpDir);
@@ -7320,8 +7483,8 @@ async function loadGraphToDB(graph, dbManager) {
     }
     let nodeCount = 0;
     for (const [table, csvPath] of nodeTableFiles) {
-      if (!fs25.existsSync(csvPath)) continue;
-      const stat = fs25.statSync(csvPath);
+      if (!fs26.existsSync(csvPath)) continue;
+      const stat = fs26.statSync(csvPath);
       if (stat.size < 50) continue;
       try {
         await dbManager.execute(
@@ -7334,8 +7497,8 @@ async function loadGraphToDB(graph, dbManager) {
     }
     let edgeCount = 0;
     for (const group of edgeGroups) {
-      if (!fs25.existsSync(group.filePath)) continue;
-      const stat = fs25.statSync(group.filePath);
+      if (!fs26.existsSync(group.filePath)) continue;
+      const stat = fs26.statSync(group.filePath);
       if (stat.size < 50) continue;
       try {
         await dbManager.execute(
@@ -7349,7 +7512,7 @@ async function loadGraphToDB(graph, dbManager) {
     return { nodeCount, edgeCount };
   } finally {
     try {
-      fs25.rmSync(tmpDir, { recursive: true, force: true });
+      fs26.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -7405,15 +7568,15 @@ var GLOBAL_DIR = path32.join(os13.homedir(), ".code-intel");
 var REPOS_FILE = path32.join(GLOBAL_DIR, "repos.json");
 function loadRegistry() {
   try {
-    const data = fs25.readFileSync(REPOS_FILE, "utf-8");
+    const data = fs26.readFileSync(REPOS_FILE, "utf-8");
     return JSON.parse(data);
   } catch {
     return [];
   }
 }
 function saveRegistry(entries) {
-  fs25.mkdirSync(GLOBAL_DIR, { recursive: true });
-  fs25.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
+  fs26.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs26.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
 }
 function upsertRepo(entry) {
   const entries = loadRegistry();
@@ -7431,12 +7594,12 @@ function removeRepo(repoPath) {
 }
 function saveMetadata(repoDir, metadata) {
   const metaDir = path32.join(repoDir, ".code-intel");
-  fs25.mkdirSync(metaDir, { recursive: true });
-  fs25.writeFileSync(path32.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
+  fs26.mkdirSync(metaDir, { recursive: true });
+  fs26.writeFileSync(path32.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
 }
 function loadMetadata(repoDir) {
   try {
-    const data = fs25.readFileSync(path32.join(repoDir, ".code-intel", "meta.json"), "utf-8");
+    const data = fs26.readFileSync(path32.join(repoDir, ".code-intel", "meta.json"), "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -7451,78 +7614,9 @@ function getVectorDbPath(repoDir) {
 
 // src/mcp-server/server.ts
 init_group_registry();
-
-// src/multi-repo/graph-from-db.ts
-var TABLE_TO_KIND2 = Object.fromEntries(
-  Object.entries(NODE_TABLE_MAP).map(([kind, table]) => [table, kind])
-);
-function parseRow(row, kind) {
-  return {
-    id: String(row["id"] ?? ""),
-    kind,
-    name: String(row["name"] ?? ""),
-    filePath: String(row["file_path"] ?? ""),
-    startLine: row["start_line"] != null ? Number(row["start_line"]) : void 0,
-    endLine: row["end_line"] != null ? Number(row["end_line"]) : void 0,
-    exported: row["exported"] != null ? Boolean(row["exported"]) : void 0,
-    content: row["content"] ? String(row["content"]) : void 0,
-    metadata: row["metadata"] ? (() => {
-      try {
-        return JSON.parse(String(row["metadata"]));
-      } catch {
-        return void 0;
-      }
-    })() : void 0
-  };
-}
-async function loadGraphFromDB(graph, db) {
-  for (const table of ALL_NODE_TABLES) {
-    const kind = TABLE_TO_KIND2[table];
-    if (!kind) continue;
-    let rows = [];
-    try {
-      rows = await db.query(`MATCH (n:${table}) RETURN n.id, n.name, n.file_path, n.start_line, n.end_line, n.exported, n.content, n.metadata`);
-    } catch {
-      continue;
-    }
-    for (const row of rows) {
-      const node = parseRow({
-        id: row["n.id"],
-        name: row["n.name"],
-        file_path: row["n.file_path"],
-        start_line: row["n.start_line"],
-        end_line: row["n.end_line"],
-        exported: row["n.exported"],
-        content: row["n.content"],
-        metadata: row["n.metadata"]
-      }, kind);
-      if (node.id && node.name) graph.addNode(node);
-    }
-  }
-  try {
-    const edgeRows = await db.query(
-      `MATCH (a)-[e:code_edges]->(b) RETURN a.id, b.id, e.kind, e.weight, e.label`
-    );
-    for (const row of edgeRows) {
-      const sourceId = String(row["a.id"] ?? "");
-      const targetId = String(row["b.id"] ?? "");
-      const kind = String(row["e.kind"] ?? "");
-      if (!sourceId || !targetId || !kind) continue;
-      const edge = {
-        id: `${sourceId}::${kind}::${targetId}`,
-        source: sourceId,
-        target: targetId,
-        kind,
-        weight: row["e.weight"] != null ? Number(row["e.weight"]) : void 0,
-        label: row["e.label"] ? String(row["e.label"]) : void 0
-      };
-      graph.addEdge(edge);
-    }
-  } catch {
-  }
-}
-
-// src/multi-repo/group-sync.ts
+init_db_manager();
+init_knowledge_graph();
+init_graph_from_db();
 init_logger();
 function scanForFiles(root, matcher, maxDepth = 2) {
   const results = [];
@@ -7530,7 +7624,7 @@ function scanForFiles(root, matcher, maxDepth = 2) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs25.readdirSync(dir, { withFileTypes: true });
+      entries = fs26.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -7559,7 +7653,7 @@ var OPENAPI_FILENAMES = /* @__PURE__ */ new Set([
 var HTTP_METHODS = ["get", "post", "put", "patch", "delete", "head", "options"];
 function tryParseFile(filePath) {
   const ext = path32.extname(filePath).toLowerCase();
-  const content = fs25.readFileSync(filePath, "utf-8");
+  const content = fs26.readFileSync(filePath, "utf-8");
   if (ext === ".json") {
     try {
       return JSON.parse(content);
@@ -7613,7 +7707,7 @@ async function parseGraphQLContracts(repoRoot) {
   const files = scanForFiles(repoRoot, (name) => name.endsWith(".graphql") || name.endsWith(".gql"));
   const contracts = [];
   for (const filePath of files) {
-    const content = fs25.readFileSync(filePath, "utf-8");
+    const content = fs26.readFileSync(filePath, "utf-8");
     const typeRegex = /type\s+(\w+)\s*\{([^}]+)\}/g;
     let match;
     while ((match = typeRegex.exec(content)) !== null) {
@@ -7644,7 +7738,7 @@ async function parseProtoContracts(repoRoot) {
   const files = scanForFiles(repoRoot, (name) => name.endsWith(".proto"));
   const contracts = [];
   for (const filePath of files) {
-    const content = fs25.readFileSync(filePath, "utf-8");
+    const content = fs26.readFileSync(filePath, "utf-8");
     const serviceRegex = /service\s+(\w+)\s*\{([^}]+)\}/g;
     let serviceMatch;
     while ((serviceMatch = serviceRegex.exec(content)) !== null) {
@@ -7850,7 +7944,7 @@ async function syncGroup(group) {
       continue;
     }
     const dbPath = path32.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs25.existsSync(dbPath)) {
+    if (!fs26.existsSync(dbPath)) {
       logger_default.warn(`  \u26A0 No index at ${dbPath} \u2014 run \`code-intel analyze ${regEntry.path}\` first`);
       continue;
     }
@@ -7916,6 +8010,9 @@ async function syncGroup(group) {
     links
   };
 }
+init_db_manager();
+init_knowledge_graph();
+init_graph_from_db();
 async function queryGroup(group, query, limit = 20) {
   const registry = loadRegistry();
   const perRepo = [];
@@ -7924,7 +8021,7 @@ async function queryGroup(group, query, limit = 20) {
     const regEntry = registry.find((r) => r.name === member.registryName);
     if (!regEntry) continue;
     const dbPath = path32.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs25.existsSync(dbPath)) continue;
+    if (!fs26.existsSync(dbPath)) continue;
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath, true);
     try {
@@ -8572,11 +8669,30 @@ function summarizeCluster(graph, cluster) {
 }
 
 // src/mcp-server/server.ts
+function compact(obj) {
+  return JSON.stringify(obj, (_key, value) => value === null || value === void 0 ? void 0 : value);
+}
 function createMcpServer(graph, repoName, workspaceRoot) {
   const server = new Server(
     { name: "code-intel", version: "0.1.0" },
     { capabilities: { tools: {}, resources: {} } }
   );
+  let bm25Index = null;
+  function ensureBm25Index() {
+    if (bm25Index) return bm25Index;
+    if (!workspaceRoot) return null;
+    try {
+      const idx = new Bm25Index(getBm25DbPath(workspaceRoot));
+      idx.load();
+      bm25Index = idx;
+      return bm25Index;
+    } catch {
+      return null;
+    }
+  }
+  if (workspaceRoot) {
+    setImmediate(() => ensureBm25Index());
+  }
   const _tokenProp = {
     _token: { type: "string", description: "Required if CODE_INTEL_TOKEN is configured" }
   };
@@ -8596,13 +8712,15 @@ function createMcpServer(graph, repoName, workspaceRoot) {
       // ── Search & inspect ─────────────────────────────────────────────────
       {
         name: "search",
-        description: "BM25 keyword search across all indexed symbols \u2014 functions, classes, files, routes, etc.",
+        description: "BM25 keyword search across all indexed symbols \u2014 functions, classes, files, routes, etc. Optionally scope to a specific repo or group.",
         inputSchema: {
           type: "object",
           properties: {
             query: { type: "string", description: "Search query (symbol name, keyword, or partial match)" },
             offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
-            limit: { type: "number", description: "Max results per page (default: 50, max: 500)" },
+            limit: { type: "number", description: "Max results per page (default: 10, max: 500)" },
+            repo: { type: "string", description: "Scope search to a specific indexed repo name (optional; defaults to current repo)" },
+            group: { type: "string", description: "Scope search across all repos in a group via cross-repo RRF merge (optional; overrides repo)" },
             ..._tokenProp
           },
           required: ["query"]
@@ -8632,7 +8750,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
               enum: ["callers", "callees", "both"],
               description: "Which direction to trace \u2014 callers (who depends on it), callees (what it depends on), or both (default: both)"
             },
-            max_hops: { type: "number", description: "Maximum traversal depth (default: 5)" },
+            max_hops: { type: "number", description: "Maximum traversal depth (default: 2, max: 10)" },
             ..._tokenProp
           },
           required: ["target"]
@@ -8646,7 +8764,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
           properties: {
             file_path: { type: "string", description: 'File path (partial match is supported, e.g. "auth/login.ts")' },
             offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
-            limit: { type: "number", description: "Max results per page (default: 50, max: 500)" },
+            limit: { type: "number", description: "Max results per page (default: 10, max: 500)" },
             ..._tokenProp
           },
           required: ["file_path"]
@@ -8677,7 +8795,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
               description: "Filter by node kind: function | class | interface | method | type_alias | constant | enum (optional)"
             },
             offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
-            limit: { type: "number", description: "Max results per page (default: 50, max: 500)" },
+            limit: { type: "number", description: "Max results per page (default: 10, max: 500)" },
             ..._tokenProp
           }
         }
@@ -8695,7 +8813,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
           type: "object",
           properties: {
             offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
-            limit: { type: "number", description: "Max clusters per page (default: 50, max: 500)" },
+            limit: { type: "number", description: "Max clusters per page (default: 10, max: 500)" },
             ..._tokenProp
           }
         }
@@ -8707,7 +8825,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
           type: "object",
           properties: {
             offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
-            limit: { type: "number", description: "Max flows per page (default: 50, max: 500)" },
+            limit: { type: "number", description: "Max flows per page (default: 10, max: 500)" },
             ..._tokenProp
           }
         }
@@ -8861,7 +8979,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
             },
             maxHops: {
               type: "number",
-              description: "Maximum BFS depth for blast radius (default: 5)"
+              description: "Maximum BFS depth for blast radius (default: 2, max: 10)"
             },
             ..._tokenProp
           }
@@ -8989,13 +9107,13 @@ function createMcpServer(graph, repoName, workspaceRoot) {
       const providedToken = a._token;
       if (providedToken !== expectedToken) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Unauthorized: invalid or missing CODE_INTEL_TOKEN" }) }],
+          content: [{ type: "text", text: compact({ error: "Unauthorized: invalid or missing CODE_INTEL_TOKEN" }) }],
           isError: true
         };
       }
     }
     const startMs = Date.now();
-    const dispatch = () => dispatchTool(name, a, graph, repoName, workspaceRoot);
+    const dispatch = () => dispatchTool(name, a, graph, repoName, workspaceRoot, ensureBm25Index);
     const MCP_TIMEOUT_MS = parseInt(process.env["CODE_INTEL_MCP_TIMEOUT_MS"] ?? "30000", 10);
     let timeoutHandle = null;
     let timedOut = false;
@@ -9027,7 +9145,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
       mcpToolDurationSeconds.observe({ tool: name }, (Date.now() - startMs) / 1e3);
       if (timedOut) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ truncated: true, reason: `Tool '${name}' timed out after ${MCP_TIMEOUT_MS}ms`, partialResults: [] }) }],
+          content: [{ type: "text", text: compact({ truncated: true, reason: `Tool '${name}' timed out after ${MCP_TIMEOUT_MS}ms`, partialResults: [] }) }],
           isError: false
         };
       }
@@ -9042,7 +9160,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
   registerResources(server, graph, repoName);
   return server;
 }
-async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
+async function dispatchTool(name, a, graph, repoName, workspaceRoot, bm25Resolver) {
   switch (name) {
     // ── repos ──────────────────────────────────────────────────────────────
     case "repos": {
@@ -9050,10 +9168,8 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify(
-            registry.map((r) => ({ name: r.name, path: r.path, indexedAt: r.indexedAt, stats: r.stats })),
-            null,
-            2
+          text: compact(
+            registry.map((r) => ({ name: r.name, path: r.path, indexedAt: r.indexedAt, stats: r.stats }))
           )
         }]
       };
@@ -9081,13 +9197,13 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             repo: repoName,
             stats: graph.size,
             nodeCounts: kindCounts,
             edgeCounts,
             health
-          }, null, 2)
+          })
         }]
       };
     }
@@ -9095,15 +9211,59 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     case "search": {
       const query = a.query;
       const offset = a.offset ?? 0;
-      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const effectiveLimit = Math.min(a.limit ?? 10, 500);
+      if (a.group) {
+        const grp = loadGroup(a.group);
+        if (!grp) {
+          return { content: [{ type: "text", text: `Group "${a.group}" not found. Use list_groups to see available groups.` }] };
+        }
+        const { perRepo, merged } = await queryGroup(grp, query, effectiveLimit + offset);
+        const paged = merged.slice(offset, offset + effectiveLimit);
+        return {
+          content: [{
+            type: "text",
+            text: compact({
+              results: paged,
+              perRepo,
+              searchMode: "bm25-cross-repo",
+              group: a.group,
+              total: merged.length,
+              offset,
+              limit: effectiveLimit,
+              hasMore: offset + effectiveLimit < merged.length
+            })
+          }]
+        };
+      }
+      const repoGraph = a.repo ? await (async () => {
+        const registry = loadRegistry();
+        const entry = registry.find((r) => r.name === a.repo || r.path === a.repo);
+        if (!entry) return graph;
+        const { DbManager: DbMgr } = await Promise.resolve().then(() => (init_db_manager(), db_manager_exports));
+        const { loadGraphFromDB: loadG } = await Promise.resolve().then(() => (init_graph_from_db(), graph_from_db_exports));
+        const { createKnowledgeGraph: createG } = await Promise.resolve().then(() => (init_knowledge_graph(), knowledge_graph_exports));
+        const dbPath = path32.join(entry.path, ".code-intel", "graph.db");
+        if (!fs26.existsSync(dbPath)) return graph;
+        const db = new DbMgr(dbPath, true);
+        await db.init();
+        const g = createG();
+        await loadG(g, db);
+        db.close();
+        return g;
+      })() : graph;
       const vdbPath = workspaceRoot ? getVectorDbPath(workspaceRoot) : void 0;
       const fetchLimit = Math.min(offset + effectiveLimit, 500);
-      const { results: allResults, searchMode } = await hybridSearch(graph, query, fetchLimit, { vectorDbPath: vdbPath });
+      const bm25 = !a.repo || a.repo === repoName ? bm25Resolver ? bm25Resolver() : null : null;
+      const bm25Results = bm25 ? bm25.search(query, fetchLimit * 3) : void 0;
+      const { results: allResults, searchMode } = await hybridSearch(repoGraph, query, fetchLimit, {
+        vectorDbPath: vdbPath,
+        bm25Results: bm25Results ?? void 0
+      });
       const total = allResults.length;
       const results = allResults.slice(offset, offset + effectiveLimit);
       const hasMore = offset + effectiveLimit < total;
       const suggestNextTools = [];
-      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] !== "false";
+      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] === "true";
       if (suggestEnabled && results.length > 0) {
         const topName = results[0].name;
         suggestNextTools.push(
@@ -9114,15 +9274,16 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             results,
             searchMode,
+            repo: a.repo ?? repoName,
             total,
             offset,
             limit: effectiveLimit,
             hasMore,
             ...suggestEnabled ? { suggested_next_tools: suggestNextTools } : {}
-          }, null, 2)
+          })
         }]
       };
     }
@@ -9144,7 +9305,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
         file: graph.getNode(e.target)?.filePath
       }));
       const cluster = incoming.filter((e) => e.kind === "belongs_to").map((e) => graph.getNode(e.target)?.name)[0];
-      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] !== "false";
+      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] === "true";
       const suggestNextTools = [];
       if (suggestEnabled) {
         const topCallerName = callers[0]?.name;
@@ -9156,7 +9317,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             node: {
               id: node.id,
               kind: node.kind,
@@ -9179,7 +9340,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
             cluster,
             content: node.content?.slice(0, 500),
             ...suggestEnabled ? { suggested_next_tools: suggestNextTools } : {}
-          }, null, 2)
+          })
         }]
       };
     }
@@ -9187,7 +9348,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     case "blast_radius": {
       const target = a.target;
       const direction = a.direction ?? "both";
-      const maxHops = a.max_hops ?? 5;
+      const maxHops = a.max_hops ?? 2;
       const node = findNodeByName(graph, target);
       if (!node) return { content: [{ type: "text", text: `Symbol "${target}" not found.` }] };
       const affected = /* @__PURE__ */ new Set();
@@ -9214,7 +9375,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
         return n ? { id, name: n.name, kind: n.kind, filePath: n.filePath } : { id };
       });
       const risk = affected.size > 10 ? "HIGH" : affected.size > 5 ? "MEDIUM" : "LOW";
-      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] !== "false";
+      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] === "true";
       const suggestNextTools = [];
       if (suggestEnabled) {
         const highestRiskSymbol = node.name;
@@ -9227,13 +9388,13 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             target: node.name,
             affectedCount: affected.size,
             riskLevel: risk,
             affected: affectedDetails,
             ...suggestEnabled ? { suggested_next_tools: suggestNextTools } : {}
-          }, null, 2)
+          })
         }]
       };
     }
@@ -9241,7 +9402,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     case "file_symbols": {
       const filePath = a.file_path;
       const offset = a.offset ?? 0;
-      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const effectiveLimit = Math.min(a.limit ?? 10, 500);
       const allMatches = [];
       for (const node of graph.allNodes()) {
         if (node.filePath && node.filePath.includes(filePath)) {
@@ -9258,7 +9419,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ symbols: matches, total, offset, limit: effectiveLimit, hasMore }, null, 2)
+          text: compact({ symbols: matches, total, offset, limit: effectiveLimit, hasMore })
         }]
       };
     }
@@ -9299,7 +9460,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ from: fromName, to: toName, hops: foundPath.length - 1, path: pathDetails }, null, 2)
+          text: compact({ from: fromName, to: toName, hops: foundPath.length - 1, path: pathDetails })
         }]
       };
     }
@@ -9307,7 +9468,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     case "list_exports": {
       const kindFilter = a.kind;
       const offset = a.offset ?? 0;
-      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const effectiveLimit = Math.min(a.limit ?? 10, 500);
       const allExports = [];
       for (const node of graph.allNodes()) {
         if (!node.exported) continue;
@@ -9320,7 +9481,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ exports: exports$1, total, offset, limit: effectiveLimit, hasMore }, null, 2)
+          text: compact({ exports: exports$1, total, offset, limit: effectiveLimit, hasMore })
         }]
       };
     }
@@ -9332,12 +9493,12 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
           routes.push({ name: node.name, filePath: node.filePath, startLine: node.startLine });
         }
       }
-      return { content: [{ type: "text", text: JSON.stringify(routes, null, 2) }] };
+      return { content: [{ type: "text", text: compact(routes) }] };
     }
     // ── clusters ───────────────────────────────────────────────────────────
     case "clusters": {
       const offset = a.offset ?? 0;
-      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const effectiveLimit = Math.min(a.limit ?? 10, 500);
       const allClusters = [];
       for (const node of graph.allNodes()) {
         if (node.kind === "cluster") {
@@ -9364,14 +9525,14 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ clusters, total, offset, limit: effectiveLimit, hasMore }, null, 2)
+          text: compact({ clusters, total, offset, limit: effectiveLimit, hasMore })
         }]
       };
     }
     // ── flows ──────────────────────────────────────────────────────────────
     case "flows": {
       const offset = a.offset ?? 0;
-      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const effectiveLimit = Math.min(a.limit ?? 10, 500);
       const allFlows = [];
       for (const node of graph.allNodes()) {
         if (node.kind === "flow") {
@@ -9391,7 +9552,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ flows, total, offset, limit: effectiveLimit, hasMore }, null, 2)
+          text: compact({ flows, total, offset, limit: effectiveLimit, hasMore })
         }]
       };
     }
@@ -9459,14 +9620,14 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             baseRef,
             changedFiles: changedFiles.map((f) => f.filePath),
             directlyChangedSymbols: changedSymbols,
             transitivelyAffectedSymbols: affectedSymbols,
             totalAffected: allAffected.size,
             riskLevel: risk
-          }, null, 2)
+          })
         }]
       };
     }
@@ -9474,14 +9635,14 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     case "query": {
       const gqlInput = a.gql;
       if (!gqlInput) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: "Missing required parameter: gql" }) }], isError: true };
+        return { content: [{ type: "text", text: compact({ error: "Missing required parameter: gql" }) }], isError: true };
       }
       const { parseGQL: parseGQL2, isGQLParseError: isGQLParseError2 } = await Promise.resolve().then(() => (init_gql_parser(), gql_parser_exports));
       const { executeGQL: executeGQL2 } = await Promise.resolve().then(() => (init_gql_executor(), gql_executor_exports));
       const ast = parseGQL2(gqlInput);
       if (isGQLParseError2(ast)) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: `GQL parse error: ${ast.message}`, pos: ast.pos, expected: ast.expected, got: ast.got }) }],
+          content: [{ type: "text", text: compact({ error: `GQL parse error: ${ast.message}`, pos: ast.pos, expected: ast.expected, got: ast.got }) }],
           isError: true
         };
       }
@@ -9492,7 +9653,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             nodes: result.nodes,
             edges: result.edges,
             groups: result.groups,
@@ -9500,7 +9661,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
             executionTimeMs: result.executionTimeMs,
             truncated: result.truncated,
             totalCount: result.totalCount
-          }, null, 2)
+          })
         }]
       };
     }
@@ -9514,7 +9675,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
         for (const node of graph.allNodes()) {
           if (node.name === nameMatch[1]) results.push(node);
         }
-        return { content: [{ type: "text", text: JSON.stringify({ deprecation: deprecationWarning, results }, null, 2) }] };
+        return { content: [{ type: "text", text: compact({ deprecation: deprecationWarning, results }) }] };
       }
       const kindMatch = q?.match(/:\s*(\w+)/);
       if (kindMatch) {
@@ -9523,9 +9684,9 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
           if (node.kind === kindMatch[1]) results.push(node);
           if (results.length >= 50) break;
         }
-        return { content: [{ type: "text", text: JSON.stringify({ deprecation: deprecationWarning, results }, null, 2) }] };
+        return { content: [{ type: "text", text: compact({ deprecation: deprecationWarning, results }) }] };
       }
-      return { content: [{ type: "text", text: JSON.stringify({ deprecation: deprecationWarning, error: "Query not recognized. Use name='X' or :kind syntax. Or use the query tool with GQL instead." }) }] };
+      return { content: [{ type: "text", text: compact({ deprecation: deprecationWarning, error: "Query not recognized. Use name='X' or :kind syntax. Or use the query tool with GQL instead." }) }] };
     }
     // ── group_list ─────────────────────────────────────────────────────────
     case "group_list": {
@@ -9533,16 +9694,14 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       if (groupName) {
         const group = loadGroup(groupName);
         if (!group) return { content: [{ type: "text", text: `Group "${groupName}" not found.` }] };
-        return { content: [{ type: "text", text: JSON.stringify(group, null, 2) }] };
+        return { content: [{ type: "text", text: compact(group) }] };
       }
       const groups = listGroups();
       return {
         content: [{
           type: "text",
-          text: JSON.stringify(
-            groups.map((g) => ({ name: g.name, createdAt: g.createdAt, lastSync: g.lastSync, memberCount: g.members.length, members: g.members })),
-            null,
-            2
+          text: compact(
+            groups.map((g) => ({ name: g.name, createdAt: g.createdAt, lastSync: g.lastSync, memberCount: g.members.length, members: g.members }))
           )
         }]
       };
@@ -9560,14 +9719,14 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             groupName: result.groupName,
             syncedAt: result.syncedAt,
             memberCount: result.memberCount,
             contractCount: result.contracts.length,
             linkCount: result.links.length,
             topLinks: result.links.slice(0, 20)
-          }, null, 2)
+          })
         }]
       };
     }
@@ -9587,7 +9746,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ syncedAt: result.syncedAt, contracts, links }, null, 2)
+          text: compact({ syncedAt: result.syncedAt, contracts, links })
         }]
       };
     }
@@ -9602,7 +9761,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ query, merged, perRepo }, null, 2)
+          text: compact({ query, merged, perRepo })
         }]
       };
     }
@@ -9634,12 +9793,12 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             group: groupName,
             lastSync: group.lastSync ?? null,
             syncAgeMinutes: syncAge,
             members: memberStatus
-          }, null, 2)
+          })
         }]
       };
     }
@@ -9648,11 +9807,11 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       const fromName = a.from;
       const toName = a.to;
       const result = explainRelationship(graph, fromName, toName);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return { content: [{ type: "text", text: compact(result) }] };
     }
     // ── pr_impact ──────────────────────────────────────────────────────────
     case "pr_impact": {
-      const maxHops = a.maxHops ?? 5;
+      const maxHops = a.maxHops ?? 2;
       let changedFiles = a.changedFiles ?? [];
       if (a.diff && typeof a.diff === "string") {
         const diffFiles = parseDiffFiles(a.diff);
@@ -9662,37 +9821,37 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
         return {
           content: [{
             type: "text",
-            text: JSON.stringify({ error: 'No changed files provided. Supply "changedFiles" or "diff".' })
+            text: compact({ error: 'No changed files provided. Supply "changedFiles" or "diff".' })
           }]
         };
       }
       const result = computePRImpact(graph, changedFiles, maxHops);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return { content: [{ type: "text", text: compact(result) }] };
     }
     // ── similar_symbols ────────────────────────────────────────────────────
     case "similar_symbols": {
       const symbolName = a.symbol;
       const limit = a.limit ?? 10;
       const result = findSimilarSymbols(graph, symbolName, limit);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return { content: [{ type: "text", text: compact(result) }] };
     }
     // ── health_report ──────────────────────────────────────────────────────
     case "health_report": {
       const scope = a.scope ?? ".";
       const result = computeHealthReport(graph, scope);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return { content: [{ type: "text", text: compact(result) }] };
     }
     // ── suggest_tests ──────────────────────────────────────────────────────
     case "suggest_tests": {
       const sym = a.symbol;
       const result = suggestTests(graph, sym);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return { content: [{ type: "text", text: compact(result) }] };
     }
     // ── cluster_summary ────────────────────────────────────────────────────
     case "cluster_summary": {
       const cluster = a.cluster;
       const result = summarizeCluster(graph, cluster);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return { content: [{ type: "text", text: compact(result) }] };
     }
     case "deprecated_usage": {
       const scope = a.scope;
@@ -9700,7 +9859,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       const detector = new DeprecatedDetector2();
       detector.tagDeprecated(graph);
       const findings = detector.detect(graph, scope);
-      return { content: [{ type: "text", text: JSON.stringify({ findings, total: findings.length }, null, 2) }] };
+      return { content: [{ type: "text", text: compact({ findings, total: findings.length }) }] };
     }
     // ── complexity_hotspots ────────────────────────────────────────────────
     case "complexity_hotspots": {
@@ -9708,7 +9867,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       const scope = a.scope;
       const limit = typeof a.limit === "number" ? a.limit : 20;
       const hotspots = computeComplexity2(graph, scope).slice(0, limit);
-      return { content: [{ type: "text", text: JSON.stringify({ hotspots, total: hotspots.length }, null, 2) }] };
+      return { content: [{ type: "text", text: compact({ hotspots, total: hotspots.length }) }] };
     }
     // ── coverage_gaps ──────────────────────────────────────────────────────
     case "coverage_gaps": {
@@ -9720,12 +9879,12 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             untestedByRisk,
             coveragePct: summary.coveragePct,
             totalExported: summary.totalExported,
             testedExported: summary.testedExported
-          }, null, 2)
+          })
         }]
       };
     }
@@ -9736,7 +9895,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       const scope = a.scope;
       const includeTestFiles = a.includeTestFiles ?? false;
       const findings = scanner.scan(graph, { scope, includeTestFiles });
-      return { content: [{ type: "text", text: JSON.stringify({ findings, total: findings.length }, null, 2) }] };
+      return { content: [{ type: "text", text: compact({ findings, total: findings.length }) }] };
     }
     // ── vulnerability_scan ─────────────────────────────────────────────────
     case "vulnerability_scan": {
@@ -9749,7 +9908,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       const minRank = sevRank[minSev] ?? 1;
       let findings = detector.detect(graph, { scope, types });
       findings = findings.filter((f) => (sevRank[f.severity] ?? 1) >= minRank);
-      return { content: [{ type: "text", text: JSON.stringify({ findings, total: findings.length }, null, 2) }] };
+      return { content: [{ type: "text", text: compact({ findings, total: findings.length }) }] };
     }
     default:
       return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
@@ -9770,21 +9929,21 @@ function registerResources(server, graph, repoName) {
       for (const node of graph.allNodes()) {
         kindCounts[node.kind] = (kindCounts[node.kind] ?? 0) + 1;
       }
-      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify({ repo: repoName, stats: graph.size, nodeCounts: kindCounts }) }] };
+      return { contents: [{ uri, mimeType: "application/json", text: compact({ repo: repoName, stats: graph.size, nodeCounts: kindCounts }) }] };
     }
     if (uri.endsWith("/clusters")) {
       const clusters = [];
       for (const node of graph.allNodes()) {
         if (node.kind === "cluster") clusters.push({ id: node.id, name: node.name, memberCount: node.metadata?.memberCount });
       }
-      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify(clusters) }] };
+      return { contents: [{ uri, mimeType: "application/json", text: compact(clusters) }] };
     }
     if (uri.endsWith("/flows")) {
       const flows = [];
       for (const node of graph.allNodes()) {
         if (node.kind === "flow") flows.push({ id: node.id, name: node.name, steps: node.metadata?.steps, entryPoint: node.metadata?.entryPoint });
       }
-      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify(flows) }] };
+      return { contents: [{ uri, mimeType: "application/json", text: compact(flows) }] };
     }
     throw new Error(`Unknown resource: ${uri}`);
   });
@@ -9834,6 +9993,8 @@ function parseDiff(diffText) {
   return result;
 }
 init_group_registry();
+init_knowledge_graph();
+init_graph_from_db();
 init_logger();
 init_codes();
 init_middleware();
@@ -9844,7 +10005,7 @@ var STUCK_THRESHOLD_MINUTES = 30;
 var JobsDB = class {
   db;
   constructor(dbPath) {
-    fs25.mkdirSync(path32.dirname(dbPath), { recursive: true });
+    fs26.mkdirSync(path32.dirname(dbPath), { recursive: true });
     this.db = new Database2(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
@@ -10109,7 +10270,7 @@ var BackupService = class {
   constructor(backupDir) {
     this.backupDir = backupDir ?? getBackupDir();
     this.key = getBackupKey();
-    fs25.mkdirSync(this.backupDir, { recursive: true });
+    fs26.mkdirSync(this.backupDir, { recursive: true });
   }
   /**
    * Create a backup for a repository.
@@ -10123,16 +10284,16 @@ var BackupService = class {
     const candidates = ["graph.db", "vector.db", "meta.json"];
     for (const f of candidates) {
       const fp = path32.join(codeIntelDir, f);
-      if (fs25.existsSync(fp)) {
+      if (fs26.existsSync(fp)) {
         filesToBackup.push({ name: f, localPath: fp });
       }
     }
     const registryPath = path32.join(os13.homedir(), ".code-intel", "registry.json");
-    if (fs25.existsSync(registryPath)) {
+    if (fs26.existsSync(registryPath)) {
       filesToBackup.push({ name: "registry.json", localPath: registryPath });
     }
     const usersDbPath = path32.join(os13.homedir(), ".code-intel", "users.db");
-    if (fs25.existsSync(usersDbPath)) {
+    if (fs26.existsSync(usersDbPath)) {
       filesToBackup.push({ name: "users.db", localPath: usersDbPath });
     }
     if (filesToBackup.length === 0) {
@@ -10143,7 +10304,7 @@ var BackupService = class {
       createdAt,
       version: BACKUP_VERSION,
       files: filesToBackup.map((f) => {
-        const data = fs25.readFileSync(f.localPath);
+        const data = fs26.readFileSync(f.localPath);
         return {
           name: f.name,
           sha256: crypto5.createHash("sha256").update(data).digest("hex"),
@@ -10157,7 +10318,7 @@ var BackupService = class {
     manifestLenBuf.writeUInt32BE(manifestBuf.length, 0);
     parts.push(manifestLenBuf, manifestBuf);
     for (const f of filesToBackup) {
-      const data = fs25.readFileSync(f.localPath);
+      const data = fs26.readFileSync(f.localPath);
       const nameBuf = Buffer.from(f.name, "utf-8");
       const nameLenBuf = Buffer.alloc(2);
       nameLenBuf.writeUInt16BE(nameBuf.length, 0);
@@ -10169,7 +10330,7 @@ var BackupService = class {
     const encrypted = encryptBuffer(plaintext, this.key);
     const backupFileName = `backup-${id}.cib`;
     const backupPath = path32.join(this.backupDir, backupFileName);
-    fs25.writeFileSync(backupPath, encrypted);
+    fs26.writeFileSync(backupPath, encrypted);
     const entry = {
       id,
       createdAt,
@@ -10198,7 +10359,7 @@ var BackupService = class {
     if (!cfg) throw new Error("S3 not configured. Set CODE_INTEL_BACKUP_S3_BUCKET, CODE_INTEL_BACKUP_S3_ACCESS_KEY_ID, CODE_INTEL_BACKUP_S3_SECRET_ACCESS_KEY.");
     const fileName = path32.basename(entry.path);
     const s3Key = `${cfg.prefix}${fileName}`;
-    const body = fs25.readFileSync(entry.path);
+    const body = fs26.readFileSync(entry.path);
     const result = await s3Request({ method: "PUT", cfg, key: s3Key, body });
     if (result.statusCode < 200 || result.statusCode >= 300) {
       throw new Error(`S3 upload failed (HTTP ${result.statusCode}): ${result.body.slice(0, 200)}`);
@@ -10215,8 +10376,8 @@ var BackupService = class {
     if (result.statusCode < 200 || result.statusCode >= 300) {
       throw new Error(`S3 download failed (HTTP ${result.statusCode}): ${result.body.slice(0, 200)}`);
     }
-    fs25.mkdirSync(path32.dirname(destPath), { recursive: true });
-    fs25.writeFileSync(destPath, Buffer.from(result.body, "binary"));
+    fs26.mkdirSync(path32.dirname(destPath), { recursive: true });
+    fs26.writeFileSync(destPath, Buffer.from(result.body, "binary"));
   }
   /**
    * List backup objects in S3 with the configured prefix.
@@ -10262,10 +10423,10 @@ var BackupService = class {
     if (!entry) {
       throw new Error(`Backup "${backupId}" not found.`);
     }
-    if (!fs25.existsSync(entry.path)) {
+    if (!fs26.existsSync(entry.path)) {
       throw new Error(`Backup file not found at: ${entry.path}`);
     }
-    const encrypted = fs25.readFileSync(entry.path);
+    const encrypted = fs26.readFileSync(entry.path);
     let plaintext;
     try {
       plaintext = decryptBuffer(encrypted, this.key);
@@ -10280,7 +10441,7 @@ var BackupService = class {
     const manifest = JSON.parse(manifestStr);
     const restoreBase = targetRepoPath ?? entry.repoPath;
     const codeIntelDir = path32.join(restoreBase, ".code-intel");
-    fs25.mkdirSync(codeIntelDir, { recursive: true });
+    fs26.mkdirSync(codeIntelDir, { recursive: true });
     for (const fileEntry of manifest.files) {
       const nameLen = plaintext.readUInt16BE(offset);
       offset += 2;
@@ -10301,14 +10462,14 @@ var BackupService = class {
       } else {
         destPath = path32.join(codeIntelDir, name);
       }
-      fs25.writeFileSync(destPath, data);
+      fs26.writeFileSync(destPath, data);
     }
   }
   /**
    * Apply retention policy: keep N daily, M weekly, L monthly backups.
    */
   applyRetention(options = { daily: 7, weekly: 4, monthly: 12 }) {
-    const entries = this._loadIndex().filter((e) => fs25.existsSync(e.path)).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    const entries = this._loadIndex().filter((e) => fs26.existsSync(e.path)).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
     const keep = /* @__PURE__ */ new Set();
     const now = /* @__PURE__ */ new Date();
     const dailyCutoff = new Date(now);
@@ -10338,7 +10499,7 @@ var BackupService = class {
     for (const e of entries) {
       if (!keep.has(e.id)) {
         try {
-          fs25.unlinkSync(e.path);
+          fs26.unlinkSync(e.path);
           deleted++;
         } catch {
         }
@@ -10354,13 +10515,13 @@ var BackupService = class {
   }
   _loadIndex() {
     try {
-      return JSON.parse(fs25.readFileSync(this._indexPath(), "utf-8"));
+      return JSON.parse(fs26.readFileSync(this._indexPath(), "utf-8"));
     } catch {
       return [];
     }
   }
   _saveIndex(entries) {
-    fs25.writeFileSync(this._indexPath(), JSON.stringify(entries, null, 2));
+    fs26.writeFileSync(this._indexPath(), JSON.stringify(entries, null, 2));
   }
   _appendIndex(entry) {
     const entries = this._loadIndex();
@@ -11156,7 +11317,7 @@ var openApiSpec = {
 var __dirname$1 = path32.dirname(fileURLToPath(import.meta.url));
 var WEB_DIST = (() => {
   const bundled = path32.resolve(__dirname$1, "..", "web");
-  if (fs25.existsSync(bundled)) return bundled;
+  if (fs26.existsSync(bundled)) return bundled;
   return path32.resolve(__dirname$1, "..", "..", "..", "web", "dist");
 })();
 function getAllowedOrigins() {
@@ -11241,8 +11402,8 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       const metaFilePath = path32.join(workspaceRoot, ".code-intel", "meta.json");
       let metaOk = false;
       try {
-        if (fs25.existsSync(metaFilePath)) {
-          const raw = fs25.readFileSync(metaFilePath, "utf-8");
+        if (fs26.existsSync(metaFilePath)) {
+          const raw = fs26.readFileSync(metaFilePath, "utf-8");
           const meta = JSON.parse(raw);
           if (meta?.indexVersion) res.setHeader("X-Index-Version", meta.indexVersion);
         }
@@ -11433,12 +11594,12 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       return;
     }
     const user = db.createUser(username, password, "admin");
-    const sessionId = createSession({ id: user.id, username: user.username, role: user.role });
-    res.setHeader("Set-Cookie", buildSessionCookie(sessionId));
+    const { sessionId, ttlMs } = createSession({ id: user.id, username: user.username, role: user.role });
+    res.setHeader("Set-Cookie", buildSessionCookie(sessionId, ttlMs));
     res.status(201).json({ user: { id: user.id, username: user.username, role: user.role } });
   });
   app.post("/auth/login", async (req, res) => {
-    const { username, password } = req.body;
+    const { username, password, rememberMe } = req.body;
     if (!username || !password) {
       res.status(400).json({
         error: {
@@ -11482,10 +11643,10 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       });
       return;
     }
-    const sessionId = createSession({ id: user.id, username: user.username, role: user.role });
+    const { sessionId, ttlMs } = createSession({ id: user.id, username: user.username, role: user.role }, rememberMe === true);
     db.logAccess(user.id, "/auth/login", "login", "allow", req.ip ?? "unknown");
     authAttemptsTotal.inc({ method: "local", outcome: "success" });
-    res.setHeader("Set-Cookie", buildSessionCookie(sessionId));
+    res.setHeader("Set-Cookie", buildSessionCookie(sessionId, ttlMs));
     res.json({ user: { id: user.id, username: user.username, role: user.role } });
   });
   app.post("/auth/logout", (req, res) => {
@@ -11607,9 +11768,9 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
         authAttemptsTotal.inc({ method: "oidc", outcome: "success" });
         logger_default.info(`[oidc] Auto-provisioned new user: ${finalUsername} (${cfg.defaultRole})`);
       }
-      const sessionId = createSession({ id: user.id, username: user.username, role: user.role });
+      const { sessionId, ttlMs } = createSession({ id: user.id, username: user.username, role: user.role });
       db.logAccess(user.id, "/auth/callback", "oidc-login", "allow", req.ip ?? "unknown");
-      res.setHeader("Set-Cookie", buildSessionCookie(sessionId));
+      res.setHeader("Set-Cookie", buildSessionCookie(sessionId, ttlMs));
       res.redirect(302, "/");
     } catch (err) {
       logger_default.warn("[oidc] Callback failed:", err instanceof Error ? err.message : err);
@@ -11727,7 +11888,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     const entry = registry.find((r) => r.name === requestedRepo || r.path === requestedRepo);
     if (!entry) return null;
     const dbPath = path32.join(entry.path, ".code-intel", "graph.db");
-    if (!fs25.existsSync(dbPath)) return null;
+    if (!fs26.existsSync(dbPath)) return null;
     const repoGraph = createKnowledgeGraph();
     const db = new DbManager(dbPath, true);
     try {
@@ -11749,7 +11910,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       const regEntry = registry.find((r) => r.name === member.registryName);
       if (!regEntry) continue;
       const dbPath = path32.join(regEntry.path, ".code-intel", "graph.db");
-      if (!fs25.existsSync(dbPath)) continue;
+      if (!fs26.existsSync(dbPath)) continue;
       const db = new DbManager(dbPath, true);
       try {
         await db.init();
@@ -11831,7 +11992,21 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     });
   });
   app.post("/api/v1/search", requireToolScope("search"), async (req, res) => {
-    const { query, limit, repo } = req.body;
+    const { query, limit, repo, group } = req.body;
+    if (group) {
+      const grp = loadGroup(group);
+      if (!grp) {
+        res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: `Group '${group}' not found`, hint: "Use /api/v1/groups to list available groups" } });
+        return;
+      }
+      try {
+        const { perRepo, merged } = await queryGroup(grp, query ?? "", limit ?? 20);
+        res.json({ results: merged, perRepo, searchMode: "bm25", group });
+      } catch (err) {
+        res.status(500).json({ error: { code: ErrorCodes.INTERNAL_ERROR, message: err instanceof Error ? err.message : String(err) } });
+      }
+      return;
+    }
     const g = await getGraphForRepo(repo);
     const vdbPath = workspaceRoot ? getVectorDbPath(workspaceRoot) : void 0;
     const bm25 = !repo || repo === repoName ? ensureBm25Index() : null;
@@ -11840,7 +12015,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       vectorDbPath: vdbPath,
       bm25Results: bm25Results ?? void 0
     });
-    res.json({ results, searchMode });
+    res.json({ results, searchMode, repo: repo ?? repoName });
   });
   app.post("/api/v1/vector-search", async (req, res) => {
     const { query, limit = 10 } = req.body;
@@ -11882,7 +12057,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       return;
     }
     try {
-      const content = fs25.readFileSync(file_path, "utf-8");
+      const content = fs26.readFileSync(file_path, "utf-8");
       res.json({ content });
     } catch {
       res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "File not found" } });
@@ -12161,7 +12336,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       const regEntry = registry.find((r) => r.name === member.registryName);
       if (!regEntry) continue;
       const dbPath = path32.join(regEntry.path, ".code-intel", "graph.db");
-      if (!fs25.existsSync(dbPath)) continue;
+      if (!fs26.existsSync(dbPath)) continue;
       const db = new DbManager(dbPath, true);
       try {
         await db.init();
@@ -12188,7 +12363,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       let edgeCount = 0;
       if (regEntry) {
         const dbPath = path32.join(regEntry.path, ".code-intel", "graph.db");
-        if (fs25.existsSync(dbPath)) {
+        if (fs26.existsSync(dbPath)) {
           try {
             const db = new DbManager(dbPath, true);
             await db.init();
@@ -12251,7 +12426,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
             const regEntry = registry.find((r) => r.name === member.registryName);
             if (!regEntry) continue;
             const candidate = path32.resolve(path32.join(regEntry.path, normalizedFile));
-            if (fs25.existsSync(candidate)) {
+            if (fs26.existsSync(candidate)) {
               baseDir = regEntry.path;
               break;
             }
@@ -12303,7 +12478,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     }
     let fileContent;
     try {
-      fileContent = fs25.readFileSync(resolvedFile, "utf-8");
+      fileContent = fs26.readFileSync(resolvedFile, "utf-8");
     } catch {
       res.status(404).json({
         error: {
@@ -12469,7 +12644,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       res.status(500).json({ error: { code: ErrorCodes.INTERNAL_ERROR, message: err instanceof Error ? err.message : String(err), requestId: req.requestId, timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
     }
   });
-  if (fs25.existsSync(WEB_DIST)) {
+  if (fs26.existsSync(WEB_DIST)) {
     app.use(express.static(WEB_DIST));
     app.get("/{*path}", (_req, res) => {
       res.sendFile(path32.join(WEB_DIST, "index.html"));
@@ -12626,6 +12801,7 @@ async function startHttpServer(graph, repoName, port = 4747, workspaceRoot, watc
 
 // src/multi-repo/index.ts
 init_group_registry();
+init_graph_from_db();
 
 // src/multi-repo/cross-repo-search.ts
 function mergeSearchResults(...perRepoResults) {