@vohongtho.infotech/code-intel 0.9.0 → 1.0.0

package/dist/cli/main.js

@@ -7,8 +7,8 @@ import { SEMRESATTRS_DEPLOYMENT_ENVIRONMENT, SEMRESATTRS_SERVICE_NAME } from '@o
 import { SpanStatusCode, trace, context } from '@opentelemetry/api';
 import winston from 'winston';
 import DailyRotateFile from 'winston-daily-rotate-file';
-import fs37, { readFileSync, existsSync } from 'fs';
-import path38, { dirname, join } from 'path';
+import fs38, { readFileSync, existsSync } from 'fs';
+import path39, { dirname, join } from 'path';
 import os13 from 'os';
 import { Registry, collectDefaultMetrics, Counter, Histogram, Gauge } from 'prom-client';
 import { createRequire } from 'module';
@@ -18,8 +18,8 @@ import { v4 } from 'uuid';
 import crypto5 from 'crypto';
 import { Worker } from 'worker_threads';
 import { EventEmitter } from 'events';
-import Database from 'better-sqlite3';
-import { Database as Database$1, Connection } from '@ladybugdb/core';
+import Database2 from 'better-sqlite3';
+import { Database, Connection } from '@ladybugdb/core';
 import { execSync } from 'child_process';
 import bcrypt from 'bcrypt';
 import * as oidcClient from 'openid-client';
@@ -327,7 +327,7 @@ var init_logger = __esm({
         };
       }
       /** Global log directory: ~/.code-intel/logs */
-      static LOG_DIR = path38.join(os13.homedir(), ".code-intel", "logs");
+      static LOG_DIR = path39.join(os13.homedir(), ".code-intel", "logs");
       static getLogger() {
         if (!_Logger.instance) {
           const isProduction = process.env.NODE_ENV === "production";
@@ -336,12 +336,12 @@ var init_logger = __esm({
           transports.push(new winston.transports.Console());
           if (!isProduction) {
             try {
-              if (!fs37.existsSync(_Logger.LOG_DIR)) {
-                fs37.mkdirSync(_Logger.LOG_DIR, { recursive: true });
+              if (!fs38.existsSync(_Logger.LOG_DIR)) {
+                fs38.mkdirSync(_Logger.LOG_DIR, { recursive: true });
               }
               transports.push(
                 new DailyRotateFile({
-                  filename: path38.join(_Logger.LOG_DIR, "%DATE%-code-intel.log"),
+                  filename: path39.join(_Logger.LOG_DIR, "%DATE%-code-intel.log"),
                   datePattern: "YYYY-MM-DD",
                   maxSize: "20m",
                   maxFiles: "14d"
@@ -518,6 +518,64 @@ var init_knowledge_graph = __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/pipeline/dag-validator.ts
 function validateDAG(phases) {
   const errors = [];
@@ -541,25 +599,25 @@ function validateDAG(phases) {
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   const phaseMap = new Map(phases.map((p) => [p.name, p]));
-  function dfs(name, path39) {
+  function dfs(name, path40) {
     if (visiting.has(name)) {
-      const cycleStart = path39.indexOf(name);
-      const cycle = path39.slice(cycleStart).concat(name);
+      const cycleStart = path40.indexOf(name);
+      const cycle = path40.slice(cycleStart).concat(name);
       errors.push({ type: "cycle", message: `Cycle detected: ${cycle.join(" \u2192 ")}` });
       return true;
     }
     if (visited.has(name)) return false;
     visiting.add(name);
-    path39.push(name);
+    path40.push(name);
     const phase = phaseMap.get(name);
     if (phase) {
       for (const dep of phase.dependencies) {
-        if (dfs(dep, path39)) return true;
+        if (dfs(dep, path40)) return true;
       }
     }
     visiting.delete(name);
     visited.add(name);
-    path39.pop();
+    path40.pop();
     return false;
   }
   for (const phase of phases) {
@@ -697,6 +755,7 @@ ${errors.map((e) => e.message).join("\n")}`);
   for (const phase of sorted) {
     context2.onProgress?.(phase.name, "running");
     const phaseStart = Date.now();
+    const memBefore = context2.profile ? Math.round(process.memoryUsage().heapUsed / 1024 / 1024) : void 0;
     const runPhase = async () => {
       const depResults = /* @__PURE__ */ new Map();
       for (const dep of phase.dependencies) {
@@ -720,6 +779,10 @@ ${errors.map((e) => e.message).join("\n")}`);
       }
       const durationSec = (Date.now() - phaseStart) / 1e3;
       pipelinePhaseDurationSeconds.observe({ phase: phase.name, status: result.status }, durationSec);
+      if (memBefore !== void 0) {
+        result.memoryBeforeMB = memBefore;
+        result.memoryAfterMB = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
+      }
       results.set(phase.name, result);
       context2.onProgress?.(phase.name, result.status);
       if (result.status === "failed") {
@@ -730,7 +793,9 @@ ${errors.map((e) => e.message).join("\n")}`);
       const result = {
         status: "failed",
         duration: Date.now() - phaseStart,
-        message: err instanceof Error ? err.message : String(err)
+        message: err instanceof Error ? err.message : String(err),
+        memoryBeforeMB: memBefore,
+        memoryAfterMB: memBefore !== void 0 ? Math.round(process.memoryUsage().heapUsed / 1024 / 1024) : void 0
       };
       pipelinePhaseDurationSeconds.observe({ phase: phase.name, status: "failed" }, (Date.now() - phaseStart) / 1e3);
       results.set(phase.name, result);
@@ -824,7 +889,7 @@ var init_id_generator = __esm({
 });
 function loadIgnorePatterns(workspaceRoot) {
   try {
-    const raw = fs37.readFileSync(path38.join(workspaceRoot, ".codeintelignore"), "utf-8");
+    const raw = fs38.readFileSync(path39.join(workspaceRoot, ".codeintelignore"), "utf-8");
     const extras = /* @__PURE__ */ new Set();
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -884,7 +949,7 @@ var init_scan_phase = __esm({
         function walk2(dir) {
           let entries;
           try {
-            entries = fs37.readdirSync(dir, { withFileTypes: true });
+            entries = fs38.readdirSync(dir, { withFileTypes: true });
           } catch {
             return;
           }
@@ -893,15 +958,15 @@ var init_scan_phase = __esm({
               if (entry.name.startsWith(".")) continue;
               if (IGNORED_DIRS.has(entry.name)) continue;
               if (extraIgnore.has(entry.name)) continue;
-              walk2(path38.join(dir, entry.name));
+              walk2(path39.join(dir, entry.name));
             } else if (entry.isFile()) {
               const name = entry.name;
               if (IGNORED_FILE_SUFFIXES.some((s) => name.endsWith(s))) continue;
-              const ext = path38.extname(name);
+              const ext = path39.extname(name);
               if (!extensions.has(ext)) continue;
-              const fullPath = path38.join(dir, name);
+              const fullPath = path39.join(dir, name);
               try {
-                const stat = fs37.statSync(fullPath);
+                const stat = fs38.statSync(fullPath);
                 if (stat.size > MAX_FILE_SIZE_BYTES) continue;
               } catch {
                 continue;
@@ -928,20 +993,20 @@ var init_scan_phase = __esm({
         const dirs = /* @__PURE__ */ new Set();
         let structDone = 0;
         for (const filePath of context2.filePaths) {
-          const relativePath = path38.relative(context2.workspaceRoot, filePath);
+          const relativePath = path39.relative(context2.workspaceRoot, filePath);
           const lang = detectLanguage(filePath);
           context2.graph.addNode({
             id: generateNodeId("file", relativePath, relativePath),
             kind: "file",
-            name: path38.basename(filePath),
+            name: path39.basename(filePath),
             filePath: relativePath,
             metadata: lang ? { language: lang } : void 0
           });
-          let dir = path38.dirname(relativePath);
+          let dir = path39.dirname(relativePath);
           while (dir && dir !== "." && dir !== "") {
             if (dirs.has(dir)) break;
             dirs.add(dir);
-            dir = path38.dirname(dir);
+            dir = path39.dirname(dir);
           }
           structDone++;
           context2.onPhaseProgress?.("structure", structDone, context2.filePaths.length);
@@ -950,7 +1015,7 @@ var init_scan_phase = __esm({
           context2.graph.addNode({
             id: generateNodeId("directory", dir, dir),
             kind: "directory",
-            name: path38.basename(dir),
+            name: path39.basename(dir),
             filePath: dir
           });
         }
@@ -964,11 +1029,11 @@ var init_scan_phase = __esm({
   }
 });
 function findBundledWasmDir() {
-  const fileDir = path38.dirname(fileURLToPath(import.meta.url));
+  const fileDir = path39.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path38.join(fileDir, "wasm"),
+    path39.join(fileDir, "wasm"),
     // dist/index.js → dist/wasm/
-    path38.join(fileDir, "../wasm")
+    path39.join(fileDir, "../wasm")
     // dist/cli/main.js → dist/wasm/
   ];
   for (const candidate of candidates) {
@@ -1009,7 +1074,7 @@ function wasmPath(lang) {
   }
   const bundled = BUNDLED_WASM_MAP[lang];
   if (bundled) {
-    const bundledPath = path38.join(_bundledWasmDir, bundled);
+    const bundledPath = path39.join(_bundledWasmDir, bundled);
     if (existsSync(bundledPath)) return bundledPath;
   }
   return null;
@@ -1022,14 +1087,14 @@ async function initParser() {
 }
 async function getLanguage(lang) {
   if (languageCache.has(lang)) return languageCache.get(lang);
-  const path39 = wasmPath(lang);
-  if (!path39) {
+  const path40 = wasmPath(lang);
+  if (!path40) {
     languageCache.set(lang, null);
     return null;
   }
   try {
     await initParser();
-    const language = await Language.load(path39);
+    const language = await Language.load(path40);
     languageCache.set(lang, language);
     return language;
   } catch {
@@ -2454,7 +2519,7 @@ var init_parse_phase = __esm({
           const batch = filePaths.slice(i, i + CONCURRENCY);
           await Promise.all(batch.map(async (filePath) => {
             try {
-              const source = await fs37.promises.readFile(filePath, "utf-8");
+              const source = await fs38.promises.readFile(filePath, "utf-8");
               context2.fileCache.set(filePath, source);
             } catch {
             }
@@ -2467,14 +2532,14 @@ var init_parse_phase = __esm({
           const lang = detectLanguage(filePath);
           if (!lang) {
             if (context2.verbose) {
-              const relativePath2 = path38.relative(context2.workspaceRoot, filePath);
+              const relativePath2 = path39.relative(context2.workspaceRoot, filePath);
               logger_default.info(`  [parse] skipped (no parser): ${relativePath2}`);
             }
             continue;
           }
           const source = context2.fileCache.get(filePath);
           if (!source) continue;
-          const relativePath = path38.relative(context2.workspaceRoot, filePath);
+          const relativePath = path39.relative(context2.workspaceRoot, filePath);
           const fileNodeId = generateNodeId("file", relativePath, relativePath);
           const fileNode = context2.graph.getNode(fileNodeId);
           if (fileNode) {
@@ -2720,11 +2785,11 @@ var init_resolve_phase = __esm({
         let heritageEdges = 0;
         const fileIndex = /* @__PURE__ */ new Map();
         for (const fp of filePaths) {
-          const rel = path38.relative(workspaceRoot, fp);
+          const rel = path39.relative(workspaceRoot, fp);
           fileIndex.set(rel, fp);
           const noExt = rel.replace(/\.\w+$/, "");
           if (!fileIndex.has(noExt)) fileIndex.set(noExt, fp);
-          const base = path38.basename(rel, path38.extname(rel));
+          const base = path39.basename(rel, path39.extname(rel));
           if (!fileIndex.has(base)) fileIndex.set(base, fp);
         }
         const symbolIndex = /* @__PURE__ */ new Map();
@@ -2755,7 +2820,7 @@ var init_resolve_phase = __esm({
         for (const filePath of filePaths) {
           const lang = detectLanguage(filePath);
           if (!lang) continue;
-          const relativePath = path38.relative(workspaceRoot, filePath);
+          const relativePath = path39.relative(workspaceRoot, filePath);
           const fileNodeId = generateNodeId("file", relativePath, relativePath);
           const source = fileCache.get(filePath);
           if (!source) continue;
@@ -2768,13 +2833,13 @@ var init_resolve_phase = __esm({
             let resolvedRelPath = null;
             if (cleaned.startsWith(".")) {
               const cleanedNoJs = cleaned.replace(/\.(js|jsx)$/, "");
-              const fromDir = path38.dirname(relativePath);
+              const fromDir = path39.dirname(relativePath);
               for (const ext of ["", ".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".go", "/index.ts", "/index.js"]) {
-                const candidate = path38.join(fromDir, cleanedNoJs + ext);
-                const normalized = path38.normalize(candidate);
+                const candidate = path39.join(fromDir, cleanedNoJs + ext);
+                const normalized = path39.normalize(candidate);
                 if (fileIndex.has(normalized)) {
                   const absPath = fileIndex.get(normalized);
-                  resolvedRelPath = path38.relative(workspaceRoot, absPath);
+                  resolvedRelPath = path39.relative(workspaceRoot, absPath);
                   break;
                 }
               }
@@ -2995,22 +3060,22 @@ var init_flow_phase = __esm({
           const queue = [{ nodeId: ep.id, path: [ep.id] }];
           const visited = /* @__PURE__ */ new Set();
           while (queue.length > 0 && flowCount < maxFlows) {
-            const { nodeId, path: path39 } = queue.shift();
-            if (path39.length > maxDepth) continue;
+            const { nodeId, path: path40 } = queue.shift();
+            if (path40.length > maxDepth) continue;
             const callEdges = [...graph.findEdgesFrom(nodeId)].filter((e) => e.kind === "calls").slice(0, maxBranching);
-            if (callEdges.length === 0 && path39.length >= 3) {
+            if (callEdges.length === 0 && path40.length >= 3) {
               const flowId = generateNodeId("flow", ep.filePath, `flow-${flowCount}`);
               graph.addNode({
                 id: flowId,
                 kind: "flow",
                 name: `${ep.name} flow ${flowCount}`,
                 filePath: ep.filePath,
-                metadata: { steps: path39, entryPoint: ep.name }
+                metadata: { steps: path40, entryPoint: ep.name }
               });
-              for (let i = 0; i < path39.length; i++) {
+              for (let i = 0; i < path40.length; i++) {
                 graph.addEdge({
-                  id: generateEdgeId(path39[i], flowId, `step_of_${i}`),
-                  source: path39[i],
+                  id: generateEdgeId(path40[i], flowId, `step_of_${i}`),
+                  source: path40[i],
                   target: flowId,
                   kind: "step_of",
                   weight: 1,
@@ -3023,7 +3088,7 @@ var init_flow_phase = __esm({
             for (const edge of callEdges) {
               if (visited.has(edge.target)) continue;
               visited.add(edge.target);
-              queue.push({ nodeId: edge.target, path: [...path39, edge.target] });
+              queue.push({ nodeId: edge.target, path: [...path40, edge.target] });
             }
           }
         }
@@ -3046,7 +3111,7 @@ var init_llm_governance = __esm({
       }
       /** Path to the JSONL log file. */
       getLogPath() {
-        return process.env["CODE_INTEL_GOVERNANCE_LOG_PATH"] ?? path38.join(os13.homedir(), ".code-intel", "llm-governance.jsonl");
+        return process.env["CODE_INTEL_GOVERNANCE_LOG_PATH"] ?? path39.join(os13.homedir(), ".code-intel", "llm-governance.jsonl");
       }
       /**
        * Append an entry to the governance log.
@@ -3062,8 +3127,8 @@ var init_llm_governance = __esm({
             ...entry
           };
           const logPath = this.getLogPath();
-          fs37.mkdirSync(path38.dirname(logPath), { recursive: true });
-          fs37.appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
+          fs38.mkdirSync(path39.dirname(logPath), { recursive: true });
+          fs38.appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
         } catch {
         }
       }
@@ -3073,7 +3138,7 @@ var init_llm_governance = __esm({
        */
       readLog(limit = 100) {
         try {
-          const raw = fs37.readFileSync(this.getLogPath(), "utf-8");
+          const raw = fs38.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 {
@@ -3297,8 +3362,14 @@ function createSummarizePhase(providerOverride) {
       if (providerOverride) {
         provider = providerOverride;
       } else {
-        const { createLLMProvider: createLLMProvider2 } = await Promise.resolve().then(() => (init_factory(), factory_exports));
-        provider = await createLLMProvider2(llmConfig ?? {});
+        try {
+          const { createLLMProvider: createLLMProvider2 } = await Promise.resolve().then(() => (init_factory(), factory_exports));
+          provider = await createLLMProvider2(llmConfig ?? {});
+        } catch (err) {
+          const msg2 = err instanceof Error ? err.message : String(err);
+          logger_default.warn(`[summarize] LLM provider unavailable: ${msg2}. Skipping summarize phase.`);
+          return { status: "completed", duration: Date.now() - start, message: `Summarize skipped: LLM API unavailable (${msg2})` };
+        }
       }
       const breaker = new CircuitBreaker();
       const batchSize = llmConfig?.batchSize ?? 20;
@@ -3386,6 +3457,7 @@ var init_summarize_phase = __esm({
   "src/pipeline/phases/summarize-phase.ts"() {
     init_llm_governance();
     init_retry();
+    init_logger();
     SUMMARIZABLE_KINDS = /* @__PURE__ */ new Set(["function", "class", "method", "interface"]);
     MAX_SNIPPET_LINES = 200;
     summarizePhase = createSummarizePhase();
@@ -3500,7 +3572,7 @@ var init_worker_pool = __esm({
 });
 function workerScriptPath() {
   const thisFile = fileURLToPath(import.meta.url);
-  return path38.join(path38.dirname(thisFile), "parse-worker.js");
+  return path39.join(path39.dirname(thisFile), "parse-worker.js");
 }
 var LANG_QUERIES2, parsePhaseParallel;
 var init_parse_phase_parallel = __esm({
@@ -3540,14 +3612,14 @@ var init_parse_phase_parallel = __esm({
           const batch = filePaths.slice(i, i + CONCURRENCY);
           await Promise.all(batch.map(async (filePath) => {
             try {
-              const source = await fs37.promises.readFile(filePath, "utf-8");
+              const source = await fs38.promises.readFile(filePath, "utf-8");
               context2.fileCache.set(filePath, source);
             } catch {
             }
           }));
         }
         const workerScript = workerScriptPath();
-        const workerScriptExists = fs37.existsSync(workerScript);
+        const workerScriptExists = fs38.existsSync(workerScript);
         if (!workerScriptExists || workerCount === 1) {
           logger_default.info(`[parse-parallel] falling back to sequential (workerCount=${workerCount}, scriptExists=${workerScriptExists})`);
           const { parsePhase: parsePhase2 } = await Promise.resolve().then(() => (init_parse_phase(), parse_phase_exports));
@@ -3559,7 +3631,7 @@ var init_parse_phase_parallel = __esm({
           if (!lang) continue;
           const source = context2.fileCache.get(filePath);
           if (!source) continue;
-          const relativePath = path38.relative(context2.workspaceRoot, filePath);
+          const relativePath = path39.relative(context2.workspaceRoot, filePath);
           const fileNodeId = generateNodeId("file", relativePath, relativePath);
           const fileNode = context2.graph.getNode(fileNodeId);
           if (fileNode) fileNode.content = source.slice(0, 2e3);
@@ -3602,7 +3674,7 @@ var init_parse_phase_parallel = __esm({
             symbolCount += res.nodes.length;
             if (res.usedTreeSitter) treeSitterCount++;
             else regexCount++;
-            const relativePath = path38.relative(context2.workspaceRoot, res.taskId);
+            const relativePath = path39.relative(context2.workspaceRoot, res.taskId);
             const funcs = res.nodes.filter((n) => n.kind === "function" || n.kind === "method").map((n) => ({ id: n.id, startLine: n.startLine ?? 0, endLine: n.endLine })).sort((a, b) => a.startLine - b.startLine);
             if (funcs.length > 0) context2.fileFunctionIndex.set(relativePath, funcs);
             parseDone++;
@@ -3626,7 +3698,7 @@ var init_parse_phase_parallel = __esm({
 });
 function workerScriptPath2() {
   const thisFile = fileURLToPath(import.meta.url);
-  return path38.join(path38.dirname(thisFile), "resolve-worker.js");
+  return path39.join(path39.dirname(thisFile), "resolve-worker.js");
 }
 var resolvePhaseParallel;
 var init_resolve_phase_parallel = __esm({
@@ -3644,11 +3716,11 @@ var init_resolve_phase_parallel = __esm({
         const fileFunctionIndex = context2.fileFunctionIndex ?? /* @__PURE__ */ new Map();
         const fileIndex = {};
         for (const fp of filePaths) {
-          const rel = path38.relative(workspaceRoot, fp);
+          const rel = path39.relative(workspaceRoot, fp);
           fileIndex[rel] = fp;
           const noExt = rel.replace(/\.\w+$/, "");
           if (!fileIndex[noExt]) fileIndex[noExt] = fp;
-          const base = path38.basename(rel, path38.extname(rel));
+          const base = path39.basename(rel, path39.extname(rel));
           if (!fileIndex[base]) fileIndex[base] = fp;
         }
         const symbolIndex = {};
@@ -3662,7 +3734,7 @@ var init_resolve_phase_parallel = __esm({
         }
         const snapshot = { symbolIndex, fileSymbolIndex, fileIndex, workspaceRoot };
         const workerScript = workerScriptPath2();
-        const workerScriptExists = fs37.existsSync(workerScript);
+        const workerScriptExists = fs38.existsSync(workerScript);
         const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os13.cpus().length - 1);
         if (!workerScriptExists || workerCount === 1) {
           logger_default.info(`[resolve-parallel] falling back to sequential`);
@@ -3675,7 +3747,7 @@ var init_resolve_phase_parallel = __esm({
           if (!lang) continue;
           const source = fileCache.get(filePath);
           if (!source) continue;
-          const relativePath = path38.relative(workspaceRoot, filePath);
+          const relativePath = path39.relative(workspaceRoot, filePath);
           const fileNodeId = generateNodeId("file", relativePath, relativePath);
           const funcList = fileFunctionIndex.get(relativePath) ?? [];
           tasks.push({ taskId: filePath, filePath, relativePath, fileNodeId, source, funcList });
@@ -3823,7 +3895,7 @@ var init_vector_index = __esm({
         this.sqlitePath = sqlitePath;
       }
       async init() {
-        this.db = new Database(this.sqlitePath);
+        this.db = new Database2(this.sqlitePath);
         this.db.pragma("journal_mode = WAL");
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS ${EMBED_TABLE} (
@@ -3981,6 +4053,278 @@ var init_embedder = __esm({
     pipelineInstance = null;
   }
 });
+
+// src/search/bm25-index.ts
+var bm25_index_exports = {};
+__export(bm25_index_exports, {
+  Bm25Index: () => Bm25Index,
+  getBm25DbPath: () => getBm25DbPath
+});
+function tokenize(text) {
+  return text.toLowerCase().split(/[\s\-_./\\:(){}[\]<>,"'`~!@#$%^&*+=|;?]+/).filter((t) => t.length >= 2 && t.length <= 64);
+}
+function nodeToDoc(node) {
+  return [
+    node.name,
+    node.kind,
+    node.filePath,
+    (node.content ?? "").slice(0, 1e3)
+  ].join(" ");
+}
+function getBm25DbPath(workspaceRoot) {
+  return path39.join(workspaceRoot, ".code-intel", "bm25.db");
+}
+var K1, B, Bm25Index;
+var init_bm25_index = __esm({
+  "src/search/bm25-index.ts"() {
+    init_logger();
+    K1 = 1.2;
+    B = 0.75;
+    Bm25Index = class {
+      constructor(dbPath) {
+        this.dbPath = dbPath;
+      }
+      dbPath;
+      /** In-memory inverted index (populated after `load()`). */
+      invertedIndex = /* @__PURE__ */ new Map();
+      docLengths = /* @__PURE__ */ new Map();
+      nodeMeta = /* @__PURE__ */ new Map();
+      avgdl = 1;
+      docCount = 0;
+      _loaded = false;
+      get isLoaded() {
+        return this._loaded;
+      }
+      // ── Build ───────────────────────────────────────────────────────────────────
+      /**
+       * Build the inverted index from a KnowledgeGraph and persist to SQLite.
+       * Called once at analysis time after the main pipeline completes.
+       */
+      build(graph) {
+        const nodeTermFreqs = /* @__PURE__ */ new Map();
+        const docLengths = /* @__PURE__ */ new Map();
+        const nodeMeta = /* @__PURE__ */ new Map();
+        for (const node of graph.allNodes()) {
+          if (["directory", "cluster", "flow"].includes(node.kind)) continue;
+          const terms = tokenize(nodeToDoc(node));
+          const tf = /* @__PURE__ */ new Map();
+          for (const t of terms) tf.set(t, (tf.get(t) ?? 0) + 1);
+          nodeTermFreqs.set(node.id, tf);
+          docLengths.set(node.id, terms.length);
+          nodeMeta.set(node.id, {
+            name: node.name,
+            kind: node.kind,
+            filePath: node.filePath,
+            snippet: node.content?.slice(0, 200)
+          });
+        }
+        const docCount = nodeTermFreqs.size;
+        const totalLen = [...docLengths.values()].reduce((a, b) => a + b, 0);
+        const avgdl = docCount > 0 ? totalLen / docCount : 1;
+        const invertedIndex = /* @__PURE__ */ new Map();
+        for (const [nodeId, tf] of nodeTermFreqs) {
+          for (const [term, count] of tf) {
+            let postings = invertedIndex.get(term);
+            if (!postings) {
+              postings = [];
+              invertedIndex.set(term, postings);
+            }
+            postings.push({ nodeId, tf: count });
+          }
+        }
+        fs38.mkdirSync(path39.dirname(this.dbPath), { recursive: true });
+        for (const f of [this.dbPath, `${this.dbPath}-shm`, `${this.dbPath}-wal`]) {
+          try {
+            if (fs38.existsSync(f)) fs38.unlinkSync(f);
+          } catch {
+          }
+        }
+        const db = new Database2(this.dbPath);
+        db.pragma("journal_mode = WAL");
+        db.exec(`
+      CREATE TABLE bm25_index   (term     TEXT PRIMARY KEY, postings TEXT NOT NULL);
+      CREATE TABLE bm25_doclen  (node_id  TEXT PRIMARY KEY, doclen   INTEGER NOT NULL);
+      CREATE TABLE bm25_nodemeta(node_id  TEXT PRIMARY KEY, name TEXT, kind TEXT, file_path TEXT, snippet TEXT);
+      CREATE TABLE bm25_meta    (key      TEXT PRIMARY KEY, value    TEXT NOT NULL);
+    `);
+        const insPosting = db.prepare("INSERT OR REPLACE INTO bm25_index    VALUES (?, ?)");
+        const insDoclen = db.prepare("INSERT OR REPLACE INTO bm25_doclen   VALUES (?, ?)");
+        const insNodeMeta = db.prepare("INSERT OR REPLACE INTO bm25_nodemeta VALUES (?, ?, ?, ?, ?)");
+        const insMeta = db.prepare("INSERT OR REPLACE INTO bm25_meta     VALUES (?, ?)");
+        db.transaction(() => {
+          for (const [term, postings] of invertedIndex) {
+            insPosting.run(term, JSON.stringify(postings));
+          }
+          for (const [nodeId, len] of docLengths) {
+            insDoclen.run(nodeId, len);
+          }
+          for (const [nodeId, meta] of nodeMeta) {
+            insNodeMeta.run(nodeId, meta.name, meta.kind, meta.filePath, meta.snippet ?? null);
+          }
+          insMeta.run("avgdl", String(avgdl));
+          insMeta.run("docCount", String(docCount));
+        })();
+        db.close();
+        logger_default.info(`  [bm25] Index built: ${invertedIndex.size} terms, ${docCount} documents`);
+      }
+      // ── Load into memory ────────────────────────────────────────────────────────
+      /**
+       * Load the full inverted index into memory.
+       * Called once on `serve` startup.
+       */
+      load() {
+        if (!fs38.existsSync(this.dbPath)) return;
+        const db = new Database2(this.dbPath, { readonly: true });
+        try {
+          const getMeta = db.prepare("SELECT value FROM bm25_meta WHERE key = ?");
+          this.avgdl = parseFloat(getMeta.get("avgdl")?.value ?? "1");
+          this.docCount = parseInt(getMeta.get("docCount")?.value ?? "0", 10);
+          this.invertedIndex.clear();
+          const postingRows = db.prepare("SELECT term, postings FROM bm25_index").all();
+          for (const row of postingRows) {
+            this.invertedIndex.set(row.term, JSON.parse(row.postings));
+          }
+          this.docLengths.clear();
+          const dlRows = db.prepare("SELECT node_id, doclen FROM bm25_doclen").all();
+          for (const row of dlRows) {
+            this.docLengths.set(row.node_id, row.doclen);
+          }
+          this.nodeMeta.clear();
+          const metaRows = db.prepare("SELECT node_id, name, kind, file_path, snippet FROM bm25_nodemeta").all();
+          for (const row of metaRows) {
+            this.nodeMeta.set(row.node_id, {
+              name: row.name,
+              kind: row.kind,
+              filePath: row.file_path,
+              snippet: row.snippet ?? void 0
+            });
+          }
+          this._loaded = true;
+          logger_default.info(`  [bm25] Index loaded (${this.invertedIndex.size} terms)`);
+        } finally {
+          db.close();
+        }
+      }
+      // ── Search ──────────────────────────────────────────────────────────────────
+      /**
+       * BM25 search. LIMIT pushdown: scores only the posting lists for query terms,
+       * then partial-sorts to return only the top `limit` results.
+       */
+      search(query, limit) {
+        if (!this._loaded || this.invertedIndex.size === 0) return [];
+        const queryTerms = [...new Set(tokenize(query))];
+        if (queryTerms.length === 0) return [];
+        const scores = /* @__PURE__ */ new Map();
+        const N = this.docCount;
+        const avgdl = this.avgdl;
+        for (const term of queryTerms) {
+          const postings = this.invertedIndex.get(term);
+          if (!postings) continue;
+          const df = postings.length;
+          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;
+            const score = idf * (tf * (K1 + 1)) / (tf + K1 * (1 - B + B * (dl / avgdl)));
+            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]) => {
+          const meta = this.nodeMeta.get(nodeId);
+          return {
+            nodeId,
+            name: meta?.name ?? nodeId,
+            kind: meta?.kind ?? "unknown",
+            filePath: meta?.filePath ?? "",
+            score,
+            snippet: meta?.snippet
+          };
+        });
+      }
+      // ── Incremental update ──────────────────────────────────────────────────────
+      /**
+       * Incrementally update index for a set of changed/added nodes.
+       * Only terms that overlap with the changed nodes are rewritten.
+       * Works even if `load()` was not called (reads affected terms directly from DB).
+       */
+      updateNodes(nodes) {
+        if (!fs38.existsSync(this.dbPath)) return;
+        if (nodes.length === 0) return;
+        const changedIds = new Set(nodes.map((n) => n.id));
+        const newTermFreqs = /* @__PURE__ */ new Map();
+        for (const node of nodes) {
+          if (["directory", "cluster", "flow"].includes(node.kind)) continue;
+          const terms = tokenize(nodeToDoc(node));
+          const tf = /* @__PURE__ */ new Map();
+          for (const t of terms) tf.set(t, (tf.get(t) ?? 0) + 1);
+          newTermFreqs.set(node.id, tf);
+        }
+        const newTermSet = new Set([...newTermFreqs.values()].flatMap((m) => [...m.keys()]));
+        const db = new Database2(this.dbPath);
+        db.pragma("journal_mode = WAL");
+        const termsToRewrite = /* @__PURE__ */ new Map();
+        for (const term of newTermSet) {
+          const row = db.prepare("SELECT postings FROM bm25_index WHERE term = ?").get(term);
+          const existing = row ? JSON.parse(row.postings) : [];
+          termsToRewrite.set(term, existing.filter((p) => !changedIds.has(p.nodeId)));
+        }
+        for (const nodeId of changedIds) {
+          const rows = db.prepare("SELECT term, postings FROM bm25_index WHERE postings LIKE ?").all(`%${nodeId}%`);
+          for (const row of rows) {
+            if (termsToRewrite.has(row.term)) continue;
+            const postings = JSON.parse(row.postings);
+            if (postings.some((p) => changedIds.has(p.nodeId))) {
+              termsToRewrite.set(row.term, postings.filter((p) => !changedIds.has(p.nodeId)));
+            }
+          }
+        }
+        for (const [nodeId, tf] of newTermFreqs) {
+          for (const [term, count] of tf) {
+            const postings = termsToRewrite.get(term) ?? [];
+            postings.push({ nodeId, tf: count });
+            termsToRewrite.set(term, postings);
+          }
+        }
+        const upsertPosting = db.prepare("INSERT OR REPLACE INTO bm25_index    VALUES (?, ?)");
+        const upsertDoclen = db.prepare("INSERT OR REPLACE INTO bm25_doclen   VALUES (?, ?)");
+        const upsertNodeMeta = db.prepare("INSERT OR REPLACE INTO bm25_nodemeta VALUES (?, ?, ?, ?, ?)");
+        db.transaction(() => {
+          for (const [term, postings] of termsToRewrite) {
+            if (postings.length === 0) {
+              db.prepare("DELETE FROM bm25_index WHERE term = ?").run(term);
+            } else {
+              upsertPosting.run(term, JSON.stringify(postings));
+            }
+          }
+          for (const node of nodes) {
+            const terms = tokenize(nodeToDoc(node));
+            upsertDoclen.run(node.id, terms.length);
+            upsertNodeMeta.run(node.id, node.name, node.kind, node.filePath, node.content?.slice(0, 200) ?? null);
+          }
+        })();
+        db.close();
+        if (this._loaded) {
+          for (const [term, postings] of termsToRewrite) {
+            if (postings.length === 0) this.invertedIndex.delete(term);
+            else this.invertedIndex.set(term, postings);
+          }
+          for (const node of nodes) {
+            const terms = tokenize(nodeToDoc(node));
+            this.docLengths.set(node.id, terms.length);
+            this.nodeMeta.set(node.id, {
+              name: node.name,
+              kind: node.kind,
+              filePath: node.filePath,
+              snippet: node.content?.slice(0, 200)
+            });
+          }
+        }
+      }
+    };
+  }
+});
 var DbManager;
 var init_db_manager = __esm({
   "src/storage/db-manager.ts"() {
@@ -3988,12 +4332,16 @@ var init_db_manager = __esm({
       db = null;
       conn = null;
       dbPath;
-      constructor(dbPath) {
+      readOnly;
+      constructor(dbPath, readOnly = false) {
         this.dbPath = dbPath;
+        this.readOnly = readOnly;
       }
       async init() {
-        fs37.mkdirSync(path38.dirname(this.dbPath), { recursive: true });
-        this.db = new Database$1(this.dbPath);
+        if (!this.readOnly) {
+          fs38.mkdirSync(path39.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();
@@ -4030,66 +4378,8 @@ var init_db_manager = __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))];
-  }
-});
 function writeNodeCSVs(graph, outputDir) {
-  fs37.mkdirSync(outputDir, { recursive: true });
+  fs38.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();
@@ -4097,7 +4387,7 @@ function writeNodeCSVs(graph, outputDir) {
     const table = NODE_TABLE_MAP[node.kind];
     if (!tableBuffers.has(table)) {
       tableBuffers.set(table, [header]);
-      tableFilePaths.set(table, path38.join(outputDir, `${table}.csv`));
+      tableFilePaths.set(table, path39.join(outputDir, `${table}.csv`));
     }
     tableBuffers.get(table).push(
       csvRow([
@@ -4117,12 +4407,12 @@ function writeNodeCSVs(graph, outputDir) {
     );
   }
   for (const [table, lines] of tableBuffers) {
-    fs37.writeFileSync(tableFilePaths.get(table), lines.join(""), "utf-8");
+    fs38.writeFileSync(tableFilePaths.get(table), lines.join(""), "utf-8");
   }
   return tableFilePaths;
 }
 function writeEdgeCSV(graph, outputDir) {
-  fs37.mkdirSync(outputDir, { recursive: true });
+  fs38.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()) {
@@ -4133,7 +4423,7 @@ function writeEdgeCSV(graph, outputDir) {
     const toTable = NODE_TABLE_MAP[targetNode.kind];
     const key = `${fromTable}->${toTable}`;
     if (!groups.has(key)) {
-      const filePath = path38.join(outputDir, `edges_${fromTable}_${toTable}.csv`);
+      const filePath = path39.join(outputDir, `edges_${fromTable}_${toTable}.csv`);
       groups.set(key, { lines: [header], from: fromTable, to: toTable, filePath });
     }
     groups.get(key).lines.push(
@@ -4148,7 +4438,7 @@ function writeEdgeCSV(graph, outputDir) {
   }
   const result = [];
   for (const group of groups.values()) {
-    fs37.writeFileSync(group.filePath, group.lines.join(""), "utf-8");
+    fs38.writeFileSync(group.filePath, group.lines.join(""), "utf-8");
     result.push({ fromTable: group.from, toTable: group.to, filePath: group.filePath });
   }
   return result;
@@ -4191,7 +4481,7 @@ async function loadGraphToDB(graph, dbManager) {
     } catch {
     }
   }
-  const tmpDir = fs37.mkdtempSync(path38.join(os13.tmpdir(), "code-intel-csv-"));
+  const tmpDir = fs38.mkdtempSync(path39.join(os13.tmpdir(), "code-intel-csv-"));
   try {
     const nodeTableFiles = writeNodeCSVs(graph, tmpDir);
     const edgeGroups = writeEdgeCSV(graph, tmpDir);
@@ -4210,8 +4500,8 @@ async function loadGraphToDB(graph, dbManager) {
     }
     let nodeCount = 0;
     for (const [table, csvPath] of nodeTableFiles) {
-      if (!fs37.existsSync(csvPath)) continue;
-      const stat = fs37.statSync(csvPath);
+      if (!fs38.existsSync(csvPath)) continue;
+      const stat = fs38.statSync(csvPath);
       if (stat.size < 50) continue;
       try {
         await dbManager.execute(
@@ -4224,8 +4514,8 @@ async function loadGraphToDB(graph, dbManager) {
     }
     let edgeCount = 0;
     for (const group of edgeGroups) {
-      if (!fs37.existsSync(group.filePath)) continue;
-      const stat = fs37.statSync(group.filePath);
+      if (!fs38.existsSync(group.filePath)) continue;
+      const stat = fs38.statSync(group.filePath);
       if (stat.size < 50) continue;
       try {
         await dbManager.execute(
@@ -4239,7 +4529,7 @@ async function loadGraphToDB(graph, dbManager) {
     return { nodeCount, edgeCount };
   } finally {
     try {
-      fs37.rmSync(tmpDir, { recursive: true, force: true });
+      fs38.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -4267,7 +4557,7 @@ async function loadEdgeGroupFallback(graph, fromTable, toTable, dbManager) {
     if (NODE_TABLE_MAP[targetNode.kind] !== toTable) continue;
     try {
       await dbManager.execute(
-        `MATCH (a:${fromTable} {id: '${escCypher(edge.source)}'}), (b:${toTable} {id: '${escCypher(edge.target)}'}) CREATE (a)-[:code_edges {kind: '${edge.kind}', weight: ${edge.weight ?? 1}, label: '${escCypher(edge.label ?? "")}'}]->(b)`
+        `MATCH (a:${fromTable} {id: '${escCypher2(edge.source)}'}), (b:${toTable} {id: '${escCypher2(edge.target)}'}) CREATE (a)-[:code_edges {kind: '${edge.kind}', weight: ${edge.weight ?? 1}, label: '${escCypher2(edge.label ?? "")}'}]->(b)`
       );
       count++;
     } catch {
@@ -4279,7 +4569,7 @@ async function upsertNode(node, dbManager) {
   const table = NODE_TABLE_MAP[node.kind];
   const props = buildNodeProps(node);
   try {
-    await dbManager.execute(`MATCH (n:${table} {id: '${escCypher(node.id)}'}) DELETE n`);
+    await dbManager.execute(`MATCH (n:${table} {id: '${escCypher2(node.id)}'}) DELETE n`);
   } catch {
   }
   try {
@@ -4298,7 +4588,7 @@ async function upsertNodes(nodes, dbManager) {
   return count;
 }
 async function removeNodesForFile(filePath, dbManager) {
-  const escaped = escCypher(filePath);
+  const escaped = escCypher2(filePath);
   for (const table of ALL_NODE_TABLES) {
     try {
       await dbManager.execute(
@@ -4309,7 +4599,7 @@ async function removeNodesForFile(filePath, dbManager) {
   }
 }
 async function removeEdgesForFile(filePath, dbManager) {
-  const escaped = escCypher(filePath);
+  const escaped = escCypher2(filePath);
   try {
     await dbManager.execute(
       `MATCH (a)-[e:code_edges]->(b) WHERE a.file_path = '${escaped}' OR b.file_path = '${escaped}' DELETE e`
@@ -4319,18 +4609,18 @@ async function removeEdgesForFile(filePath, dbManager) {
 }
 function buildNodeProps(node) {
   const parts = [
-    `id: '${escCypher(node.id)}'`,
-    `name: '${escCypher(node.name)}'`,
-    `file_path: '${escCypher(node.filePath)}'`
+    `id: '${escCypher2(node.id)}'`,
+    `name: '${escCypher2(node.name)}'`,
+    `file_path: '${escCypher2(node.filePath)}'`
   ];
   if (node.startLine !== void 0) parts.push(`start_line: ${node.startLine}`);
   if (node.endLine !== void 0) parts.push(`end_line: ${node.endLine}`);
   if (node.exported !== void 0) parts.push(`exported: ${node.exported}`);
-  if (node.content) parts.push(`content: '${escCypher(node.content.slice(0, 500))}'`);
-  if (node.metadata) parts.push(`metadata: '${escCypher(JSON.stringify(node.metadata))}'`);
+  if (node.content) parts.push(`content: '${escCypher2(node.content.slice(0, 500))}'`);
+  if (node.metadata) parts.push(`metadata: '${escCypher2(JSON.stringify(node.metadata))}'`);
   return `{${parts.join(", ")}}`;
 }
-function escCypher(s) {
+function escCypher2(s) {
   return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "");
 }
 var init_graph_loader = __esm({
@@ -4350,15 +4640,15 @@ __export(repo_registry_exports, {
 });
 function loadRegistry() {
   try {
-    const data = fs37.readFileSync(REPOS_FILE, "utf-8");
+    const data = fs38.readFileSync(REPOS_FILE, "utf-8");
     return JSON.parse(data);
   } catch {
     return [];
   }
 }
 function saveRegistry(entries) {
-  fs37.mkdirSync(GLOBAL_DIR, { recursive: true });
-  fs37.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
+  fs38.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs38.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
 }
 function upsertRepo(entry) {
   const entries = loadRegistry();
@@ -4377,8 +4667,8 @@ function removeRepo(repoPath) {
 var GLOBAL_DIR, REPOS_FILE;
 var init_repo_registry = __esm({
   "src/storage/repo-registry.ts"() {
-    GLOBAL_DIR = path38.join(os13.homedir(), ".code-intel");
-    REPOS_FILE = path38.join(GLOBAL_DIR, "repos.json");
+    GLOBAL_DIR = path39.join(os13.homedir(), ".code-intel");
+    REPOS_FILE = path39.join(GLOBAL_DIR, "repos.json");
   }
 });
 
@@ -4391,23 +4681,23 @@ __export(metadata_exports, {
   saveMetadata: () => saveMetadata
 });
 function saveMetadata(repoDir, metadata) {
-  const metaDir = path38.join(repoDir, ".code-intel");
-  fs37.mkdirSync(metaDir, { recursive: true });
-  fs37.writeFileSync(path38.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
+  const metaDir = path39.join(repoDir, ".code-intel");
+  fs38.mkdirSync(metaDir, { recursive: true });
+  fs38.writeFileSync(path39.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
 }
 function loadMetadata(repoDir) {
   try {
-    const data = fs37.readFileSync(path38.join(repoDir, ".code-intel", "meta.json"), "utf-8");
+    const data = fs38.readFileSync(path39.join(repoDir, ".code-intel", "meta.json"), "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
   }
 }
 function getDbPath(repoDir) {
-  return path38.join(repoDir, ".code-intel", "graph.db");
+  return path39.join(repoDir, ".code-intel", "graph.db");
 }
 function getVectorDbPath(repoDir) {
-  return path38.join(repoDir, ".code-intel", "vector.db");
+  return path39.join(repoDir, ".code-intel", "vector.db");
 }
 var init_metadata = __esm({
   "src/storage/metadata.ts"() {
@@ -4463,27 +4753,27 @@ __export(group_registry_exports, {
   saveSyncResult: () => saveSyncResult
 });
 function groupFile(name) {
-  return path38.join(GROUPS_DIR, `${name}.json`);
+  return path39.join(GROUPS_DIR, `${name}.json`);
 }
 function loadGroup(name) {
   try {
-    return JSON.parse(fs37.readFileSync(groupFile(name), "utf-8"));
+    return JSON.parse(fs38.readFileSync(groupFile(name), "utf-8"));
   } catch {
     return null;
   }
 }
 function saveGroup(group) {
-  fs37.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs37.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
+  fs38.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs38.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
 }
 function listGroups() {
   const groups = [];
   try {
-    for (const file of fs37.readdirSync(GROUPS_DIR)) {
+    for (const file of fs38.readdirSync(GROUPS_DIR)) {
       if (!file.endsWith(".json") || file.endsWith(".sync.json")) continue;
       try {
         const g = JSON.parse(
-          fs37.readFileSync(path38.join(GROUPS_DIR, file), "utf-8")
+          fs38.readFileSync(path39.join(GROUPS_DIR, file), "utf-8")
         );
         groups.push(g);
       } catch {
@@ -4495,16 +4785,16 @@ function listGroups() {
 }
 function deleteGroup(name) {
   try {
-    fs37.unlinkSync(groupFile(name));
+    fs38.unlinkSync(groupFile(name));
   } catch {
   }
   try {
-    fs37.unlinkSync(path38.join(GROUPS_DIR, `${name}.sync.json`));
+    fs38.unlinkSync(path39.join(GROUPS_DIR, `${name}.sync.json`));
   } catch {
   }
 }
 function groupExists(name) {
-  return fs37.existsSync(groupFile(name));
+  return fs38.existsSync(groupFile(name));
 }
 function addMember(groupName, member) {
   const group = loadGroup(groupName);
@@ -4530,16 +4820,16 @@ function removeMember(groupName, groupPath) {
   return group;
 }
 function saveSyncResult(result) {
-  fs37.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs37.writeFileSync(
-    path38.join(GROUPS_DIR, `${result.groupName}.sync.json`),
+  fs38.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs38.writeFileSync(
+    path39.join(GROUPS_DIR, `${result.groupName}.sync.json`),
     JSON.stringify(result, null, 2) + "\n"
   );
 }
 function loadSyncResult(groupName) {
   try {
     return JSON.parse(
-      fs37.readFileSync(path38.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
+      fs38.readFileSync(path39.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
     );
   } catch {
     return null;
@@ -4548,7 +4838,7 @@ function loadSyncResult(groupName) {
 var GROUPS_DIR;
 var init_group_registry = __esm({
   "src/multi-repo/group-registry.ts"() {
-    GROUPS_DIR = path38.join(os13.homedir(), ".code-intel", "groups");
+    GROUPS_DIR = path39.join(os13.homedir(), ".code-intel", "groups");
   }
 });
 
@@ -4574,7 +4864,7 @@ function parseRow(row, kind) {
 }
 async function loadGraphFromDB(graph, db) {
   for (const table of ALL_NODE_TABLES) {
-    const kind = TABLE_TO_KIND[table];
+    const kind = TABLE_TO_KIND2[table];
     if (!kind) continue;
     let rows = [];
     try {
@@ -4618,11 +4908,11 @@ async function loadGraphFromDB(graph, db) {
   } catch {
   }
 }
-var TABLE_TO_KIND;
+var TABLE_TO_KIND2;
 var init_graph_from_db = __esm({
   "src/multi-repo/graph-from-db.ts"() {
     init_schema();
-    TABLE_TO_KIND = Object.fromEntries(
+    TABLE_TO_KIND2 = Object.fromEntries(
       Object.entries(NODE_TABLE_MAP).map(([kind, table]) => [table, kind])
     );
   }
@@ -4633,12 +4923,12 @@ function scanForFiles(root, matcher, maxDepth = 2) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs37.readdirSync(dir, { withFileTypes: true });
+      entries = fs38.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path38.join(dir, entry.name);
+      const full = path39.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
         walk2(full, depth + 1);
       } else if (entry.isFile() && matcher(entry.name)) {
@@ -4654,8 +4944,8 @@ var init_file_scanner = __esm({
   }
 });
 function tryParseFile(filePath) {
-  const ext = path38.extname(filePath).toLowerCase();
-  const content = fs37.readFileSync(filePath, "utf-8");
+  const ext = path39.extname(filePath).toLowerCase();
+  const content = fs38.readFileSync(filePath, "utf-8");
   if (ext === ".json") {
     try {
       return JSON.parse(content);
@@ -4724,7 +5014,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 = fs37.readFileSync(filePath, "utf-8");
+    const content = fs38.readFileSync(filePath, "utf-8");
     const typeRegex = /type\s+(\w+)\s*\{([^}]+)\}/g;
     let match;
     while ((match = typeRegex.exec(content)) !== null) {
@@ -4760,7 +5050,7 @@ async function parseProtoContracts(repoRoot) {
   const files = scanForFiles(repoRoot, (name) => name.endsWith(".proto"));
   const contracts = [];
   for (const filePath of files) {
-    const content = fs37.readFileSync(filePath, "utf-8");
+    const content = fs38.readFileSync(filePath, "utf-8");
     const serviceRegex = /service\s+(\w+)\s*\{([^}]+)\}/g;
     let serviceMatch;
     while ((serviceMatch = serviceRegex.exec(content)) !== null) {
@@ -4978,13 +5268,13 @@ async function syncGroup(group) {
       logger_default.warn(`  \u26A0 Registry entry "${member.registryName}" not found \u2014 skipping ${member.groupPath}`);
       continue;
     }
-    const dbPath = path38.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs37.existsSync(dbPath)) {
+    const dbPath = path39.join(regEntry.path, ".code-intel", "graph.db");
+    if (!fs38.existsSync(dbPath)) {
       logger_default.warn(`  \u26A0 No index at ${dbPath} \u2014 run \`code-intel analyze ${regEntry.path}\` first`);
       continue;
     }
     const graph = createKnowledgeGraph();
-    const db = new DbManager(dbPath);
+    const db = new DbManager(dbPath, true);
     try {
       await db.init();
       await loadGraphFromDB(graph, db);
@@ -5160,10 +5450,10 @@ var init_codes = __esm({
   }
 });
 function secureMkdir(dir) {
-  fs37.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
+  fs38.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
   if (process.platform !== "win32") {
     try {
-      fs37.chmodSync(dir, SECURE_DIR_MODE);
+      fs38.chmodSync(dir, SECURE_DIR_MODE);
     } catch {
     }
   }
@@ -5171,22 +5461,22 @@ function secureMkdir(dir) {
 function secureChmodFile(file) {
   if (process.platform === "win32") return;
   try {
-    fs37.chmodSync(file, SECURE_FILE_MODE);
+    fs38.chmodSync(file, SECURE_FILE_MODE);
   } catch {
   }
 }
 function secureWriteFile(file, data) {
-  secureMkdir(path38.dirname(file));
-  fs37.writeFileSync(file, data, { mode: SECURE_FILE_MODE });
+  secureMkdir(path39.dirname(file));
+  fs38.writeFileSync(file, data, { mode: SECURE_FILE_MODE });
   secureChmodFile(file);
 }
 function tightenDbFiles(dir) {
   if (process.platform === "win32") return;
-  if (!fs37.existsSync(dir)) return;
-  for (const name of fs37.readdirSync(dir)) {
+  if (!fs38.existsSync(dir)) return;
+  for (const name of fs38.readdirSync(dir)) {
     if (name.endsWith(".db") || name.endsWith(".db-wal") || name.endsWith(".db-shm")) {
       try {
-        fs37.chmodSync(path38.join(dir, name), SECURE_FILE_MODE);
+        fs38.chmodSync(path39.join(dir, name), SECURE_FILE_MODE);
       } catch {
       }
     }
@@ -5200,7 +5490,7 @@ var init_fs_secure = __esm({
   }
 });
 function getUsersDBPath() {
-  return process.env["CODE_INTEL_USERS_DB_PATH"] ?? path38.join(os13.homedir(), ".code-intel", "users.db");
+  return process.env["CODE_INTEL_USERS_DB_PATH"] ?? path39.join(os13.homedir(), ".code-intel", "users.db");
 }
 function getOrCreateUsersDB() {
   if (!_usersDB) {
@@ -5216,9 +5506,9 @@ var init_users_db = __esm({
     UsersDB = class {
       db;
       constructor(dbPath) {
-        const dir = path38.dirname(dbPath);
+        const dir = path39.dirname(dbPath);
         secureMkdir(dir);
-        this.db = new Database(dbPath);
+        this.db = new Database2(dbPath);
         this.db.pragma("journal_mode = WAL");
         this.db.pragma("foreign_keys = ON");
         this.createTables();
@@ -5493,7 +5783,7 @@ function getScryptN() {
   return Number.isInteger(v) && v >= 1024 ? v : 1 << 14;
 }
 function getSecretsPath() {
-  return process.env["CODE_INTEL_SECRETS_PATH"] ?? path38.join(os13.homedir(), ".code-intel", ".secrets");
+  return process.env["CODE_INTEL_SECRETS_PATH"] ?? path39.join(os13.homedir(), ".code-intel", ".secrets");
 }
 function getMasterPassword() {
   const fromEnv = process.env["CODE_INTEL_SECRET_KEY"];
@@ -5535,12 +5825,12 @@ function decryptSecrets(encrypted) {
   return JSON.parse(plaintext.toString("utf8"));
 }
 function loadSecrets(secretsPath = getSecretsPath()) {
-  if (!fs37.existsSync(secretsPath)) return {};
-  const blob = fs37.readFileSync(secretsPath);
+  if (!fs38.existsSync(secretsPath)) return {};
+  const blob = fs38.readFileSync(secretsPath);
   return decryptSecrets(blob);
 }
 function saveSecrets(blob, secretsPath = getSecretsPath()) {
-  secureMkdir(path38.dirname(secretsPath));
+  secureMkdir(path39.dirname(secretsPath));
   const encrypted = encryptSecrets(blob);
   secureWriteFile(secretsPath, encrypted);
   secureChmodFile(secretsPath);
@@ -6034,7 +6324,7 @@ __export(gql_parser_exports, {
 function isGQLParseError(v) {
   return v.type === "GQLParseError";
 }
-function tokenize(input) {
+function tokenize2(input) {
   const tokens = [];
   let i = 0;
   const len = input.length;
@@ -6129,7 +6419,7 @@ function tokenize(input) {
   return tokens;
 }
 function parseGQL(input) {
-  const tokens = tokenize(input.trim());
+  const tokens = tokenize2(input.trim());
   if (!Array.isArray(tokens)) return tokens;
   const parser = new Parser2(tokens);
   return parser.parse();
@@ -7433,7 +7723,7 @@ function isTestFile(filePath) {
   if (filePath.includes(".test.") || filePath.includes(".spec.")) return true;
   if (filePath.includes("_test.") || filePath.endsWith("_test.go")) return true;
   if (filePath.includes("__tests__")) return true;
-  const base = path38.basename(filePath);
+  const base = path39.basename(filePath);
   if (base.startsWith("Test") && filePath.endsWith(".java")) return true;
   return false;
 }
@@ -7478,7 +7768,7 @@ function computeCoverage(graph, scope) {
   }
   const baseNameToTestFiles = /* @__PURE__ */ new Map();
   for (const testPath of testFilePaths) {
-    const base = path38.basename(testPath);
+    const base = path39.basename(testPath);
     const stripped = base.replace(/\.test\.[^.]+$/, "").replace(/\.spec\.[^.]+$/, "").replace(/_test\.[^.]+$/, "").replace(/_test$/, "");
     const existing = baseNameToTestFiles.get(stripped) ?? [];
     existing.push(testPath);
@@ -7511,7 +7801,7 @@ function computeCoverage(graph, scope) {
         }
       }
     }
-    const nodeBase = path38.basename(node.filePath).replace(/\.[^.]+$/, "");
+    const nodeBase = path39.basename(node.filePath).replace(/\.[^.]+$/, "");
     const matchingTestFiles = baseNameToTestFiles.get(nodeBase) ?? [];
     for (const tf of matchingTestFiles) {
       if (!testFiles.includes(tf)) testFiles.push(tf);
@@ -7581,7 +7871,7 @@ var init_secret_scanner = __esm({
         const ignorePatterns = [...options?.ignorePatterns ?? []];
         if (options?.workspaceRoot) {
           try {
-            const raw = fs37.readFileSync(path38.join(options.workspaceRoot, ".codeintelignore"), "utf-8");
+            const raw = fs38.readFileSync(path39.join(options.workspaceRoot, ".codeintelignore"), "utf-8");
             for (const line of raw.split("\n")) {
               const trimmed = line.trim();
               if (trimmed && !trimmed.startsWith("#")) ignorePatterns.push(trimmed);
@@ -7839,22 +8129,22 @@ __export(init_wizard_exports, {
   wipeConfig: () => wipeConfig
 });
 function configExists() {
-  return fs37.existsSync(CONFIG_PATH);
+  return fs38.existsSync(CONFIG_PATH);
 }
 function loadConfig() {
   if (!configExists()) return null;
   try {
-    return JSON.parse(fs37.readFileSync(CONFIG_PATH, "utf-8"));
+    return JSON.parse(fs38.readFileSync(CONFIG_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveConfig(cfg) {
-  fs37.mkdirSync(GLOBAL_DIR2, { recursive: true });
-  fs37.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+  fs38.mkdirSync(GLOBAL_DIR2, { recursive: true });
+  fs38.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
 }
 function wipeConfig() {
-  if (fs37.existsSync(CONFIG_PATH)) fs37.unlinkSync(CONFIG_PATH);
+  if (fs38.existsSync(CONFIG_PATH)) fs38.unlinkSync(CONFIG_PATH);
 }
 function commandExists(bin) {
   try {
@@ -7931,11 +8221,11 @@ async function runInitWizard(opts = {}) {
               "code-intel": { type: "stdio", command: "npx", args: ["code-intel", "mcp", "."] }
             }
           };
-          const mcpFile = path38.resolve(editor.mcpConfigKey);
+          const mcpFile = path39.resolve(editor.mcpConfigKey);
           try {
             let existing = {};
-            if (fs37.existsSync(mcpFile)) {
-              existing = JSON.parse(fs37.readFileSync(mcpFile, "utf-8"));
+            if (fs38.existsSync(mcpFile)) {
+              existing = JSON.parse(fs38.readFileSync(mcpFile, "utf-8"));
             }
             const merged = {
               ...existing,
@@ -7944,8 +8234,8 @@ async function runInitWizard(opts = {}) {
                 ...mcpConfig.servers
               }
             };
-            fs37.mkdirSync(path38.dirname(mcpFile), { recursive: true });
-            fs37.writeFileSync(mcpFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+            fs38.mkdirSync(path39.dirname(mcpFile), { recursive: true });
+            fs38.writeFileSync(mcpFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
             console.log(`  \u2705  MCP registered for ${name} \u2192 ${editor.mcpConfigKey}`);
           } catch {
             console.log(`  \u26A0   Could not write MCP config for ${name} \u2014 do it manually.`);
@@ -8041,8 +8331,8 @@ function printNextSteps() {
 var GLOBAL_DIR2, CONFIG_PATH, DEFAULT_CONFIG, EDITORS;
 var init_init_wizard = __esm({
   "src/cli/init-wizard.ts"() {
-    GLOBAL_DIR2 = path38.join(os13.homedir(), ".code-intel");
-    CONFIG_PATH = path38.join(GLOBAL_DIR2, "config.json");
+    GLOBAL_DIR2 = path39.join(os13.homedir(), ".code-intel");
+    CONFIG_PATH = path39.join(GLOBAL_DIR2, "config.json");
     DEFAULT_CONFIG = {
       $schema: "https://code-intel.dev/config-schema.json",
       llm: {
@@ -8082,9 +8372,9 @@ var init_init_wizard = __esm({
         binaries: ["code"],
         configFile: (home) => {
           const platform = process.platform;
-          if (platform === "darwin") return path38.join(home, "Library", "Application Support", "Code", "User", "settings.json");
-          if (platform === "win32") return path38.join(home, "AppData", "Roaming", "Code", "User", "settings.json");
-          return path38.join(home, ".config", "Code", "User", "settings.json");
+          if (platform === "darwin") return path39.join(home, "Library", "Application Support", "Code", "User", "settings.json");
+          if (platform === "win32") return path39.join(home, "AppData", "Roaming", "Code", "User", "settings.json");
+          return path39.join(home, ".config", "Code", "User", "settings.json");
         },
         mcpConfigKey: ".vscode/mcp.json"
       },
@@ -8093,9 +8383,9 @@ var init_init_wizard = __esm({
         binaries: ["cursor"],
         configFile: (home) => {
           const platform = process.platform;
-          if (platform === "darwin") return path38.join(home, "Library", "Application Support", "Cursor", "User", "settings.json");
-          if (platform === "win32") return path38.join(home, "AppData", "Roaming", "Cursor", "User", "settings.json");
-          return path38.join(home, ".config", "Cursor", "User", "settings.json");
+          if (platform === "darwin") return path39.join(home, "Library", "Application Support", "Cursor", "User", "settings.json");
+          if (platform === "win32") return path39.join(home, "AppData", "Roaming", "Cursor", "User", "settings.json");
+          return path39.join(home, ".config", "Cursor", "User", "settings.json");
         },
         mcpConfigKey: ".cursor/mcp.json"
       },
@@ -8103,15 +8393,15 @@ var init_init_wizard = __esm({
         name: "Windsurf",
         binaries: ["windsurf"],
         configFile: (home) => {
-          if (process.platform === "darwin") return path38.join(home, "Library", "Application Support", "Windsurf", "User", "settings.json");
-          return path38.join(home, ".config", "Windsurf", "User", "settings.json");
+          if (process.platform === "darwin") return path39.join(home, "Library", "Application Support", "Windsurf", "User", "settings.json");
+          return path39.join(home, ".config", "Windsurf", "User", "settings.json");
         },
         mcpConfigKey: ".windsurf/mcp.json"
       },
       {
         name: "Zed",
         binaries: ["zed"],
-        configFile: (home) => path38.join(home, ".config", "zed", "settings.json"),
+        configFile: (home) => path39.join(home, ".config", "zed", "settings.json"),
         mcpConfigKey: ".zed/mcp.json"
       }
     ];
@@ -8378,6 +8668,263 @@ var init_config_manager = __esm({
   }
 });
 
+// src/graph/intern-table.ts
+function internNode(node, table = globalInternTable) {
+  node.filePath = table.get(node.filePath);
+  node.kind = table.get(node.kind);
+  node.name = table.get(node.name);
+  return node;
+}
+function internEdge(edge, table = globalInternTable) {
+  edge.kind = table.get(edge.kind);
+  edge.source = table.get(edge.source);
+  edge.target = table.get(edge.target);
+  return edge;
+}
+var InternTable, globalInternTable;
+var init_intern_table = __esm({
+  "src/graph/intern-table.ts"() {
+    InternTable = class {
+      table = /* @__PURE__ */ new Map();
+      /**
+       * Return the canonical (interned) copy of `s`.
+       * First call stores it; subsequent calls return the same reference.
+       */
+      get(s) {
+        let interned = this.table.get(s);
+        if (interned === void 0) {
+          this.table.set(s, s);
+          interned = s;
+        }
+        return interned;
+      }
+      /** Number of unique strings stored. */
+      get size() {
+        return this.table.size;
+      }
+      clear() {
+        this.table.clear();
+      }
+    };
+    globalInternTable = new InternTable();
+  }
+});
+
+// src/graph/compact-knowledge-graph.ts
+var compact_knowledge_graph_exports = {};
+__export(compact_knowledge_graph_exports, {
+  CompactKnowledgeGraph: () => CompactKnowledgeGraph,
+  createCompactKnowledgeGraph: () => createCompactKnowledgeGraph
+});
+function createCompactKnowledgeGraph(maxMemoryMB = 0) {
+  return new CompactKnowledgeGraph(maxMemoryMB);
+}
+var CompactKnowledgeGraph;
+var init_compact_knowledge_graph = __esm({
+  "src/graph/compact-knowledge-graph.ts"() {
+    init_intern_table();
+    init_logger();
+    CompactKnowledgeGraph = class {
+      // ── Storage ────────────────────────────────────────────────────────────────
+      nodes = /* @__PURE__ */ new Map();
+      edges = /* @__PURE__ */ new Map();
+      // Typed adjacency: Int32 edge-index lists per node
+      // We store the edge index (into edgeArray) rather than the edge ID string.
+      edgesFromNode = /* @__PURE__ */ new Map();
+      edgesToNode = /* @__PURE__ */ new Map();
+      edgesByKind = /* @__PURE__ */ new Map();
+      // Flat ordered edge array for O(1) index→edge lookup
+      edgeArray = [];
+      // Float32Array for weights (parallel to edgeArray)
+      weightArray = new Float32Array(1024);
+      // Symbol intern table
+      intern = new InternTable();
+      // --max-memory spill threshold (MB). 0 = disabled.
+      maxMemoryMB;
+      spillCount = 0;
+      constructor(maxMemoryMB = 0) {
+        this.maxMemoryMB = maxMemoryMB;
+      }
+      // ── KnowledgeGraph interface ───────────────────────────────────────────────
+      addNode(node) {
+        internNode(node, this.intern);
+        this.nodes.set(node.id, node);
+        if (this.maxMemoryMB > 0) this._maybeSpill();
+      }
+      addEdge(edge) {
+        internEdge(edge, this.intern);
+        this.edges.set(edge.id, edge);
+        const edgeIdx = this.edgeArray.length;
+        this.edgeArray.push(edge);
+        if (edgeIdx >= this.weightArray.length) {
+          const next = new Float32Array(this.weightArray.length * 2);
+          next.set(this.weightArray);
+          this.weightArray = next;
+        }
+        this.weightArray[edgeIdx] = edge.weight ?? 1;
+        this._appendToList(this.edgesFromNode, edge.source, edgeIdx);
+        this._appendToList(this.edgesToNode, edge.target, edgeIdx);
+        let kindList = this.edgesByKind.get(edge.kind);
+        if (!kindList) {
+          kindList = [];
+          this.edgesByKind.set(edge.kind, kindList);
+        }
+        kindList.push(edgeIdx);
+      }
+      getNode(id) {
+        return this.nodes.get(id);
+      }
+      getEdge(id) {
+        return this.edges.get(id);
+      }
+      *findEdgesByKind(kind) {
+        const idxList = this.edgesByKind.get(kind);
+        if (!idxList) return;
+        for (const idx of idxList) {
+          const edge = this.edgeArray[idx];
+          if (edge) yield edge;
+        }
+      }
+      *findEdgesFrom(sourceId) {
+        const idxList = this.edgesFromNode.get(sourceId);
+        if (!idxList) return;
+        for (const idx of idxList) {
+          const edge = this.edgeArray[idx];
+          if (edge) yield edge;
+        }
+      }
+      *findEdgesTo(targetId) {
+        const idxList = this.edgesToNode.get(targetId);
+        if (!idxList) return;
+        for (const idx of idxList) {
+          const edge = this.edgeArray[idx];
+          if (edge) yield edge;
+        }
+      }
+      removeNodeCascade(id) {
+        const fromIdxs = this.edgesFromNode.get(id);
+        if (fromIdxs) {
+          for (const idx of fromIdxs) {
+            const edge = this.edgeArray[idx];
+            if (edge) {
+              this.edges.delete(edge.id);
+              this.edgeArray[idx] = void 0;
+              this._removeFromList(this.edgesToNode, edge.target, idx);
+              this._removeFromKindList(edge.kind, idx);
+            }
+          }
+        }
+        const toIdxs = this.edgesToNode.get(id);
+        if (toIdxs) {
+          for (const idx of toIdxs) {
+            const edge = this.edgeArray[idx];
+            if (edge) {
+              this.edges.delete(edge.id);
+              this.edgeArray[idx] = void 0;
+              this._removeFromList(this.edgesFromNode, edge.source, idx);
+              this._removeFromKindList(edge.kind, idx);
+            }
+          }
+        }
+        this.edgesFromNode.delete(id);
+        this.edgesToNode.delete(id);
+        this.nodes.delete(id);
+      }
+      removeEdge(id) {
+        const edge = this.edges.get(id);
+        if (!edge) return;
+        this.edges.delete(id);
+        const idx = this.edgeArray.indexOf(edge);
+        if (idx !== -1) {
+          this.edgeArray[idx] = void 0;
+          this._removeFromList(this.edgesFromNode, edge.source, idx);
+          this._removeFromList(this.edgesToNode, edge.target, idx);
+          this._removeFromKindList(edge.kind, idx);
+        }
+      }
+      *allNodes() {
+        yield* this.nodes.values();
+      }
+      *allEdges() {
+        for (const edge of this.edgeArray) {
+          if (edge) yield edge;
+        }
+      }
+      get size() {
+        return { nodes: this.nodes.size, edges: this.edges.size };
+      }
+      clear() {
+        this.nodes.clear();
+        this.edges.clear();
+        this.edgesFromNode.clear();
+        this.edgesToNode.clear();
+        this.edgesByKind.clear();
+        this.edgeArray.length = 0;
+        this.weightArray = new Float32Array(1024);
+        this.intern.clear();
+        this.spillCount = 0;
+      }
+      // ── Diagnostics ────────────────────────────────────────────────────────────
+      /** Number of unique interned strings (useful for memory audit). */
+      get internedStringCount() {
+        return this.intern.size;
+      }
+      /** Number of nodes that had content spilled due to memory pressure. */
+      get spilledNodeCount() {
+        return this.spillCount;
+      }
+      // ── Private helpers ────────────────────────────────────────────────────────
+      _appendToList(map, key, idx) {
+        const existing = map.get(key);
+        if (!existing) {
+          map.set(key, [idx]);
+        } else {
+          existing.push(idx);
+        }
+      }
+      _removeFromList(map, key, idx) {
+        const list = map.get(key);
+        if (!list) return;
+        const arr = list;
+        const pos = arr.indexOf(idx);
+        if (pos !== -1) arr.splice(pos, 1);
+      }
+      _removeFromKindList(kind, idx) {
+        const list = this.edgesByKind.get(kind);
+        if (!list) return;
+        const pos = list.indexOf(idx);
+        if (pos !== -1) list.splice(pos, 1);
+      }
+      /**
+       * Memory-pressure spill: when RSS > maxMemoryMB, clear the `content` field
+       * of nodes that are less likely to be needed (no outgoing call edges = leaf nodes).
+       * This frees the largest string blobs while keeping graph topology intact.
+       */
+      _maybeSpill() {
+        if (this.maxMemoryMB <= 0) return;
+        const rssMB = process.memoryUsage().rss / (1024 * 1024);
+        if (rssMB <= this.maxMemoryMB) return;
+        let spilled = 0;
+        for (const node of this.nodes.values()) {
+          if (node.content === void 0) continue;
+          const outgoing = this.edgesFromNode.get(node.id);
+          if (!outgoing || outgoing.length === 0) {
+            node.content = void 0;
+            spilled++;
+            this.spillCount++;
+            if (spilled >= 100) break;
+          }
+        }
+        if (spilled > 0) {
+          logger_default.warn(
+            `  [compact-graph] Memory pressure (${rssMB.toFixed(0)} MB > ${this.maxMemoryMB} MB): spilled content for ${spilled} nodes`
+          );
+        }
+      }
+    };
+  }
+});
+
 // src/pipeline/file-watcher.ts
 var file_watcher_exports = {};
 __export(file_watcher_exports, {
@@ -8456,10 +9003,10 @@ var init_file_watcher = __esm({
       }
       // ── private ─────────────────────────────────────────────────────────────────
       readCodeIntelIgnore() {
-        const ignoreFile = path38.join(this.workspaceRoot, ".codeintelignore");
+        const ignoreFile = path39.join(this.workspaceRoot, ".codeintelignore");
         try {
-          if (!fs37.existsSync(ignoreFile)) return [];
-          return fs37.readFileSync(ignoreFile, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+          if (!fs38.existsSync(ignoreFile)) return [];
+          return fs38.readFileSync(ignoreFile, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
         } catch {
           return [];
         }
@@ -8482,6 +9029,7 @@ var init_incremental_indexer = __esm({
     init_parse_phase();
     init_resolve_phase();
     init_logger();
+    init_bm25_index();
     IncrementalIndexer = class {
       graph;
       workspaceRoot;
@@ -8511,7 +9059,7 @@ var init_incremental_indexer = __esm({
         }
         const nodeIdsToRemove = /* @__PURE__ */ new Set();
         for (const absPath of changedFiles) {
-          const relPath2 = path38.relative(workspaceRoot, absPath);
+          const relPath2 = path39.relative(workspaceRoot, absPath);
           for (const id of nodesByFilePath.get(relPath2) ?? []) nodeIdsToRemove.add(id);
           for (const id of nodesByFilePath.get(absPath) ?? []) nodeIdsToRemove.add(id);
         }
@@ -8519,12 +9067,12 @@ var init_incremental_indexer = __esm({
           graph.removeNodeCascade(id);
           nodesRemoved++;
         }
-        if (fs37.existsSync(dbPath)) {
+        if (fs38.existsSync(dbPath)) {
           try {
             const db = new DbManager(dbPath);
             await db.init();
             for (const absPath of changedFiles) {
-              const relPath2 = path38.relative(workspaceRoot, absPath);
+              const relPath2 = path39.relative(workspaceRoot, absPath);
               await removeNodesForFile(relPath2, db);
             }
             db.close();
@@ -8534,7 +9082,7 @@ var init_incremental_indexer = __esm({
         }
         const existingFiles = changedFiles.filter((f) => {
           try {
-            return fs37.statSync(f).isFile();
+            return fs38.statSync(f).isFile();
           } catch {
             return false;
           }
@@ -8556,16 +9104,26 @@ var init_incremental_indexer = __esm({
           await runPipeline([noopScan, parsePhase, resolvePhase], context2);
         }
         const nodesAdded = Math.max(0, graph.size.nodes - (nodesBeforeParse - nodesRemoved));
-        if (fs37.existsSync(dbPath) && existingFiles.length > 0) {
+        if (fs38.existsSync(dbPath) && existingFiles.length > 0) {
           try {
             const db = new DbManager(dbPath);
             await db.init();
-            const changedRelPaths = new Set(changedFiles.map((f) => path38.relative(workspaceRoot, f)));
+            const changedRelPaths = new Set(changedFiles.map((f) => path39.relative(workspaceRoot, f)));
             const nodesToUpsert = [...graph.allNodes()].filter(
-              (n) => changedRelPaths.has(n.filePath) || changedRelPaths.has(path38.relative(workspaceRoot, n.filePath))
+              (n) => changedRelPaths.has(n.filePath) || changedRelPaths.has(path39.relative(workspaceRoot, n.filePath))
             );
             await upsertNodes(nodesToUpsert, db);
             db.close();
+            try {
+              const bm25DbPath = getBm25DbPath(workspaceRoot);
+              if (fs38.existsSync(bm25DbPath)) {
+                const bm25 = new Bm25Index(bm25DbPath);
+                bm25.updateNodes(nodesToUpsert);
+                logger_default.info(`[incremental] BM25 index updated: ${nodesToUpsert.length} nodes`);
+              }
+            } catch (bm25Err) {
+              logger_default.warn(`[incremental] BM25 update failed: ${bm25Err instanceof Error ? bm25Err.message : bm25Err}`);
+            }
           } catch (err) {
             logger_default.warn(`[incremental] DB upsert failed: ${err instanceof Error ? err.message : err}`);
           }
@@ -8593,35 +9151,35 @@ __export(saved_queries_exports, {
   saveQuery: () => saveQuery
 });
 function getQueriesDir(workspaceRoot) {
-  return path38.join(workspaceRoot, ".code-intel", "queries");
+  return path39.join(workspaceRoot, ".code-intel", "queries");
 }
 function ensureQueriesDir(workspaceRoot) {
   const dir = getQueriesDir(workspaceRoot);
-  if (!fs37.existsSync(dir)) {
-    fs37.mkdirSync(dir, { recursive: true });
+  if (!fs38.existsSync(dir)) {
+    fs38.mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 function saveQuery(workspaceRoot, name, gql) {
   const dir = ensureQueriesDir(workspaceRoot);
-  const filePath = path38.join(dir, `${name}.gql`);
-  fs37.writeFileSync(filePath, gql, "utf-8");
+  const filePath = path39.join(dir, `${name}.gql`);
+  fs38.writeFileSync(filePath, gql, "utf-8");
 }
 function loadQuery(workspaceRoot, name) {
   const dir = getQueriesDir(workspaceRoot);
-  const filePath = path38.join(dir, `${name}.gql`);
-  if (!fs37.existsSync(filePath)) return null;
-  return fs37.readFileSync(filePath, "utf-8");
+  const filePath = path39.join(dir, `${name}.gql`);
+  if (!fs38.existsSync(filePath)) return null;
+  return fs38.readFileSync(filePath, "utf-8");
 }
 function listQueries(workspaceRoot) {
   const dir = getQueriesDir(workspaceRoot);
-  if (!fs37.existsSync(dir)) return [];
-  const files = fs37.readdirSync(dir).filter((f) => f.endsWith(".gql"));
+  if (!fs38.existsSync(dir)) return [];
+  const files = fs38.readdirSync(dir).filter((f) => f.endsWith(".gql"));
   return files.map((f) => {
-    const filePath = path38.join(dir, f);
+    const filePath = path39.join(dir, f);
     const name = f.replace(/\.gql$/, "");
-    const content = fs37.readFileSync(filePath, "utf-8");
-    const stat = fs37.statSync(filePath);
+    const content = fs38.readFileSync(filePath, "utf-8");
+    const stat = fs38.statSync(filePath);
     return {
       name,
       content,
@@ -8632,15 +9190,15 @@ function listQueries(workspaceRoot) {
 }
 function deleteQuery(workspaceRoot, name) {
   const dir = getQueriesDir(workspaceRoot);
-  const filePath = path38.join(dir, `${name}.gql`);
-  if (!fs37.existsSync(filePath)) return false;
-  fs37.unlinkSync(filePath);
+  const filePath = path39.join(dir, `${name}.gql`);
+  if (!fs38.existsSync(filePath)) return false;
+  fs38.unlinkSync(filePath);
   return true;
 }
 function queryExists(workspaceRoot, name) {
   const dir = getQueriesDir(workspaceRoot);
-  const filePath = path38.join(dir, `${name}.gql`);
-  return fs37.existsSync(filePath);
+  const filePath = path39.join(dir, `${name}.gql`);
+  return fs38.existsSync(filePath);
 }
 var init_saved_queries = __esm({
   "src/query/saved-queries.ts"() {
@@ -8711,10 +9269,439 @@ var init_sarif_builder = __esm({
 // src/cli/main.ts
 init_logger();
 init_knowledge_graph();
-init_orchestrator();
-init_phases();
 
-// src/search/text-search.ts
+// src/graph/lazy-knowledge-graph.ts
+init_schema();
+init_logger();
+var TABLE_TO_KIND = Object.fromEntries(
+  Object.entries(NODE_TABLE_MAP).map(([kind, table]) => [table, kind])
+);
+var LRUCache = class {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  maxSize;
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    const val = this.map.get(key);
+    if (val !== void 0) {
+      this.map.delete(key);
+      this.map.set(key, val);
+    }
+    return val;
+  }
+  set(key, value) {
+    if (this.map.has(key)) this.map.delete(key);
+    this.map.set(key, value);
+    if (this.map.size > this.maxSize) {
+      const lruKey = this.map.keys().next().value;
+      this.map.delete(lruKey);
+    }
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  get size() {
+    return this.map.size;
+  }
+  values() {
+    return this.map.values();
+  }
+  clear() {
+    this.map.clear();
+  }
+  /** Evict LRU entries until cache is at or below maxSize */
+  evict() {
+    while (this.map.size > this.maxSize) {
+      const lruKey = this.map.keys().next().value;
+      this.map.delete(lruKey);
+    }
+  }
+};
+function parseNodeRow(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
+  };
+}
+function escCypher(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "");
+}
+var LazyKnowledgeGraph = class {
+  lazy = true;
+  nodeCache;
+  edges = /* @__PURE__ */ new Map();
+  edgesFromNode = /* @__PURE__ */ new Map();
+  edgesToNode = /* @__PURE__ */ new Map();
+  edgesByKind = /* @__PURE__ */ new Map();
+  _nodeCount = 0;
+  _edgeCount = 0;
+  dbManager = null;
+  /**
+   * Per-table row counts, populated lazily on first getNodePage call.
+   * Allows native SKIP/LIMIT at the DB layer instead of streaming-and-discarding.
+   */
+  _tableNodeCounts = null;
+  async getTableNodeCounts() {
+    if (this._tableNodeCounts) return this._tableNodeCounts;
+    if (!this.dbManager) return /* @__PURE__ */ new Map();
+    const counts = /* @__PURE__ */ new Map();
+    await Promise.all(
+      ALL_NODE_TABLES.map(async (table) => {
+        try {
+          const rows = await this.dbManager.query(
+            `MATCH (n:${table}) RETURN count(n) AS cnt`
+          );
+          counts.set(table, Number(rows[0]?.["cnt"] ?? 0));
+        } catch {
+          counts.set(table, 0);
+        }
+      })
+    );
+    this._tableNodeCounts = counts;
+    return counts;
+  }
+  constructor() {
+    const maxSize = parseInt(process.env["GRAPH_CACHE_SIZE"] ?? "5000", 10);
+    this.nodeCache = new LRUCache(maxSize);
+  }
+  // ── Initialization ─────────────────────────────────────────────────────────
+  /**
+   * Init: load ALL edges into memory (lightweight — no content field).
+   * Node counts come from meta.json — no nodes are loaded here.
+   *
+   * @param dbManager  Open DB connection (kept alive for lazy node fetches).
+   * @param nodeCount  Total node count from meta.json stats.
+   * @param edgeCount  Estimated edge count from meta.json stats (updated after load).
+   */
+  async init(dbManager, nodeCount, edgeCount) {
+    this.dbManager = dbManager;
+    if (nodeCount !== void 0) this._nodeCount = nodeCount;
+    if (edgeCount !== void 0) this._edgeCount = edgeCount;
+    await this._loadAllEdges();
+  }
+  // ── Async extensions ───────────────────────────────────────────────────────
+  /** Fetch a single node from DB on cache miss. */
+  async getNodeAsync(id) {
+    const cached = this.nodeCache.get(id);
+    if (cached) return cached;
+    if (!this.dbManager) return void 0;
+    const colonIdx = id.indexOf(":");
+    if (colonIdx === -1) return void 0;
+    const kind = id.slice(0, colonIdx);
+    const table = NODE_TABLE_MAP[kind];
+    if (!table) return void 0;
+    try {
+      const rows = await this.dbManager.query(
+        `MATCH (n:${table} {id: '${escCypher(id)}'}) RETURN n.id, n.name, n.file_path, n.start_line, n.end_line, n.exported, n.content, n.metadata`
+      );
+      if (rows.length === 0) return void 0;
+      const row = rows[0];
+      const node = parseNodeRow(
+        {
+          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) {
+        this.nodeCache.set(node.id, node);
+        return node;
+      }
+      return void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Return a page of nodes using native SKIP/LIMIT at the DB layer.
+   * This avoids streaming and discarding rows for high offsets, making
+   * large-offset pages (e.g. offset=2200) as fast as offset=0.
+   */
+  async getNodePage(offset, limit) {
+    if (!this.dbManager) return [];
+    const tableCounts = await this.getTableNodeCounts();
+    const result = [];
+    let tableStart = 0;
+    for (const table of ALL_NODE_TABLES) {
+      if (result.length >= limit) break;
+      const tableCount = tableCounts.get(table) ?? 0;
+      if (tableCount === 0) {
+        tableStart += tableCount;
+        continue;
+      }
+      const tableEnd = tableStart + tableCount;
+      if (offset >= tableEnd) {
+        tableStart = tableEnd;
+        continue;
+      }
+      const kind = TABLE_TO_KIND[table];
+      if (!kind) {
+        tableStart = tableEnd;
+        continue;
+      }
+      const skipInTable = Math.max(0, offset - tableStart);
+      const remaining = limit - result.length;
+      try {
+        const rows = await this.dbManager.query(
+          `MATCH (n:${table}) RETURN n.id, n.name, n.file_path, n.start_line, n.end_line, n.exported, n.content, n.metadata SKIP ${skipInTable} LIMIT ${remaining}`
+        );
+        for (const row of rows) {
+          const node = parseNodeRow(
+            {
+              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) {
+            this.nodeCache.set(node.id, node);
+            result.push(node);
+          }
+        }
+      } catch {
+      }
+      tableStart = tableEnd;
+    }
+    return result;
+  }
+  /**
+   * Pre-warm the LRU cache with the top-N highest-blast-radius nodes
+   * (those with the most outgoing edges).  Called in background after startup.
+   */
+  async warmTopNodes(topN = 500) {
+    if (!this.dbManager) return;
+    const scored = [];
+    for (const [nodeId, edgeSet] of this.edgesFromNode) {
+      scored.push([nodeId, edgeSet.size]);
+    }
+    scored.sort((a, b) => b[1] - a[1]);
+    const topIds = scored.slice(0, topN).map(([id]) => id);
+    let loaded = 0;
+    for (const id of topIds) {
+      if (!this.nodeCache.has(id)) {
+        await this.getNodeAsync(id);
+        loaded++;
+      }
+    }
+    logger_default.info(
+      `  [lazy-graph] Background warm: ${loaded} high-blast-radius nodes loaded into cache`
+    );
+  }
+  /** Async generator: stream all nodes from DB, caching each one. */
+  async *allNodesAsync() {
+    if (!this.dbManager) return;
+    for (const table of ALL_NODE_TABLES) {
+      const kind = TABLE_TO_KIND[table];
+      if (!kind) continue;
+      try {
+        const rows = await this.dbManager.query(
+          `MATCH (n:${table}) RETURN n.id, n.name, n.file_path, n.start_line, n.end_line, n.exported, n.content, n.metadata`
+        );
+        for (const row of rows) {
+          const node = parseNodeRow(
+            {
+              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) {
+            this.nodeCache.set(node.id, node);
+            yield node;
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  // ── KnowledgeGraph interface ───────────────────────────────────────────────
+  addNode(node) {
+    this.nodeCache.set(node.id, node);
+    this._nodeCount++;
+  }
+  addEdge(edge) {
+    this.edges.set(edge.id, edge);
+    this._indexEdge(edge);
+    this._edgeCount = this.edges.size;
+  }
+  /**
+   * Sync node lookup — returns from LRU cache only.
+   * Use `getNodeAsync(id)` for a full DB lookup on cache miss.
+   */
+  getNode(id) {
+    return this.nodeCache.get(id);
+  }
+  getEdge(id) {
+    return this.edges.get(id);
+  }
+  *findEdgesByKind(kind) {
+    const ids = this.edgesByKind.get(kind);
+    if (!ids) return;
+    for (const id of ids) {
+      const edge = this.edges.get(id);
+      if (edge) yield edge;
+    }
+  }
+  *findEdgesFrom(sourceId) {
+    const ids = this.edgesFromNode.get(sourceId);
+    if (!ids) return;
+    for (const id of ids) {
+      const edge = this.edges.get(id);
+      if (edge) yield edge;
+    }
+  }
+  *findEdgesTo(targetId) {
+    const ids = this.edgesToNode.get(targetId);
+    if (!ids) return;
+    for (const id of ids) {
+      const edge = this.edges.get(id);
+      if (edge) yield edge;
+    }
+  }
+  removeNodeCascade(id) {
+    for (const edgeId of [...this.edgesFromNode.get(id) ?? []]) {
+      const edge = this.edges.get(edgeId);
+      if (edge) {
+        this._unindexEdge(edge);
+        this.edges.delete(edgeId);
+      }
+    }
+    for (const edgeId of [...this.edgesToNode.get(id) ?? []]) {
+      const edge = this.edges.get(edgeId);
+      if (edge) {
+        this._unindexEdge(edge);
+        this.edges.delete(edgeId);
+      }
+    }
+    this.edgesFromNode.delete(id);
+    this.edgesToNode.delete(id);
+    this._nodeCount = Math.max(0, this._nodeCount - 1);
+  }
+  removeEdge(id) {
+    const edge = this.edges.get(id);
+    if (edge) {
+      this._unindexEdge(edge);
+      this.edges.delete(id);
+    }
+  }
+  /**
+   * Iterates only the cached nodes.
+   * For full graph iteration use `allNodesAsync()`.
+   */
+  *allNodes() {
+    yield* this.nodeCache.values();
+  }
+  *allEdges() {
+    yield* this.edges.values();
+  }
+  get size() {
+    return { nodes: this._nodeCount, edges: this._edgeCount };
+  }
+  clear() {
+    this.nodeCache.clear();
+    this.edges.clear();
+    this.edgesFromNode.clear();
+    this.edgesToNode.clear();
+    this.edgesByKind.clear();
+    this._nodeCount = 0;
+    this._edgeCount = 0;
+  }
+  // ── Private helpers ────────────────────────────────────────────────────────
+  async _loadAllEdges() {
+    if (!this.dbManager) return;
+    try {
+      const edgeRows = await this.dbManager.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
+        };
+        this.edges.set(edge.id, edge);
+        this._indexEdge(edge);
+      }
+      this._edgeCount = this.edges.size;
+    } catch (err) {
+      logger_default.warn("[lazy-graph] Failed to load edges:", err instanceof Error ? err.message : err);
+    }
+  }
+  _indexEdge(edge) {
+    let kindSet = this.edgesByKind.get(edge.kind);
+    if (!kindSet) {
+      kindSet = /* @__PURE__ */ new Set();
+      this.edgesByKind.set(edge.kind, kindSet);
+    }
+    kindSet.add(edge.id);
+    let fromSet = this.edgesFromNode.get(edge.source);
+    if (!fromSet) {
+      fromSet = /* @__PURE__ */ new Set();
+      this.edgesFromNode.set(edge.source, fromSet);
+    }
+    fromSet.add(edge.id);
+    let toSet = this.edgesToNode.get(edge.target);
+    if (!toSet) {
+      toSet = /* @__PURE__ */ new Set();
+      this.edgesToNode.set(edge.target, toSet);
+    }
+    toSet.add(edge.id);
+  }
+  _unindexEdge(edge) {
+    this.edgesByKind.get(edge.kind)?.delete(edge.id);
+    this.edgesFromNode.get(edge.source)?.delete(edge.id);
+    this.edgesToNode.get(edge.target)?.delete(edge.id);
+  }
+};
+function isLazyGraph(g) {
+  return "lazy" in g && g.lazy === true;
+}
+
+// src/cli/main.ts
+init_orchestrator();
+init_phases();
+
+// src/search/text-search.ts
 function textSearch(graph, query, limit = 20) {
   const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
   const results = [];
@@ -8774,9 +9761,9 @@ function reciprocalRankFusion(...rankings) {
 init_vector_index();
 init_embedder();
 async function hybridSearch(graph, query, limit, options = {}) {
-  const { vectorDbPath, bm25Limit = 50, vectorLimit = 50 } = options;
-  const bm25Promise = Promise.resolve(textSearch(graph, query, bm25Limit));
-  const hasVectorDb = Boolean(vectorDbPath && fs37.existsSync(vectorDbPath));
+  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 && fs38.existsSync(vectorDbPath));
   if (!hasVectorDb) {
     const bm25Results2 = await bm25Promise;
     return {
@@ -8827,8 +9814,8 @@ async function runVectorSearch(vectorDbPath, query, topK) {
 }
 
 // src/http/app.ts
+init_bm25_index();
 init_storage();
-init_metadata();
 init_vector_index();
 init_group_registry();
 init_group_sync();
@@ -8843,10 +9830,10 @@ async function queryGroup(group, query, limit = 20) {
   for (const member of group.members) {
     const regEntry = registry.find((r) => r.name === member.registryName);
     if (!regEntry) continue;
-    const dbPath = path38.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs37.existsSync(dbPath)) continue;
+    const dbPath = path39.join(regEntry.path, ".code-intel", "graph.db");
+    if (!fs38.existsSync(dbPath)) continue;
     const graph = createKnowledgeGraph();
-    const db = new DbManager(dbPath);
+    const db = new DbManager(dbPath, true);
     try {
       await db.init();
       await loadGraphFromDB(graph, db);
@@ -8886,8 +9873,8 @@ var STUCK_THRESHOLD_MINUTES = 30;
 var JobsDB = class {
   db;
   constructor(dbPath) {
-    fs37.mkdirSync(path38.dirname(dbPath), { recursive: true });
-    this.db = new Database(dbPath);
+    fs38.mkdirSync(path39.dirname(dbPath), { recursive: true });
+    this.db = new Database2(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
     this.createTables();
@@ -9028,7 +10015,7 @@ var JobsDB = class {
   }
 };
 function getJobsDBPath() {
-  return path38.join(os13.homedir(), ".code-intel", "jobs.db");
+  return path39.join(os13.homedir(), ".code-intel", "jobs.db");
 }
 var _jobsDB = null;
 function getOrCreateJobsDB() {
@@ -9123,7 +10110,7 @@ var BACKUP_VERSION = "1.0";
 var ALGORITHM = "aes-256-gcm";
 var IV_LENGTH = 16;
 function getBackupDir() {
-  return path38.join(os13.homedir(), ".code-intel", "backups");
+  return path39.join(os13.homedir(), ".code-intel", "backups");
 }
 function getBackupKey() {
   const keyHex = process.env["CODE_INTEL_BACKUP_KEY"];
@@ -9154,30 +10141,30 @@ var BackupService = class {
   constructor(backupDir) {
     this.backupDir = backupDir ?? getBackupDir();
     this.key = getBackupKey();
-    fs37.mkdirSync(this.backupDir, { recursive: true });
+    fs38.mkdirSync(this.backupDir, { recursive: true });
   }
   /**
    * Create a backup for a repository.
    * Returns the backup entry.
    */
   createBackup(repoPath) {
-    const codeIntelDir = path38.join(repoPath, ".code-intel");
+    const codeIntelDir = path39.join(repoPath, ".code-intel");
     const id = v4();
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
     const filesToBackup = [];
     const candidates = ["graph.db", "vector.db", "meta.json"];
     for (const f of candidates) {
-      const fp = path38.join(codeIntelDir, f);
-      if (fs37.existsSync(fp)) {
+      const fp = path39.join(codeIntelDir, f);
+      if (fs38.existsSync(fp)) {
         filesToBackup.push({ name: f, localPath: fp });
       }
     }
-    const registryPath = path38.join(os13.homedir(), ".code-intel", "registry.json");
-    if (fs37.existsSync(registryPath)) {
+    const registryPath = path39.join(os13.homedir(), ".code-intel", "registry.json");
+    if (fs38.existsSync(registryPath)) {
       filesToBackup.push({ name: "registry.json", localPath: registryPath });
     }
-    const usersDbPath = path38.join(os13.homedir(), ".code-intel", "users.db");
-    if (fs37.existsSync(usersDbPath)) {
+    const usersDbPath = path39.join(os13.homedir(), ".code-intel", "users.db");
+    if (fs38.existsSync(usersDbPath)) {
       filesToBackup.push({ name: "users.db", localPath: usersDbPath });
     }
     if (filesToBackup.length === 0) {
@@ -9188,7 +10175,7 @@ var BackupService = class {
       createdAt,
       version: BACKUP_VERSION,
       files: filesToBackup.map((f) => {
-        const data = fs37.readFileSync(f.localPath);
+        const data = fs38.readFileSync(f.localPath);
         return {
           name: f.name,
           sha256: crypto5.createHash("sha256").update(data).digest("hex"),
@@ -9202,7 +10189,7 @@ var BackupService = class {
     manifestLenBuf.writeUInt32BE(manifestBuf.length, 0);
     parts.push(manifestLenBuf, manifestBuf);
     for (const f of filesToBackup) {
-      const data = fs37.readFileSync(f.localPath);
+      const data = fs38.readFileSync(f.localPath);
       const nameBuf = Buffer.from(f.name, "utf-8");
       const nameLenBuf = Buffer.alloc(2);
       nameLenBuf.writeUInt16BE(nameBuf.length, 0);
@@ -9213,8 +10200,8 @@ var BackupService = class {
     const plaintext = Buffer.concat(parts);
     const encrypted = encryptBuffer(plaintext, this.key);
     const backupFileName = `backup-${id}.cib`;
-    const backupPath = path38.join(this.backupDir, backupFileName);
-    fs37.writeFileSync(backupPath, encrypted);
+    const backupPath = path39.join(this.backupDir, backupFileName);
+    fs38.writeFileSync(backupPath, encrypted);
     const entry = {
       id,
       createdAt,
@@ -9241,9 +10228,9 @@ var BackupService = class {
   async uploadToS3(entry) {
     const cfg = getS3Config();
     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 = path38.basename(entry.path);
+    const fileName = path39.basename(entry.path);
     const s3Key = `${cfg.prefix}${fileName}`;
-    const body = fs37.readFileSync(entry.path);
+    const body = fs38.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)}`);
@@ -9260,8 +10247,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)}`);
     }
-    fs37.mkdirSync(path38.dirname(destPath), { recursive: true });
-    fs37.writeFileSync(destPath, Buffer.from(result.body, "binary"));
+    fs38.mkdirSync(path39.dirname(destPath), { recursive: true });
+    fs38.writeFileSync(destPath, Buffer.from(result.body, "binary"));
   }
   /**
    * List backup objects in S3 with the configured prefix.
@@ -9307,10 +10294,10 @@ var BackupService = class {
     if (!entry) {
       throw new Error(`Backup "${backupId}" not found.`);
     }
-    if (!fs37.existsSync(entry.path)) {
+    if (!fs38.existsSync(entry.path)) {
       throw new Error(`Backup file not found at: ${entry.path}`);
     }
-    const encrypted = fs37.readFileSync(entry.path);
+    const encrypted = fs38.readFileSync(entry.path);
     let plaintext;
     try {
       plaintext = decryptBuffer(encrypted, this.key);
@@ -9324,8 +10311,8 @@ var BackupService = class {
     offset += manifestLen;
     const manifest = JSON.parse(manifestStr);
     const restoreBase = targetRepoPath ?? entry.repoPath;
-    const codeIntelDir = path38.join(restoreBase, ".code-intel");
-    fs37.mkdirSync(codeIntelDir, { recursive: true });
+    const codeIntelDir = path39.join(restoreBase, ".code-intel");
+    fs38.mkdirSync(codeIntelDir, { recursive: true });
     for (const fileEntry of manifest.files) {
       const nameLen = plaintext.readUInt16BE(offset);
       offset += 2;
@@ -9342,18 +10329,18 @@ var BackupService = class {
       }
       let destPath;
       if (name === "registry.json" || name === "users.db") {
-        destPath = path38.join(os13.homedir(), ".code-intel", name);
+        destPath = path39.join(os13.homedir(), ".code-intel", name);
       } else {
-        destPath = path38.join(codeIntelDir, name);
+        destPath = path39.join(codeIntelDir, name);
       }
-      fs37.writeFileSync(destPath, data);
+      fs38.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) => fs37.existsSync(e.path)).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    const entries = this._loadIndex().filter((e) => fs38.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);
@@ -9383,7 +10370,7 @@ var BackupService = class {
     for (const e of entries) {
       if (!keep.has(e.id)) {
         try {
-          fs37.unlinkSync(e.path);
+          fs38.unlinkSync(e.path);
           deleted++;
         } catch {
         }
@@ -9395,17 +10382,17 @@ var BackupService = class {
   }
   // ── Index helpers ──────────────────────────────────────────────────────────
   _indexPath() {
-    return path38.join(this.backupDir, "index.json");
+    return path39.join(this.backupDir, "index.json");
   }
   _loadIndex() {
     try {
-      return JSON.parse(fs37.readFileSync(this._indexPath(), "utf-8"));
+      return JSON.parse(fs38.readFileSync(this._indexPath(), "utf-8"));
     } catch {
       return [];
     }
   }
   _saveIndex(entries) {
-    fs37.writeFileSync(this._indexPath(), JSON.stringify(entries, null, 2));
+    fs38.writeFileSync(this._indexPath(), JSON.stringify(entries, null, 2));
   }
   _appendIndex(entry) {
     const entries = this._loadIndex();
@@ -10046,11 +11033,11 @@ var openApiSpec = {
 };
 
 // src/http/app.ts
-var __dirname$1 = path38.dirname(fileURLToPath(import.meta.url));
+var __dirname$1 = path39.dirname(fileURLToPath(import.meta.url));
 var WEB_DIST = (() => {
-  const bundled = path38.resolve(__dirname$1, "..", "web");
-  if (fs37.existsSync(bundled)) return bundled;
-  return path38.resolve(__dirname$1, "..", "..", "..", "web", "dist");
+  const bundled = path39.resolve(__dirname$1, "..", "web");
+  if (fs38.existsSync(bundled)) return bundled;
+  return path39.resolve(__dirname$1, "..", "..", "..", "web", "dist");
 })();
 function getAllowedOrigins() {
   const env = process.env["CODE_INTEL_CORS_ORIGINS"];
@@ -10059,13 +11046,17 @@ function getAllowedOrigins() {
 }
 function createDefaultLimiter() {
   const max = parseInt(process.env["CODE_INTEL_RATE_LIMIT_MAX"] ?? "100", 10);
-  const windowMs = parseInt(process.env["CODE_INTEL_RATE_LIMIT_WINDOW_MS"] ?? `${15 * 60 * 1e3}`, 10);
+  const windowMs = parseInt(process.env["CODE_INTEL_RATE_LIMIT_WINDOW_MS"] ?? `${60 * 1e3}`, 10);
   return rateLimit({
     windowMs,
     max,
     standardHeaders: true,
     legacyHeaders: false,
-    skip: (req) => req.path.startsWith("/health") || req.path === "/metrics",
+    // Skip health checks, metrics, and read-only listing/pagination endpoints.
+    // The node pagination and group/repo listing endpoints are hit many times
+    // when loading a large graph — rate-limiting them only hurts the user's own
+    // session without providing meaningful abuse protection.
+    skip: (req) => req.path.startsWith("/health") || req.path === "/metrics" || req.path === "/api/v1/repos" || req.path === "/api/v1/groups" || req.method === "GET" && req.path.startsWith("/api/v1/groups/") || /^\/api\/v1\/graph\/[^/]+\/nodes$/.test(req.path),
     message: {
       error: {
         code: ErrorCodes.RATE_LIMIT_EXCEEDED,
@@ -10124,12 +11115,31 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
   });
   app.use(requestIdMiddleware);
   app.use(authMiddleware);
+  let dbUnavailableSince = null;
   app.use((_req, res, next) => {
     if (workspaceRoot) {
+      const metaFilePath = path39.join(workspaceRoot, ".code-intel", "meta.json");
+      let metaOk = false;
       try {
-        const meta = loadMetadata(workspaceRoot);
-        if (meta?.indexVersion) res.setHeader("X-Index-Version", meta.indexVersion);
-      } catch {
+        if (fs38.existsSync(metaFilePath)) {
+          const raw = fs38.readFileSync(metaFilePath, "utf-8");
+          const meta = JSON.parse(raw);
+          if (meta?.indexVersion) res.setHeader("X-Index-Version", meta.indexVersion);
+        }
+        metaOk = true;
+        if (dbUnavailableSince !== null) {
+          dbUnavailableSince = null;
+          logger_default.info("[serve] DB back online \u2014 cleared stale flag");
+        }
+      } catch (err) {
+        if (dbUnavailableSince === null) {
+          dbUnavailableSince = (/* @__PURE__ */ new Date()).toISOString();
+          logger_default.warn(`[serve] DB unavailable since ${dbUnavailableSince}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      if (!metaOk) {
+        res.setHeader("X-Stale", "true");
+        res.setHeader("X-Stale-Since", dbUnavailableSince);
       }
     }
     next();
@@ -10185,6 +11195,21 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
   let vectorIndex = null;
   let vectorIndexBuilding = false;
   let vectorIndexReady = false;
+  let bm25Index = null;
+  function ensureBm25Index() {
+    if (bm25Index) return bm25Index;
+    if (!workspaceRoot) return null;
+    const idx = new Bm25Index(getBm25DbPath(workspaceRoot));
+    idx.load();
+    if (idx.isLoaded) {
+      bm25Index = idx;
+      return idx;
+    }
+    return null;
+  }
+  if (workspaceRoot && process.env["NODE_ENV"] !== "test") {
+    setImmediate(() => ensureBm25Index());
+  }
   async function ensureVectorIndex() {
     if (vectorIndexReady && vectorIndex) return vectorIndex;
     if (!workspaceRoot || vectorIndexBuilding) return null;
@@ -10581,10 +11606,10 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     const registry = loadRegistry();
     const entry = registry.find((r) => r.name === requestedRepo || r.path === requestedRepo);
     if (!entry) return null;
-    const dbPath = path38.join(entry.path, ".code-intel", "graph.db");
-    if (!fs37.existsSync(dbPath)) return null;
+    const dbPath = path39.join(entry.path, ".code-intel", "graph.db");
+    if (!fs38.existsSync(dbPath)) return null;
     const repoGraph = createKnowledgeGraph();
-    const db = new DbManager(dbPath);
+    const db = new DbManager(dbPath, true);
     try {
       await db.init();
       await loadGraphFromDB(repoGraph, db);
@@ -10595,10 +11620,33 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       return null;
     }
   }
+  async function loadGroupGraph(groupName) {
+    const group = loadGroup(groupName);
+    if (!group) return null;
+    const registry = loadRegistry();
+    const mergedGraph = createKnowledgeGraph();
+    for (const member of group.members) {
+      const regEntry = registry.find((r) => r.name === member.registryName);
+      if (!regEntry) continue;
+      const dbPath = path39.join(regEntry.path, ".code-intel", "graph.db");
+      if (!fs38.existsSync(dbPath)) continue;
+      const db = new DbManager(dbPath, true);
+      try {
+        await db.init();
+        await loadGraphFromDB(mergedGraph, db);
+        db.close();
+      } catch {
+        db.close();
+      }
+    }
+    return mergedGraph.size.nodes > 0 ? mergedGraph : null;
+  }
   async function getGraphForRepo(requestedRepo) {
     if (!requestedRepo || requestedRepo === repoName) return graph;
     const g = await loadRepoGraph(requestedRepo);
-    return g ?? graph;
+    if (g) return g;
+    const gg = await loadGroupGraph(requestedRepo);
+    return gg ?? graph;
   }
   app.get("/api/v1/graph/:repo", requireRepoAccess((req) => {
     const p = req.params["repo"];
@@ -10622,11 +11670,56 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     }
     res.json({ nodes: [...g.allNodes()], edges: [...g.allEdges()] });
   });
+  app.get("/api/v1/graph/:repo/nodes", requireRepoAccess((req) => {
+    const p = req.params["repo"];
+    const repo = Array.isArray(p) ? p[0] : p;
+    return repo ? decodeURIComponent(repo) : void 0;
+  }), async (req, res) => {
+    const rawRepo = req.params["repo"];
+    const requestedRepo = decodeURIComponent(Array.isArray(rawRepo) ? rawRepo[0] ?? "" : rawRepo ?? "");
+    const limit = Math.min(parseInt(req.query["limit"] ?? "200", 10), 1e3);
+    const offset = Math.max(parseInt(req.query["offset"] ?? "0", 10), 0);
+    const g = requestedRepo === repoName ? graph : await loadRepoGraph(requestedRepo);
+    if (!g) {
+      res.status(404).json({
+        error: {
+          code: ErrorCodes.NOT_FOUND,
+          message: `Repo "${requestedRepo}" not found or not indexed`,
+          hint: `Run: code-intel analyze <path>`,
+          requestId: req.requestId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      return;
+    }
+    let nodes;
+    if (isLazyGraph(g)) {
+      nodes = await g.getNodePage(offset, limit);
+    } else {
+      const eager = g;
+      if (!eager._nodeArray) {
+        eager._nodeArray = [...g.allNodes()];
+      }
+      nodes = eager._nodeArray.slice(offset, offset + limit);
+    }
+    res.json({
+      nodes,
+      offset,
+      limit,
+      total: g.size.nodes,
+      hasMore: offset + nodes.length < g.size.nodes
+    });
+  });
   app.post("/api/v1/search", requireToolScope("search"), async (req, res) => {
     const { query, limit, repo } = req.body;
     const g = await getGraphForRepo(repo);
     const vdbPath = workspaceRoot ? getVectorDbPath(workspaceRoot) : void 0;
-    const { results, searchMode } = await hybridSearch(g, query ?? "", limit ?? 20, { vectorDbPath: vdbPath });
+    const bm25 = !repo || repo === repoName ? ensureBm25Index() : null;
+    const bm25Results = bm25 ? bm25.search(query ?? "", (limit ?? 20) * 3) : null;
+    const { results, searchMode } = await hybridSearch(g, query ?? "", limit ?? 20, {
+      vectorDbPath: vdbPath,
+      bm25Results: bm25Results ?? void 0
+    });
     res.json({ results, searchMode });
   });
   app.post("/api/v1/vector-search", async (req, res) => {
@@ -10669,7 +11762,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       return;
     }
     try {
-      const content = fs37.readFileSync(file_path, "utf-8");
+      const content = fs38.readFileSync(file_path, "utf-8");
       res.json({ content });
     } catch {
       res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "File not found" } });
@@ -10706,7 +11799,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     if (workspaceRoot) {
       try {
         const dbPath = getDbPath(workspaceRoot);
-        const dbm = new DbManager(dbPath);
+        const dbm = new DbManager(dbPath, true);
         await dbm.init();
         const rows = await dbm.query(q);
         dbm.close();
@@ -10747,33 +11840,53 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
   app.get("/api/v1/nodes/:id", async (req, res) => {
     const nodeId = decodeURIComponent(req.params.id);
     const g = await getGraphForRepo(req.query["repo"]);
-    const node = g.getNode(nodeId);
+    const node = isLazyGraph(g) ? await g.getNodeAsync(nodeId) : g.getNode(nodeId);
     if (!node) {
       res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Node not found", requestId: req.requestId } });
       return;
     }
     const incoming = [...g.findEdgesTo(nodeId)];
     const outgoing = [...g.findEdgesFrom(nodeId)];
+    const resolveName = isLazyGraph(g) ? async (id) => {
+      const n = g.getNode(id) ?? await g.getNodeAsync(id);
+      return n?.name;
+    } : (id) => Promise.resolve(g.getNode(id)?.name);
+    const resolveKind = isLazyGraph(g) ? async (id) => {
+      const n = g.getNode(id) ?? await g.getNodeAsync(id);
+      return n?.kind;
+    } : (id) => Promise.resolve(g.getNode(id)?.kind);
     res.json({
       node,
-      callers: incoming.filter((e) => e.kind === "calls").map((e) => ({ id: e.source, name: g.getNode(e.source)?.name, weight: e.weight })),
-      callees: outgoing.filter((e) => e.kind === "calls").map((e) => ({ id: e.target, name: g.getNode(e.target)?.name, weight: e.weight })),
-      imports: outgoing.filter((e) => e.kind === "imports").map((e) => ({ id: e.target, name: g.getNode(e.target)?.name })),
-      importedBy: incoming.filter((e) => e.kind === "imports").map((e) => ({ id: e.source, name: g.getNode(e.source)?.name })),
-      extends: outgoing.filter((e) => e.kind === "extends").map((e) => ({ id: e.target, name: g.getNode(e.target)?.name })),
-      implementsEdges: outgoing.filter((e) => e.kind === "implements").map((e) => ({ id: e.target, name: g.getNode(e.target)?.name })),
-      members: outgoing.filter((e) => e.kind === "has_member").map((e) => ({ id: e.target, name: g.getNode(e.target)?.name, kind: g.getNode(e.target)?.kind })),
-      cluster: incoming.filter((e) => e.kind === "belongs_to").map((e) => g.getNode(e.target)?.name)[0]
+      callers: await Promise.all(incoming.filter((e) => e.kind === "calls").map(async (e) => ({ id: e.source, name: await resolveName(e.source), weight: e.weight }))),
+      callees: await Promise.all(outgoing.filter((e) => e.kind === "calls").map(async (e) => ({ id: e.target, name: await resolveName(e.target), weight: e.weight }))),
+      imports: await Promise.all(outgoing.filter((e) => e.kind === "imports").map(async (e) => ({ id: e.target, name: await resolveName(e.target) }))),
+      importedBy: await Promise.all(incoming.filter((e) => e.kind === "imports").map(async (e) => ({ id: e.source, name: await resolveName(e.source) }))),
+      extends: await Promise.all(outgoing.filter((e) => e.kind === "extends").map(async (e) => ({ id: e.target, name: await resolveName(e.target) }))),
+      implementsEdges: await Promise.all(outgoing.filter((e) => e.kind === "implements").map(async (e) => ({ id: e.target, name: await resolveName(e.target) }))),
+      members: await Promise.all(outgoing.filter((e) => e.kind === "has_member").map(async (e) => ({ id: e.target, name: await resolveName(e.target), kind: await resolveKind(e.target) }))),
+      cluster: (await Promise.all(incoming.filter((e) => e.kind === "belongs_to").map(async (e) => resolveName(e.target))))[0]
     });
   });
   app.post("/api/v1/blast-radius", async (req, res) => {
     const { target, direction = "both", max_hops = 5, repo } = req.body;
     const g = await getGraphForRepo(repo);
     let targetNode = null;
-    for (const node of g.allNodes()) {
-      if (node.name === target || node.id === target) {
-        targetNode = node;
-        break;
+    if (isLazyGraph(g) && target) {
+      targetNode = g.getNode(target) ?? await g.getNodeAsync(target) ?? null;
+      if (!targetNode) {
+        for await (const node of g.allNodesAsync()) {
+          if (node.name === target || node.id === target) {
+            targetNode = node;
+            break;
+          }
+        }
+      }
+    } else {
+      for (const node of g.allNodes()) {
+        if (node.name === target || node.id === target) {
+          targetNode = node;
+          break;
+        }
       }
     }
     if (!targetNode) {
@@ -10927,9 +12040,9 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     for (const member of group.members) {
       const regEntry = registry.find((r) => r.name === member.registryName);
       if (!regEntry) continue;
-      const dbPath = path38.join(regEntry.path, ".code-intel", "graph.db");
-      if (!fs37.existsSync(dbPath)) continue;
-      const db = new DbManager(dbPath);
+      const dbPath = path39.join(regEntry.path, ".code-intel", "graph.db");
+      if (!fs38.existsSync(dbPath)) continue;
+      const db = new DbManager(dbPath, true);
       try {
         await db.init();
         await loadGraphFromDB(mergedGraph, db);
@@ -10954,10 +12067,10 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       let nodeCount = 0;
       let edgeCount = 0;
       if (regEntry) {
-        const dbPath = path38.join(regEntry.path, ".code-intel", "graph.db");
-        if (fs37.existsSync(dbPath)) {
+        const dbPath = path39.join(regEntry.path, ".code-intel", "graph.db");
+        if (fs38.existsSync(dbPath)) {
           try {
-            const db = new DbManager(dbPath);
+            const db = new DbManager(dbPath, true);
             await db.init();
             const g = createKnowledgeGraph();
             await loadGraphFromDB(g, db);
@@ -10980,7 +12093,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     res.json({ repos, edges });
   });
   app.get("/api/v1/source", requireAuth, requireRole("viewer"), (req, res) => {
-    const { file, startLine: startLineStr, endLine: endLineStr } = req.query;
+    const { file, startLine: startLineStr, endLine: endLineStr, repo } = req.query;
     if (!file) {
       res.status(400).json({
         error: {
@@ -11004,14 +12117,36 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       });
       return;
     }
-    let rawResolved = path38.normalize(file);
-    if (!path38.isAbsolute(rawResolved) && workspaceRoot) {
-      rawResolved = path38.join(workspaceRoot, rawResolved);
+    let baseDir = workspaceRoot;
+    if (repo && repo !== repoName) {
+      const registry = loadRegistry();
+      const entry = registry.find((r) => r.name === repo || r.path === repo);
+      if (entry) {
+        baseDir = entry.path;
+      } else {
+        const group = loadGroup(repo);
+        if (group) {
+          const normalizedFile = path39.normalize(file);
+          for (const member of group.members) {
+            const regEntry = registry.find((r) => r.name === member.registryName);
+            if (!regEntry) continue;
+            const candidate = path39.resolve(path39.join(regEntry.path, normalizedFile));
+            if (fs38.existsSync(candidate)) {
+              baseDir = regEntry.path;
+              break;
+            }
+          }
+        }
+      }
+    }
+    let rawResolved = path39.normalize(file);
+    if (!path39.isAbsolute(rawResolved) && baseDir) {
+      rawResolved = path39.join(baseDir, rawResolved);
     }
-    const resolvedFile = path38.resolve(rawResolved);
+    const resolvedFile = path39.resolve(rawResolved);
     function isInsideDir(fileAbs, dir) {
-      const rel = path38.relative(path38.resolve(dir), fileAbs);
-      return !rel.startsWith("..") && !path38.isAbsolute(rel);
+      const rel = path39.relative(path39.resolve(dir), fileAbs);
+      return !rel.startsWith("..") && !path39.isAbsolute(rel);
     }
     if (workspaceRoot) {
       if (!isInsideDir(resolvedFile, workspaceRoot)) {
@@ -11048,7 +12183,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     }
     let fileContent;
     try {
-      fileContent = fs37.readFileSync(resolvedFile, "utf-8");
+      fileContent = fs38.readFileSync(resolvedFile, "utf-8");
     } catch {
       res.status(404).json({
         error: {
@@ -11079,7 +12214,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     const contextStart = Math.max(1, startLine - 20);
     const contextEnd = Math.min(lines.length, endLine + 20);
     const content = lines.slice(contextStart - 1, contextEnd).join("\n");
-    const ext = path38.extname(resolvedFile).toLowerCase();
+    const ext = path39.extname(resolvedFile).toLowerCase();
     const languageMap = {
       ".ts": "typescript",
       ".tsx": "typescript",
@@ -11214,10 +12349,10 @@ 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 (fs37.existsSync(WEB_DIST)) {
+  if (fs38.existsSync(WEB_DIST)) {
     app.use(express.static(WEB_DIST));
     app.get("/{*path}", (_req, res) => {
-      res.sendFile(path38.join(WEB_DIST, "index.html"));
+      res.sendFile(path39.join(WEB_DIST, "index.html"));
     });
   }
   app.use("/admin", requireRole("admin"));
@@ -11746,22 +12881,22 @@ function suggestTests(graph, symbolName) {
   const callPaths = [];
   const pathQueue = [{ id: targetId, path: [symbolName], depth: 0 }];
   while (pathQueue.length > 0 && callPaths.length < 5) {
-    const { id, path: path39, depth } = pathQueue.shift();
+    const { id, path: path40, depth } = pathQueue.shift();
     let hasCallers2 = false;
     for (const edge of graph.findEdgesTo(id)) {
       if (edge.kind !== "calls") continue;
       const callerNode = graph.getNode(edge.source);
       if (!callerNode) continue;
       hasCallers2 = true;
-      const newPath = [callerNode.name, ...path39];
+      const newPath = [callerNode.name, ...path40];
       if (depth + 1 >= 3 || callPaths.length >= 5) {
         if (callPaths.length < 5) callPaths.push(newPath);
         continue;
       }
       pathQueue.push({ id: edge.source, path: newPath, depth: depth + 1 });
     }
-    if (!hasCallers2 && path39.length > 1) {
-      callPaths.push(path39);
+    if (!hasCallers2 && path40.length > 1) {
+      callPaths.push(path40);
     }
   }
   if (callPaths.length === 0) {
@@ -12318,24 +13453,44 @@ function createMcpServer(graph, repoName, workspaceRoot) {
     }
     const startMs = Date.now();
     const dispatch = () => dispatchTool(name, a, graph, repoName, workspaceRoot);
+    const MCP_TIMEOUT_MS = parseInt(process.env["CODE_INTEL_MCP_TIMEOUT_MS"] ?? "30000", 10);
+    let timeoutHandle = null;
+    let timedOut = false;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        reject(new Error(`MCP tool '${name}' timed out after ${MCP_TIMEOUT_MS}ms`));
+      }, MCP_TIMEOUT_MS);
+    });
     let result;
     let status = "success";
     try {
       if (isTracingEnabled()) {
-        result = await withSpan(
-          `mcp.tool.${name}`,
-          sanitizeAttrs({ "mcp.tool": name, "mcp.repo": repoName }),
-          dispatch
-        );
+        result = await Promise.race([
+          withSpan(
+            `mcp.tool.${name}`,
+            sanitizeAttrs({ "mcp.tool": name, "mcp.repo": repoName }),
+            dispatch
+          ),
+          timeoutPromise
+        ]);
       } else {
-        result = await dispatch();
+        result = await Promise.race([dispatch(), timeoutPromise]);
       }
       if (result.isError) status = "error";
     } catch (err) {
       status = "error";
       mcpToolCallsTotal.inc({ tool: name, status });
       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: [] }) }],
+          isError: false
+        };
+      }
       throw err;
+    } finally {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
     }
     mcpToolCallsTotal.inc({ tool: name, status });
     mcpToolDurationSeconds.observe({ tool: name }, (Date.now() - startMs) / 1e3);
@@ -12723,7 +13878,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       for (const { filePath: changedFile, changedLines } of changedFiles) {
         for (const node of graph.allNodes()) {
           if (!node.filePath) continue;
-          const normNode = node.filePath.replace(repoRoot + "/", "").replace(repoRoot + path38.sep, "");
+          const normNode = node.filePath.replace(repoRoot + "/", "").replace(repoRoot + path39.sep, "");
           const normChanged = changedFile.replace(/^a\/|^b\//, "");
           if (!normNode.endsWith(normChanged) && !normChanged.endsWith(normNode)) continue;
           if (node.startLine !== void 0 && node.endLine !== void 0) {
@@ -13139,20 +14294,20 @@ function parseDiff(diffText) {
 // src/cli/main.ts
 init_metadata();
 async function writeSkillFiles(graph, workspaceRoot, projectName) {
-  const outputDir = path38.join(workspaceRoot, ".claude", "skills", "code-intel");
+  const outputDir = path39.join(workspaceRoot, ".claude", "skills", "code-intel");
   const areas = buildAreaMap(graph, workspaceRoot);
   if (areas.length === 0) return { skills: [], outputDir };
-  fs37.rmSync(outputDir, { recursive: true, force: true });
-  fs37.mkdirSync(outputDir, { recursive: true });
+  fs38.rmSync(outputDir, { recursive: true, force: true });
+  fs38.mkdirSync(outputDir, { recursive: true });
   const skills = [];
   const usedNames = /* @__PURE__ */ new Set();
   for (const area of areas) {
     const kebab = uniqueKebab(area.label, usedNames);
     usedNames.add(kebab);
     const content = renderSkill(area, projectName, kebab);
-    const dir = path38.join(outputDir, kebab);
-    fs37.mkdirSync(dir, { recursive: true });
-    fs37.writeFileSync(path38.join(dir, "SKILL.md"), content, "utf-8");
+    const dir = path39.join(outputDir, kebab);
+    fs38.mkdirSync(dir, { recursive: true });
+    fs38.writeFileSync(path39.join(dir, "SKILL.md"), content, "utf-8");
     skills.push({ name: kebab, label: area.label, symbolCount: area.nodes.length, fileCount: area.files.size });
   }
   return { skills, outputDir };
@@ -13332,17 +14487,17 @@ var BLOCK_START = "<!-- code-intel:start -->";
 var BLOCK_END = "<!-- code-intel:end -->";
 function writeContextFiles(workspaceRoot, projectName, stats, skills) {
   const block = buildBlock(projectName, stats, skills);
-  upsertFile(path38.join(workspaceRoot, "AGENTS.md"), block, "AGENTS.md");
-  upsertFile(path38.join(workspaceRoot, "CLAUDE.md"), block, "CLAUDE.md");
-  const githubDir = path38.join(workspaceRoot, ".github");
-  if (!fs37.existsSync(githubDir)) fs37.mkdirSync(githubDir, { recursive: true });
-  upsertFile(path38.join(githubDir, "copilot-instructions.md"), block, "copilot-instructions.md");
-  const cursorDir = path38.join(workspaceRoot, ".cursor", "rules");
-  if (!fs37.existsSync(cursorDir)) fs37.mkdirSync(cursorDir, { recursive: true });
-  upsertFile(path38.join(cursorDir, "code-intel.mdc"), block, "code-intel.mdc");
-  const kiroDir = path38.join(workspaceRoot, ".kiro", "steering");
-  if (!fs37.existsSync(kiroDir)) fs37.mkdirSync(kiroDir, { recursive: true });
-  upsertFile(path38.join(kiroDir, "code-intel.md"), block, "code-intel.md");
+  upsertFile(path39.join(workspaceRoot, "AGENTS.md"), block, "AGENTS.md");
+  upsertFile(path39.join(workspaceRoot, "CLAUDE.md"), block, "CLAUDE.md");
+  const githubDir = path39.join(workspaceRoot, ".github");
+  if (!fs38.existsSync(githubDir)) fs38.mkdirSync(githubDir, { recursive: true });
+  upsertFile(path39.join(githubDir, "copilot-instructions.md"), block, "copilot-instructions.md");
+  const cursorDir = path39.join(workspaceRoot, ".cursor", "rules");
+  if (!fs38.existsSync(cursorDir)) fs38.mkdirSync(cursorDir, { recursive: true });
+  upsertFile(path39.join(cursorDir, "code-intel.mdc"), block, "code-intel.mdc");
+  const kiroDir = path39.join(workspaceRoot, ".kiro", "steering");
+  if (!fs38.existsSync(kiroDir)) fs38.mkdirSync(kiroDir, { recursive: true });
+  upsertFile(path39.join(kiroDir, "code-intel.md"), block, "code-intel.md");
 }
 function buildBlock(projectName, stats, skills) {
   const skillTableRows = skills.map(
@@ -13479,7 +14634,7 @@ ${skillTable}
 ${BLOCK_END}`;
 }
 function upsertFile(filePath, block, fileName) {
-  if (!fs37.existsSync(filePath)) {
+  if (!fs38.existsSync(filePath)) {
     const newContent = [
       `# ${fileName}`,
       "",
@@ -13490,17 +14645,17 @@ function upsertFile(filePath, block, fileName) {
       "<!-- Add your own custom notes below this line. They will never be overwritten by code-intel. -->",
       ""
     ].join("\n");
-    fs37.writeFileSync(filePath, newContent, "utf-8");
+    fs38.writeFileSync(filePath, newContent, "utf-8");
     return;
   }
-  const existing = fs37.readFileSync(filePath, "utf-8");
+  const existing = fs38.readFileSync(filePath, "utf-8");
   const startIdx = findLineMarker(existing, BLOCK_START);
   const endIdx = findLineMarker(existing, BLOCK_END, startIdx === -1 ? 0 : startIdx);
   if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
     const before = existing.slice(0, startIdx);
     const after = existing.slice(endIdx + BLOCK_END.length);
     const updated = (before + block + after).trimEnd() + "\n";
-    fs37.writeFileSync(filePath, updated, "utf-8");
+    fs38.writeFileSync(filePath, updated, "utf-8");
     return;
   }
   const appended = [
@@ -13513,7 +14668,7 @@ function upsertFile(filePath, block, fileName) {
     block,
     ""
   ].join("\n");
-  fs37.writeFileSync(filePath, appended, "utf-8");
+  fs38.writeFileSync(filePath, appended, "utf-8");
 }
 function findLineMarker(content, marker, startFrom = 0) {
   let idx = content.indexOf(marker, startFrom);
@@ -13555,14 +14710,14 @@ function getChangedFilesSince(workspaceRoot, baseHash) {
 function filterChangedByMtime(allFilePaths, workspaceRoot, storedMtimes) {
   const changed = [];
   for (const absPath of allFilePaths) {
-    const rel = path38.relative(workspaceRoot, absPath);
+    const rel = path39.relative(workspaceRoot, absPath);
     const stored = storedMtimes[rel];
     if (stored === void 0) {
       changed.push(absPath);
       continue;
     }
     try {
-      const { mtimeMs } = fs37.statSync(absPath);
+      const { mtimeMs } = fs38.statSync(absPath);
       if (mtimeMs > stored) changed.push(absPath);
     } catch {
       changed.push(absPath);
@@ -13574,8 +14729,8 @@ function buildMtimeSnapshot(filePaths, workspaceRoot) {
   const snap = {};
   for (const absPath of filePaths) {
     try {
-      const { mtimeMs } = fs37.statSync(absPath);
-      snap[path38.relative(workspaceRoot, absPath)] = mtimeMs;
+      const { mtimeMs } = fs38.statSync(absPath);
+      snap[path39.relative(workspaceRoot, absPath)] = mtimeMs;
     } catch {
     }
   }
@@ -13586,8 +14741,8 @@ function decideIncremental(workspaceRoot, allFilePaths, prevCommitHash, storedMt
   if (prevCommitHash) {
     const changed = getChangedFilesSince(workspaceRoot, prevCommitHash);
     if (changed !== null) {
-      const scanSet = new Set(allFilePaths.map((p) => path38.relative(workspaceRoot, p)));
-      const changedInScan = changed.filter((rel) => scanSet.has(rel)).map((rel) => path38.join(workspaceRoot, rel));
+      const scanSet = new Set(allFilePaths.map((p) => path39.relative(workspaceRoot, p)));
+      const changedInScan = changed.filter((rel) => scanSet.has(rel)).map((rel) => path39.join(workspaceRoot, rel));
       if (total > 0 && changedInScan.length / total > 0.2) {
         return { incremental: false, fallbackReason: `changed files (${changedInScan.length}) > 20% of total (${total})` };
       }
@@ -13614,11 +14769,11 @@ init_group_sync();
 function expandGlob(root, pattern) {
   const parts = pattern.replace(/\/\*\*?$/, "").split("/").filter(Boolean);
   if (parts.length === 0) return [];
-  const dir = path38.join(root, ...parts);
-  if (!fs37.existsSync(dir)) return [];
-  return fs37.readdirSync(dir).map((entry) => path38.join(dir, entry)).filter((p) => {
+  const dir = path39.join(root, ...parts);
+  if (!fs38.existsSync(dir)) return [];
+  return fs38.readdirSync(dir).map((entry) => path39.join(dir, entry)).filter((p) => {
     try {
-      return fs37.statSync(p).isDirectory();
+      return fs38.statSync(p).isDirectory();
     } catch {
       return false;
     }
@@ -13629,11 +14784,11 @@ function resolvePackages(root, patterns) {
   for (const pattern of patterns) {
     const dirs = expandGlob(root, pattern);
     for (const dir of dirs) {
-      const pkgJsonPath = path38.join(dir, "package.json");
-      if (!fs37.existsSync(pkgJsonPath)) continue;
+      const pkgJsonPath = path39.join(dir, "package.json");
+      if (!fs38.existsSync(pkgJsonPath)) continue;
       try {
-        const pkgJson = JSON.parse(fs37.readFileSync(pkgJsonPath, "utf-8"));
-        const name = pkgJson.name ?? path38.basename(dir);
+        const pkgJson = JSON.parse(fs38.readFileSync(pkgJsonPath, "utf-8"));
+        const name = pkgJson.name ?? path39.basename(dir);
         packages.push({ name, path: dir });
       } catch {
       }
@@ -13642,13 +14797,13 @@ function resolvePackages(root, patterns) {
   return packages;
 }
 async function detectWorkspace(root) {
-  const turboJsonPath = path38.join(root, "turbo.json");
-  if (fs37.existsSync(turboJsonPath)) {
+  const turboJsonPath = path39.join(root, "turbo.json");
+  if (fs38.existsSync(turboJsonPath)) {
     let patterns = [];
-    const pkgJsonPath = path38.join(root, "package.json");
-    if (fs37.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path39.join(root, "package.json");
+    if (fs38.existsSync(pkgJsonPath)) {
       try {
-        const pkgJson = JSON.parse(fs37.readFileSync(pkgJsonPath, "utf-8"));
+        const pkgJson = JSON.parse(fs38.readFileSync(pkgJsonPath, "utf-8"));
         if (pkgJson.workspaces) {
           patterns = Array.isArray(pkgJson.workspaces) ? pkgJson.workspaces : pkgJson.workspaces.packages;
         }
@@ -13656,16 +14811,16 @@ async function detectWorkspace(root) {
       }
     }
     if (patterns.length === 0) {
-      const fallbackDir = path38.join(root, "packages");
-      if (fs37.existsSync(fallbackDir)) patterns = ["packages/*"];
+      const fallbackDir = path39.join(root, "packages");
+      if (fs38.existsSync(fallbackDir)) patterns = ["packages/*"];
     }
     const packages = resolvePackages(root, patterns);
     return { type: "turborepo", root, packages };
   }
-  const npmPkgJsonPath = path38.join(root, "package.json");
-  if (fs37.existsSync(npmPkgJsonPath)) {
+  const npmPkgJsonPath = path39.join(root, "package.json");
+  if (fs38.existsSync(npmPkgJsonPath)) {
     try {
-      const pkgJson = JSON.parse(fs37.readFileSync(npmPkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs38.readFileSync(npmPkgJsonPath, "utf-8"));
       if (pkgJson.workspaces) {
         const patterns = Array.isArray(pkgJson.workspaces) ? pkgJson.workspaces : pkgJson.workspaces.packages;
         const packages = resolvePackages(root, patterns);
@@ -13674,11 +14829,11 @@ async function detectWorkspace(root) {
     } catch {
     }
   }
-  const pnpmYamlPath = path38.join(root, "pnpm-workspace.yaml");
-  if (fs37.existsSync(pnpmYamlPath)) {
+  const pnpmYamlPath = path39.join(root, "pnpm-workspace.yaml");
+  if (fs38.existsSync(pnpmYamlPath)) {
     const patterns = [];
     try {
-      const content = fs37.readFileSync(pnpmYamlPath, "utf-8");
+      const content = fs38.readFileSync(pnpmYamlPath, "utf-8");
       let inPackages = false;
       for (const line of content.split("\n")) {
         if (/^packages\s*:/.test(line)) {
@@ -13698,30 +14853,30 @@ async function detectWorkspace(root) {
     const packages = resolvePackages(root, patterns);
     return { type: "pnpm", root, packages };
   }
-  const nxJsonPath = path38.join(root, "nx.json");
-  if (fs37.existsSync(nxJsonPath)) {
+  const nxJsonPath = path39.join(root, "nx.json");
+  if (fs38.existsSync(nxJsonPath)) {
     const packages = [];
     const scanForProjects = (dir, depth) => {
       if (depth > 2) return;
       let entries;
       try {
-        entries = fs37.readdirSync(dir);
+        entries = fs38.readdirSync(dir);
       } catch {
         return;
       }
       for (const entry of entries) {
         if (entry === "node_modules" || entry.startsWith(".")) continue;
-        const fullPath = path38.join(dir, entry);
+        const fullPath = path39.join(dir, entry);
         try {
-          if (!fs37.statSync(fullPath).isDirectory()) continue;
+          if (!fs38.statSync(fullPath).isDirectory()) continue;
         } catch {
           continue;
         }
-        const projectJsonPath = path38.join(fullPath, "project.json");
-        if (fs37.existsSync(projectJsonPath)) {
+        const projectJsonPath = path39.join(fullPath, "project.json");
+        if (fs38.existsSync(projectJsonPath)) {
           try {
-            const proj = JSON.parse(fs37.readFileSync(projectJsonPath, "utf-8"));
-            const name = proj.name ?? path38.basename(fullPath);
+            const proj = JSON.parse(fs38.readFileSync(projectJsonPath, "utf-8"));
+            const name = proj.name ?? path39.basename(fullPath);
             packages.push({ name, path: fullPath });
           } catch {
           }
@@ -13829,17 +14984,17 @@ var MigrationRunner = class {
   autoBackupBeforeMigration() {
     try {
       const dbFile = this.db.name;
-      if (!dbFile || !fs37.existsSync(dbFile)) return;
-      const backupDir = path38.join(os13.homedir(), ".code-intel", "backups", "pre-migration");
-      fs37.mkdirSync(backupDir, { recursive: true });
+      if (!dbFile || !fs38.existsSync(dbFile)) return;
+      const backupDir = path39.join(os13.homedir(), ".code-intel", "backups", "pre-migration");
+      fs38.mkdirSync(backupDir, { recursive: true });
       const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const baseName = path38.basename(dbFile, ".db");
-      const backupPath = path38.join(backupDir, `${baseName}-pre-migration-${ts}.db`);
+      const baseName = path39.basename(dbFile, ".db");
+      const backupPath = path39.join(backupDir, `${baseName}-pre-migration-${ts}.db`);
       try {
         this.db.pragma("wal_checkpoint(TRUNCATE)");
       } catch {
       }
-      fs37.copyFileSync(dbFile, backupPath);
+      fs38.copyFileSync(dbFile, backupPath);
     } catch {
     }
   }
@@ -13986,10 +15141,10 @@ init_tracing();
 init_init_wizard();
 init_config_manager();
 init_codes();
-var GLOBAL_DIR3 = path38.join(os13.homedir(), ".code-intel");
+var GLOBAL_DIR3 = path39.join(os13.homedir(), ".code-intel");
 function loadRepoPaths() {
   try {
-    const data = fs37.readFileSync(path38.join(GLOBAL_DIR3, "repos.json"), "utf-8");
+    const data = fs38.readFileSync(path39.join(GLOBAL_DIR3, "repos.json"), "utf-8");
     const repos = JSON.parse(data);
     return repos.map((r) => r.path);
   } catch {
@@ -13997,9 +15152,9 @@ function loadRepoPaths() {
   }
 }
 function loadGroupNames() {
-  const groupsDir = path38.join(GLOBAL_DIR3, "groups");
+  const groupsDir = path39.join(GLOBAL_DIR3, "groups");
   try {
-    return fs37.readdirSync(groupsDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
+    return fs38.readdirSync(groupsDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
   } catch {
     return [];
   }
@@ -14260,10 +15415,10 @@ function autoInstallCompletion() {
   }
   console.log(`  Detected shell: ${shell}`);
   if (shell === "fish") {
-    const dir = path38.join(os13.homedir(), ".config", "fish", "completions");
-    const dest = path38.join(dir, "code-intel.fish");
-    fs37.mkdirSync(dir, { recursive: true });
-    fs37.writeFileSync(dest, fishCompletion(), "utf-8");
+    const dir = path39.join(os13.homedir(), ".config", "fish", "completions");
+    const dest = path39.join(dir, "code-intel.fish");
+    fs38.mkdirSync(dir, { recursive: true });
+    fs38.writeFileSync(dest, fishCompletion(), "utf-8");
     console.log(`  \u2705  Fish completion installed \u2192 ${dest}
 `);
     return;
@@ -14273,15 +15428,15 @@ source <(code-intel completion zsh)
 ` : `
 source <(code-intel completion bash)
 `;
-  const rcFile = shell === "zsh" ? path38.join(os13.homedir(), ".zshrc") : path38.join(os13.homedir(), ".bashrc");
+  const rcFile = shell === "zsh" ? path39.join(os13.homedir(), ".zshrc") : path39.join(os13.homedir(), ".bashrc");
   try {
-    const existing = fs37.existsSync(rcFile) ? fs37.readFileSync(rcFile, "utf-8") : "";
+    const existing = fs38.existsSync(rcFile) ? fs38.readFileSync(rcFile, "utf-8") : "";
     if (existing.includes("code-intel completion")) {
       console.log(`  \u2139  Completion already configured in ${rcFile}
 `);
       return;
     }
-    fs37.appendFileSync(rcFile, script, "utf-8");
+    fs38.appendFileSync(rcFile, script, "utf-8");
     console.log(`  \u2705  ${shell} completion added to ${rcFile}`);
     console.log(`     Restart your shell or run: source ${rcFile}
 `);
@@ -14300,20 +15455,20 @@ function generateCompletion(shell) {
       return fishCompletion();
   }
 }
-var GLOBAL_DIR4 = path38.join(os13.homedir(), ".code-intel");
-var META_PATH = path38.join(GLOBAL_DIR4, "update-meta.json");
+var GLOBAL_DIR4 = path39.join(os13.homedir(), ".code-intel");
+var META_PATH = path39.join(GLOBAL_DIR4, "update-meta.json");
 var PACKAGE_NAME = "code-intel";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 function loadMeta() {
   try {
-    return JSON.parse(fs37.readFileSync(META_PATH, "utf-8"));
+    return JSON.parse(fs38.readFileSync(META_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveMeta(meta) {
-  fs37.mkdirSync(GLOBAL_DIR4, { recursive: true });
-  fs37.writeFileSync(META_PATH, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+  fs38.mkdirSync(GLOBAL_DIR4, { recursive: true });
+  fs38.writeFileSync(META_PATH, JSON.stringify(meta, null, 2) + "\n", "utf-8");
 }
 function isNewer(current, candidate) {
   const parse = (v) => v.replace(/^v/, "").split(".").map(Number);
@@ -14534,7 +15689,17 @@ program.name("code-intel").description("Code Intelligence Platform \u2014 Static
   Docs: https://github.com/vohongtho/code-intel-platform
 `);
 async function analyzeWorkspace(targetPath, options) {
-  const workspaceRoot = path38.resolve(targetPath);
+  const workspaceRoot = path39.resolve(targetPath);
+  if (!fs38.existsSync(workspaceRoot)) {
+    logger_default.error(`Path does not exist: ${workspaceRoot}`);
+    console.error(`  \u2717  Path does not exist: ${workspaceRoot}`);
+    process.exit(1);
+  }
+  if (!fs38.statSync(workspaceRoot).isDirectory()) {
+    logger_default.error(`Path is not a directory: ${workspaceRoot}`);
+    console.error(`  \u2717  Path is not a directory: ${workspaceRoot}`);
+    process.exit(1);
+  }
   if (!options?.silent) console.log(`Analyzing: ${workspaceRoot}`);
   logger_default.info(`analyze started: ${workspaceRoot}`);
   if (options?.force) {
@@ -14555,18 +15720,19 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of wipeFiles) {
       try {
-        if (fs37.existsSync(f)) fs37.unlinkSync(f);
+        if (fs38.existsSync(f)) fs38.unlinkSync(f);
       } catch {
       }
     }
   }
   if (!options?.skipGit) {
-    const gitDir = path38.join(workspaceRoot, ".git");
-    if (!fs37.existsSync(gitDir)) {
+    const gitDir = path39.join(workspaceRoot, ".git");
+    if (!fs38.existsSync(gitDir)) {
       logger_default.warn(`${workspaceRoot} is not a Git repository`);
     }
   }
   const graph = createKnowledgeGraph();
+  let activeGraph = graph;
   const BAR_WIDTH = 30;
   let currentPhase = "";
   function renderBar(phase, done, total) {
@@ -14597,12 +15763,22 @@ async function analyzeWorkspace(targetPath, options) {
     }
     process.stdout.write("\r" + " ".repeat(60) + "\r");
   }
+  const maxMemoryMB = options?.maxMemoryMB ?? (() => {
+    const v = parseInt(process.env["GRAPH_MAX_MEMORY_MB"] ?? "", 10);
+    return Number.isFinite(v) && v >= 1 ? v : 0;
+  })();
+  if (maxMemoryMB > 0) {
+    const { createCompactKnowledgeGraph: createCompactKnowledgeGraph2 } = await Promise.resolve().then(() => (init_compact_knowledge_graph(), compact_knowledge_graph_exports));
+    activeGraph = createCompactKnowledgeGraph2(maxMemoryMB);
+    logger_default.info(`  [analyze] Using CompactKnowledgeGraph with ${maxMemoryMB} MB memory limit`);
+  }
   const context2 = {
     workspaceRoot,
-    graph,
+    graph: activeGraph,
     filePaths: [],
     verbose: options?.verbose,
     summarize: options?.summarize,
+    profile: options?.profile,
     llmConfig: options?.summarize ? {
       provider: options.llmProvider ?? "ollama",
       model: options.llmModel,
@@ -14671,19 +15847,64 @@ async function analyzeWorkspace(targetPath, options) {
   };
   const phases = isIncremental ? [noopScanPhase, structurePhase, chosenParsePhase, chosenResolvePhase, clusterPhase, flowPhase, summarizePhase] : [scanPhase, structurePhase, chosenParsePhase, chosenResolvePhase, clusterPhase, flowPhase, summarizePhase];
   const result = await runPipeline(phases, context2);
+  if (options?.profile) {
+    const profileEntries = [];
+    for (const [phaseName, pr] of result.results) {
+      const entry = {
+        phase: phaseName,
+        duration: pr.duration,
+        memoryBeforeMB: pr.memoryBeforeMB,
+        memoryAfterMB: pr.memoryAfterMB,
+        memoryDeltaMB: pr.memoryBeforeMB !== void 0 && pr.memoryAfterMB !== void 0 ? pr.memoryAfterMB - pr.memoryBeforeMB : void 0
+      };
+      profileEntries.push(entry);
+    }
+    const profileJson = {
+      profiledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      totalDuration: result.totalDuration,
+      phases: profileEntries
+    };
+    const profilePath = path39.join(workspaceRoot, ".code-intel", "profile.json");
+    try {
+      fs38.mkdirSync(path39.join(workspaceRoot, ".code-intel"), { recursive: true });
+      fs38.writeFileSync(profilePath, JSON.stringify(profileJson, null, 2));
+      if (!options?.silent) console.log(`  \u2713 Profile written: ${profilePath}`);
+    } catch (err) {
+      logger_default.warn(`Failed to write profile.json: ${err instanceof Error ? err.message : err}`);
+    }
+    for (const entry of profileEntries) {
+      if (result.totalDuration > 0 && entry.duration / result.totalDuration > 0.5) {
+        logger_default.warn(`[profile] Bottleneck detected: phase '${entry.phase}' took ${entry.duration}ms (${(entry.duration / result.totalDuration * 100).toFixed(0)}% of total ${result.totalDuration}ms)`);
+        if (!options?.silent) {
+          console.warn(`  \u26A0  Bottleneck: '${entry.phase}' took ${(entry.duration / result.totalDuration * 100).toFixed(0)}% of total time (${entry.duration}ms)`);
+        }
+      }
+    }
+  }
+  if (options?.verbose && !options?.silent) {
+    console.log("\n  Phase timing:");
+    const nameW = 12;
+    const durW = 8;
+    for (const [phaseName, pr] of result.results) {
+      const durStr = pr.duration >= 1e3 ? `${(pr.duration / 1e3).toFixed(2)}s` : `${pr.duration}ms`;
+      const memStr = pr.memoryBeforeMB !== void 0 && pr.memoryAfterMB !== void 0 ? `  mem: ${pr.memoryBeforeMB}\u2192${pr.memoryAfterMB} MB` : "";
+      console.log(`    ${phaseName.padEnd(nameW)} ${durStr.padStart(durW)}${memStr}`);
+    }
+    console.log("");
+  }
   if (isIncremental && incrementalChangedFiles && incrementalChangedFiles.length > 0) {
     const dbPath = getDbPath(workspaceRoot);
-    if (fs37.existsSync(dbPath)) {
+    if (fs38.existsSync(dbPath)) {
       try {
         const db = new DbManager(dbPath);
         await db.init();
         for (const absPath of incrementalChangedFiles) {
-          const rel = path38.relative(workspaceRoot, absPath);
+          const rel = path39.relative(workspaceRoot, absPath);
           await removeNodesForFile(rel, db);
         }
         const { upsertNodes: upsertNodesBatch } = await Promise.resolve().then(() => (init_graph_loader(), graph_loader_exports));
         const changedRelPaths = new Set(
-          incrementalChangedFiles.map((f) => path38.relative(workspaceRoot, f))
+          incrementalChangedFiles.map((f) => path39.relative(workspaceRoot, f))
         );
         const nodesToUpsert = [...graph.allNodes()].filter(
           (n) => changedRelPaths.has(n.filePath)
@@ -14708,7 +15929,7 @@ async function analyzeWorkspace(targetPath, options) {
     mergedMtimes = newMtimes;
   }
   const currentCommitHash = getCurrentCommitHash(workspaceRoot) ?? void 0;
-  const repoName = path38.basename(workspaceRoot);
+  const repoName = path39.basename(workspaceRoot);
   const indexVersion = v4();
   saveMetadata(workspaceRoot, {
     indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -14746,7 +15967,7 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of newStaleFiles) {
       try {
-        if (fs37.existsSync(f)) fs37.unlinkSync(f);
+        if (fs38.existsSync(f)) fs38.unlinkSync(f);
       } catch {
       }
     }
@@ -14763,21 +15984,21 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of staleFiles) {
       try {
-        if (fs37.existsSync(f)) fs37.unlinkSync(f);
+        if (fs38.existsSync(f)) fs38.unlinkSync(f);
       } catch {
       }
     }
     for (const f of newStaleFiles) {
       if (f === dbPathNew) continue;
-      if (fs37.existsSync(f)) {
+      if (fs38.existsSync(f)) {
         const dest = f.replace(dbPathNew, dbPath);
         try {
-          fs37.renameSync(f, dest);
+          fs38.renameSync(f, dest);
         } catch {
         }
       }
     }
-    fs37.renameSync(dbPathNew, dbPath);
+    fs38.renameSync(dbPathNew, dbPath);
     stopSpinner();
     logger_default.info(`DB persisted: ${nodeCount} nodes, ${edgeCount} edges`);
     if (!options?.silent) {
@@ -14787,6 +16008,17 @@ async function analyzeWorkspace(targetPath, options) {
     stopSpinner();
     logger_default.warn(`DB persist failed: ${err instanceof Error ? err.message : err}`);
   }
+  startSpinner("Building BM25 inverted index");
+  try {
+    const { Bm25Index: Bm25Index2, getBm25DbPath: getBm25DbPath2 } = await Promise.resolve().then(() => (init_bm25_index(), bm25_index_exports));
+    const bm25 = new Bm25Index2(getBm25DbPath2(workspaceRoot));
+    bm25.build(graph);
+    stopSpinner();
+    if (!options?.silent) console.log(`  \u2713 BM25 index built`);
+  } catch (err) {
+    stopSpinner();
+    logger_default.warn(`BM25 index build failed: ${err instanceof Error ? err.message : err}`);
+  }
   const doEmbeddings = options?.embeddings && !options?.skipEmbeddings;
   if (doEmbeddings) {
     startSpinner("Building vector embeddings");
@@ -14798,7 +16030,7 @@ async function analyzeWorkspace(targetPath, options) {
       const staleVdb = [vdbPath, `${vdbPath}-shm`, `${vdbPath}-wal`];
       for (const f of staleVdb) {
         try {
-          if (fs37.existsSync(f)) fs37.unlinkSync(f);
+          if (fs38.existsSync(f)) fs38.unlinkSync(f);
         } catch {
         }
       }
@@ -14894,7 +16126,7 @@ async function analyzeWorkspace(targetPath, options) {
       }
     }
   }
-  return { graph, result, repoName, workspaceRoot };
+  return { graph: activeGraph, result, repoName, workspaceRoot };
 }
 program.command("init").description("Interactive setup wizard \u2014 creates ~/.code-intel/config.json").option("--reset", "Wipe existing config and re-run the wizard").option("--yes", "Non-interactive: accept all defaults (skips prompts)").addHelpText("after", `
   Walks you through 5 setup steps:
@@ -15015,8 +16247,8 @@ program.command("setup").description("Configure MCP server for your editors (one
     const configFile = `${configDir}/claude_desktop_config.json`;
     try {
       let existing = {};
-      if (fs37.existsSync(configFile)) {
-        existing = JSON.parse(fs37.readFileSync(configFile, "utf-8"));
+      if (fs38.existsSync(configFile)) {
+        existing = JSON.parse(fs38.readFileSync(configFile, "utf-8"));
       }
       const merged = {
         ...existing,
@@ -15025,8 +16257,8 @@ program.command("setup").description("Configure MCP server for your editors (one
           ...mcpConfig.mcpServers
         }
       };
-      fs37.mkdirSync(configDir, { recursive: true });
-      fs37.writeFileSync(configFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      fs38.mkdirSync(configDir, { recursive: true });
+      fs38.writeFileSync(configFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
       console.log(`
   \u2705  Written to ${configFile}`);
     } catch (err) {
@@ -15040,7 +16272,7 @@ program.command("setup").description("Configure MCP server for your editors (one
   console.log('\n  To verify in VS Code: open Command Palette \u2192 "MCP: List Servers" and confirm code-intel is Running.');
   console.log("\n  Next: run `code-intel analyze` inside your project to build the knowledge graph.\n");
 });
-program.command("analyze").description("Index a repository and build the knowledge graph").argument("[path]", "Path to the repository (default: current directory)", ".").option("--force", "Force full re-index, ignoring cached data").option("--incremental", "Only re-parse files changed since last analysis (git diff or mtime)").option("--parallel", "Use worker threads for parse + resolve phases (faster on multi-core)").option("--skills", "Generate .claude/skills/ SKILL.md files from detected clusters").option("--embeddings", "Build vector embeddings for semantic search (slower, recommended)").option("--skip-embeddings", "Skip embedding generation (faster, text-search only)").option("--skip-agents-md", "Preserve any custom edits inside AGENTS.md / CLAUDE.md").option("--skip-git", "Allow indexing directories that are not Git repositories").option("--verbose", "Log every file skipped due to missing parser support").option("--summarize", "Generate AI summaries for function/class/method/interface nodes (opt-in)").option("--llm-provider <provider>", "LLM provider for --summarize: openai | anthropic | ollama (default: ollama)").option("--llm-model <model>", "LLM model name (e.g. gpt-4o-mini, claude-haiku-4-5, llama3)").option("--llm-batch-size <n>", "Concurrent LLM calls per batch (default: 20)", "20").option("--llm-max-nodes <n>", "Max nodes to summarize per run (cost guard)").option("--no-group-sync", "Skip automatic group sync after analysis").option("--dry-run", "Preview files that would be scanned + estimated time; no DB write").addHelpText("after", `
+program.command("analyze").description("Index a repository and build the knowledge graph").argument("[path]", "Path to the repository (default: current directory)", ".").option("--force", "Force full re-index, ignoring cached data").option("--incremental", "Only re-parse files changed since last analysis (git diff or mtime)").option("--parallel", "Use worker threads for parse + resolve phases (faster on multi-core)").option("--skills", "Generate .claude/skills/ SKILL.md files from detected clusters").option("--embeddings", "Build vector embeddings for semantic search (slower, recommended)").option("--skip-embeddings", "Skip embedding generation (faster, text-search only)").option("--skip-agents-md", "Preserve any custom edits inside AGENTS.md / CLAUDE.md").option("--skip-git", "Allow indexing directories that are not Git repositories").option("--verbose", "Log every file skipped due to missing parser support").option("--summarize", "Generate AI summaries for function/class/method/interface nodes (opt-in)").option("--llm-provider <provider>", "LLM provider for --summarize: openai | anthropic | ollama (default: ollama)").option("--llm-model <model>", "LLM model name (e.g. gpt-4o-mini, claude-haiku-4-5, llama3)").option("--llm-batch-size <n>", "Concurrent LLM calls per batch (default: 20)", "20").option("--llm-max-nodes <n>", "Max nodes to summarize per run (cost guard)").option("--no-group-sync", "Skip automatic group sync after analysis").option("--dry-run", "Preview files that would be scanned + estimated time; no DB write").option("--max-memory <MB>", "Limit graph memory (MB); spill node content to free RAM when exceeded").option("--profile", "Write per-phase profiling data to .code-intel/profile.json").addHelpText("after", `
   Parses your source code with tree-sitter, builds a Knowledge Graph of
   symbols and their relationships, persists it to .code-intel/graph.db,
   and auto-generates AGENTS.md + CLAUDE.md context blocks.
@@ -15063,7 +16295,7 @@ program.command("analyze").description("Index a repository and build the knowled
     $ code-intel analyze --dry-run             Preview files that would be scanned
 `).action(async (targetPath, opts) => {
   if (opts.dryRun) {
-    const workspaceRoot = path38.resolve(targetPath);
+    const workspaceRoot = path39.resolve(targetPath);
     const { scanPhase: sp } = await Promise.resolve().then(() => (init_phases(), phases_exports));
     const graph = createKnowledgeGraph();
     const context2 = {
@@ -15105,7 +16337,12 @@ program.command("analyze").description("Index a repository and build the knowled
     llmMaxNodes: (() => {
       const v = parseInt(opts.llmMaxNodes ?? "", 10);
       return Number.isFinite(v) && v >= 1 ? v : void 0;
-    })()
+    })(),
+    maxMemoryMB: (() => {
+      const v = parseInt(opts.maxMemory ?? "", 10);
+      return Number.isFinite(v) && v >= 1 ? v : void 0;
+    })(),
+    profile: opts.profile
   });
   process.exit(0);
 });
@@ -15120,13 +16357,17 @@ program.command("mcp").description("Start MCP server over stdio \u2014 exposes a
     $ code-intel mcp
     $ code-intel mcp ./my-project
 `).action(async (targetPath) => {
-  const workspaceRoot = path38.resolve(targetPath);
-  const repoName = path38.basename(workspaceRoot);
+  const workspaceRoot = path39.resolve(targetPath);
+  const repoName = path39.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = fs37.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  if (!fs38.existsSync(workspaceRoot) || !fs38.statSync(workspaceRoot).isDirectory()) {
+    console.error(`  \u2717  Path does not exist: ${workspaceRoot}`);
+    process.exit(1);
+  }
+  const existingIndex = fs38.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const graph = createKnowledgeGraph();
-    const db = new DbManager(dbPath);
+    const db = new DbManager(dbPath, true);
     await db.init();
     await loadGraphFromDB(graph, db);
     db.close();
@@ -15154,30 +16395,35 @@ program.command("serve").description("Start the local HTTP server + web UI for g
     $ code-intel serve --port 8080
     $ code-intel serve --force
 `).action(async (targetPath, options) => {
-  const workspaceRoot = path38.resolve(targetPath);
-  const repoName = path38.basename(workspaceRoot);
+  const workspaceRoot = path39.resolve(targetPath);
+  const repoName = path39.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = !options.force && fs37.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  if (!fs38.existsSync(workspaceRoot) || !fs38.statSync(workspaceRoot).isDirectory()) {
+    console.error(`  \u2717  Path does not exist: ${workspaceRoot}`);
+    process.exit(1);
+  }
+  const existingIndex = !options.force && fs38.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const meta = loadMetadata(workspaceRoot);
     if (meta.parser === "regex" || meta.parser === void 0) {
-      logger_default.warn(`  [serve] Index was built with regex parser \u2014 running full re-analysis to upgrade to tree-sitter`);
-      console.log(`Re-analyzing with tree-sitter parser: ${workspaceRoot}`);
-      const { graph: newGraph, workspaceRoot: root, repoName: name } = await analyzeWorkspace(targetPath, { force: true });
-      await startHttpServer(newGraph, name, parseInt(options.port, 10), root);
+      logger_default.warn(`  [serve] Index was built with regex parser. Run \`code-intel analyze\` to upgrade to tree-sitter, then re-run \`code-intel serve\`.`);
+      process.exit(1);
     } else {
-      console.log(`Loading index: ${workspaceRoot}`);
+      console.log(`Loading index (lazy): ${workspaceRoot}`);
       console.log(`  \u25C8  ${meta.stats.nodes} nodes \xB7 ${meta.stats.edges} edges \xB7 ${meta.stats.files} files  (indexed ${meta.indexedAt})`);
-      const graph = createKnowledgeGraph();
-      const db = new DbManager(dbPath);
+      const lazyGraph = new LazyKnowledgeGraph();
+      const db = new DbManager(dbPath, true);
       await db.init();
-      await loadGraphFromDB(graph, db);
-      db.close();
-      await startHttpServer(graph, repoName, parseInt(options.port, 10), workspaceRoot);
+      await lazyGraph.init(db, meta.stats.nodes, meta.stats.edges);
+      logger_default.info(`  [serve] Lazy graph ready \u2014 ${lazyGraph.size.edges} edges loaded; nodes fetched on demand`);
+      setImmediate(() => lazyGraph.warmTopNodes(500).catch(() => {
+      }));
+      await startHttpServer(lazyGraph, repoName, parseInt(options.port, 10), workspaceRoot);
     }
   } else {
-    const { graph, workspaceRoot: root, repoName: name } = await analyzeWorkspace(targetPath, { force: options.force });
-    await startHttpServer(graph, name, parseInt(options.port, 10), root);
+    logger_default.warn(`  [serve] No index found for: ${workspaceRoot}`);
+    logger_default.warn(`  [serve] Run \`code-intel analyze\` first, then re-run \`code-intel serve\`.`);
+    process.exit(1);
   }
 });
 program.command("watch").description("Start HTTP server + file watcher (auto-reindex on file changes)").argument("[path]", "Path to watch (default: current directory)", ".").option("-p, --port <port>", "Port to listen on", "4747").option("--force", "Force re-analysis even if an index already exists").addHelpText("after", `
@@ -15191,10 +16437,14 @@ program.command("watch").description("Start HTTP server + file watcher (auto-rei
 `).action(async (targetPath, options) => {
   const { FileWatcher: FileWatcher2 } = await Promise.resolve().then(() => (init_file_watcher(), file_watcher_exports));
   const { IncrementalIndexer: IncrementalIndexer2 } = await Promise.resolve().then(() => (init_incremental_indexer(), incremental_indexer_exports));
-  const workspaceRoot = path38.resolve(targetPath);
-  const repoName = path38.basename(workspaceRoot);
+  const workspaceRoot = path39.resolve(targetPath);
+  const repoName = path39.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = !options.force && fs37.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  if (!fs38.existsSync(workspaceRoot) || !fs38.statSync(workspaceRoot).isDirectory()) {
+    console.error(`  \u2717  Path does not exist: ${workspaceRoot}`);
+    process.exit(1);
+  }
+  const existingIndex = !options.force && fs38.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   let graph;
   if (existingIndex) {
     const meta = loadMetadata(workspaceRoot);
@@ -15202,13 +16452,15 @@ program.command("watch").description("Start HTTP server + file watcher (auto-rei
       const result = await analyzeWorkspace(targetPath, { force: true });
       graph = result.graph;
     } else {
-      graph = createKnowledgeGraph();
-      const db = new DbManager(dbPath);
+      const lazyGraph = new LazyKnowledgeGraph();
+      const db = new DbManager(dbPath, true);
       await db.init();
-      await loadGraphFromDB(graph, db);
-      db.close();
-      console.log(`Loading index: ${workspaceRoot}`);
+      await lazyGraph.init(db, meta.stats.nodes, meta.stats.edges);
+      console.log(`Loading index (lazy): ${workspaceRoot}`);
       console.log(`  \u25C8  ${meta.stats.nodes} nodes \xB7 ${meta.stats.edges} edges`);
+      setImmediate(() => lazyGraph.warmTopNodes(500).catch(() => {
+      }));
+      graph = lazyGraph;
     }
   } else {
     const result = await analyzeWorkspace(targetPath, { force: options.force });
@@ -15218,25 +16470,32 @@ program.command("watch").description("Start HTTP server + file watcher (auto-rei
   const { wsServer } = await startHttpServer(graph, repoName, parseInt(options.port, 10), workspaceRoot, watcherState);
   const indexer = new IncrementalIndexer2(graph, workspaceRoot, dbPath);
   const watcher = new FileWatcher2(workspaceRoot);
-  watcher.start(async (changedFiles) => {
-    watcherState.lastEventAt = Date.now();
-    console.log(`
+  function startWatcher() {
+    watcher.start(async (changedFiles) => {
+      watcherState.lastEventAt = Date.now();
+      console.log(`
   \u27F3  Re-indexing ${changedFiles.length} changed file(s)\u2026`);
-    const result = await indexer.patchGraph(changedFiles);
-    if (wsServer) {
-      const meta = loadMetadata(workspaceRoot);
-      wsServer.broadcast({
-        type: "graph:updated",
-        indexVersion: meta?.indexVersion ?? "unknown",
-        stats: { nodes: graph.size.nodes, edges: graph.size.edges },
-        changedFiles: changedFiles.map((f) => path38.relative(workspaceRoot, f)),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
-    console.log(
-      `  \u2705  Patch done: -${result.nodesRemoved} +${result.nodesAdded} nodes \xB7 ${result.duration}ms`
-    );
-  });
+      try {
+        const result = await indexer.patchGraph(changedFiles);
+        if (wsServer) {
+          const meta = loadMetadata(workspaceRoot);
+          wsServer.broadcast({
+            type: "graph:updated",
+            indexVersion: meta?.indexVersion ?? "unknown",
+            stats: { nodes: graph.size.nodes, edges: graph.size.edges },
+            changedFiles: changedFiles.map((f) => path39.relative(workspaceRoot, f)),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        console.log(
+          `  \u2705  Patch done: -${result.nodesRemoved} +${result.nodesAdded} nodes \xB7 ${result.duration}ms`
+        );
+      } catch (err) {
+        logger_default.error(`[watcher] patchGraph error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
+  }
+  startWatcher();
   console.log(`
   \u{1F441}  Watching: ${workspaceRoot}`);
   console.log(`     Web UI:   http://localhost:${options.port}`);
@@ -15280,7 +16539,7 @@ program.command("status").description("Show index freshness and statistics for a
     $ code-intel status
     $ code-intel status ./my-project
 `).action((targetPath) => {
-  const workspaceRoot = path38.resolve(targetPath);
+  const workspaceRoot = path39.resolve(targetPath);
   const meta = loadMetadata(workspaceRoot);
   if (!meta) {
     console.log(`
@@ -15304,18 +16563,18 @@ function trashDirName(repoPath) {
   return `.code-intel-trash-${date}`;
 }
 function softDeleteCodeIntel(repoPath) {
-  const codeIntelDir = path38.join(repoPath, ".code-intel");
-  if (!fs37.existsSync(codeIntelDir)) return;
+  const codeIntelDir = path39.join(repoPath, ".code-intel");
+  if (!fs38.existsSync(codeIntelDir)) return;
   const trashName = trashDirName();
-  const trashDir = path38.join(repoPath, trashName);
+  const trashDir = path39.join(repoPath, trashName);
   let dest = trashDir;
   let counter = 1;
-  while (fs37.existsSync(dest)) {
+  while (fs38.existsSync(dest)) {
     dest = `${trashDir}-${counter++}`;
   }
-  fs37.renameSync(codeIntelDir, dest);
-  fs37.writeFileSync(
-    path38.join(dest, "TRASH_META.json"),
+  fs38.renameSync(codeIntelDir, dest);
+  fs38.writeFileSync(
+    path39.join(dest, "TRASH_META.json"),
     JSON.stringify({ deletedAt: (/* @__PURE__ */ new Date()).toISOString(), repoPath, permanent: false }, null, 2)
   );
   console.log(`  \u2713  Moved to trash: ${dest}`);
@@ -15324,15 +16583,15 @@ function softDeleteCodeIntel(repoPath) {
 function purgeStaleTrashes(repoPath) {
   const cutoff = Date.now() - TRASH_TTL_DAYS * 24 * 60 * 60 * 1e3;
   try {
-    for (const entry of fs37.readdirSync(repoPath)) {
+    for (const entry of fs38.readdirSync(repoPath)) {
       if (!entry.startsWith(".code-intel-trash-")) continue;
-      const fullPath = path38.join(repoPath, entry);
-      const metaPath = path38.join(fullPath, "TRASH_META.json");
-      if (fs37.existsSync(metaPath)) {
+      const fullPath = path39.join(repoPath, entry);
+      const metaPath = path39.join(fullPath, "TRASH_META.json");
+      if (fs38.existsSync(metaPath)) {
         try {
-          const meta = JSON.parse(fs37.readFileSync(metaPath, "utf-8"));
+          const meta = JSON.parse(fs38.readFileSync(metaPath, "utf-8"));
           if (new Date(meta.deletedAt).getTime() < cutoff) {
-            fs37.rmSync(fullPath, { recursive: true, force: true });
+            fs38.rmSync(fullPath, { recursive: true, force: true });
             console.log(`  \u2713  Auto-purged stale trash: ${fullPath}`);
           }
         } catch {
@@ -15358,19 +16617,19 @@ program.command("clean").description("Soft-delete the knowledge graph index for
 `).action((targetPath, opts) => {
   if (opts.dryRun) {
     const showDryRun = (repoPath) => {
-      const codeIntelDir = path38.join(path38.resolve(repoPath), ".code-intel");
-      if (!fs37.existsSync(codeIntelDir)) {
+      const codeIntelDir = path39.join(path39.resolve(repoPath), ".code-intel");
+      if (!fs38.existsSync(codeIntelDir)) {
         console.log(`  (no .code-intel/ found at ${repoPath})`);
         return;
       }
       let totalBytes = 0;
       const countDir = (dir) => {
         try {
-          for (const entry of fs37.readdirSync(dir, { withFileTypes: true })) {
-            const full = path38.join(dir, entry.name);
+          for (const entry of fs38.readdirSync(dir, { withFileTypes: true })) {
+            const full = path39.join(dir, entry.name);
             if (entry.isDirectory()) countDir(full);
             else try {
-              totalBytes += fs37.statSync(full).size;
+              totalBytes += fs38.statSync(full).size;
             } catch {
             }
           }
@@ -15393,7 +16652,7 @@ program.command("clean").description("Soft-delete the knowledge graph index for
       for (const r of repos) showDryRun(r.path);
     } else {
       console.log(`
-  \u25C8  Dry run \u2014 clean ${path38.resolve(targetPath)}
+  \u25C8  Dry run \u2014 clean ${path39.resolve(targetPath)}
 `);
       showDryRun(targetPath);
     }
@@ -15403,18 +16662,18 @@ program.command("clean").description("Soft-delete the knowledge graph index for
   if (opts.listTrash) {
     const repos = loadRegistry();
     const roots = repos.map((r) => r.path);
-    if (roots.length === 0) roots.push(path38.resolve("."));
+    if (roots.length === 0) roots.push(path39.resolve("."));
     let found = 0;
     for (const root of roots) {
       try {
-        for (const entry of fs37.readdirSync(root)) {
+        for (const entry of fs38.readdirSync(root)) {
           if (!entry.startsWith(".code-intel-trash-")) continue;
-          const fullPath = path38.join(root, entry);
-          const metaPath = path38.join(fullPath, "TRASH_META.json");
+          const fullPath = path39.join(root, entry);
+          const metaPath = path39.join(fullPath, "TRASH_META.json");
           let deletedAt = "unknown";
-          if (fs37.existsSync(metaPath)) {
+          if (fs38.existsSync(metaPath)) {
             try {
-              deletedAt = JSON.parse(fs37.readFileSync(metaPath, "utf-8")).deletedAt;
+              deletedAt = JSON.parse(fs38.readFileSync(metaPath, "utf-8")).deletedAt;
             } catch {
             }
           }
@@ -15442,9 +16701,9 @@ program.command("clean").description("Soft-delete the knowledge graph index for
     }
     for (const r of repos) {
       if (opts.purge) {
-        const codeIntelDir = path38.join(r.path, ".code-intel");
-        if (fs37.existsSync(codeIntelDir)) {
-          fs37.rmSync(codeIntelDir, { recursive: true, force: true });
+        const codeIntelDir = path39.join(r.path, ".code-intel");
+        if (fs38.existsSync(codeIntelDir)) {
+          fs38.rmSync(codeIntelDir, { recursive: true, force: true });
           console.log(`  \u2713  Hard-deleted ${codeIntelDir}`);
         }
       } else {
@@ -15458,11 +16717,11 @@ program.command("clean").description("Soft-delete the knowledge graph index for
 `);
     return;
   }
-  const workspaceRoot = path38.resolve(targetPath);
+  const workspaceRoot = path39.resolve(targetPath);
   if (opts.purge) {
-    const codeIntelDir = path38.join(workspaceRoot, ".code-intel");
-    if (fs37.existsSync(codeIntelDir)) {
-      fs37.rmSync(codeIntelDir, { recursive: true, force: true });
+    const codeIntelDir = path39.join(workspaceRoot, ".code-intel");
+    if (fs38.existsSync(codeIntelDir)) {
+      fs38.rmSync(codeIntelDir, { recursive: true, force: true });
       console.log(`
   \u2713  Hard-deleted ${codeIntelDir}`);
     }
@@ -15474,16 +16733,16 @@ program.command("clean").description("Soft-delete the knowledge graph index for
   console.log("  Index cleaned.\n");
 });
 async function loadOrAnalyzeWorkspace(targetPath) {
-  const workspaceRoot = path38.resolve(targetPath);
+  const workspaceRoot = path39.resolve(targetPath);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = fs37.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = fs38.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const graph = createKnowledgeGraph();
-    const db = new DbManager(dbPath);
+    const db = new DbManager(dbPath, true);
     await db.init();
     await loadGraphFromDB(graph, db);
     db.close();
-    return { graph, workspaceRoot, repoName: path38.basename(workspaceRoot) };
+    return { graph, workspaceRoot, repoName: path39.basename(workspaceRoot) };
   }
   return analyzeWorkspace(targetPath, { silent: true });
 }
@@ -15962,9 +17221,9 @@ groupCmd.command("status <name>").description("Check index freshness and sync st
       console.log(`  \u2717  ${m.groupPath.padEnd(35)} [${m.registryName}]  \u2014 NOT IN REGISTRY`);
       continue;
     }
-    const metaPath = path38.join(regEntry.path, ".code-intel", "meta.json");
+    const metaPath = path39.join(regEntry.path, ".code-intel", "meta.json");
     try {
-      const meta = JSON.parse(fs37.readFileSync(metaPath, "utf-8"));
+      const meta = JSON.parse(fs38.readFileSync(metaPath, "utf-8"));
       const indexedAt = meta.indexedAt;
       const ageMin = Math.round((now - new Date(indexedAt).getTime()) / 6e4);
       const stale = ageMin > 1440 ? "  \u26A0  STALE (>24h)" : "";
@@ -15981,7 +17240,7 @@ groupCmd.command("status <name>").description("Check index freshness and sync st
   }
 });
 groupCmd.command("init-workspace [path]").description("Auto-discover workspace packages and create a group").option("--name <name>", "Group name (default: workspace root dirname)").option("--no-analyze", "Register packages without running analysis").option("--yes", "Skip confirmation prompt").option("--parallel <n>", "Concurrent analyses (default: 2)", "2").action(async (targetPath, opts) => {
-  const root = path38.resolve(targetPath ?? ".");
+  const root = path39.resolve(targetPath ?? ".");
   const ws = await detectWorkspace(root);
   if (!ws) {
     console.error(`
@@ -15990,7 +17249,7 @@ groupCmd.command("init-workspace [path]").description("Auto-discover workspace p
 `);
     process.exit(1);
   }
-  const groupName = opts.name ?? path38.basename(root);
+  const groupName = opts.name ?? path39.basename(root);
   console.log(`
   \u25C8  Workspace detected: ${ws.type}`);
   console.log(`     Group name    : ${groupName}`);
@@ -16269,7 +17528,7 @@ backupCmd.command("create [path]").description("Create an encrypted backup of th
     $ code-intel backup create
     $ code-intel backup create ./my-project
 `).action((targetPath = ".") => {
-  const repoPath = path38.resolve(targetPath);
+  const repoPath = path39.resolve(targetPath);
   const svc = new BackupService();
   try {
     const entry = svc.createBackup(repoPath);
@@ -16298,7 +17557,7 @@ backupCmd.command("list").description("List all available backups").action(() =>
   Backups (${entries.length}):
 `);
   for (const e of entries) {
-    const exists = fs37.existsSync(e.path);
+    const exists = fs38.existsSync(e.path);
     const status = exists ? "\u2713" : "\u2717 (missing)";
     console.log(`  ${status}  ${e.id.slice(0, 8)}  ${e.createdAt}  ${(e.size / 1024).toFixed(1)} KB  \u2192  ${e.repoPath}`);
   }
@@ -16311,7 +17570,7 @@ backupCmd.command("restore <id>").description("Restore a backup by ID").option("
 `).action((id, opts) => {
   const svc = new BackupService();
   try {
-    const targetPath = opts.target ? path38.resolve(opts.target) : void 0;
+    const targetPath = opts.target ? path39.resolve(opts.target) : void 0;
     svc.restoreBackup(id, targetPath);
     console.log(`
   \u2705  Backup "${id}" restored successfully.
@@ -16330,15 +17589,15 @@ program.command("migrate").description("Manage database schema migrations").opti
     $ code-intel migrate
     $ code-intel migrate --rollback
 `).action((opts) => {
-  const dbPath = opts.db ?? path38.join(os13.homedir(), ".code-intel", "users.db");
-  if (!fs37.existsSync(dbPath)) {
+  const dbPath = opts.db ?? path39.join(os13.homedir(), ".code-intel", "users.db");
+  if (!fs38.existsSync(dbPath)) {
     console.error(`
   \u2717  Database not found: ${dbPath}
   Run \`code-intel serve\` or \`code-intel user create\` first.
 `);
     process.exit(1);
   }
-  const db = new Database(dbPath);
+  const db = new Database2(dbPath);
   db.pragma("journal_mode = WAL");
   const runner = new MigrationRunner(db);
   try {
@@ -16446,15 +17705,15 @@ authCmd.command("login").description("Authenticate via OIDC device flow \u2014 o
   }
   try {
     const tokens = await pollDeviceFlow3(config, deviceResponse);
-    const tokenPath = path38.join(os13.homedir(), ".code-intel", "oidc-token.json");
+    const tokenPath = path39.join(os13.homedir(), ".code-intel", "oidc-token.json");
     const tokenData = {
       accessToken: tokens.accessToken,
       refreshToken: tokens.refreshToken,
       server: serverUrl,
       storedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs37.mkdirSync(path38.dirname(tokenPath), { recursive: true });
-    fs37.writeFileSync(tokenPath, JSON.stringify(tokenData, null, 2), { mode: 384 });
+    fs38.mkdirSync(path39.dirname(tokenPath), { recursive: true });
+    fs38.writeFileSync(tokenPath, JSON.stringify(tokenData, null, 2), { mode: 384 });
     console.log(`  \u2705  Authenticated successfully!`);
     console.log(`  Token stored at: ${tokenPath}`);
     console.log(`  Use CODE_INTEL_TOKEN env var or --token flag to use it with CLI/MCP.
@@ -16467,13 +17726,13 @@ authCmd.command("login").description("Authenticate via OIDC device flow \u2014 o
   }
 });
 authCmd.command("status").description("Show the current OIDC authentication status").action(() => {
-  const tokenPath = path38.join(os13.homedir(), ".code-intel", "oidc-token.json");
-  if (!fs37.existsSync(tokenPath)) {
+  const tokenPath = path39.join(os13.homedir(), ".code-intel", "oidc-token.json");
+  if (!fs38.existsSync(tokenPath)) {
     console.log("\n  Not authenticated via OIDC. Run: code-intel auth login\n");
     return;
   }
   try {
-    const data = JSON.parse(fs37.readFileSync(tokenPath, "utf-8"));
+    const data = JSON.parse(fs38.readFileSync(tokenPath, "utf-8"));
     console.log(`
   \u2705  OIDC token stored`);
     console.log(`  Server : ${data.server ?? "unknown"}`);
@@ -16485,9 +17744,9 @@ authCmd.command("status").description("Show the current OIDC authentication stat
   }
 });
 authCmd.command("logout").description("Remove locally stored OIDC token").action(() => {
-  const tokenPath = path38.join(os13.homedir(), ".code-intel", "oidc-token.json");
-  if (fs37.existsSync(tokenPath)) {
-    fs37.unlinkSync(tokenPath);
+  const tokenPath = path39.join(os13.homedir(), ".code-intel", "oidc-token.json");
+  if (fs38.existsSync(tokenPath)) {
+    fs38.unlinkSync(tokenPath);
     console.log("\n  \u2705  OIDC token removed. You are now logged out.\n");
   } else {
     console.log("\n  No stored token found.\n");
@@ -16611,8 +17870,8 @@ program.command("config-validate <file>").description("Validate a JSON config fi
     $ code-intel config-validate ./config.json
     $ code-intel config-validate ~/.code-intel/config.json
 `).action((file) => {
-  const filePath = path38.resolve(file);
-  if (!fs37.existsSync(filePath)) {
+  const filePath = path39.resolve(file);
+  if (!fs38.existsSync(filePath)) {
     console.error(`
   \u2717  File not found: ${filePath}
 `);
@@ -16620,7 +17879,7 @@ program.command("config-validate <file>").description("Validate a JSON config fi
   }
   let cfg;
   try {
-    cfg = JSON.parse(fs37.readFileSync(filePath, "utf-8"));
+    cfg = JSON.parse(fs38.readFileSync(filePath, "utf-8"));
   } catch (err) {
     console.error(`
   \u2717  Could not parse JSON: ${err instanceof Error ? err.message : err}
@@ -16641,7 +17900,7 @@ ${err instanceof Error ? err.message : err}
 });
 (function ensurePermissions() {
   try {
-    const dir = path38.join(os13.homedir(), ".code-intel");
+    const dir = path39.join(os13.homedir(), ".code-intel");
     secureMkdir(dir);
     tightenDbFiles(dir);
   } catch {
@@ -16658,10 +17917,10 @@ program.command("health").description("Run code health checks: dead code, circul
     $ code-intel health --json
     $ code-intel health --threshold 80
 `).action(async (targetPath, opts) => {
-  const workspaceRoot = path38.resolve(targetPath);
+  const workspaceRoot = path39.resolve(targetPath);
   const dbPath = getDbPath(workspaceRoot);
   const meta = loadMetadata(workspaceRoot);
-  if (!meta || !fs37.existsSync(dbPath)) {
+  if (!meta || !fs38.existsSync(dbPath)) {
     console.error(`
   \u2717  ${workspaceRoot} is not indexed.`);
     console.error("     Run `code-intel analyze` first to build the index.\n");
@@ -16669,7 +17928,7 @@ program.command("health").description("Run code health checks: dead code, circul
   }
   const { computeHealthReport: computeHealthReport3 } = await Promise.resolve().then(() => (init_health_score(), health_score_exports));
   const graph = createKnowledgeGraph();
-  const db = new DbManager(dbPath);
+  const db = new DbManager(dbPath, true);
   await db.init();
   await loadGraphFromDB(graph, db);
   db.close();
@@ -16746,7 +18005,7 @@ program.command("query").description("Execute a GQL (Graph Query Language) query
     $ code-intel query --list
     $ code-intel query --delete auth-search
 `).action(async (gqlArg, opts) => {
-  const workspaceRoot = path38.resolve(opts.path);
+  const workspaceRoot = path39.resolve(opts.path);
   const { saveQuery: saveQuery2, loadQuery: loadQuery2, listQueries: listQueries2, deleteQuery: deleteQuery2 } = await Promise.resolve().then(() => (init_saved_queries(), saved_queries_exports));
   if (opts.list) {
     const queries = listQueries2(workspaceRoot);
@@ -16805,14 +18064,14 @@ program.command("query").description("Execute a GQL (Graph Query Language) query
     }
     gqlInput = content;
   } else if (opts.file) {
-    const filePath = path38.resolve(opts.file);
-    if (!fs37.existsSync(filePath)) {
+    const filePath = path39.resolve(opts.file);
+    if (!fs38.existsSync(filePath)) {
       console.error(`
   \u2717  File not found: ${filePath}
 `);
       process.exit(1);
     }
-    gqlInput = fs37.readFileSync(filePath, "utf-8");
+    gqlInput = fs38.readFileSync(filePath, "utf-8");
   } else if (gqlArg) {
     gqlInput = gqlArg;
   } else {
@@ -16935,7 +18194,7 @@ program.command("pr-impact").description("Compute PR blast radius and risk score
     $ code-intel pr-impact --base main --head HEAD --format sarif
     $ code-intel pr-impact --base main --head HEAD --format json
 `).action(async (opts) => {
-  const repoPath = path38.resolve(opts.path ?? ".");
+  const repoPath = path39.resolve(opts.path ?? ".");
   const { execSync: execSync5 } = await import('child_process');
   let diff;
   try {
@@ -17235,7 +18494,7 @@ program.command("scan").description("Run security scans: secrets + OWASP vulnera
       const medCount = filtered.filter((f) => f.severity === "MEDIUM").length;
       const lowCount = filtered.filter((f) => f.severity === "LOW").length;
       console.log(`
-  \u25C8  Security Scan \u2014 ${path38.resolve(targetPath)}
+  \u25C8  Security Scan \u2014 ${path39.resolve(targetPath)}
 `);
       console.log(`  HIGH: ${highCount}  MEDIUM: ${medCount}  LOW: ${lowCount}
 `);
@@ -17327,8 +18586,8 @@ program.command("doctor").description("Run diagnostics \u2014 check Node.js, git
     const dbPath = getDbPath2(repo.path);
     let dbOk = false;
     try {
-      const Database6 = (await import('better-sqlite3')).default;
-      const db = new Database6(dbPath, { readonly: true, fileMustExist: true });
+      const Database7 = (await import('better-sqlite3')).default;
+      const db = new Database7(dbPath, { readonly: true, fileMustExist: true });
       db.prepare("SELECT COUNT(*) FROM nodes").get();
       db.close();
       dbOk = true;
@@ -17340,7 +18599,7 @@ program.command("doctor").description("Run diagnostics \u2014 check Node.js, git
       continue;
     }
     const vdbPath = getVectorDbPath2(repo.path);
-    if (fs37.existsSync(vdbPath)) {
+    if (fs38.existsSync(vdbPath)) {
       try {
         const Database22 = (await import('better-sqlite3')).default;
         const vdb = new Database22(vdbPath, { readonly: true, fileMustExist: true });