@vohongtho.infotech/code-intel 0.5.0 → 0.7.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 fs28, { readFileSync, existsSync } from 'fs';
-import path30, { dirname, join } from 'path';
+import fs33, { readFileSync, existsSync } from 'fs';
+import path33, { dirname, join } from 'path';
 import os12 from 'os';
 import { Registry, collectDefaultMetrics, Counter, Histogram, Gauge } from 'prom-client';
 import { createRequire } from 'module';
@@ -326,7 +326,7 @@ var init_logger = __esm({
         };
       }
       /** Global log directory: ~/.code-intel/logs */
-      static LOG_DIR = path30.join(os12.homedir(), ".code-intel", "logs");
+      static LOG_DIR = path33.join(os12.homedir(), ".code-intel", "logs");
       static getLogger() {
         if (!_Logger.instance) {
           const isProduction = process.env.NODE_ENV === "production";
@@ -335,12 +335,12 @@ var init_logger = __esm({
           transports.push(new winston.transports.Console());
           if (!isProduction) {
             try {
-              if (!fs28.existsSync(_Logger.LOG_DIR)) {
-                fs28.mkdirSync(_Logger.LOG_DIR, { recursive: true });
+              if (!fs33.existsSync(_Logger.LOG_DIR)) {
+                fs33.mkdirSync(_Logger.LOG_DIR, { recursive: true });
               }
               transports.push(
                 new DailyRotateFile({
-                  filename: path30.join(_Logger.LOG_DIR, "%DATE%-code-intel.log"),
+                  filename: path33.join(_Logger.LOG_DIR, "%DATE%-code-intel.log"),
                   datePattern: "YYYY-MM-DD",
                   maxSize: "20m",
                   maxFiles: "14d"
@@ -392,6 +392,131 @@ var init_logger = __esm({
   }
 });
 
+// src/graph/knowledge-graph.ts
+function createKnowledgeGraph() {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const edgesByKind = /* @__PURE__ */ new Map();
+  const edgesFromNode = /* @__PURE__ */ new Map();
+  const edgesToNode = /* @__PURE__ */ new Map();
+  function indexEdge(edge) {
+    let kindSet = edgesByKind.get(edge.kind);
+    if (!kindSet) {
+      kindSet = /* @__PURE__ */ new Set();
+      edgesByKind.set(edge.kind, kindSet);
+    }
+    kindSet.add(edge.id);
+    let fromSet = edgesFromNode.get(edge.source);
+    if (!fromSet) {
+      fromSet = /* @__PURE__ */ new Set();
+      edgesFromNode.set(edge.source, fromSet);
+    }
+    fromSet.add(edge.id);
+    let toSet = edgesToNode.get(edge.target);
+    if (!toSet) {
+      toSet = /* @__PURE__ */ new Set();
+      edgesToNode.set(edge.target, toSet);
+    }
+    toSet.add(edge.id);
+  }
+  function unindexEdge(edge) {
+    edgesByKind.get(edge.kind)?.delete(edge.id);
+    edgesFromNode.get(edge.source)?.delete(edge.id);
+    edgesToNode.get(edge.target)?.delete(edge.id);
+  }
+  return {
+    addNode(node) {
+      nodes.set(node.id, node);
+    },
+    addEdge(edge) {
+      edges.set(edge.id, edge);
+      indexEdge(edge);
+    },
+    getNode(id) {
+      return nodes.get(id);
+    },
+    getEdge(id) {
+      return edges.get(id);
+    },
+    *findEdgesByKind(kind) {
+      const ids = edgesByKind.get(kind);
+      if (!ids) return;
+      for (const id of ids) {
+        const edge = edges.get(id);
+        if (edge) yield edge;
+      }
+    },
+    *findEdgesFrom(sourceId) {
+      const ids = edgesFromNode.get(sourceId);
+      if (!ids) return;
+      for (const id of ids) {
+        const edge = edges.get(id);
+        if (edge) yield edge;
+      }
+    },
+    *findEdgesTo(targetId) {
+      const ids = edgesToNode.get(targetId);
+      if (!ids) return;
+      for (const id of ids) {
+        const edge = edges.get(id);
+        if (edge) yield edge;
+      }
+    },
+    removeNodeCascade(id) {
+      const fromEdges = edgesFromNode.get(id);
+      if (fromEdges) {
+        for (const edgeId of [...fromEdges]) {
+          const edge = edges.get(edgeId);
+          if (edge) {
+            unindexEdge(edge);
+            edges.delete(edgeId);
+          }
+        }
+      }
+      const toEdges = edgesToNode.get(id);
+      if (toEdges) {
+        for (const edgeId of [...toEdges]) {
+          const edge = edges.get(edgeId);
+          if (edge) {
+            unindexEdge(edge);
+            edges.delete(edgeId);
+          }
+        }
+      }
+      edgesFromNode.delete(id);
+      edgesToNode.delete(id);
+      nodes.delete(id);
+    },
+    removeEdge(id) {
+      const edge = edges.get(id);
+      if (edge) {
+        unindexEdge(edge);
+        edges.delete(id);
+      }
+    },
+    *allNodes() {
+      yield* nodes.values();
+    },
+    *allEdges() {
+      yield* edges.values();
+    },
+    get size() {
+      return { nodes: nodes.size, edges: edges.size };
+    },
+    clear() {
+      nodes.clear();
+      edges.clear();
+      edgesByKind.clear();
+      edgesFromNode.clear();
+      edgesToNode.clear();
+    }
+  };
+}
+var init_knowledge_graph = __esm({
+  "src/graph/knowledge-graph.ts"() {
+  }
+});
+
 // src/pipeline/dag-validator.ts
 function validateDAG(phases) {
   const errors = [];
@@ -415,25 +540,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, path31) {
+  function dfs(name, path34) {
     if (visiting.has(name)) {
-      const cycleStart = path31.indexOf(name);
-      const cycle = path31.slice(cycleStart).concat(name);
+      const cycleStart = path34.indexOf(name);
+      const cycle = path34.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);
-    path31.push(name);
+    path34.push(name);
     const phase = phaseMap.get(name);
     if (phase) {
       for (const dep of phase.dependencies) {
-        if (dfs(dep, path31)) return true;
+        if (dfs(dep, path34)) return true;
       }
     }
     visiting.delete(name);
     visited.add(name);
-    path31.pop();
+    path34.pop();
     return false;
   }
   for (const phase of phases) {
@@ -693,11 +818,11 @@ var init_id_generator = __esm({
   }
 });
 function findBundledWasmDir() {
-  const fileDir = path30.dirname(fileURLToPath(import.meta.url));
+  const fileDir = path33.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path30.join(fileDir, "wasm"),
+    path33.join(fileDir, "wasm"),
     // dist/index.js → dist/wasm/
-    path30.join(fileDir, "../wasm")
+    path33.join(fileDir, "../wasm")
     // dist/cli/main.js → dist/wasm/
   ];
   for (const candidate of candidates) {
@@ -738,7 +863,7 @@ function wasmPath(lang) {
   }
   const bundled = BUNDLED_WASM_MAP[lang];
   if (bundled) {
-    const bundledPath = path30.join(_bundledWasmDir, bundled);
+    const bundledPath = path33.join(_bundledWasmDir, bundled);
     if (existsSync(bundledPath)) return bundledPath;
   }
   return null;
@@ -751,14 +876,14 @@ async function initParser() {
 }
 async function getLanguage(lang) {
   if (languageCache.has(lang)) return languageCache.get(lang);
-  const path31 = wasmPath(lang);
-  if (!path31) {
+  const path34 = wasmPath(lang);
+  if (!path34) {
     languageCache.set(lang, null);
     return null;
   }
   try {
     await initParser();
-    const language = await Language.load(path31);
+    const language = await Language.load(path34);
     languageCache.set(lang, language);
     return language;
   } catch {
@@ -2183,7 +2308,7 @@ var init_parse_phase = __esm({
           const batch = filePaths.slice(i, i + CONCURRENCY);
           await Promise.all(batch.map(async (filePath) => {
             try {
-              const source = await fs28.promises.readFile(filePath, "utf-8");
+              const source = await fs33.promises.readFile(filePath, "utf-8");
               context2.fileCache.set(filePath, source);
             } catch {
             }
@@ -2196,14 +2321,14 @@ var init_parse_phase = __esm({
           const lang = detectLanguage(filePath);
           if (!lang) {
             if (context2.verbose) {
-              const relativePath2 = path30.relative(context2.workspaceRoot, filePath);
+              const relativePath2 = path33.relative(context2.workspaceRoot, filePath);
               logger_default.info(`  [parse] skipped (no parser): ${relativePath2}`);
             }
             continue;
           }
           const source = context2.fileCache.get(filePath);
           if (!source) continue;
-          const relativePath = path30.relative(context2.workspaceRoot, filePath);
+          const relativePath = path33.relative(context2.workspaceRoot, filePath);
           const fileNodeId = generateNodeId("file", relativePath, relativePath);
           const fileNode = context2.graph.getNode(fileNodeId);
           if (fileNode) {
@@ -2449,11 +2574,11 @@ var init_resolve_phase = __esm({
         let heritageEdges = 0;
         const fileIndex = /* @__PURE__ */ new Map();
         for (const fp of filePaths) {
-          const rel = path30.relative(workspaceRoot, fp);
+          const rel = path33.relative(workspaceRoot, fp);
           fileIndex.set(rel, fp);
           const noExt = rel.replace(/\.\w+$/, "");
           if (!fileIndex.has(noExt)) fileIndex.set(noExt, fp);
-          const base = path30.basename(rel, path30.extname(rel));
+          const base = path33.basename(rel, path33.extname(rel));
           if (!fileIndex.has(base)) fileIndex.set(base, fp);
         }
         const symbolIndex = /* @__PURE__ */ new Map();
@@ -2484,7 +2609,7 @@ var init_resolve_phase = __esm({
         for (const filePath of filePaths) {
           const lang = detectLanguage(filePath);
           if (!lang) continue;
-          const relativePath = path30.relative(workspaceRoot, filePath);
+          const relativePath = path33.relative(workspaceRoot, filePath);
           const fileNodeId = generateNodeId("file", relativePath, relativePath);
           const source = fileCache.get(filePath);
           if (!source) continue;
@@ -2497,13 +2622,13 @@ var init_resolve_phase = __esm({
             let resolvedRelPath = null;
             if (cleaned.startsWith(".")) {
               const cleanedNoJs = cleaned.replace(/\.(js|jsx)$/, "");
-              const fromDir = path30.dirname(relativePath);
+              const fromDir = path33.dirname(relativePath);
               for (const ext of ["", ".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".go", "/index.ts", "/index.js"]) {
-                const candidate = path30.join(fromDir, cleanedNoJs + ext);
-                const normalized = path30.normalize(candidate);
+                const candidate = path33.join(fromDir, cleanedNoJs + ext);
+                const normalized = path33.normalize(candidate);
                 if (fileIndex.has(normalized)) {
                   const absPath = fileIndex.get(normalized);
-                  resolvedRelPath = path30.relative(workspaceRoot, absPath);
+                  resolvedRelPath = path33.relative(workspaceRoot, absPath);
                   break;
                 }
               }
@@ -2968,7 +3093,7 @@ var init_db_manager = __esm({
         this.dbPath = dbPath;
       }
       async init() {
-        fs28.mkdirSync(path30.dirname(this.dbPath), { recursive: true });
+        fs33.mkdirSync(path33.dirname(this.dbPath), { recursive: true });
         this.db = new Database$1(this.dbPath);
         await this.db.init();
         this.conn = new Connection(this.db);
@@ -3058,13 +3183,14 @@ var init_schema = __esm({
       constant: "const_nodes",
       route: "route_nodes",
       cluster: "cluster_nodes",
-      flow: "flow_nodes"
+      flow: "flow_nodes",
+      vulnerability: "vuln_nodes"
     };
     ALL_NODE_TABLES = [...new Set(Object.values(NODE_TABLE_MAP))];
   }
 });
 function writeNodeCSVs(graph, outputDir) {
-  fs28.mkdirSync(outputDir, { recursive: true });
+  fs33.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();
@@ -3072,7 +3198,7 @@ function writeNodeCSVs(graph, outputDir) {
     const table = NODE_TABLE_MAP[node.kind];
     if (!tableBuffers.has(table)) {
       tableBuffers.set(table, [header]);
-      tableFilePaths.set(table, path30.join(outputDir, `${table}.csv`));
+      tableFilePaths.set(table, path33.join(outputDir, `${table}.csv`));
     }
     tableBuffers.get(table).push(
       csvRow([
@@ -3092,12 +3218,12 @@ function writeNodeCSVs(graph, outputDir) {
     );
   }
   for (const [table, lines] of tableBuffers) {
-    fs28.writeFileSync(tableFilePaths.get(table), lines.join(""), "utf-8");
+    fs33.writeFileSync(tableFilePaths.get(table), lines.join(""), "utf-8");
   }
   return tableFilePaths;
 }
 function writeEdgeCSV(graph, outputDir) {
-  fs28.mkdirSync(outputDir, { recursive: true });
+  fs33.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()) {
@@ -3108,7 +3234,7 @@ function writeEdgeCSV(graph, outputDir) {
     const toTable = NODE_TABLE_MAP[targetNode.kind];
     const key = `${fromTable}->${toTable}`;
     if (!groups.has(key)) {
-      const filePath = path30.join(outputDir, `edges_${fromTable}_${toTable}.csv`);
+      const filePath = path33.join(outputDir, `edges_${fromTable}_${toTable}.csv`);
       groups.set(key, { lines: [header], from: fromTable, to: toTable, filePath });
     }
     groups.get(key).lines.push(
@@ -3123,7 +3249,7 @@ function writeEdgeCSV(graph, outputDir) {
   }
   const result = [];
   for (const group of groups.values()) {
-    fs28.writeFileSync(group.filePath, group.lines.join(""), "utf-8");
+    fs33.writeFileSync(group.filePath, group.lines.join(""), "utf-8");
     result.push({ fromTable: group.from, toTable: group.to, filePath: group.filePath });
   }
   return result;
@@ -3166,7 +3292,7 @@ async function loadGraphToDB(graph, dbManager) {
     } catch {
     }
   }
-  const tmpDir = fs28.mkdtempSync(path30.join(os12.tmpdir(), "code-intel-csv-"));
+  const tmpDir = fs33.mkdtempSync(path33.join(os12.tmpdir(), "code-intel-csv-"));
   try {
     const nodeTableFiles = writeNodeCSVs(graph, tmpDir);
     const edgeGroups = writeEdgeCSV(graph, tmpDir);
@@ -3185,8 +3311,8 @@ async function loadGraphToDB(graph, dbManager) {
     }
     let nodeCount = 0;
     for (const [table, csvPath] of nodeTableFiles) {
-      if (!fs28.existsSync(csvPath)) continue;
-      const stat = fs28.statSync(csvPath);
+      if (!fs33.existsSync(csvPath)) continue;
+      const stat = fs33.statSync(csvPath);
       if (stat.size < 50) continue;
       try {
         await dbManager.execute(
@@ -3199,8 +3325,8 @@ async function loadGraphToDB(graph, dbManager) {
     }
     let edgeCount = 0;
     for (const group of edgeGroups) {
-      if (!fs28.existsSync(group.filePath)) continue;
-      const stat = fs28.statSync(group.filePath);
+      if (!fs33.existsSync(group.filePath)) continue;
+      const stat = fs33.statSync(group.filePath);
       if (stat.size < 50) continue;
       try {
         await dbManager.execute(
@@ -3214,7 +3340,7 @@ async function loadGraphToDB(graph, dbManager) {
     return { nodeCount, edgeCount };
   } finally {
     try {
-      fs28.rmSync(tmpDir, { recursive: true, force: true });
+      fs33.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -3316,15 +3442,15 @@ var init_graph_loader = __esm({
 });
 function loadRegistry() {
   try {
-    const data = fs28.readFileSync(REPOS_FILE, "utf-8");
+    const data = fs33.readFileSync(REPOS_FILE, "utf-8");
     return JSON.parse(data);
   } catch {
     return [];
   }
 }
 function saveRegistry(entries) {
-  fs28.mkdirSync(GLOBAL_DIR, { recursive: true });
-  fs28.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
+  fs33.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs33.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
 }
 function upsertRepo(entry) {
   const entries = loadRegistry();
@@ -3343,28 +3469,28 @@ function removeRepo(repoPath) {
 var GLOBAL_DIR, REPOS_FILE;
 var init_repo_registry = __esm({
   "src/storage/repo-registry.ts"() {
-    GLOBAL_DIR = path30.join(os12.homedir(), ".code-intel");
-    REPOS_FILE = path30.join(GLOBAL_DIR, "repos.json");
+    GLOBAL_DIR = path33.join(os12.homedir(), ".code-intel");
+    REPOS_FILE = path33.join(GLOBAL_DIR, "repos.json");
   }
 });
 function saveMetadata(repoDir, metadata) {
-  const metaDir = path30.join(repoDir, ".code-intel");
-  fs28.mkdirSync(metaDir, { recursive: true });
-  fs28.writeFileSync(path30.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
+  const metaDir = path33.join(repoDir, ".code-intel");
+  fs33.mkdirSync(metaDir, { recursive: true });
+  fs33.writeFileSync(path33.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
 }
 function loadMetadata(repoDir) {
   try {
-    const data = fs28.readFileSync(path30.join(repoDir, ".code-intel", "meta.json"), "utf-8");
+    const data = fs33.readFileSync(path33.join(repoDir, ".code-intel", "meta.json"), "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
   }
 }
 function getDbPath(repoDir) {
-  return path30.join(repoDir, ".code-intel", "graph.db");
+  return path33.join(repoDir, ".code-intel", "graph.db");
 }
 function getVectorDbPath(repoDir) {
-  return path30.join(repoDir, ".code-intel", "vector.db");
+  return path33.join(repoDir, ".code-intel", "vector.db");
 }
 var init_metadata = __esm({
   "src/storage/metadata.ts"() {
@@ -3420,27 +3546,27 @@ __export(group_registry_exports, {
   saveSyncResult: () => saveSyncResult
 });
 function groupFile(name) {
-  return path30.join(GROUPS_DIR, `${name}.json`);
+  return path33.join(GROUPS_DIR, `${name}.json`);
 }
 function loadGroup(name) {
   try {
-    return JSON.parse(fs28.readFileSync(groupFile(name), "utf-8"));
+    return JSON.parse(fs33.readFileSync(groupFile(name), "utf-8"));
   } catch {
     return null;
   }
 }
 function saveGroup(group) {
-  fs28.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs28.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
+  fs33.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs33.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
 }
 function listGroups() {
   const groups = [];
   try {
-    for (const file of fs28.readdirSync(GROUPS_DIR)) {
+    for (const file of fs33.readdirSync(GROUPS_DIR)) {
       if (!file.endsWith(".json") || file.endsWith(".sync.json")) continue;
       try {
         const g = JSON.parse(
-          fs28.readFileSync(path30.join(GROUPS_DIR, file), "utf-8")
+          fs33.readFileSync(path33.join(GROUPS_DIR, file), "utf-8")
         );
         groups.push(g);
       } catch {
@@ -3452,16 +3578,16 @@ function listGroups() {
 }
 function deleteGroup(name) {
   try {
-    fs28.unlinkSync(groupFile(name));
+    fs33.unlinkSync(groupFile(name));
   } catch {
   }
   try {
-    fs28.unlinkSync(path30.join(GROUPS_DIR, `${name}.sync.json`));
+    fs33.unlinkSync(path33.join(GROUPS_DIR, `${name}.sync.json`));
   } catch {
   }
 }
 function groupExists(name) {
-  return fs28.existsSync(groupFile(name));
+  return fs33.existsSync(groupFile(name));
 }
 function addMember(groupName, member) {
   const group = loadGroup(groupName);
@@ -3487,16 +3613,16 @@ function removeMember(groupName, groupPath) {
   return group;
 }
 function saveSyncResult(result) {
-  fs28.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs28.writeFileSync(
-    path30.join(GROUPS_DIR, `${result.groupName}.sync.json`),
+  fs33.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs33.writeFileSync(
+    path33.join(GROUPS_DIR, `${result.groupName}.sync.json`),
     JSON.stringify(result, null, 2) + "\n"
   );
 }
 function loadSyncResult(groupName) {
   try {
     return JSON.parse(
-      fs28.readFileSync(path30.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
+      fs33.readFileSync(path33.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
     );
   } catch {
     return null;
@@ -3505,90 +3631,597 @@ function loadSyncResult(groupName) {
 var GROUPS_DIR;
 var init_group_registry = __esm({
   "src/multi-repo/group-registry.ts"() {
-    GROUPS_DIR = path30.join(os12.homedir(), ".code-intel", "groups");
+    GROUPS_DIR = path33.join(os12.homedir(), ".code-intel", "groups");
   }
 });
 
-// src/errors/codes.ts
-var ErrorCodes, AppError;
-var init_codes = __esm({
-  "src/errors/codes.ts"() {
-    ErrorCodes = {
-      UNAUTHORIZED: "CI-1000",
-      FORBIDDEN: "CI-1001",
-      NOT_FOUND: "CI-1002",
-      ANALYSIS_IN_PROGRESS: "CI-1003",
-      INDEX_NOT_FOUND: "CI-1004",
-      DB_CORRUPTED: "CI-1042",
-      RATE_LIMIT_EXCEEDED: "CI-1100",
-      PAYLOAD_TOO_LARGE: "CI-1101",
-      INVALID_REQUEST: "CI-1200",
-      INTERNAL_ERROR: "CI-5000"
-    };
-    AppError = class extends Error {
-      constructor(code, message, hint, statusCode = 500, docs) {
-        super(message);
-        this.code = code;
-        this.hint = hint;
-        this.statusCode = statusCode;
-        this.docs = docs;
-        this.name = "AppError";
+// src/multi-repo/graph-from-db.ts
+function parseRow(row, kind) {
+  return {
+    id: String(row["id"] ?? ""),
+    kind,
+    name: String(row["name"] ?? ""),
+    filePath: String(row["file_path"] ?? ""),
+    startLine: row["start_line"] != null ? Number(row["start_line"]) : void 0,
+    endLine: row["end_line"] != null ? Number(row["end_line"]) : void 0,
+    exported: row["exported"] != null ? Boolean(row["exported"]) : void 0,
+    content: row["content"] ? String(row["content"]) : void 0,
+    metadata: row["metadata"] ? (() => {
+      try {
+        return JSON.parse(String(row["metadata"]));
+      } catch {
+        return void 0;
       }
-      code;
-      hint;
-      statusCode;
-      docs;
-    };
-  }
-});
-function secureMkdir(dir) {
-  fs28.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
-  if (process.platform !== "win32") {
+    })() : void 0
+  };
+}
+async function loadGraphFromDB(graph, db) {
+  for (const table of ALL_NODE_TABLES) {
+    const kind = TABLE_TO_KIND[table];
+    if (!kind) continue;
+    let rows = [];
     try {
-      fs28.chmodSync(dir, SECURE_DIR_MODE);
+      rows = await db.query(`MATCH (n:${table}) RETURN n.id, n.name, n.file_path, n.start_line, n.end_line, n.exported, n.content, n.metadata`);
     } catch {
+      continue;
+    }
+    for (const row of rows) {
+      const node = parseRow({
+        id: row["n.id"],
+        name: row["n.name"],
+        file_path: row["n.file_path"],
+        start_line: row["n.start_line"],
+        end_line: row["n.end_line"],
+        exported: row["n.exported"],
+        content: row["n.content"],
+        metadata: row["n.metadata"]
+      }, kind);
+      if (node.id && node.name) graph.addNode(node);
     }
   }
-}
-function secureChmodFile(file) {
-  if (process.platform === "win32") return;
   try {
-    fs28.chmodSync(file, SECURE_FILE_MODE);
+    const edgeRows = await db.query(
+      `MATCH (a)-[e:code_edges]->(b) RETURN a.id, b.id, e.kind, e.weight, e.label`
+    );
+    for (const row of edgeRows) {
+      const sourceId = String(row["a.id"] ?? "");
+      const targetId = String(row["b.id"] ?? "");
+      const kind = String(row["e.kind"] ?? "");
+      if (!sourceId || !targetId || !kind) continue;
+      const edge = {
+        id: `${sourceId}::${kind}::${targetId}`,
+        source: sourceId,
+        target: targetId,
+        kind,
+        weight: row["e.weight"] != null ? Number(row["e.weight"]) : void 0,
+        label: row["e.label"] ? String(row["e.label"]) : void 0
+      };
+      graph.addEdge(edge);
+    }
   } catch {
   }
 }
-function secureWriteFile(file, data) {
-  secureMkdir(path30.dirname(file));
-  fs28.writeFileSync(file, data, { mode: SECURE_FILE_MODE });
-  secureChmodFile(file);
-}
-function tightenDbFiles(dir) {
-  if (process.platform === "win32") return;
-  if (!fs28.existsSync(dir)) return;
-  for (const name of fs28.readdirSync(dir)) {
-    if (name.endsWith(".db") || name.endsWith(".db-wal") || name.endsWith(".db-shm")) {
-      try {
-        fs28.chmodSync(path30.join(dir, name), SECURE_FILE_MODE);
-      } catch {
+var TABLE_TO_KIND;
+var init_graph_from_db = __esm({
+  "src/multi-repo/graph-from-db.ts"() {
+    init_schema();
+    TABLE_TO_KIND = Object.fromEntries(
+      Object.entries(NODE_TABLE_MAP).map(([kind, table]) => [table, kind])
+    );
+  }
+});
+function scanForFiles(root, matcher, maxDepth = 2) {
+  const results = [];
+  function walk2(dir, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = fs33.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path33.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)) {
+        results.push(full);
       }
     }
   }
+  walk2(root, 0);
+  return results;
 }
-var SECURE_DIR_MODE, SECURE_FILE_MODE;
-var init_fs_secure = __esm({
-  "src/shared/fs-secure.ts"() {
-    SECURE_DIR_MODE = 448;
-    SECURE_FILE_MODE = 384;
+var init_file_scanner = __esm({
+  "src/multi-repo/schema-parsers/file-scanner.ts"() {
   }
 });
-function getUsersDBPath() {
-  return process.env["CODE_INTEL_USERS_DB_PATH"] ?? path30.join(os12.homedir(), ".code-intel", "users.db");
+function tryParseFile(filePath) {
+  const ext = path33.extname(filePath).toLowerCase();
+  const content = fs33.readFileSync(filePath, "utf-8");
+  if (ext === ".json") {
+    try {
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  return null;
 }
-function getOrCreateUsersDB() {
-  if (!_usersDB) {
-    _usersDB = new UsersDB(getUsersDBPath());
+async function parseOpenAPIContracts(repoRoot) {
+  const files = scanForFiles(repoRoot, (name) => OPENAPI_FILENAMES.has(name));
+  const contracts = [];
+  for (const filePath of files) {
+    const spec = tryParseFile(filePath);
+    if (!spec) continue;
+    const paths = spec["paths"];
+    if (!paths || typeof paths !== "object") continue;
+    for (const [pathStr, pathItem] of Object.entries(paths)) {
+      if (!pathItem || typeof pathItem !== "object") continue;
+      const ops = pathItem;
+      for (const method of HTTP_METHODS) {
+        if (!(method in ops)) continue;
+        const operation = ops[method];
+        if (!operation) continue;
+        const requestBody = operation["requestBody"];
+        const requestSchema = requestBody?.["content"] ? requestBody["content"]["application/json"]?.["schema"] : void 0;
+        const responses = operation["responses"];
+        const ok200 = responses?.["200"];
+        const responseSchema = ok200?.["content"] ? ok200["content"]["application/json"]?.["schema"] : void 0;
+        contracts.push({
+          name: `${method.toUpperCase()} ${pathStr}`,
+          kind: "route",
+          method: method.toUpperCase(),
+          path: pathStr,
+          ...requestSchema ? { requestSchema } : {},
+          ...responseSchema ? { responseSchema } : {},
+          filePath
+        });
+      }
+    }
   }
-  return _usersDB;
+  return contracts;
+}
+var OPENAPI_FILENAMES, HTTP_METHODS;
+var init_openapi_parser = __esm({
+  "src/multi-repo/schema-parsers/openapi-parser.ts"() {
+    init_file_scanner();
+    OPENAPI_FILENAMES = /* @__PURE__ */ new Set([
+      "openapi.yaml",
+      "openapi.json",
+      "openapi.yml",
+      "swagger.yaml",
+      "swagger.json",
+      "swagger.yml"
+    ]);
+    HTTP_METHODS = ["get", "post", "put", "patch", "delete", "head", "options"];
+  }
+});
+function extractFieldNames(block) {
+  return block.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => {
+    const m = line.match(/^(\w+)\s*[(:]/);
+    return m ? m[1] : null;
+  }).filter((f) => f !== null);
+}
+async function parseGraphQLContracts(repoRoot) {
+  const files = scanForFiles(repoRoot, (name) => name.endsWith(".graphql") || name.endsWith(".gql"));
+  const contracts = [];
+  for (const filePath of files) {
+    const content = fs33.readFileSync(filePath, "utf-8");
+    const typeRegex = /type\s+(\w+)\s*\{([^}]+)\}/g;
+    let match;
+    while ((match = typeRegex.exec(content)) !== null) {
+      const typeName = match[1];
+      const body = match[2];
+      const fields = extractFieldNames(body);
+      const lcName = typeName.toLowerCase();
+      if (lcName === "query") {
+        for (const field of fields) {
+          contracts.push({ name: `query.${field}`, kind: "graphql", operation: "query", fields, filePath });
+        }
+      } else if (lcName === "mutation") {
+        for (const field of fields) {
+          contracts.push({ name: `mutation.${field}`, kind: "graphql", operation: "mutation", fields, filePath });
+        }
+      } else if (lcName === "subscription") {
+        for (const field of fields) {
+          contracts.push({ name: `subscription.${field}`, kind: "graphql", operation: "subscription", fields, filePath });
+        }
+      } else {
+        contracts.push({ name: `type.${typeName}`, kind: "graphql", operation: "type", fields, filePath });
+      }
+    }
+  }
+  return contracts;
+}
+var init_graphql_parser = __esm({
+  "src/multi-repo/schema-parsers/graphql-parser.ts"() {
+    init_file_scanner();
+  }
+});
+async function parseProtoContracts(repoRoot) {
+  const files = scanForFiles(repoRoot, (name) => name.endsWith(".proto"));
+  const contracts = [];
+  for (const filePath of files) {
+    const content = fs33.readFileSync(filePath, "utf-8");
+    const serviceRegex = /service\s+(\w+)\s*\{([^}]+)\}/g;
+    let serviceMatch;
+    while ((serviceMatch = serviceRegex.exec(content)) !== null) {
+      const serviceName = serviceMatch[1];
+      const body = serviceMatch[2];
+      const rpcRegex = /rpc\s+(\w+)\s*\((\w+)\)\s*returns\s*\((\w+)\)/g;
+      let rpcMatch;
+      while ((rpcMatch = rpcRegex.exec(body)) !== null) {
+        const rpcName = rpcMatch[1];
+        const inputType = rpcMatch[2];
+        const outputType = rpcMatch[3];
+        contracts.push({
+          name: `${serviceName}.${rpcName}`,
+          kind: "grpc",
+          serviceName,
+          rpcName,
+          inputType,
+          outputType,
+          filePath
+        });
+      }
+    }
+  }
+  return contracts;
+}
+var init_proto_parser = __esm({
+  "src/multi-repo/schema-parsers/proto-parser.ts"() {
+    init_file_scanner();
+  }
+});
+
+// src/multi-repo/type-similarity.ts
+function normalizeType(t) {
+  return t.toLowerCase().replace(/[\[\]?<>\s]/g, "").trim();
+}
+function paramTypeSimilarity(paramsA, paramsB) {
+  if (paramsA.length === 0 && paramsB.length === 0) return 1;
+  if (paramsA.length === 0 || paramsB.length === 0) return 0;
+  const setA = new Set(paramsA.map((p) => normalizeType(p.type ?? "")).filter(Boolean));
+  const setB = new Set(paramsB.map((p) => normalizeType(p.type ?? "")).filter(Boolean));
+  if (setA.size === 0 && setB.size === 0) return 1;
+  if (setA.size === 0 || setB.size === 0) return 0;
+  const intersection = [...setA].filter((x) => setB.has(x)).length;
+  const union = (/* @__PURE__ */ new Set([...setA, ...setB])).size;
+  return intersection / union;
+}
+function returnTypeSimilarity(typeA, typeB) {
+  if (!typeA || !typeB) return 0.5;
+  const a = normalizeType(typeA);
+  const b = normalizeType(typeB);
+  if (a === b) return 1;
+  const compatible = [
+    ["string", "str"],
+    ["number", "int"],
+    ["number", "float"],
+    ["number", "double"],
+    ["boolean", "bool"],
+    ["void", "unit"],
+    ["void", "none"]
+  ];
+  for (const [x, y] of compatible) {
+    if (a === x && b === y || a === y && b === x) return 0.8;
+  }
+  return 0;
+}
+function paramCountSimilarity(countA, countB) {
+  const maxCount = Math.max(countA, countB, 1);
+  return 1 - Math.abs(countA - countB) / maxCount;
+}
+function computeContractSimilarity(a, b, nameSim) {
+  const paramsA = a.parameters ?? [];
+  const paramsB = b.parameters ?? [];
+  const ptSim = paramTypeSimilarity(paramsA, paramsB);
+  const rtSim = returnTypeSimilarity(a.returnType, b.returnType);
+  const pcSim = paramCountSimilarity(paramsA.length, paramsB.length);
+  let score = 0.4 * nameSim + 0.3 * ptSim + 0.2 * rtSim + 0.1 * pcSim;
+  if (ptSim > 0.8) {
+    score = Math.min(1, score * 1.2);
+  }
+  return score;
+}
+var init_type_similarity = __esm({
+  "src/multi-repo/type-similarity.ts"() {
+  }
+});
+
+// src/multi-repo/group-sync.ts
+var group_sync_exports = {};
+__export(group_sync_exports, {
+  syncGroup: () => syncGroup
+});
+function extractContracts(graph, repoName, repoPath) {
+  const contracts = [];
+  for (const node of graph.allNodes()) {
+    if (node.exported === true && ["function", "class", "interface", "method", "type_alias", "constant", "enum", "struct", "trait"].includes(node.kind)) {
+      contracts.push({
+        repoName,
+        repoPath,
+        kind: "export",
+        name: node.name,
+        nodeId: node.id,
+        nodeKind: node.kind,
+        filePath: node.filePath,
+        signature: node.content?.split("\n")[0]?.trim(),
+        parameters: node.metadata?.parameters ?? node.metadata?.params,
+        returnType: node.metadata?.returnType,
+        exported: node.exported
+      });
+    }
+    if (node.kind === "route") {
+      contracts.push({
+        repoName,
+        repoPath,
+        kind: "route",
+        name: node.name,
+        nodeId: node.id,
+        nodeKind: node.kind,
+        filePath: node.filePath,
+        signature: node.content?.split("\n")[0]?.trim()
+      });
+    }
+    if (["interface", "type_alias"].includes(node.kind)) {
+      const nameLower = node.name.toLowerCase();
+      if (nameLower.includes("event") || nameLower.includes("message")) {
+        contracts.push({
+          repoName,
+          repoPath,
+          kind: "event",
+          name: node.name,
+          nodeId: node.id,
+          nodeKind: node.kind,
+          filePath: node.filePath
+        });
+      } else if (nameLower.includes("schema") || nameLower.includes("dto") || nameLower.includes("request") || nameLower.includes("response")) {
+        contracts.push({
+          repoName,
+          repoPath,
+          kind: "schema",
+          name: node.name,
+          nodeId: node.id,
+          nodeKind: node.kind,
+          filePath: node.filePath
+        });
+      }
+    }
+  }
+  return contracts;
+}
+function matchContracts(allContracts) {
+  const links = [];
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const c of allContracts) {
+    const arr = byRepo.get(c.repoName) ?? [];
+    arr.push(c);
+    byRepo.set(c.repoName, arr);
+  }
+  const repoNames = [...byRepo.keys()];
+  for (let i = 0; i < repoNames.length; i++) {
+    for (let j = 0; j < repoNames.length; j++) {
+      if (i === j) continue;
+      const providerContracts = byRepo.get(repoNames[i]);
+      const consumerContracts = byRepo.get(repoNames[j]);
+      const consumerByName = /* @__PURE__ */ new Map();
+      for (const c of consumerContracts) consumerByName.set(c.name, c);
+      for (const provider of providerContracts) {
+        const consumer = consumerByName.get(provider.name);
+        if (consumer) {
+          const sameKind = provider.kind === consumer.kind;
+          const typedScore = computeContractSimilarity(provider, consumer, 1);
+          const confidence = sameKind ? Math.max(typedScore, 0.9) : Math.max(typedScore, 0.6);
+          links.push({
+            providerRepo: provider.repoName,
+            providerContract: provider.name,
+            consumerRepo: consumer.repoName,
+            consumerContract: consumer.name,
+            matchKind: provider.kind === "route" ? "route-match" : "name-match",
+            confidence: Math.min(1, confidence)
+          });
+        } else {
+          const providerLC = provider.name.toLowerCase();
+          for (const c of consumerContracts) {
+            if (c.name.toLowerCase().includes(providerLC) || providerLC.includes(c.name.toLowerCase())) {
+              if (c.name.length >= 4 && provider.name.length >= 4) {
+                links.push({
+                  providerRepo: provider.repoName,
+                  providerContract: provider.name,
+                  consumerRepo: c.repoName,
+                  consumerContract: c.name,
+                  matchKind: "name-match",
+                  confidence: 0.4
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    const key = `${link.providerRepo}:${link.providerContract}:${link.consumerRepo}:${link.consumerContract}`;
+    const existing = seen.get(key);
+    if (!existing || link.confidence > existing.confidence) {
+      seen.set(key, link);
+    }
+  }
+  return [...seen.values()].sort((a, b) => b.confidence - a.confidence);
+}
+async function syncGroup(group) {
+  const registry = loadRegistry();
+  const allContracts = [];
+  for (const member of group.members) {
+    const regEntry = registry.find((r) => r.name === member.registryName);
+    if (!regEntry) {
+      logger_default.warn(`  \u26A0 Registry entry "${member.registryName}" not found \u2014 skipping ${member.groupPath}`);
+      continue;
+    }
+    const dbPath = path33.join(regEntry.path, ".code-intel", "graph.db");
+    if (!fs33.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);
+    try {
+      await db.init();
+      await loadGraphFromDB(graph, db);
+      db.close();
+    } catch (err) {
+      db.close();
+      logger_default.warn(`  \u26A0 Could not load graph for "${member.registryName}": ${err instanceof Error ? err.message : err}`);
+      continue;
+    }
+    const contracts = extractContracts(graph, member.registryName, regEntry.path);
+    const [openapiContracts, graphqlContracts, protoContracts] = await Promise.all([
+      parseOpenAPIContracts(regEntry.path).catch(() => []),
+      parseGraphQLContracts(regEntry.path).catch(() => []),
+      parseProtoContracts(regEntry.path).catch(() => [])
+    ]);
+    for (const c of openapiContracts) {
+      contracts.push({
+        repoName: member.registryName,
+        repoPath: regEntry.path,
+        kind: "route",
+        name: c.name,
+        nodeId: `openapi:${c.method}:${c.path}`,
+        nodeKind: "route",
+        filePath: c.filePath
+      });
+    }
+    for (const c of graphqlContracts) {
+      contracts.push({
+        repoName: member.registryName,
+        repoPath: regEntry.path,
+        kind: "graphql",
+        name: c.name,
+        nodeId: `graphql:${c.name}`,
+        nodeKind: "graphql",
+        filePath: c.filePath
+      });
+    }
+    for (const c of protoContracts) {
+      contracts.push({
+        repoName: member.registryName,
+        repoPath: regEntry.path,
+        kind: "grpc",
+        name: c.name,
+        nodeId: `grpc:${c.serviceName}:${c.rpcName}`,
+        nodeKind: "grpc",
+        filePath: c.filePath
+      });
+    }
+    logger_default.info(`  \u2713 ${member.registryName} (${member.groupPath}): ${contracts.length} contracts`);
+    allContracts.push(...contracts);
+  }
+  const links = matchContracts(allContracts);
+  return {
+    groupName: group.name,
+    syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    memberCount: group.members.length,
+    contracts: allContracts,
+    links
+  };
+}
+var init_group_sync = __esm({
+  "src/multi-repo/group-sync.ts"() {
+    init_repo_registry();
+    init_db_manager();
+    init_knowledge_graph();
+    init_graph_from_db();
+    init_logger();
+    init_openapi_parser();
+    init_graphql_parser();
+    init_proto_parser();
+    init_type_similarity();
+  }
+});
+
+// src/errors/codes.ts
+var ErrorCodes, AppError;
+var init_codes = __esm({
+  "src/errors/codes.ts"() {
+    ErrorCodes = {
+      UNAUTHORIZED: "CI-1000",
+      FORBIDDEN: "CI-1001",
+      NOT_FOUND: "CI-1002",
+      ANALYSIS_IN_PROGRESS: "CI-1003",
+      INDEX_NOT_FOUND: "CI-1004",
+      DB_CORRUPTED: "CI-1042",
+      RATE_LIMIT_EXCEEDED: "CI-1100",
+      PAYLOAD_TOO_LARGE: "CI-1101",
+      INVALID_REQUEST: "CI-1200",
+      INTERNAL_ERROR: "CI-5000"
+    };
+    AppError = class extends Error {
+      constructor(code, message, hint, statusCode = 500, docs) {
+        super(message);
+        this.code = code;
+        this.hint = hint;
+        this.statusCode = statusCode;
+        this.docs = docs;
+        this.name = "AppError";
+      }
+      code;
+      hint;
+      statusCode;
+      docs;
+    };
+  }
+});
+function secureMkdir(dir) {
+  fs33.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
+  if (process.platform !== "win32") {
+    try {
+      fs33.chmodSync(dir, SECURE_DIR_MODE);
+    } catch {
+    }
+  }
+}
+function secureChmodFile(file) {
+  if (process.platform === "win32") return;
+  try {
+    fs33.chmodSync(file, SECURE_FILE_MODE);
+  } catch {
+  }
+}
+function secureWriteFile(file, data) {
+  secureMkdir(path33.dirname(file));
+  fs33.writeFileSync(file, data, { mode: SECURE_FILE_MODE });
+  secureChmodFile(file);
+}
+function tightenDbFiles(dir) {
+  if (process.platform === "win32") return;
+  if (!fs33.existsSync(dir)) return;
+  for (const name of fs33.readdirSync(dir)) {
+    if (name.endsWith(".db") || name.endsWith(".db-wal") || name.endsWith(".db-shm")) {
+      try {
+        fs33.chmodSync(path33.join(dir, name), SECURE_FILE_MODE);
+      } catch {
+      }
+    }
+  }
+}
+var SECURE_DIR_MODE, SECURE_FILE_MODE;
+var init_fs_secure = __esm({
+  "src/shared/fs-secure.ts"() {
+    SECURE_DIR_MODE = 448;
+    SECURE_FILE_MODE = 384;
+  }
+});
+function getUsersDBPath() {
+  return process.env["CODE_INTEL_USERS_DB_PATH"] ?? path33.join(os12.homedir(), ".code-intel", "users.db");
+}
+function getOrCreateUsersDB() {
+  if (!_usersDB) {
+    _usersDB = new UsersDB(getUsersDBPath());
+  }
+  return _usersDB;
 }
 var BCRYPT_ROUNDS, UsersDB, _usersDB;
 var init_users_db = __esm({
@@ -3598,7 +4231,7 @@ var init_users_db = __esm({
     UsersDB = class {
       db;
       constructor(dbPath) {
-        const dir = path30.dirname(dbPath);
+        const dir = path33.dirname(dbPath);
         secureMkdir(dir);
         this.db = new Database(dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -3875,7 +4508,7 @@ function getScryptN() {
   return Number.isInteger(v) && v >= 1024 ? v : 1 << 14;
 }
 function getSecretsPath() {
-  return process.env["CODE_INTEL_SECRETS_PATH"] ?? path30.join(os12.homedir(), ".code-intel", ".secrets");
+  return process.env["CODE_INTEL_SECRETS_PATH"] ?? path33.join(os12.homedir(), ".code-intel", ".secrets");
 }
 function getMasterPassword() {
   const fromEnv = process.env["CODE_INTEL_SECRET_KEY"];
@@ -3917,12 +4550,12 @@ function decryptSecrets(encrypted) {
   return JSON.parse(plaintext.toString("utf8"));
 }
 function loadSecrets(secretsPath = getSecretsPath()) {
-  if (!fs28.existsSync(secretsPath)) return {};
-  const blob = fs28.readFileSync(secretsPath);
+  if (!fs33.existsSync(secretsPath)) return {};
+  const blob = fs33.readFileSync(secretsPath);
   return decryptSecrets(blob);
 }
 function saveSecrets(blob, secretsPath = getSecretsPath()) {
-  secureMkdir(path30.dirname(secretsPath));
+  secureMkdir(path33.dirname(secretsPath));
   const encrypted = encryptSecrets(blob);
   secureWriteFile(secretsPath, encrypted);
   secureChmodFile(secretsPath);
@@ -4056,6 +4689,9 @@ function requireAuth(req, res, next) {
   }
   next();
 }
+function meetsRole(userRole, required) {
+  return (ROLE_RANK[userRole] ?? 0) >= (ROLE_RANK[required] ?? 0);
+}
 function requireRole(...roles) {
   return (req, res, next) => {
     if (!req.user) {
@@ -4070,7 +4706,8 @@ function requireRole(...roles) {
       });
       return;
     }
-    if (!roles.includes(req.user.role)) {
+    const allowed = roles.some((r) => meetsRole(req.user.role, r));
+    if (!allowed) {
       res.status(403).json({
         error: {
           code: ErrorCodes.FORBIDDEN,
@@ -4179,7 +4816,7 @@ function clearSessionCookie() {
 async function verifyPassword(plain, hash) {
   return bcrypt.compare(plain, hash);
 }
-var sessionStore, SESSION_COOKIE_NAME;
+var sessionStore, SESSION_COOKIE_NAME, ROLE_RANK;
 var init_middleware = __esm({
   "src/auth/middleware.ts"() {
     init_users_db();
@@ -4187,6 +4824,12 @@ var init_middleware = __esm({
     init_secret_store();
     sessionStore = /* @__PURE__ */ new Map();
     SESSION_COOKIE_NAME = "code_intel_session";
+    ROLE_RANK = {
+      viewer: 1,
+      "repo-owner": 2,
+      analyst: 3,
+      admin: 4
+    };
   }
 });
 
@@ -5267,6 +5910,117 @@ var init_websocket_server = __esm({
   }
 });
 
+// src/query/pr-impact.ts
+var pr_impact_exports = {};
+__export(pr_impact_exports, {
+  computePRImpact: () => computePRImpact,
+  parseDiffFiles: () => parseDiffFiles
+});
+function parseDiffFiles(diff) {
+  const files = [];
+  for (const line of diff.split("\n")) {
+    const match = line.match(/^\+\+\+ b\/(.+)/);
+    if (match) {
+      files.push(match[1]);
+    }
+  }
+  return files;
+}
+function computePRImpact(graph, changedFiles, maxHops) {
+  const changedSymbolIds = /* @__PURE__ */ new Set();
+  for (const node of graph.allNodes()) {
+    if (!node.filePath) continue;
+    for (const changedFile of changedFiles) {
+      if (node.filePath === changedFile || node.filePath.endsWith(changedFile) || changedFile.endsWith(node.filePath)) {
+        changedSymbolIds.add(node.id);
+        break;
+      }
+    }
+  }
+  const allBlastRadiusNodes = /* @__PURE__ */ new Set();
+  const changedSymbols = [];
+  for (const symbolId of changedSymbolIds) {
+    const symbolNode = graph.getNode(symbolId);
+    if (!symbolNode) continue;
+    const blastRadius = /* @__PURE__ */ new Set();
+    const queue = [{ id: symbolId, depth: 0 }];
+    const visited = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const { id, depth } = queue.shift();
+      if (visited.has(id) || depth > maxHops) continue;
+      visited.add(id);
+      if (id !== symbolId) blastRadius.add(id);
+      for (const edge of graph.findEdgesTo(id)) {
+        if (edge.kind === "calls" || edge.kind === "imports") {
+          queue.push({ id: edge.source, depth: depth + 1 });
+        }
+      }
+    }
+    for (const id of blastRadius) allBlastRadiusNodes.add(id);
+    const blastCount = blastRadius.size;
+    let risk;
+    if (blastCount > 50) {
+      risk = "HIGH";
+    } else if (blastCount >= 10) {
+      risk = "MEDIUM";
+    } else {
+      risk = "LOW";
+    }
+    let callerCount = 0;
+    for (const edge of graph.findEdgesTo(symbolId)) {
+      if (edge.kind === "calls") callerCount++;
+    }
+    let testCoverage = false;
+    for (const edge of graph.findEdgesTo(symbolId)) {
+      if (edge.kind === "imports") {
+        const callerNode = graph.getNode(edge.source);
+        if (callerNode?.filePath && (callerNode.filePath.includes(".test.") || callerNode.filePath.includes(".spec."))) {
+          testCoverage = true;
+          break;
+        }
+      }
+    }
+    changedSymbols.push({ name: symbolNode.name, risk, callerCount, testCoverage });
+  }
+  const impactedSymbols = [];
+  for (const id of allBlastRadiusNodes) {
+    if (changedSymbolIds.has(id)) continue;
+    const node = graph.getNode(id);
+    if (node) {
+      impactedSymbols.push({ name: node.name, filePath: node.filePath });
+    }
+  }
+  const riskSummary = { HIGH: 0, MEDIUM: 0, LOW: 0 };
+  for (const s of changedSymbols) {
+    riskSummary[s.risk]++;
+  }
+  const coverageGaps = [];
+  for (const s of changedSymbols) {
+    if ((s.risk === "HIGH" || s.risk === "MEDIUM") && !s.testCoverage) {
+      coverageGaps.push(`${s.name} has no test coverage`);
+    }
+  }
+  const fileImpactCount = /* @__PURE__ */ new Map();
+  for (const sym of impactedSymbols) {
+    if (sym.filePath) {
+      fileImpactCount.set(sym.filePath, (fileImpactCount.get(sym.filePath) ?? 0) + 1);
+    }
+  }
+  const filesToReview = [...fileImpactCount.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([fp]) => fp);
+  return {
+    changedSymbols,
+    impactedSymbols,
+    riskSummary,
+    coverageGaps,
+    filesToReview,
+    crossRepoImpact: null
+  };
+}
+var init_pr_impact = __esm({
+  "src/query/pr-impact.ts"() {
+  }
+});
+
 // src/health/dead-code.ts
 function detectDeadCode(graph) {
   const results = [];
@@ -5516,9 +6270,9 @@ var init_orphan_files = __esm({
 // src/health/health-score.ts
 var health_score_exports = {};
 __export(health_score_exports, {
-  computeHealthReport: () => computeHealthReport
+  computeHealthReport: () => computeHealthReport2
 });
-function computeHealthReport(graph, godNodeConfig) {
+function computeHealthReport2(graph, godNodeConfig) {
   const deadCode = detectDeadCode(graph);
   const cycles = detectCircularDeps(graph);
   const godNodes = detectGodNodes(graph, godNodeConfig);
@@ -5622,10 +6376,10 @@ var init_file_watcher = __esm({
       }
       // ── private ─────────────────────────────────────────────────────────────────
       readCodeIntelIgnore() {
-        const ignoreFile = path30.join(this.workspaceRoot, ".codeintelignore");
+        const ignoreFile = path33.join(this.workspaceRoot, ".codeintelignore");
         try {
-          if (!fs28.existsSync(ignoreFile)) return [];
-          return fs28.readFileSync(ignoreFile, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+          if (!fs33.existsSync(ignoreFile)) return [];
+          return fs33.readFileSync(ignoreFile, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
         } catch {
           return [];
         }
@@ -5677,7 +6431,7 @@ var init_incremental_indexer = __esm({
         }
         const nodeIdsToRemove = /* @__PURE__ */ new Set();
         for (const absPath of changedFiles) {
-          const relPath2 = path30.relative(workspaceRoot, absPath);
+          const relPath2 = path33.relative(workspaceRoot, absPath);
           for (const id of nodesByFilePath.get(relPath2) ?? []) nodeIdsToRemove.add(id);
           for (const id of nodesByFilePath.get(absPath) ?? []) nodeIdsToRemove.add(id);
         }
@@ -5685,12 +6439,12 @@ var init_incremental_indexer = __esm({
           graph.removeNodeCascade(id);
           nodesRemoved++;
         }
-        if (fs28.existsSync(dbPath)) {
+        if (fs33.existsSync(dbPath)) {
           try {
             const db = new DbManager(dbPath);
             await db.init();
             for (const absPath of changedFiles) {
-              const relPath2 = path30.relative(workspaceRoot, absPath);
+              const relPath2 = path33.relative(workspaceRoot, absPath);
               await removeNodesForFile(relPath2, db);
             }
             db.close();
@@ -5700,7 +6454,7 @@ var init_incremental_indexer = __esm({
         }
         const existingFiles = changedFiles.filter((f) => {
           try {
-            return fs28.statSync(f).isFile();
+            return fs33.statSync(f).isFile();
           } catch {
             return false;
           }
@@ -5722,13 +6476,13 @@ var init_incremental_indexer = __esm({
           await runPipeline([noopScan, parsePhase, resolvePhase], context2);
         }
         const nodesAdded = Math.max(0, graph.size.nodes - (nodesBeforeParse - nodesRemoved));
-        if (fs28.existsSync(dbPath) && existingFiles.length > 0) {
+        if (fs33.existsSync(dbPath) && existingFiles.length > 0) {
           try {
             const db = new DbManager(dbPath);
             await db.init();
-            const changedRelPaths = new Set(changedFiles.map((f) => path30.relative(workspaceRoot, f)));
+            const changedRelPaths = new Set(changedFiles.map((f) => path33.relative(workspaceRoot, f)));
             const nodesToUpsert = [...graph.allNodes()].filter(
-              (n) => changedRelPaths.has(n.filePath) || changedRelPaths.has(path30.relative(workspaceRoot, n.filePath))
+              (n) => changedRelPaths.has(n.filePath) || changedRelPaths.has(path33.relative(workspaceRoot, n.filePath))
             );
             await upsertNodes(nodesToUpsert, db);
             db.close();
@@ -5759,35 +6513,35 @@ __export(saved_queries_exports, {
   saveQuery: () => saveQuery
 });
 function getQueriesDir(workspaceRoot) {
-  return path30.join(workspaceRoot, ".code-intel", "queries");
+  return path33.join(workspaceRoot, ".code-intel", "queries");
 }
 function ensureQueriesDir(workspaceRoot) {
   const dir = getQueriesDir(workspaceRoot);
-  if (!fs28.existsSync(dir)) {
-    fs28.mkdirSync(dir, { recursive: true });
+  if (!fs33.existsSync(dir)) {
+    fs33.mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 function saveQuery(workspaceRoot, name, gql) {
   const dir = ensureQueriesDir(workspaceRoot);
-  const filePath = path30.join(dir, `${name}.gql`);
-  fs28.writeFileSync(filePath, gql, "utf-8");
+  const filePath = path33.join(dir, `${name}.gql`);
+  fs33.writeFileSync(filePath, gql, "utf-8");
 }
 function loadQuery(workspaceRoot, name) {
   const dir = getQueriesDir(workspaceRoot);
-  const filePath = path30.join(dir, `${name}.gql`);
-  if (!fs28.existsSync(filePath)) return null;
-  return fs28.readFileSync(filePath, "utf-8");
+  const filePath = path33.join(dir, `${name}.gql`);
+  if (!fs33.existsSync(filePath)) return null;
+  return fs33.readFileSync(filePath, "utf-8");
 }
 function listQueries(workspaceRoot) {
   const dir = getQueriesDir(workspaceRoot);
-  if (!fs28.existsSync(dir)) return [];
-  const files = fs28.readdirSync(dir).filter((f) => f.endsWith(".gql"));
+  if (!fs33.existsSync(dir)) return [];
+  const files = fs33.readdirSync(dir).filter((f) => f.endsWith(".gql"));
   return files.map((f) => {
-    const filePath = path30.join(dir, f);
+    const filePath = path33.join(dir, f);
     const name = f.replace(/\.gql$/, "");
-    const content = fs28.readFileSync(filePath, "utf-8");
-    const stat = fs28.statSync(filePath);
+    const content = fs33.readFileSync(filePath, "utf-8");
+    const stat = fs33.statSync(filePath);
     return {
       name,
       content,
@@ -5798,146 +6552,85 @@ function listQueries(workspaceRoot) {
 }
 function deleteQuery(workspaceRoot, name) {
   const dir = getQueriesDir(workspaceRoot);
-  const filePath = path30.join(dir, `${name}.gql`);
-  if (!fs28.existsSync(filePath)) return false;
-  fs28.unlinkSync(filePath);
+  const filePath = path33.join(dir, `${name}.gql`);
+  if (!fs33.existsSync(filePath)) return false;
+  fs33.unlinkSync(filePath);
   return true;
 }
 function queryExists(workspaceRoot, name) {
   const dir = getQueriesDir(workspaceRoot);
-  const filePath = path30.join(dir, `${name}.gql`);
-  return fs28.existsSync(filePath);
+  const filePath = path33.join(dir, `${name}.gql`);
+  return fs33.existsSync(filePath);
 }
 var init_saved_queries = __esm({
   "src/query/saved-queries.ts"() {
   }
 });
 
-// src/cli/main.ts
-init_logger();
-
-// src/graph/knowledge-graph.ts
-function createKnowledgeGraph() {
-  const nodes = /* @__PURE__ */ new Map();
-  const edges = /* @__PURE__ */ new Map();
-  const edgesByKind = /* @__PURE__ */ new Map();
-  const edgesFromNode = /* @__PURE__ */ new Map();
-  const edgesToNode = /* @__PURE__ */ new Map();
-  function indexEdge(edge) {
-    let kindSet = edgesByKind.get(edge.kind);
-    if (!kindSet) {
-      kindSet = /* @__PURE__ */ new Set();
-      edgesByKind.set(edge.kind, kindSet);
-    }
-    kindSet.add(edge.id);
-    let fromSet = edgesFromNode.get(edge.source);
-    if (!fromSet) {
-      fromSet = /* @__PURE__ */ new Set();
-      edgesFromNode.set(edge.source, fromSet);
-    }
-    fromSet.add(edge.id);
-    let toSet = edgesToNode.get(edge.target);
-    if (!toSet) {
-      toSet = /* @__PURE__ */ new Set();
-      edgesToNode.set(edge.target, toSet);
-    }
-    toSet.add(edge.id);
-  }
-  function unindexEdge(edge) {
-    edgesByKind.get(edge.kind)?.delete(edge.id);
-    edgesFromNode.get(edge.source)?.delete(edge.id);
-    edgesToNode.get(edge.target)?.delete(edge.id);
-  }
-  return {
-    addNode(node) {
-      nodes.set(node.id, node);
-    },
-    addEdge(edge) {
-      edges.set(edge.id, edge);
-      indexEdge(edge);
-    },
-    getNode(id) {
-      return nodes.get(id);
-    },
-    getEdge(id) {
-      return edges.get(id);
-    },
-    *findEdgesByKind(kind) {
-      const ids = edgesByKind.get(kind);
-      if (!ids) return;
-      for (const id of ids) {
-        const edge = edges.get(id);
-        if (edge) yield edge;
-      }
-    },
-    *findEdgesFrom(sourceId) {
-      const ids = edgesFromNode.get(sourceId);
-      if (!ids) return;
-      for (const id of ids) {
-        const edge = edges.get(id);
-        if (edge) yield edge;
-      }
-    },
-    *findEdgesTo(targetId) {
-      const ids = edgesToNode.get(targetId);
-      if (!ids) return;
-      for (const id of ids) {
-        const edge = edges.get(id);
-        if (edge) yield edge;
-      }
-    },
-    removeNodeCascade(id) {
-      const fromEdges = edgesFromNode.get(id);
-      if (fromEdges) {
-        for (const edgeId of [...fromEdges]) {
-          const edge = edges.get(edgeId);
-          if (edge) {
-            unindexEdge(edge);
-            edges.delete(edgeId);
+// src/cli/sarif-builder.ts
+var sarif_builder_exports = {};
+__export(sarif_builder_exports, {
+  buildSARIF: () => buildSARIF
+});
+function buildSARIF(result, version) {
+  const results = [];
+  for (const sym of result.changedSymbols) {
+    if (sym.risk !== "HIGH" && sym.risk !== "MEDIUM") continue;
+    const ruleId = sym.risk === "HIGH" ? "HIGH-RISK-SYMBOL" : "MEDIUM-RISK-SYMBOL";
+    const level = sym.risk === "HIGH" ? "error" : "warning";
+    const uri = result.filesToReview[0] ?? "unknown";
+    results.push({
+      ruleId,
+      level,
+      message: {
+        text: `${sym.name} has blast radius of ${sym.callerCount} callers (${sym.risk} risk)`
+      },
+      locations: [
+        {
+          physicalLocation: {
+            artifactLocation: { uri },
+            region: { startLine: 1 }
           }
         }
-      }
-      const toEdges = edgesToNode.get(id);
-      if (toEdges) {
-        for (const edgeId of [...toEdges]) {
-          const edge = edges.get(edgeId);
-          if (edge) {
-            unindexEdge(edge);
-            edges.delete(edgeId);
+      ]
+    });
+  }
+  return {
+    $schema: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "code-intel",
+            version,
+            rules: [
+              {
+                id: "HIGH-RISK-SYMBOL",
+                name: "HighRiskSymbol",
+                shortDescription: { text: "Symbol has high blast radius" }
+              },
+              {
+                id: "MEDIUM-RISK-SYMBOL",
+                name: "MediumRiskSymbol",
+                shortDescription: { text: "Symbol has medium blast radius" }
+              }
+            ]
           }
-        }
-      }
-      edgesFromNode.delete(id);
-      edgesToNode.delete(id);
-      nodes.delete(id);
-    },
-    removeEdge(id) {
-      const edge = edges.get(id);
-      if (edge) {
-        unindexEdge(edge);
-        edges.delete(id);
+        },
+        results
       }
-    },
-    *allNodes() {
-      yield* nodes.values();
-    },
-    *allEdges() {
-      yield* edges.values();
-    },
-    get size() {
-      return { nodes: nodes.size, edges: edges.size };
-    },
-    clear() {
-      nodes.clear();
-      edges.clear();
-      edgesByKind.clear();
-      edgesFromNode.clear();
-      edgesToNode.clear();
-    }
+    ]
   };
 }
+var init_sarif_builder = __esm({
+  "src/cli/sarif-builder.ts"() {
+  }
+});
 
 // src/cli/main.ts
+init_logger();
+init_knowledge_graph();
 init_orchestrator();
 
 // src/pipeline/phases/scan-phase.ts
@@ -5976,7 +6669,7 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
 ]);
 function loadIgnorePatterns(workspaceRoot) {
   try {
-    const raw = fs28.readFileSync(path30.join(workspaceRoot, ".codeintelignore"), "utf-8");
+    const raw = fs33.readFileSync(path33.join(workspaceRoot, ".codeintelignore"), "utf-8");
     const extras = /* @__PURE__ */ new Set();
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -6000,7 +6693,7 @@ var scanPhase = {
     function walk2(dir) {
       let entries;
       try {
-        entries = fs28.readdirSync(dir, { withFileTypes: true });
+        entries = fs33.readdirSync(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -6009,15 +6702,15 @@ var scanPhase = {
           if (entry.name.startsWith(".")) continue;
           if (IGNORED_DIRS.has(entry.name)) continue;
           if (extraIgnore.has(entry.name)) continue;
-          walk2(path30.join(dir, entry.name));
+          walk2(path33.join(dir, entry.name));
         } else if (entry.isFile()) {
           const name = entry.name;
           if (IGNORED_FILE_SUFFIXES.some((s) => name.endsWith(s))) continue;
-          const ext = path30.extname(name);
+          const ext = path33.extname(name);
           if (!extensions.has(ext)) continue;
-          const fullPath = path30.join(dir, name);
+          const fullPath = path33.join(dir, name);
           try {
-            const stat = fs28.statSync(fullPath);
+            const stat = fs33.statSync(fullPath);
             if (stat.size > MAX_FILE_SIZE_BYTES) continue;
           } catch {
             continue;
@@ -6044,20 +6737,20 @@ var structurePhase = {
     const dirs = /* @__PURE__ */ new Set();
     let structDone = 0;
     for (const filePath of context2.filePaths) {
-      const relativePath = path30.relative(context2.workspaceRoot, filePath);
+      const relativePath = path33.relative(context2.workspaceRoot, filePath);
       const lang = detectLanguage(filePath);
       context2.graph.addNode({
         id: generateNodeId("file", relativePath, relativePath),
         kind: "file",
-        name: path30.basename(filePath),
+        name: path33.basename(filePath),
         filePath: relativePath,
         metadata: lang ? { language: lang } : void 0
       });
-      let dir = path30.dirname(relativePath);
+      let dir = path33.dirname(relativePath);
       while (dir && dir !== "." && dir !== "") {
         if (dirs.has(dir)) break;
         dirs.add(dir);
-        dir = path30.dirname(dir);
+        dir = path33.dirname(dir);
       }
       structDone++;
       context2.onPhaseProgress?.("structure", structDone, context2.filePaths.length);
@@ -6066,7 +6759,7 @@ var structurePhase = {
       context2.graph.addNode({
         id: generateNodeId("directory", dir, dir),
         kind: "directory",
-        name: path30.basename(dir),
+        name: path33.basename(dir),
         filePath: dir
       });
     }
@@ -6177,22 +6870,22 @@ var flowPhase = {
       const queue = [{ nodeId: ep.id, path: [ep.id] }];
       const visited = /* @__PURE__ */ new Set();
       while (queue.length > 0 && flowCount < maxFlows) {
-        const { nodeId, path: path31 } = queue.shift();
-        if (path31.length > maxDepth) continue;
+        const { nodeId, path: path34 } = queue.shift();
+        if (path34.length > maxDepth) continue;
         const callEdges = [...graph.findEdgesFrom(nodeId)].filter((e) => e.kind === "calls").slice(0, maxBranching);
-        if (callEdges.length === 0 && path31.length >= 3) {
+        if (callEdges.length === 0 && path34.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: path31, entryPoint: ep.name }
+            metadata: { steps: path34, entryPoint: ep.name }
           });
-          for (let i = 0; i < path31.length; i++) {
+          for (let i = 0; i < path34.length; i++) {
             graph.addEdge({
-              id: generateEdgeId(path31[i], flowId, `step_of_${i}`),
-              source: path31[i],
+              id: generateEdgeId(path34[i], flowId, `step_of_${i}`),
+              source: path34[i],
               target: flowId,
               kind: "step_of",
               weight: 1,
@@ -6205,7 +6898,7 @@ var flowPhase = {
         for (const edge of callEdges) {
           if (visited.has(edge.target)) continue;
           visited.add(edge.target);
-          queue.push({ nodeId: edge.target, path: [...path31, edge.target] });
+          queue.push({ nodeId: edge.target, path: [...path34, edge.target] });
         }
       }
     }
@@ -6223,7 +6916,7 @@ var LLMGovernanceLogger = class {
   }
   /** Path to the JSONL log file. */
   getLogPath() {
-    return process.env["CODE_INTEL_GOVERNANCE_LOG_PATH"] ?? path30.join(os12.homedir(), ".code-intel", "llm-governance.jsonl");
+    return process.env["CODE_INTEL_GOVERNANCE_LOG_PATH"] ?? path33.join(os12.homedir(), ".code-intel", "llm-governance.jsonl");
   }
   /**
    * Append an entry to the governance log.
@@ -6239,8 +6932,8 @@ var LLMGovernanceLogger = class {
         ...entry
       };
       const logPath = this.getLogPath();
-      fs28.mkdirSync(path30.dirname(logPath), { recursive: true });
-      fs28.appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
+      fs33.mkdirSync(path33.dirname(logPath), { recursive: true });
+      fs33.appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
     } catch {
     }
   }
@@ -6250,7 +6943,7 @@ var LLMGovernanceLogger = class {
    */
   readLog(limit = 100) {
     try {
-      const raw = fs28.readFileSync(this.getLogPath(), "utf-8");
+      const raw = fs33.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 {
@@ -6564,7 +7257,7 @@ var LANG_QUERIES2 = {
 };
 function workerScriptPath() {
   const thisFile = fileURLToPath(import.meta.url);
-  return path30.join(path30.dirname(thisFile), "parse-worker.js");
+  return path33.join(path33.dirname(thisFile), "parse-worker.js");
 }
 var parsePhaseParallel = {
   name: "parse",
@@ -6580,14 +7273,14 @@ var parsePhaseParallel = {
       const batch = filePaths.slice(i, i + CONCURRENCY);
       await Promise.all(batch.map(async (filePath) => {
         try {
-          const source = await fs28.promises.readFile(filePath, "utf-8");
+          const source = await fs33.promises.readFile(filePath, "utf-8");
           context2.fileCache.set(filePath, source);
         } catch {
         }
       }));
     }
     const workerScript = workerScriptPath();
-    const workerScriptExists = fs28.existsSync(workerScript);
+    const workerScriptExists = fs33.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));
@@ -6599,7 +7292,7 @@ var parsePhaseParallel = {
       if (!lang) continue;
       const source = context2.fileCache.get(filePath);
       if (!source) continue;
-      const relativePath = path30.relative(context2.workspaceRoot, filePath);
+      const relativePath = path33.relative(context2.workspaceRoot, filePath);
       const fileNodeId = generateNodeId("file", relativePath, relativePath);
       const fileNode = context2.graph.getNode(fileNodeId);
       if (fileNode) fileNode.content = source.slice(0, 2e3);
@@ -6642,7 +7335,7 @@ var parsePhaseParallel = {
         symbolCount += res.nodes.length;
         if (res.usedTreeSitter) treeSitterCount++;
         else regexCount++;
-        const relativePath = path30.relative(context2.workspaceRoot, res.taskId);
+        const relativePath = path33.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++;
@@ -6669,7 +7362,7 @@ init_id_generator();
 init_logger();
 function workerScriptPath2() {
   const thisFile = fileURLToPath(import.meta.url);
-  return path30.join(path30.dirname(thisFile), "resolve-worker.js");
+  return path33.join(path33.dirname(thisFile), "resolve-worker.js");
 }
 var resolvePhaseParallel = {
   name: "resolve",
@@ -6681,11 +7374,11 @@ var resolvePhaseParallel = {
     const fileFunctionIndex = context2.fileFunctionIndex ?? /* @__PURE__ */ new Map();
     const fileIndex = {};
     for (const fp of filePaths) {
-      const rel = path30.relative(workspaceRoot, fp);
+      const rel = path33.relative(workspaceRoot, fp);
       fileIndex[rel] = fp;
       const noExt = rel.replace(/\.\w+$/, "");
       if (!fileIndex[noExt]) fileIndex[noExt] = fp;
-      const base = path30.basename(rel, path30.extname(rel));
+      const base = path33.basename(rel, path33.extname(rel));
       if (!fileIndex[base]) fileIndex[base] = fp;
     }
     const symbolIndex = {};
@@ -6699,427 +7392,202 @@ var resolvePhaseParallel = {
     }
     const snapshot = { symbolIndex, fileSymbolIndex, fileIndex, workspaceRoot };
     const workerScript = workerScriptPath2();
-    const workerScriptExists = fs28.existsSync(workerScript);
-    const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os12.cpus().length - 1);
-    if (!workerScriptExists || workerCount === 1) {
-      logger_default.info(`[resolve-parallel] falling back to sequential`);
-      const { resolvePhase: resolvePhase2 } = await Promise.resolve().then(() => (init_resolve_phase(), resolve_phase_exports));
-      return resolvePhase2.execute(context2, /* @__PURE__ */ new Map());
-    }
-    const tasks = [];
-    for (const filePath of filePaths) {
-      const lang = detectLanguage(filePath);
-      if (!lang) continue;
-      const source = fileCache.get(filePath);
-      if (!source) continue;
-      const relativePath = path30.relative(workspaceRoot, filePath);
-      const fileNodeId = generateNodeId("file", relativePath, relativePath);
-      const funcList = fileFunctionIndex.get(relativePath) ?? [];
-      tasks.push({ taskId: filePath, filePath, relativePath, fileNodeId, source, funcList });
-    }
-    let importEdges = 0;
-    let callEdges = 0;
-    let heritageEdges = 0;
-    let fileDone = 0;
-    const BATCH_SIZE = 100;
-    const workers = [];
-    for (let i = 0; i < workerCount; i++) {
-      workers.push({ w: new Worker(workerScript, { workerData: snapshot }), busy: false });
-    }
-    const pendingResolvers = /* @__PURE__ */ new Map();
-    for (const { w } of workers) {
-      w.on("message", (result) => {
-        const resolve = pendingResolvers.get(result.taskId);
-        if (resolve) {
-          pendingResolvers.delete(result.taskId);
-          resolve(result);
-        }
-      });
-      w.on("error", (err) => logger_default.warn(`[resolve-worker] error: ${err.message}`));
-    }
-    let workerIdx = 0;
-    function runTask(task) {
-      return new Promise((resolve) => {
-        pendingResolvers.set(task.taskId, resolve);
-        const { w } = workers[workerIdx % workers.length];
-        workerIdx++;
-        w.postMessage(task);
-      });
-    }
-    const seen = /* @__PURE__ */ new Set();
-    for (let i = 0; i < tasks.length; i += BATCH_SIZE) {
-      const batch = tasks.slice(i, i + BATCH_SIZE);
-      const results = await Promise.all(batch.map((t) => runTask(t)));
-      for (const res of results) {
-        if (res.error) logger_default.warn(`[resolve-parallel] task error: ${res.error}`);
-        for (const edge of res.edges) {
-          if (seen.has(edge.id)) continue;
-          seen.add(edge.id);
-          graph.addEdge(edge);
-          if (edge.kind === "imports") importEdges++;
-          else if (edge.kind === "calls") callEdges++;
-          else heritageEdges++;
-        }
-        fileDone++;
-        context2.onPhaseProgress?.("resolve", fileDone, tasks.length);
-      }
-    }
-    await Promise.all(workers.map(({ w }) => w.terminate()));
-    return {
-      status: "completed",
-      duration: Date.now() - start,
-      message: `Resolved ${importEdges} imports, ${callEdges} calls, ${heritageEdges} heritage edges. Graph: ${graph.size.nodes} nodes, ${graph.size.edges} edges`
-    };
-  }
-};
-
-// src/search/text-search.ts
-function textSearch(graph, query, limit = 20) {
-  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
-  const results = [];
-  const isTestPath = (fp) => fp.includes("test") || fp.includes("spec") || fp.includes("__test");
-  const isDistPath = (fp) => fp.includes("/dist") || fp.includes("\\dist") || fp.includes(".d.ts");
-  for (const node of graph.allNodes()) {
-    if (["directory", "cluster", "flow"].includes(node.kind)) continue;
-    let score = 0;
-    const nameLC = node.name.toLowerCase();
-    const pathLC = node.filePath.toLowerCase();
-    for (const term of terms) {
-      if (nameLC === term) score += 10;
-      else if (nameLC.startsWith(term)) score += 7;
-      else if (nameLC.includes(term)) score += 5;
-      if (pathLC.includes(term)) score += 2;
-      if (node.content?.toLowerCase().includes(term)) score += 3;
-    }
-    if (score > 0) {
-      if (isDistPath(node.filePath)) score -= 8;
-      if (isTestPath(node.filePath)) score -= 4;
-      if (["function", "class", "interface", "method"].includes(node.kind)) score += 1;
-    }
-    if (score > 0) {
-      results.push({
-        nodeId: node.id,
-        name: node.name,
-        kind: node.kind,
-        filePath: node.filePath,
-        score,
-        snippet: node.content?.slice(0, 200)
-      });
-    }
-  }
-  results.sort((a, b) => b.score - a.score);
-  return results.slice(0, limit);
-}
-function reciprocalRankFusion(...rankings) {
-  const K = 60;
-  const scoreMap = /* @__PURE__ */ new Map();
-  for (const ranking of rankings) {
-    for (let rank = 0; rank < ranking.length; rank++) {
-      const result = ranking[rank];
-      const existing = scoreMap.get(result.nodeId);
-      const rrfContribution = 1 / (K + rank + 1);
-      if (existing) {
-        existing.rrfScore += rrfContribution;
-      } else {
-        scoreMap.set(result.nodeId, {
-          result,
-          rrfScore: rrfContribution
-        });
-      }
-    }
-  }
-  return [...scoreMap.values()].sort((a, b) => b.rrfScore - a.rrfScore).map((entry) => ({ ...entry.result, score: entry.rrfScore }));
-}
-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 && fs28.existsSync(vectorDbPath));
-  if (!hasVectorDb) {
-    const bm25Results2 = await bm25Promise;
-    return {
-      results: bm25Results2.slice(0, limit).map((r) => ({ ...r, searchMode: "bm25" })),
-      searchMode: "bm25"
-    };
-  }
-  const vectorPromise = runVectorSearch(vectorDbPath, query, vectorLimit);
-  const [bm25Results, vectorResults] = await Promise.all([bm25Promise, vectorPromise]);
-  if (vectorResults === null || vectorResults.length === 0) {
-    return {
-      results: bm25Results.slice(0, limit).map((r) => ({ ...r, searchMode: "bm25" })),
-      searchMode: "bm25"
-    };
-  }
-  const vectorAsSearchResults = vectorResults.map((h) => ({
-    nodeId: h.nodeId,
-    name: h.name,
-    kind: h.kind,
-    filePath: h.filePath,
-    score: h.score,
-    snippet: graph.getNode(h.nodeId)?.content?.slice(0, 200)
-  }));
-  const merged = reciprocalRankFusion(bm25Results, vectorAsSearchResults);
-  return {
-    results: merged.slice(0, limit).map((r) => ({ ...r, searchMode: "hybrid" })),
-    searchMode: "hybrid"
-  };
-}
-async function runVectorSearch(vectorDbPath, query, topK) {
-  try {
-    const idx = new VectorIndex(vectorDbPath);
-    await idx.init();
-    const built = await idx.isBuilt();
-    if (!built) {
-      idx.close();
-      return null;
-    }
-    const embedder = await getEmbedder();
-    const out = await embedder(query, { pooling: "mean", normalize: true });
-    const queryEmbedding = Array.from(out.data);
-    const hits = await idx.search(queryEmbedding, topK);
-    idx.close();
-    return hits;
-  } catch {
-    return null;
-  }
-}
-
-// src/http/app.ts
-init_storage();
-init_metadata();
-init_vector_index();
-init_group_registry();
-
-// src/multi-repo/group-sync.ts
-init_repo_registry();
-init_db_manager();
-
-// src/multi-repo/graph-from-db.ts
-init_schema();
-var TABLE_TO_KIND = Object.fromEntries(
-  Object.entries(NODE_TABLE_MAP).map(([kind, table]) => [table, kind])
-);
-function parseRow(row, kind) {
-  return {
-    id: String(row["id"] ?? ""),
-    kind,
-    name: String(row["name"] ?? ""),
-    filePath: String(row["file_path"] ?? ""),
-    startLine: row["start_line"] != null ? Number(row["start_line"]) : void 0,
-    endLine: row["end_line"] != null ? Number(row["end_line"]) : void 0,
-    exported: row["exported"] != null ? Boolean(row["exported"]) : void 0,
-    content: row["content"] ? String(row["content"]) : void 0,
-    metadata: row["metadata"] ? (() => {
-      try {
-        return JSON.parse(String(row["metadata"]));
-      } catch {
-        return void 0;
-      }
-    })() : void 0
-  };
-}
-async function loadGraphFromDB(graph, db) {
-  for (const table of ALL_NODE_TABLES) {
-    const kind = TABLE_TO_KIND[table];
-    if (!kind) continue;
-    let rows = [];
-    try {
-      rows = await db.query(`MATCH (n:${table}) RETURN n.id, n.name, n.file_path, n.start_line, n.end_line, n.exported, n.content, n.metadata`);
-    } catch {
-      continue;
-    }
-    for (const row of rows) {
-      const node = parseRow({
-        id: row["n.id"],
-        name: row["n.name"],
-        file_path: row["n.file_path"],
-        start_line: row["n.start_line"],
-        end_line: row["n.end_line"],
-        exported: row["n.exported"],
-        content: row["n.content"],
-        metadata: row["n.metadata"]
-      }, kind);
-      if (node.id && node.name) graph.addNode(node);
+    const workerScriptExists = fs33.existsSync(workerScript);
+    const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os12.cpus().length - 1);
+    if (!workerScriptExists || workerCount === 1) {
+      logger_default.info(`[resolve-parallel] falling back to sequential`);
+      const { resolvePhase: resolvePhase2 } = await Promise.resolve().then(() => (init_resolve_phase(), resolve_phase_exports));
+      return resolvePhase2.execute(context2, /* @__PURE__ */ new Map());
     }
-  }
-  try {
-    const edgeRows = await db.query(
-      `MATCH (a)-[e:code_edges]->(b) RETURN a.id, b.id, e.kind, e.weight, e.label`
-    );
-    for (const row of edgeRows) {
-      const sourceId = String(row["a.id"] ?? "");
-      const targetId = String(row["b.id"] ?? "");
-      const kind = String(row["e.kind"] ?? "");
-      if (!sourceId || !targetId || !kind) continue;
-      const edge = {
-        id: `${sourceId}::${kind}::${targetId}`,
-        source: sourceId,
-        target: targetId,
-        kind,
-        weight: row["e.weight"] != null ? Number(row["e.weight"]) : void 0,
-        label: row["e.label"] ? String(row["e.label"]) : void 0
-      };
-      graph.addEdge(edge);
+    const tasks = [];
+    for (const filePath of filePaths) {
+      const lang = detectLanguage(filePath);
+      if (!lang) continue;
+      const source = fileCache.get(filePath);
+      if (!source) continue;
+      const relativePath = path33.relative(workspaceRoot, filePath);
+      const fileNodeId = generateNodeId("file", relativePath, relativePath);
+      const funcList = fileFunctionIndex.get(relativePath) ?? [];
+      tasks.push({ taskId: filePath, filePath, relativePath, fileNodeId, source, funcList });
     }
-  } catch {
-  }
-}
-
-// src/multi-repo/group-sync.ts
-init_logger();
-function extractContracts(graph, repoName, repoPath) {
-  const contracts = [];
-  for (const node of graph.allNodes()) {
-    if (node.exported === true && ["function", "class", "interface", "method", "type_alias", "constant", "enum", "struct", "trait"].includes(node.kind)) {
-      contracts.push({
-        repoName,
-        repoPath,
-        kind: "export",
-        name: node.name,
-        nodeId: node.id,
-        nodeKind: node.kind,
-        filePath: node.filePath,
-        signature: node.content?.split("\n")[0]?.trim()
-      });
+    let importEdges = 0;
+    let callEdges = 0;
+    let heritageEdges = 0;
+    let fileDone = 0;
+    const BATCH_SIZE = 100;
+    const workers = [];
+    for (let i = 0; i < workerCount; i++) {
+      workers.push({ w: new Worker(workerScript, { workerData: snapshot }), busy: false });
     }
-    if (node.kind === "route") {
-      contracts.push({
-        repoName,
-        repoPath,
-        kind: "route",
-        name: node.name,
-        nodeId: node.id,
-        nodeKind: node.kind,
-        filePath: node.filePath,
-        signature: node.content?.split("\n")[0]?.trim()
+    const pendingResolvers = /* @__PURE__ */ new Map();
+    for (const { w } of workers) {
+      w.on("message", (result) => {
+        const resolve = pendingResolvers.get(result.taskId);
+        if (resolve) {
+          pendingResolvers.delete(result.taskId);
+          resolve(result);
+        }
       });
+      w.on("error", (err) => logger_default.warn(`[resolve-worker] error: ${err.message}`));
     }
-    if (["interface", "type_alias"].includes(node.kind)) {
-      const nameLower = node.name.toLowerCase();
-      if (nameLower.includes("event") || nameLower.includes("message")) {
-        contracts.push({
-          repoName,
-          repoPath,
-          kind: "event",
-          name: node.name,
-          nodeId: node.id,
-          nodeKind: node.kind,
-          filePath: node.filePath
-        });
-      } else if (nameLower.includes("schema") || nameLower.includes("dto") || nameLower.includes("request") || nameLower.includes("response")) {
-        contracts.push({
-          repoName,
-          repoPath,
-          kind: "schema",
-          name: node.name,
-          nodeId: node.id,
-          nodeKind: node.kind,
-          filePath: node.filePath
-        });
-      }
+    let workerIdx = 0;
+    function runTask(task) {
+      return new Promise((resolve) => {
+        pendingResolvers.set(task.taskId, resolve);
+        const { w } = workers[workerIdx % workers.length];
+        workerIdx++;
+        w.postMessage(task);
+      });
     }
-  }
-  return contracts;
-}
-function matchContracts(allContracts) {
-  const links = [];
-  const byRepo = /* @__PURE__ */ new Map();
-  for (const c of allContracts) {
-    const arr = byRepo.get(c.repoName) ?? [];
-    arr.push(c);
-    byRepo.set(c.repoName, arr);
-  }
-  const repoNames = [...byRepo.keys()];
-  for (let i = 0; i < repoNames.length; i++) {
-    for (let j = 0; j < repoNames.length; j++) {
-      if (i === j) continue;
-      const providerContracts = byRepo.get(repoNames[i]);
-      const consumerContracts = byRepo.get(repoNames[j]);
-      const consumerByName = /* @__PURE__ */ new Map();
-      for (const c of consumerContracts) consumerByName.set(c.name, c);
-      for (const provider of providerContracts) {
-        const consumer = consumerByName.get(provider.name);
-        if (consumer) {
-          const sameKind = provider.kind === consumer.kind;
-          links.push({
-            providerRepo: provider.repoName,
-            providerContract: provider.name,
-            consumerRepo: consumer.repoName,
-            consumerContract: consumer.name,
-            matchKind: provider.kind === "route" ? "route-match" : "name-match",
-            confidence: sameKind ? 0.9 : 0.6
-          });
-        } else {
-          const providerLC = provider.name.toLowerCase();
-          for (const c of consumerContracts) {
-            if (c.name.toLowerCase().includes(providerLC) || providerLC.includes(c.name.toLowerCase())) {
-              if (c.name.length >= 4 && provider.name.length >= 4) {
-                links.push({
-                  providerRepo: provider.repoName,
-                  providerContract: provider.name,
-                  consumerRepo: c.repoName,
-                  consumerContract: c.name,
-                  matchKind: "name-match",
-                  confidence: 0.4
-                });
-              }
-            }
-          }
+    const seen = /* @__PURE__ */ new Set();
+    for (let i = 0; i < tasks.length; i += BATCH_SIZE) {
+      const batch = tasks.slice(i, i + BATCH_SIZE);
+      const results = await Promise.all(batch.map((t) => runTask(t)));
+      for (const res of results) {
+        if (res.error) logger_default.warn(`[resolve-parallel] task error: ${res.error}`);
+        for (const edge of res.edges) {
+          if (seen.has(edge.id)) continue;
+          seen.add(edge.id);
+          graph.addEdge(edge);
+          if (edge.kind === "imports") importEdges++;
+          else if (edge.kind === "calls") callEdges++;
+          else heritageEdges++;
         }
+        fileDone++;
+        context2.onPhaseProgress?.("resolve", fileDone, tasks.length);
       }
     }
+    await Promise.all(workers.map(({ w }) => w.terminate()));
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Resolved ${importEdges} imports, ${callEdges} calls, ${heritageEdges} heritage edges. Graph: ${graph.size.nodes} nodes, ${graph.size.edges} edges`
+    };
   }
-  const seen = /* @__PURE__ */ new Map();
-  for (const link of links) {
-    const key = `${link.providerRepo}:${link.providerContract}:${link.consumerRepo}:${link.consumerContract}`;
-    const existing = seen.get(key);
-    if (!existing || link.confidence > existing.confidence) {
-      seen.set(key, link);
+};
+
+// src/search/text-search.ts
+function textSearch(graph, query, limit = 20) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const results = [];
+  const isTestPath = (fp) => fp.includes("test") || fp.includes("spec") || fp.includes("__test");
+  const isDistPath = (fp) => fp.includes("/dist") || fp.includes("\\dist") || fp.includes(".d.ts");
+  for (const node of graph.allNodes()) {
+    if (["directory", "cluster", "flow"].includes(node.kind)) continue;
+    let score = 0;
+    const nameLC = node.name.toLowerCase();
+    const pathLC = node.filePath.toLowerCase();
+    for (const term of terms) {
+      if (nameLC === term) score += 10;
+      else if (nameLC.startsWith(term)) score += 7;
+      else if (nameLC.includes(term)) score += 5;
+      if (pathLC.includes(term)) score += 2;
+      if (node.content?.toLowerCase().includes(term)) score += 3;
     }
-  }
-  return [...seen.values()].sort((a, b) => b.confidence - a.confidence);
-}
-async function syncGroup(group) {
-  const registry = loadRegistry();
-  const allContracts = [];
-  for (const member of group.members) {
-    const regEntry = registry.find((r) => r.name === member.registryName);
-    if (!regEntry) {
-      logger_default.warn(`  \u26A0 Registry entry "${member.registryName}" not found \u2014 skipping ${member.groupPath}`);
-      continue;
+    if (score > 0) {
+      if (isDistPath(node.filePath)) score -= 8;
+      if (isTestPath(node.filePath)) score -= 4;
+      if (["function", "class", "interface", "method"].includes(node.kind)) score += 1;
     }
-    const dbPath = path30.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs28.existsSync(dbPath)) {
-      logger_default.warn(`  \u26A0 No index at ${dbPath} \u2014 run \`code-intel analyze ${regEntry.path}\` first`);
-      continue;
+    if (score > 0) {
+      results.push({
+        nodeId: node.id,
+        name: node.name,
+        kind: node.kind,
+        filePath: node.filePath,
+        score,
+        snippet: node.content?.slice(0, 200)
+      });
     }
-    const graph = createKnowledgeGraph();
-    const db = new DbManager(dbPath);
-    try {
-      await db.init();
-      await loadGraphFromDB(graph, db);
-      db.close();
-    } catch (err) {
-      db.close();
-      logger_default.warn(`  \u26A0 Could not load graph for "${member.registryName}": ${err instanceof Error ? err.message : err}`);
-      continue;
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, limit);
+}
+function reciprocalRankFusion(...rankings) {
+  const K = 60;
+  const scoreMap = /* @__PURE__ */ new Map();
+  for (const ranking of rankings) {
+    for (let rank = 0; rank < ranking.length; rank++) {
+      const result = ranking[rank];
+      const existing = scoreMap.get(result.nodeId);
+      const rrfContribution = 1 / (K + rank + 1);
+      if (existing) {
+        existing.rrfScore += rrfContribution;
+      } else {
+        scoreMap.set(result.nodeId, {
+          result,
+          rrfScore: rrfContribution
+        });
+      }
     }
-    const contracts = extractContracts(graph, member.registryName, regEntry.path);
-    logger_default.info(`  \u2713 ${member.registryName} (${member.groupPath}): ${contracts.length} contracts`);
-    allContracts.push(...contracts);
   }
-  const links = matchContracts(allContracts);
+  return [...scoreMap.values()].sort((a, b) => b.rrfScore - a.rrfScore).map((entry) => ({ ...entry.result, score: entry.rrfScore }));
+}
+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 && fs33.existsSync(vectorDbPath));
+  if (!hasVectorDb) {
+    const bm25Results2 = await bm25Promise;
+    return {
+      results: bm25Results2.slice(0, limit).map((r) => ({ ...r, searchMode: "bm25" })),
+      searchMode: "bm25"
+    };
+  }
+  const vectorPromise = runVectorSearch(vectorDbPath, query, vectorLimit);
+  const [bm25Results, vectorResults] = await Promise.all([bm25Promise, vectorPromise]);
+  if (vectorResults === null || vectorResults.length === 0) {
+    return {
+      results: bm25Results.slice(0, limit).map((r) => ({ ...r, searchMode: "bm25" })),
+      searchMode: "bm25"
+    };
+  }
+  const vectorAsSearchResults = vectorResults.map((h) => ({
+    nodeId: h.nodeId,
+    name: h.name,
+    kind: h.kind,
+    filePath: h.filePath,
+    score: h.score,
+    snippet: graph.getNode(h.nodeId)?.content?.slice(0, 200)
+  }));
+  const merged = reciprocalRankFusion(bm25Results, vectorAsSearchResults);
   return {
-    groupName: group.name,
-    syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    memberCount: group.members.length,
-    contracts: allContracts,
-    links
+    results: merged.slice(0, limit).map((r) => ({ ...r, searchMode: "hybrid" })),
+    searchMode: "hybrid"
   };
 }
+async function runVectorSearch(vectorDbPath, query, topK) {
+  try {
+    const idx = new VectorIndex(vectorDbPath);
+    await idx.init();
+    const built = await idx.isBuilt();
+    if (!built) {
+      idx.close();
+      return null;
+    }
+    const embedder = await getEmbedder();
+    const out = await embedder(query, { pooling: "mean", normalize: true });
+    const queryEmbedding = Array.from(out.data);
+    const hits = await idx.search(queryEmbedding, topK);
+    idx.close();
+    return hits;
+  } catch {
+    return null;
+  }
+}
+
+// src/http/app.ts
+init_storage();
+init_metadata();
+init_vector_index();
+init_group_registry();
+init_group_sync();
 init_repo_registry();
 init_db_manager();
+init_knowledge_graph();
+init_graph_from_db();
 async function queryGroup(group, query, limit = 20) {
   const registry = loadRegistry();
   const perRepo = [];
@@ -7127,8 +7595,8 @@ 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 = path30.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs28.existsSync(dbPath)) continue;
+    const dbPath = path33.join(regEntry.path, ".code-intel", "graph.db");
+    if (!fs33.existsSync(dbPath)) continue;
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
     try {
@@ -7157,6 +7625,8 @@ async function queryGroup(group, query, limit = 20) {
 }
 
 // src/http/app.ts
+init_knowledge_graph();
+init_graph_from_db();
 init_repo_registry();
 init_logger();
 init_codes();
@@ -7168,7 +7638,7 @@ var STUCK_THRESHOLD_MINUTES = 30;
 var JobsDB = class {
   db;
   constructor(dbPath) {
-    fs28.mkdirSync(path30.dirname(dbPath), { recursive: true });
+    fs33.mkdirSync(path33.dirname(dbPath), { recursive: true });
     this.db = new Database(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
@@ -7310,7 +7780,7 @@ var JobsDB = class {
   }
 };
 function getJobsDBPath() {
-  return path30.join(os12.homedir(), ".code-intel", "jobs.db");
+  return path33.join(os12.homedir(), ".code-intel", "jobs.db");
 }
 var _jobsDB = null;
 function getOrCreateJobsDB() {
@@ -7402,7 +7872,7 @@ var BACKUP_VERSION = "1.0";
 var ALGORITHM = "aes-256-gcm";
 var IV_LENGTH = 16;
 function getBackupDir() {
-  return path30.join(os12.homedir(), ".code-intel", "backups");
+  return path33.join(os12.homedir(), ".code-intel", "backups");
 }
 function getBackupKey() {
   const keyHex = process.env["CODE_INTEL_BACKUP_KEY"];
@@ -7433,30 +7903,30 @@ var BackupService = class {
   constructor(backupDir) {
     this.backupDir = backupDir ?? getBackupDir();
     this.key = getBackupKey();
-    fs28.mkdirSync(this.backupDir, { recursive: true });
+    fs33.mkdirSync(this.backupDir, { recursive: true });
   }
   /**
    * Create a backup for a repository.
    * Returns the backup entry.
    */
   createBackup(repoPath) {
-    const codeIntelDir = path30.join(repoPath, ".code-intel");
+    const codeIntelDir = path33.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 = path30.join(codeIntelDir, f);
-      if (fs28.existsSync(fp)) {
+      const fp = path33.join(codeIntelDir, f);
+      if (fs33.existsSync(fp)) {
         filesToBackup.push({ name: f, localPath: fp });
       }
     }
-    const registryPath = path30.join(os12.homedir(), ".code-intel", "registry.json");
-    if (fs28.existsSync(registryPath)) {
+    const registryPath = path33.join(os12.homedir(), ".code-intel", "registry.json");
+    if (fs33.existsSync(registryPath)) {
       filesToBackup.push({ name: "registry.json", localPath: registryPath });
     }
-    const usersDbPath = path30.join(os12.homedir(), ".code-intel", "users.db");
-    if (fs28.existsSync(usersDbPath)) {
+    const usersDbPath = path33.join(os12.homedir(), ".code-intel", "users.db");
+    if (fs33.existsSync(usersDbPath)) {
       filesToBackup.push({ name: "users.db", localPath: usersDbPath });
     }
     if (filesToBackup.length === 0) {
@@ -7467,7 +7937,7 @@ var BackupService = class {
       createdAt,
       version: BACKUP_VERSION,
       files: filesToBackup.map((f) => {
-        const data = fs28.readFileSync(f.localPath);
+        const data = fs33.readFileSync(f.localPath);
         return {
           name: f.name,
           sha256: crypto5.createHash("sha256").update(data).digest("hex"),
@@ -7481,7 +7951,7 @@ var BackupService = class {
     manifestLenBuf.writeUInt32BE(manifestBuf.length, 0);
     parts.push(manifestLenBuf, manifestBuf);
     for (const f of filesToBackup) {
-      const data = fs28.readFileSync(f.localPath);
+      const data = fs33.readFileSync(f.localPath);
       const nameBuf = Buffer.from(f.name, "utf-8");
       const nameLenBuf = Buffer.alloc(2);
       nameLenBuf.writeUInt16BE(nameBuf.length, 0);
@@ -7492,8 +7962,8 @@ var BackupService = class {
     const plaintext = Buffer.concat(parts);
     const encrypted = encryptBuffer(plaintext, this.key);
     const backupFileName = `backup-${id}.cib`;
-    const backupPath = path30.join(this.backupDir, backupFileName);
-    fs28.writeFileSync(backupPath, encrypted);
+    const backupPath = path33.join(this.backupDir, backupFileName);
+    fs33.writeFileSync(backupPath, encrypted);
     const entry = {
       id,
       createdAt,
@@ -7520,9 +7990,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 = path30.basename(entry.path);
+    const fileName = path33.basename(entry.path);
     const s3Key = `${cfg.prefix}${fileName}`;
-    const body = fs28.readFileSync(entry.path);
+    const body = fs33.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)}`);
@@ -7539,8 +8009,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)}`);
     }
-    fs28.mkdirSync(path30.dirname(destPath), { recursive: true });
-    fs28.writeFileSync(destPath, Buffer.from(result.body, "binary"));
+    fs33.mkdirSync(path33.dirname(destPath), { recursive: true });
+    fs33.writeFileSync(destPath, Buffer.from(result.body, "binary"));
   }
   /**
    * List backup objects in S3 with the configured prefix.
@@ -7586,10 +8056,10 @@ var BackupService = class {
     if (!entry) {
       throw new Error(`Backup "${backupId}" not found.`);
     }
-    if (!fs28.existsSync(entry.path)) {
+    if (!fs33.existsSync(entry.path)) {
       throw new Error(`Backup file not found at: ${entry.path}`);
     }
-    const encrypted = fs28.readFileSync(entry.path);
+    const encrypted = fs33.readFileSync(entry.path);
     let plaintext;
     try {
       plaintext = decryptBuffer(encrypted, this.key);
@@ -7603,8 +8073,8 @@ var BackupService = class {
     offset += manifestLen;
     const manifest = JSON.parse(manifestStr);
     const restoreBase = targetRepoPath ?? entry.repoPath;
-    const codeIntelDir = path30.join(restoreBase, ".code-intel");
-    fs28.mkdirSync(codeIntelDir, { recursive: true });
+    const codeIntelDir = path33.join(restoreBase, ".code-intel");
+    fs33.mkdirSync(codeIntelDir, { recursive: true });
     for (const fileEntry of manifest.files) {
       const nameLen = plaintext.readUInt16BE(offset);
       offset += 2;
@@ -7621,18 +8091,18 @@ var BackupService = class {
       }
       let destPath;
       if (name === "registry.json" || name === "users.db") {
-        destPath = path30.join(os12.homedir(), ".code-intel", name);
+        destPath = path33.join(os12.homedir(), ".code-intel", name);
       } else {
-        destPath = path30.join(codeIntelDir, name);
+        destPath = path33.join(codeIntelDir, name);
       }
-      fs28.writeFileSync(destPath, data);
+      fs33.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) => fs28.existsSync(e.path)).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    const entries = this._loadIndex().filter((e) => fs33.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);
@@ -7662,7 +8132,7 @@ var BackupService = class {
     for (const e of entries) {
       if (!keep.has(e.id)) {
         try {
-          fs28.unlinkSync(e.path);
+          fs33.unlinkSync(e.path);
           deleted++;
         } catch {
         }
@@ -7674,17 +8144,17 @@ var BackupService = class {
   }
   // ── Index helpers ──────────────────────────────────────────────────────────
   _indexPath() {
-    return path30.join(this.backupDir, "index.json");
+    return path33.join(this.backupDir, "index.json");
   }
   _loadIndex() {
     try {
-      return JSON.parse(fs28.readFileSync(this._indexPath(), "utf-8"));
+      return JSON.parse(fs33.readFileSync(this._indexPath(), "utf-8"));
     } catch {
       return [];
     }
   }
   _saveIndex(entries) {
-    fs28.writeFileSync(this._indexPath(), JSON.stringify(entries, null, 2));
+    fs33.writeFileSync(this._indexPath(), JSON.stringify(entries, null, 2));
   }
   _appendIndex(entry) {
     const entries = this._loadIndex();
@@ -8191,6 +8661,30 @@ var openApiSpec = {
         }
       }
     },
+    "/groups/{name}/topology": {
+      get: {
+        tags: ["Groups"],
+        summary: "Get the topology of repos and cross-repo contract edges for a group",
+        parameters: [{ name: "name", in: "path", required: true, schema: { type: "string" } }],
+        responses: {
+          "200": {
+            description: "Repos and cross-repo edges",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    repos: { type: "array", items: { type: "object", properties: { name: { type: "string" }, groupPath: { type: "string" }, nodeCount: { type: "integer" }, edgeCount: { type: "integer" } } } },
+                    edges: { type: "array", items: { type: "object", properties: { source: { type: "string" }, target: { type: "string" }, contractName: { type: "string" }, confidence: { type: "number" }, kind: { type: "string" } } } }
+                  }
+                }
+              }
+            }
+          },
+          "404": { description: "Group not found", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } }
+        }
+      }
+    },
     "/query": {
       post: {
         tags: ["GQL"],
@@ -8301,11 +8795,11 @@ var openApiSpec = {
 };
 
 // src/http/app.ts
-var __dirname$1 = path30.dirname(fileURLToPath(import.meta.url));
+var __dirname$1 = path33.dirname(fileURLToPath(import.meta.url));
 var WEB_DIST = (() => {
-  const bundled = path30.resolve(__dirname$1, "..", "web");
-  if (fs28.existsSync(bundled)) return bundled;
-  return path30.resolve(__dirname$1, "..", "..", "..", "web", "dist");
+  const bundled = path33.resolve(__dirname$1, "..", "web");
+  if (fs33.existsSync(bundled)) return bundled;
+  return path33.resolve(__dirname$1, "..", "..", "..", "web", "dist");
 })();
 function getAllowedOrigins() {
   const env = process.env["CODE_INTEL_CORS_ORIGINS"];
@@ -8836,8 +9330,8 @@ 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 = path30.join(entry.path, ".code-intel", "graph.db");
-    if (!fs28.existsSync(dbPath)) return null;
+    const dbPath = path33.join(entry.path, ".code-intel", "graph.db");
+    if (!fs33.existsSync(dbPath)) return null;
     const repoGraph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
     try {
@@ -8924,7 +9418,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       return;
     }
     try {
-      const content = fs28.readFileSync(file_path, "utf-8");
+      const content = fs33.readFileSync(file_path, "utf-8");
       res.json({ content });
     } catch {
       res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "File not found" } });
@@ -9182,8 +9676,8 @@ 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 = path30.join(regEntry.path, ".code-intel", "graph.db");
-      if (!fs28.existsSync(dbPath)) continue;
+      const dbPath = path33.join(regEntry.path, ".code-intel", "graph.db");
+      if (!fs33.existsSync(dbPath)) continue;
       const db = new DbManager(dbPath);
       try {
         await db.init();
@@ -9195,6 +9689,45 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     }
     res.json({ nodes: [...mergedGraph.allNodes()], edges: [...mergedGraph.allEdges()] });
   });
+  app.get("/api/v1/groups/:name/topology", requireAuth, requireRole("viewer"), async (req, res) => {
+    const groupName = req.params["name"];
+    const group = loadGroup(groupName);
+    if (!group) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    const syncResult = loadSyncResult(groupName);
+    const registry = loadRegistry();
+    const repos = await Promise.all(group.members.map(async (member) => {
+      const regEntry = registry.find((r) => r.name === member.registryName);
+      let nodeCount = 0;
+      let edgeCount = 0;
+      if (regEntry) {
+        const dbPath = path33.join(regEntry.path, ".code-intel", "graph.db");
+        if (fs33.existsSync(dbPath)) {
+          try {
+            const db = new DbManager(dbPath);
+            await db.init();
+            const g = createKnowledgeGraph();
+            await loadGraphFromDB(g, db);
+            db.close();
+            nodeCount = g.size.nodes;
+            edgeCount = g.size.edges;
+          } catch {
+          }
+        }
+      }
+      return { name: member.registryName, groupPath: member.groupPath, nodeCount, edgeCount };
+    }));
+    const edges = syncResult ? syncResult.links.map((link) => ({
+      source: link.providerRepo,
+      target: link.consumerRepo,
+      contractName: link.providerContract,
+      confidence: link.confidence,
+      kind: "contract"
+    })) : [];
+    res.json({ repos, edges });
+  });
   app.get("/api/v1/source", requireAuth, requireRole("viewer"), (req, res) => {
     const { file, startLine: startLineStr, endLine: endLineStr } = req.query;
     if (!file) {
@@ -9220,14 +9753,14 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       });
       return;
     }
-    let rawResolved = path30.normalize(file);
-    if (!path30.isAbsolute(rawResolved) && workspaceRoot) {
-      rawResolved = path30.join(workspaceRoot, rawResolved);
+    let rawResolved = path33.normalize(file);
+    if (!path33.isAbsolute(rawResolved) && workspaceRoot) {
+      rawResolved = path33.join(workspaceRoot, rawResolved);
     }
-    const resolvedFile = path30.resolve(rawResolved);
+    const resolvedFile = path33.resolve(rawResolved);
     function isInsideDir(fileAbs, dir) {
-      const rel = path30.relative(path30.resolve(dir), fileAbs);
-      return !rel.startsWith("..") && !path30.isAbsolute(rel);
+      const rel = path33.relative(path33.resolve(dir), fileAbs);
+      return !rel.startsWith("..") && !path33.isAbsolute(rel);
     }
     if (workspaceRoot) {
       if (!isInsideDir(resolvedFile, workspaceRoot)) {
@@ -9264,7 +9797,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     }
     let fileContent;
     try {
-      fileContent = fs28.readFileSync(resolvedFile, "utf-8");
+      fileContent = fs33.readFileSync(resolvedFile, "utf-8");
     } catch {
       res.status(404).json({
         error: {
@@ -9295,7 +9828,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 = path30.extname(resolvedFile).toLowerCase();
+    const ext = path33.extname(resolvedFile).toLowerCase();
     const languageMap = {
       ".ts": "typescript",
       ".tsx": "typescript",
@@ -9430,10 +9963,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 (fs28.existsSync(WEB_DIST)) {
+  if (fs33.existsSync(WEB_DIST)) {
     app.use(express.static(WEB_DIST));
     app.get("/{*path}", (_req, res) => {
-      res.sendFile(path30.join(WEB_DIST, "index.html"));
+      res.sendFile(path33.join(WEB_DIST, "index.html"));
     });
   }
   app.use("/admin", requireRole("admin"));
@@ -9580,16 +10113,536 @@ async function startHttpServer(graph, repoName, port = 4747, workspaceRoot, watc
         wsServer = new WsServer2(httpServer);
       } catch {
       }
-      resolve({ wsServer });
-    });
-  });
+      resolve({ wsServer });
+    });
+  });
+}
+init_storage();
+init_repo_registry();
+init_metadata();
+init_group_registry();
+init_group_sync();
+init_tracing();
+init_metrics();
+
+// src/query/explain-relationship.ts
+function explainRelationship(graph, from, to) {
+  const allNodes = [...graph.allNodes()];
+  const fromNode = allNodes.find((n) => n.name === from);
+  if (!fromNode) {
+    const firstChar = from[0]?.toLowerCase() ?? "";
+    const fromLower = from.toLowerCase();
+    const suggestions = allNodes.filter((n) => n.name.toLowerCase().startsWith(firstChar) || n.name.toLowerCase().includes(fromLower)).slice(0, 5).map((n) => n.name);
+    return { error: `Symbol not found: ${from}`, suggestions };
+  }
+  const toNode = allNodes.find((n) => n.name === to);
+  if (!toNode) {
+    const firstChar = to[0]?.toLowerCase() ?? "";
+    const toLower = to.toLowerCase();
+    const suggestions = allNodes.filter((n) => n.name.toLowerCase().startsWith(firstChar) || n.name.toLowerCase().includes(toLower)).slice(0, 5).map((n) => n.name);
+    return { error: `Symbol not found: ${to}`, suggestions };
+  }
+  const paths = [];
+  const queue = [{
+    id: fromNode.id,
+    nodeNames: [fromNode.name],
+    lastEdgeKind: "",
+    visited: /* @__PURE__ */ new Set([fromNode.id])
+  }];
+  while (queue.length > 0 && paths.length < 10) {
+    const entry = queue.shift();
+    const { id, nodeNames, visited } = entry;
+    if (nodeNames.length > 6) continue;
+    for (const edge of graph.findEdgesFrom(id)) {
+      const targetNode = graph.getNode(edge.target);
+      if (!targetNode) continue;
+      if (visited.has(edge.target)) continue;
+      const newNames = [...nodeNames, targetNode.name];
+      if (edge.target === toNode.id) {
+        paths.push({ hops: newNames.length - 1, nodes: newNames, edgeKind: edge.kind });
+        if (paths.length >= 10) break;
+        continue;
+      }
+      if (newNames.length < 6) {
+        const newVisited = new Set(visited);
+        newVisited.add(edge.target);
+        queue.push({ id: edge.target, nodeNames: newNames, lastEdgeKind: edge.kind, visited: newVisited });
+      }
+    }
+  }
+  const fromImports = /* @__PURE__ */ new Set();
+  for (const edge of graph.findEdgesFrom(fromNode.id)) {
+    if (edge.kind === "imports") fromImports.add(edge.target);
+  }
+  const sharedImportIds = [];
+  for (const edge of graph.findEdgesFrom(toNode.id)) {
+    if (edge.kind === "imports" && fromImports.has(edge.target)) {
+      sharedImportIds.push(edge.target);
+    }
+  }
+  const sharedImports = sharedImportIds.map((id) => graph.getNode(id)?.name ?? id);
+  let heritage = null;
+  for (const edge of graph.findEdgesFrom(fromNode.id)) {
+    if ((edge.kind === "extends" || edge.kind === "implements") && edge.target === toNode.id) {
+      heritage = `${from} ${edge.kind} ${to}`;
+      break;
+    }
+  }
+  if (!heritage) {
+    for (const edge of graph.findEdgesFrom(toNode.id)) {
+      if ((edge.kind === "extends" || edge.kind === "implements") && edge.target === fromNode.id) {
+        heritage = `${to} ${edge.kind} ${from}`;
+        break;
+      }
+    }
+  }
+  const sharedStr = sharedImports.length > 0 ? sharedImports.join(", ") : "none";
+  const heritageStr = heritage ?? "none";
+  const connectionStr = paths.length === 0 ? "No connection found." : `${from} \u2192 ${to} via ${paths.length} path(s).`;
+  const summary = `${connectionStr} Shared imports: [${sharedStr}]. Heritage: ${heritageStr}.`;
+  return { paths, sharedImports, heritage, summary };
+}
+
+// src/mcp-server/server.ts
+init_pr_impact();
+
+// src/query/similar-symbols.ts
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    (_, i) => Array.from({ length: n + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
+  );
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1];
+      } else {
+        dp[i][j] = 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+      }
+    }
+  }
+  return dp[m][n];
+}
+function findSimilarSymbols(graph, symbolName, limit) {
+  const clampedLimit = Math.min(Math.max(1, limit), 50);
+  const allNodes = [...graph.allNodes()];
+  const targetNode = allNodes.find((n) => n.name === symbolName);
+  if (!targetNode) {
+    return { similar: [] };
+  }
+  let targetCluster = null;
+  for (const edge of graph.findEdgesFrom(targetNode.id)) {
+    if (edge.kind === "belongs_to") {
+      const clusterNode = graph.getNode(edge.target);
+      if (clusterNode) {
+        targetCluster = clusterNode.name;
+        break;
+      }
+    }
+  }
+  if (!targetCluster) {
+    for (const edge of graph.findEdgesTo(targetNode.id)) {
+      if (edge.kind === "belongs_to") {
+        const clusterNode = graph.getNode(edge.source);
+        if (clusterNode) {
+          targetCluster = clusterNode.name;
+          break;
+        }
+      }
+    }
+  }
+  const results = [];
+  for (const node of allNodes) {
+    if (node.id === targetNode.id) continue;
+    const maxLen = Math.max(symbolName.length, node.name.length);
+    const nameSim = maxLen === 0 ? 1 : 1 - levenshtein(symbolName, node.name) / maxLen;
+    const structuralSim = node.kind === targetNode.kind ? 0.5 : 0;
+    const combined = 0.5 * nameSim + 0.5 * structuralSim;
+    const reasons = [];
+    if (nameSim >= 0.6) reasons.push("similar name");
+    if (node.kind === targetNode.kind) reasons.push("same kind");
+    if (targetCluster !== null) {
+      let nodeCluster = null;
+      for (const edge of graph.findEdgesFrom(node.id)) {
+        if (edge.kind === "belongs_to") {
+          const clusterNode = graph.getNode(edge.target);
+          if (clusterNode) {
+            nodeCluster = clusterNode.name;
+            break;
+          }
+        }
+      }
+      if (!nodeCluster) {
+        for (const edge of graph.findEdgesTo(node.id)) {
+          if (edge.kind === "belongs_to") {
+            const clusterNode = graph.getNode(edge.source);
+            if (clusterNode) {
+              nodeCluster = clusterNode.name;
+              break;
+            }
+          }
+        }
+      }
+      if (nodeCluster !== null && nodeCluster === targetCluster) {
+        reasons.push("same module");
+      }
+    }
+    if (targetNode.metadata?.["cluster"] !== void 0 && node.metadata?.["cluster"] !== void 0 && node.metadata["cluster"] === targetNode.metadata["cluster"]) {
+      if (!reasons.includes("same module")) reasons.push("same module");
+    }
+    results.push({ name: node.name, similarity: combined, reasons });
+  }
+  results.sort((a, b) => b.similarity - a.similarity);
+  return { similar: results.slice(0, clampedLimit) };
+}
+
+// src/query/health-report.ts
+function computeHealthReport(graph, scope) {
+  const wholeRepo = scope === ".";
+  function inScope(filePath) {
+    if (wholeRepo) return true;
+    return filePath.startsWith(scope) || filePath.includes(scope);
+  }
+  const scopedNodes = [...graph.allNodes()].filter((n) => inScope(n.filePath));
+  const deadCodeKinds = /* @__PURE__ */ new Set(["function", "method", "class"]);
+  const deadCode = [];
+  for (const node of scopedNodes) {
+    if (!deadCodeKinds.has(node.kind)) continue;
+    if (node.exported === true) continue;
+    let hasIncoming = false;
+    for (const _edge of graph.findEdgesTo(node.id)) {
+      hasIncoming = true;
+      break;
+    }
+    if (!hasIncoming) {
+      deadCode.push({ name: node.name, filePath: node.filePath, kind: node.kind });
+      if (deadCode.length >= 20) break;
+    }
+  }
+  const cycles = [];
+  const scopedNodeIds = new Set(scopedNodes.map((n) => n.id));
+  const importAdj = /* @__PURE__ */ new Map();
+  for (const node of scopedNodes) {
+    importAdj.set(node.id, []);
+  }
+  for (const edge of graph.findEdgesByKind("imports")) {
+    if (scopedNodeIds.has(edge.source) && scopedNodeIds.has(edge.target)) {
+      importAdj.get(edge.source).push(edge.target);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const stackPath = [];
+  function dfs(nodeId) {
+    if (cycles.length >= 5) return;
+    visited.add(nodeId);
+    inStack.add(nodeId);
+    stackPath.push(nodeId);
+    for (const neighborId of importAdj.get(nodeId) ?? []) {
+      if (cycles.length >= 5) break;
+      if (inStack.has(neighborId)) {
+        const cycleStart = stackPath.indexOf(neighborId);
+        const cyclePath = stackPath.slice(cycleStart).map((id) => {
+          const node = graph.getNode(id);
+          return node ? node.name : id;
+        });
+        cycles.push(cyclePath);
+      } else if (!visited.has(neighborId)) {
+        dfs(neighborId);
+      }
+    }
+    stackPath.pop();
+    inStack.delete(nodeId);
+  }
+  for (const node of scopedNodes) {
+    if (cycles.length >= 5) break;
+    if (!visited.has(node.id)) {
+      dfs(node.id);
+    }
+  }
+  const godNodes = [];
+  for (const node of scopedNodes) {
+    let edgeCount = 0;
+    for (const _edge of graph.findEdgesFrom(node.id)) {
+      edgeCount++;
+    }
+    if (edgeCount > 10) {
+      godNodes.push({ name: node.name, edgeCount, filePath: node.filePath });
+    }
+  }
+  godNodes.sort((a, b) => b.edgeCount - a.edgeCount);
+  godNodes.splice(10);
+  const filePathToNodes = /* @__PURE__ */ new Map();
+  for (const node of scopedNodes) {
+    if (!node.filePath) continue;
+    let arr = filePathToNodes.get(node.filePath);
+    if (!arr) {
+      arr = [];
+      filePathToNodes.set(node.filePath, arr);
+    }
+    arr.push(node.id);
+  }
+  const orphanFiles = [];
+  for (const [filePath, nodeIds] of filePathToNodes) {
+    if (orphanFiles.length >= 10) break;
+    let hasAnyEdge = false;
+    for (const nodeId of nodeIds) {
+      let hasOut = false;
+      for (const _edge of graph.findEdgesFrom(nodeId)) {
+        hasOut = true;
+        break;
+      }
+      let hasIn = false;
+      for (const _edge of graph.findEdgesTo(nodeId)) {
+        hasIn = true;
+        break;
+      }
+      if (hasOut || hasIn) {
+        hasAnyEdge = true;
+        break;
+      }
+    }
+    if (!hasAnyEdge) {
+      orphanFiles.push(filePath);
+    }
+  }
+  const hotspotCandidates = [];
+  for (const node of scopedNodes) {
+    const visitedBfs = /* @__PURE__ */ new Set();
+    const queue = [{ id: node.id, depth: 0 }];
+    while (queue.length > 0) {
+      const item = queue.shift();
+      if (item.depth > 5 || visitedBfs.has(item.id)) continue;
+      visitedBfs.add(item.id);
+      for (const edge of graph.findEdgesTo(item.id)) {
+        if (edge.kind === "calls" || edge.kind === "imports") {
+          if (!visitedBfs.has(edge.source)) {
+            queue.push({ id: edge.source, depth: item.depth + 1 });
+          }
+        }
+      }
+    }
+    const blastRadius = visitedBfs.size - 1;
+    hotspotCandidates.push({ name: node.name, blastRadius, filePath: node.filePath });
+  }
+  hotspotCandidates.sort((a, b) => b.blastRadius - a.blastRadius);
+  const complexityHotspots = hotspotCandidates.slice(0, 5);
+  const healthScore = Math.max(
+    0,
+    Math.min(100, 100 - deadCode.length * 2 - cycles.length * 5 - godNodes.length * 3)
+  );
+  return {
+    healthScore,
+    deadCode,
+    cycles,
+    godNodes,
+    orphanFiles,
+    complexityHotspots
+  };
+}
+
+// src/query/suggest-tests.ts
+function getSuggestedCases(symbolName) {
+  const lower = symbolName.toLowerCase();
+  if (/parse|validate|check|verify/.test(lower)) {
+    return [
+      "Valid input \u2192 success",
+      "Invalid input \u2192 throws error",
+      "Edge case: empty/null input \u2192 handled gracefully"
+    ];
+  }
+  if (/create|add|insert|save/.test(lower)) {
+    return [
+      "Success: valid data \u2192 created",
+      "Duplicate: existing item \u2192 error or no-op",
+      "Missing required fields \u2192 validation error"
+    ];
+  }
+  if (/delete|remove|destroy/.test(lower)) {
+    return [
+      "Existing item \u2192 deleted successfully",
+      "Non-existent item \u2192 no error or 404",
+      "Unauthorized access \u2192 rejected"
+    ];
+  }
+  if (/get|find|fetch|load/.test(lower)) {
+    return [
+      "Found: returns correct data",
+      "Not found: returns null or throws",
+      "Empty collection: returns []"
+    ];
+  }
+  return [
+    "Happy path: valid input \u2192 expected output",
+    "Error case: invalid input \u2192 error handled",
+    "Edge case: boundary values \u2192 correct behavior"
+  ];
+}
+function suggestTests(graph, symbolName) {
+  let targetNode = void 0;
+  for (const node of graph.allNodes()) {
+    if (node.name === symbolName) {
+      targetNode = node;
+      break;
+    }
+  }
+  if (!targetNode) {
+    return { error: `Symbol not found: ${symbolName}` };
+  }
+  const targetId = targetNode.id;
+  const callPaths = [];
+  const pathQueue = [{ id: targetId, path: [symbolName], depth: 0 }];
+  while (pathQueue.length > 0 && callPaths.length < 5) {
+    const { id, path: path34, depth } = pathQueue.shift();
+    let hasCallers = false;
+    for (const edge of graph.findEdgesTo(id)) {
+      if (edge.kind !== "calls") continue;
+      const callerNode = graph.getNode(edge.source);
+      if (!callerNode) continue;
+      hasCallers = true;
+      const newPath = [callerNode.name, ...path34];
+      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 (!hasCallers && path34.length > 1) {
+      callPaths.push(path34);
+    }
+  }
+  if (callPaths.length === 0) {
+    for (const edge of graph.findEdgesTo(targetId)) {
+      if (edge.kind !== "calls") continue;
+      const callerNode = graph.getNode(edge.source);
+      if (!callerNode) continue;
+      callPaths.push([callerNode.name, symbolName]);
+      if (callPaths.length >= 5) break;
+    }
+  }
+  const existingTestFiles = /* @__PURE__ */ new Set();
+  for (const edge of graph.findEdgesTo(targetId)) {
+    if (edge.kind !== "imports") continue;
+    const importerNode = graph.getNode(edge.source);
+    if (!importerNode) continue;
+    if (importerNode.filePath.includes(".test.") || importerNode.filePath.includes(".spec.")) {
+      existingTestFiles.add(importerNode.filePath);
+    }
+  }
+  const existingTests = [...existingTestFiles];
+  const untestedCallers = [];
+  for (const edge of graph.findEdgesTo(targetId)) {
+    if (edge.kind !== "calls") continue;
+    const callerNode = graph.getNode(edge.source);
+    if (!callerNode) continue;
+    if (callerNode.filePath.includes(".test.") || callerNode.filePath.includes(".spec.")) {
+      continue;
+    }
+    let callerHasTest = false;
+    for (const callerImportEdge of graph.findEdgesTo(callerNode.id)) {
+      if (callerImportEdge.kind !== "imports") continue;
+      const importerOfCaller = graph.getNode(callerImportEdge.source);
+      if (!importerOfCaller) continue;
+      if (importerOfCaller.filePath.includes(".test.") || importerOfCaller.filePath.includes(".spec.")) {
+        callerHasTest = true;
+        break;
+      }
+    }
+    if (!callerHasTest) {
+      untestedCallers.push(callerNode.name);
+    }
+  }
+  const suggestedCases = getSuggestedCases(symbolName);
+  return {
+    callPaths,
+    suggestedCases,
+    existingTests,
+    untestedCallers
+  };
+}
+
+// src/query/cluster-summary.ts
+function getPathPrefix(filePath) {
+  const parts = filePath.replace(/\\/g, "/").split("/");
+  return parts.slice(0, 2).join("/");
+}
+function summarizeCluster(graph, cluster) {
+  const clusterNodes = [...graph.allNodes()].filter(
+    (n) => n.filePath.startsWith(cluster) || n.metadata?.["cluster"] === cluster
+  );
+  if (clusterNodes.length === 0) {
+    return { error: `Cluster not found: ${cluster}` };
+  }
+  const clusterNodeIds = new Set(clusterNodes.map((n) => n.id));
+  const callerCountMap = /* @__PURE__ */ new Map();
+  for (const node of clusterNodes) {
+    let count = 0;
+    for (const _edge of graph.findEdgesTo(node.id)) {
+      count++;
+    }
+    callerCountMap.set(node.id, count);
+  }
+  const sortedByCallers = [...clusterNodes].sort(
+    (a, b) => (callerCountMap.get(b.id) ?? 0) - (callerCountMap.get(a.id) ?? 0)
+  );
+  const keySymbols = sortedByCallers.slice(0, 5).map((n) => ({
+    name: n.name,
+    callerCount: callerCountMap.get(n.id) ?? 0
+  }));
+  const depsSet = /* @__PURE__ */ new Set();
+  for (const node of clusterNodes) {
+    for (const edge of graph.findEdgesFrom(node.id)) {
+      if (edge.kind !== "imports") continue;
+      const targetNode = graph.getNode(edge.target);
+      if (!targetNode) continue;
+      if (!clusterNodeIds.has(targetNode.id)) {
+        const prefix = getPathPrefix(targetNode.filePath);
+        depsSet.add(prefix);
+      }
+    }
+  }
+  const dependencies = [...depsSet];
+  const dependentsSet = /* @__PURE__ */ new Set();
+  for (const node of clusterNodes) {
+    for (const edge of graph.findEdgesTo(node.id)) {
+      if (edge.kind !== "imports") continue;
+      const sourceNode = graph.getNode(edge.source);
+      if (!sourceNode) continue;
+      if (!clusterNodeIds.has(sourceNode.id)) {
+        const prefix = getPathPrefix(sourceNode.filePath);
+        dependentsSet.add(prefix);
+      }
+    }
+  }
+  const dependents = [...dependentsSet];
+  const healthResult = computeHealthReport(graph, cluster);
+  const health = { score: healthResult.healthScore };
+  const symbolCount = {};
+  for (const node of clusterNodes) {
+    symbolCount[node.kind] = (symbolCount[node.kind] ?? 0) + 1;
+  }
+  let purpose;
+  const topNode = sortedByCallers[0];
+  if (topNode?.metadata?.["summary"] && typeof topNode.metadata["summary"] === "string") {
+    purpose = topNode.metadata["summary"];
+  } else {
+    const clusterName = cluster.split("/").pop() ?? cluster;
+    purpose = `Handles ${clusterName.replace(/[-_/]/g, " ")} functionality`;
+  }
+  return {
+    cluster,
+    purpose,
+    keySymbols,
+    dependencies,
+    dependents,
+    health,
+    symbolCount
+  };
 }
-init_storage();
-init_repo_registry();
-init_metadata();
-init_group_registry();
-init_tracing();
-init_metrics();
+
+// src/mcp-server/server.ts
 function createMcpServer(graph, repoName, workspaceRoot) {
   const server = new Server(
     { name: "code-intel", version: "0.1.0" },
@@ -9619,7 +10672,8 @@ function createMcpServer(graph, repoName, workspaceRoot) {
           type: "object",
           properties: {
             query: { type: "string", description: "Search query (symbol name, keyword, or partial match)" },
-            limit: { type: "number", description: "Max results to return (default: 20)" },
+            offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
+            limit: { type: "number", description: "Max results per page (default: 50, max: 500)" },
             ..._tokenProp
           },
           required: ["query"]
@@ -9662,6 +10716,8 @@ function createMcpServer(graph, repoName, workspaceRoot) {
           type: "object",
           properties: {
             file_path: { type: "string", description: 'File path (partial match is supported, e.g. "auth/login.ts")' },
+            offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
+            limit: { type: "number", description: "Max results per page (default: 50, max: 500)" },
             ..._tokenProp
           },
           required: ["file_path"]
@@ -9691,7 +10747,8 @@ function createMcpServer(graph, repoName, workspaceRoot) {
               type: "string",
               description: "Filter by node kind: function | class | interface | method | type_alias | constant | enum (optional)"
             },
-            limit: { type: "number", description: "Max results (default: 100)" },
+            offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
+            limit: { type: "number", description: "Max results per page (default: 50, max: 500)" },
             ..._tokenProp
           }
         }
@@ -9708,7 +10765,8 @@ function createMcpServer(graph, repoName, workspaceRoot) {
         inputSchema: {
           type: "object",
           properties: {
-            limit: { type: "number", description: "Max clusters to return (default: 50)" },
+            offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
+            limit: { type: "number", description: "Max clusters per page (default: 50, max: 500)" },
             ..._tokenProp
           }
         }
@@ -9719,7 +10777,8 @@ function createMcpServer(graph, repoName, workspaceRoot) {
         inputSchema: {
           type: "object",
           properties: {
-            limit: { type: "number", description: "Max flows to return (default: 50)" },
+            offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
+            limit: { type: "number", description: "Max flows per page (default: 50, max: 500)" },
             ..._tokenProp
           }
         }
@@ -9841,6 +10900,91 @@ function createMcpServer(graph, repoName, workspaceRoot) {
           },
           required: ["name"]
         }
+      },
+      // ── Reasoning / analysis tools ────────────────────────────────────────
+      {
+        name: "explain_relationship",
+        description: "Explain how two symbols are connected: directed paths, shared imports, and heritage (extends/implements). Returns up to 10 paths with at most 5 hops each.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            from: { type: "string", description: "Source symbol name" },
+            to: { type: "string", description: "Target symbol name" },
+            ..._tokenProp
+          },
+          required: ["from", "to"]
+        }
+      },
+      {
+        name: "pr_impact",
+        description: "Given changed files or a unified diff, compute full blast radius with risk scores (HIGH/MEDIUM/LOW), test coverage gaps, and top files to review.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            changedFiles: {
+              type: "array",
+              items: { type: "string" },
+              description: "List of changed file paths (relative or absolute)"
+            },
+            diff: {
+              type: "string",
+              description: "Raw unified diff text. Changed files are extracted automatically."
+            },
+            maxHops: {
+              type: "number",
+              description: "Maximum BFS depth for blast radius (default: 5)"
+            },
+            ..._tokenProp
+          }
+        }
+      },
+      {
+        name: "similar_symbols",
+        description: "Find symbols with similar names or structure using Levenshtein distance and kind matching. Useful for finding related functions, classes, or interfaces.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            symbol: { type: "string", description: "Symbol name to find similar symbols for" },
+            limit: { type: "number", description: "Maximum number of results (default: 10, max: 50)" },
+            ..._tokenProp
+          },
+          required: ["symbol"]
+        }
+      },
+      {
+        name: "health_report",
+        description: "Code health signals for a scope: dead code, cycles, god nodes, orphan files, complexity hotspots",
+        inputSchema: {
+          type: "object",
+          properties: {
+            scope: { type: "string", description: "Directory scope, e.g. 'src/api/' or '.' for whole repo" },
+            ..._tokenProp
+          }
+        }
+      },
+      {
+        name: "suggest_tests",
+        description: "Suggest test cases for a symbol: call paths, suggested cases, existing tests, untested callers",
+        inputSchema: {
+          type: "object",
+          properties: {
+            symbol: { type: "string", description: "Symbol name to generate test suggestions for" },
+            ..._tokenProp
+          },
+          required: ["symbol"]
+        }
+      },
+      {
+        name: "cluster_summary",
+        description: "Rich summary of a module/cluster: purpose, key symbols, dependencies, health",
+        inputSchema: {
+          type: "object",
+          properties: {
+            cluster: { type: "string", description: "Cluster path e.g. 'src/auth'" },
+            ..._tokenProp
+          },
+          required: ["cluster"]
+        }
       }
     ]
   }));
@@ -9911,8 +11055,8 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       for (const edge of graph.allEdges()) {
         edgeCounts[edge.kind] = (edgeCounts[edge.kind] ?? 0) + 1;
       }
-      const { computeHealthReport: computeHealthReport2 } = await Promise.resolve().then(() => (init_health_score(), health_score_exports));
-      const healthReport = computeHealthReport2(graph);
+      const { computeHealthReport: computeHealthReport3 } = await Promise.resolve().then(() => (init_health_score(), health_score_exports));
+      const healthReport = computeHealthReport3(graph);
       const health = {
         score: Math.round(healthReport.score),
         grade: healthReport.grade,
@@ -9937,10 +11081,37 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     // ── search ─────────────────────────────────────────────────────────────
     case "search": {
       const query = a.query;
-      const limit = a.limit ?? 20;
+      const offset = a.offset ?? 0;
+      const effectiveLimit = Math.min(a.limit ?? 50, 500);
       const vdbPath = workspaceRoot ? getVectorDbPath(workspaceRoot) : void 0;
-      const { results, searchMode } = await hybridSearch(graph, query, limit, { vectorDbPath: vdbPath });
-      return { content: [{ type: "text", text: JSON.stringify({ results, searchMode, suggested_next_tools: ["inspect", "query", "blast_radius"] }, null, 2) }] };
+      const fetchLimit = Math.min(offset + effectiveLimit, 500);
+      const { results: allResults, searchMode } = await hybridSearch(graph, query, fetchLimit, { vectorDbPath: vdbPath });
+      const total = allResults.length;
+      const results = allResults.slice(offset, offset + effectiveLimit);
+      const hasMore = offset + effectiveLimit < total;
+      const suggestNextTools = [];
+      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] !== "false";
+      if (suggestEnabled && results.length > 0) {
+        const topName = results[0].name;
+        suggestNextTools.push(
+          { tool: "inspect", reason: "Inspect the top result in detail", input: { symbol: topName } },
+          { tool: "similar_symbols", reason: "Find symbols similar to the top result", input: { symbol: topName } }
+        );
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            results,
+            searchMode,
+            total,
+            offset,
+            limit: effectiveLimit,
+            hasMore,
+            ...suggestEnabled ? { suggested_next_tools: suggestNextTools } : {}
+          }, null, 2)
+        }]
+      };
     }
     // ── inspect ────────────────────────────────────────────────────────────
     case "inspect": {
@@ -9949,6 +11120,26 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       if (!node) return { content: [{ type: "text", text: `Symbol "${symbolName}" not found. Try search first.` }] };
       const incoming = [...graph.findEdgesTo(node.id)];
       const outgoing = [...graph.findEdgesFrom(node.id)];
+      const callers = incoming.filter((e) => e.kind === "calls").map((e) => ({
+        id: e.source,
+        name: graph.getNode(e.source)?.name,
+        file: graph.getNode(e.source)?.filePath
+      }));
+      const callees = outgoing.filter((e) => e.kind === "calls").map((e) => ({
+        id: e.target,
+        name: graph.getNode(e.target)?.name,
+        file: graph.getNode(e.target)?.filePath
+      }));
+      const cluster = incoming.filter((e) => e.kind === "belongs_to").map((e) => graph.getNode(e.target)?.name)[0];
+      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] !== "false";
+      const suggestNextTools = [];
+      if (suggestEnabled) {
+        const topCallerName = callers[0]?.name;
+        suggestNextTools.push(
+          ...topCallerName ? [{ tool: "explain_relationship", reason: "Explain connection to a related symbol", input: { from: node.name, to: topCallerName } }] : [],
+          ...cluster ? [{ tool: "cluster_summary", reason: "Summarize the module this symbol belongs to", input: { cluster } }] : [{ tool: "cluster_summary", reason: "Summarize the module this symbol belongs to", input: { cluster: node.filePath } }]
+        );
+      }
       return {
         content: [{
           type: "text",
@@ -9962,16 +11153,8 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
               endLine: node.endLine,
               exported: node.exported
             },
-            callers: incoming.filter((e) => e.kind === "calls").map((e) => ({
-              id: e.source,
-              name: graph.getNode(e.source)?.name,
-              file: graph.getNode(e.source)?.filePath
-            })),
-            callees: outgoing.filter((e) => e.kind === "calls").map((e) => ({
-              id: e.target,
-              name: graph.getNode(e.target)?.name,
-              file: graph.getNode(e.target)?.filePath
-            })),
+            callers,
+            callees,
             imports: incoming.filter((e) => e.kind === "imports").map((e) => graph.getNode(e.source)?.name),
             importedBy: outgoing.filter((e) => e.kind === "imports").map((e) => graph.getNode(e.target)?.name),
             extends: outgoing.filter((e) => e.kind === "extends").map((e) => graph.getNode(e.target)?.name),
@@ -9980,8 +11163,9 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
               name: graph.getNode(e.target)?.name,
               kind: graph.getNode(e.target)?.kind
             })),
-            cluster: incoming.filter((e) => e.kind === "belongs_to").map((e) => graph.getNode(e.target)?.name)[0],
-            content: node.content?.slice(0, 500)
+            cluster,
+            content: node.content?.slice(0, 500),
+            ...suggestEnabled ? { suggested_next_tools: suggestNextTools } : {}
           }, null, 2)
         }]
       };
@@ -10017,6 +11201,16 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
         return n ? { id, name: n.name, kind: n.kind, filePath: n.filePath } : { id };
       });
       const risk = affected.size > 10 ? "HIGH" : affected.size > 5 ? "MEDIUM" : "LOW";
+      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] !== "false";
+      const suggestNextTools = [];
+      if (suggestEnabled) {
+        const highestRiskSymbol = node.name;
+        const firstFilePath = affectedDetails[0]?.filePath ?? "";
+        suggestNextTools.push(
+          { tool: "suggest_tests", reason: "Generate tests for the highest-risk symbol", input: { symbol: highestRiskSymbol } },
+          { tool: "pr_impact", reason: "Compute full PR impact for changed files", input: { changedFiles: [firstFilePath] } }
+        );
+      }
       return {
         content: [{
           type: "text",
@@ -10024,7 +11218,8 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
             target: node.name,
             affectedCount: affected.size,
             riskLevel: risk,
-            affected: affectedDetails
+            affected: affectedDetails,
+            ...suggestEnabled ? { suggested_next_tools: suggestNextTools } : {}
           }, null, 2)
         }]
       };
@@ -10032,17 +11227,27 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     // ── file_symbols ───────────────────────────────────────────────────────
     case "file_symbols": {
       const filePath = a.file_path;
-      const matches = [];
+      const offset = a.offset ?? 0;
+      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const allMatches = [];
       for (const node of graph.allNodes()) {
         if (node.filePath && node.filePath.includes(filePath)) {
-          matches.push({ kind: node.kind, name: node.name, startLine: node.startLine, exported: node.exported });
+          allMatches.push({ kind: node.kind, name: node.name, startLine: node.startLine, exported: node.exported });
         }
       }
-      if (matches.length === 0) {
+      if (allMatches.length === 0) {
         return { content: [{ type: "text", text: `No symbols found for file path matching "${filePath}".` }] };
       }
-      matches.sort((a2, b) => (a2.startLine ?? 0) - (b.startLine ?? 0));
-      return { content: [{ type: "text", text: JSON.stringify(matches, null, 2) }] };
+      allMatches.sort((a2, b) => (a2.startLine ?? 0) - (b.startLine ?? 0));
+      const total = allMatches.length;
+      const matches = allMatches.slice(offset, offset + effectiveLimit);
+      const hasMore = offset + effectiveLimit < total;
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ symbols: matches, total, offset, limit: effectiveLimit, hasMore }, null, 2)
+        }]
+      };
     }
     // ── find_path ──────────────────────────────────────────────────────────
     case "find_path": {
@@ -10088,15 +11293,23 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     // ── list_exports ───────────────────────────────────────────────────────
     case "list_exports": {
       const kindFilter = a.kind;
-      const limit = a.limit ?? 100;
-      const exports$1 = [];
+      const offset = a.offset ?? 0;
+      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const allExports = [];
       for (const node of graph.allNodes()) {
         if (!node.exported) continue;
         if (kindFilter && node.kind !== kindFilter) continue;
-        exports$1.push({ kind: node.kind, name: node.name, filePath: node.filePath, startLine: node.startLine });
-        if (exports$1.length >= limit) break;
+        allExports.push({ kind: node.kind, name: node.name, filePath: node.filePath, startLine: node.startLine });
       }
-      return { content: [{ type: "text", text: JSON.stringify({ total: exports$1.length, exports: exports$1 }, null, 2) }] };
+      const total = allExports.length;
+      const exports$1 = allExports.slice(offset, offset + effectiveLimit);
+      const hasMore = offset + effectiveLimit < total;
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ exports: exports$1, total, offset, limit: effectiveLimit, hasMore }, null, 2)
+        }]
+      };
     }
     // ── routes ─────────────────────────────────────────────────────────────
     case "routes": {
@@ -10110,8 +11323,9 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     }
     // ── clusters ───────────────────────────────────────────────────────────
     case "clusters": {
-      const limit = a.limit ?? 50;
-      const clusters = [];
+      const offset = a.offset ?? 0;
+      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const allClusters = [];
       for (const node of graph.allNodes()) {
         if (node.kind === "cluster") {
           const members = [];
@@ -10123,35 +11337,50 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
               }
             }
           }
-          clusters.push({
+          allClusters.push({
             id: node.id,
             name: node.name,
             memberCount: node.metadata?.memberCount ?? members.length,
             topSymbols: members.slice(0, 10)
           });
-          if (clusters.length >= limit) break;
         }
       }
-      return { content: [{ type: "text", text: JSON.stringify(clusters, null, 2) }] };
+      const total = allClusters.length;
+      const clusters = allClusters.slice(offset, offset + effectiveLimit);
+      const hasMore = offset + effectiveLimit < total;
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ clusters, total, offset, limit: effectiveLimit, hasMore }, null, 2)
+        }]
+      };
     }
     // ── flows ──────────────────────────────────────────────────────────────
     case "flows": {
-      const limit = a.limit ?? 50;
-      const flows = [];
+      const offset = a.offset ?? 0;
+      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const allFlows = [];
       for (const node of graph.allNodes()) {
         if (node.kind === "flow") {
           const steps = node.metadata?.steps;
-          flows.push({
+          allFlows.push({
             id: node.id,
             name: node.name,
             entryPoint: node.metadata?.entryPoint,
             steps: steps ?? [],
             stepCount: Array.isArray(steps) ? steps.length : 0
           });
-          if (flows.length >= limit) break;
         }
       }
-      return { content: [{ type: "text", text: JSON.stringify(flows, null, 2) }] };
+      const total = allFlows.length;
+      const flows = allFlows.slice(offset, offset + effectiveLimit);
+      const hasMore = offset + effectiveLimit < total;
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ flows, total, offset, limit: effectiveLimit, hasMore }, null, 2)
+        }]
+      };
     }
     // ── detect_changes ─────────────────────────────────────────────────────
     case "detect_changes": {
@@ -10179,7 +11408,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 + path30.sep, "");
+          const normNode = node.filePath.replace(repoRoot + "/", "").replace(repoRoot + path33.sep, "");
           const normChanged = changedFile.replace(/^a\/|^b\//, "");
           if (!normNode.endsWith(normChanged) && !normChanged.endsWith(normNode)) continue;
           if (node.startLine !== void 0 && node.endLine !== void 0) {
@@ -10401,6 +11630,57 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
         }]
       };
     }
+    // ── explain_relationship ───────────────────────────────────────────────
+    case "explain_relationship": {
+      const fromName = a.from;
+      const toName = a.to;
+      const result = explainRelationship(graph, fromName, toName);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    // ── pr_impact ──────────────────────────────────────────────────────────
+    case "pr_impact": {
+      const maxHops = a.maxHops ?? 5;
+      let changedFiles = a.changedFiles ?? [];
+      if (a.diff && typeof a.diff === "string") {
+        const diffFiles = parseDiffFiles(a.diff);
+        changedFiles = [.../* @__PURE__ */ new Set([...changedFiles, ...diffFiles])];
+      }
+      if (changedFiles.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ error: 'No changed files provided. Supply "changedFiles" or "diff".' })
+          }]
+        };
+      }
+      const result = computePRImpact(graph, changedFiles, maxHops);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    // ── similar_symbols ────────────────────────────────────────────────────
+    case "similar_symbols": {
+      const symbolName = a.symbol;
+      const limit = a.limit ?? 10;
+      const result = findSimilarSymbols(graph, symbolName, limit);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    // ── health_report ──────────────────────────────────────────────────────
+    case "health_report": {
+      const scope = a.scope ?? ".";
+      const result = computeHealthReport(graph, scope);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    // ── suggest_tests ──────────────────────────────────────────────────────
+    case "suggest_tests": {
+      const sym = a.symbol;
+      const result = suggestTests(graph, sym);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    // ── cluster_summary ────────────────────────────────────────────────────
+    case "cluster_summary": {
+      const cluster = a.cluster;
+      const result = summarizeCluster(graph, cluster);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
     default:
       return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
   }
@@ -10487,20 +11767,20 @@ function parseDiff(diffText) {
 // src/cli/main.ts
 init_metadata();
 async function writeSkillFiles(graph, workspaceRoot, projectName) {
-  const outputDir = path30.join(workspaceRoot, ".claude", "skills", "code-intel");
+  const outputDir = path33.join(workspaceRoot, ".claude", "skills", "code-intel");
   const areas = buildAreaMap(graph, workspaceRoot);
   if (areas.length === 0) return { skills: [], outputDir };
-  fs28.rmSync(outputDir, { recursive: true, force: true });
-  fs28.mkdirSync(outputDir, { recursive: true });
+  fs33.rmSync(outputDir, { recursive: true, force: true });
+  fs33.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 = path30.join(outputDir, kebab);
-    fs28.mkdirSync(dir, { recursive: true });
-    fs28.writeFileSync(path30.join(dir, "SKILL.md"), content, "utf-8");
+    const dir = path33.join(outputDir, kebab);
+    fs33.mkdirSync(dir, { recursive: true });
+    fs33.writeFileSync(path33.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 };
@@ -10680,8 +11960,8 @@ 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(path30.join(workspaceRoot, "AGENTS.md"), block, "AGENTS.md");
-  upsertFile(path30.join(workspaceRoot, "CLAUDE.md"), block, "CLAUDE.md");
+  upsertFile(path33.join(workspaceRoot, "AGENTS.md"), block, "AGENTS.md");
+  upsertFile(path33.join(workspaceRoot, "CLAUDE.md"), block, "CLAUDE.md");
 }
 function buildBlock(projectName, stats, skills) {
   const skillRows = skills.map(
@@ -10735,7 +12015,7 @@ ${skillTable}
 ${BLOCK_END}`;
 }
 function upsertFile(filePath, block, fileName) {
-  if (!fs28.existsSync(filePath)) {
+  if (!fs33.existsSync(filePath)) {
     const newContent = [
       `# ${fileName}`,
       "",
@@ -10746,17 +12026,17 @@ function upsertFile(filePath, block, fileName) {
       "<!-- Add your own custom notes below this line. They will never be overwritten by code-intel. -->",
       ""
     ].join("\n");
-    fs28.writeFileSync(filePath, newContent, "utf-8");
+    fs33.writeFileSync(filePath, newContent, "utf-8");
     return;
   }
-  const existing = fs28.readFileSync(filePath, "utf-8");
+  const existing = fs33.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";
-    fs28.writeFileSync(filePath, updated, "utf-8");
+    fs33.writeFileSync(filePath, updated, "utf-8");
     return;
   }
   const appended = [
@@ -10769,7 +12049,7 @@ function upsertFile(filePath, block, fileName) {
     block,
     ""
   ].join("\n");
-  fs28.writeFileSync(filePath, appended, "utf-8");
+  fs33.writeFileSync(filePath, appended, "utf-8");
 }
 function findLineMarker(content, marker, startFrom = 0) {
   let idx = content.indexOf(marker, startFrom);
@@ -10811,14 +12091,14 @@ function getChangedFilesSince(workspaceRoot, baseHash) {
 function filterChangedByMtime(allFilePaths, workspaceRoot, storedMtimes) {
   const changed = [];
   for (const absPath of allFilePaths) {
-    const rel = path30.relative(workspaceRoot, absPath);
+    const rel = path33.relative(workspaceRoot, absPath);
     const stored = storedMtimes[rel];
     if (stored === void 0) {
       changed.push(absPath);
       continue;
     }
     try {
-      const { mtimeMs } = fs28.statSync(absPath);
+      const { mtimeMs } = fs33.statSync(absPath);
       if (mtimeMs > stored) changed.push(absPath);
     } catch {
       changed.push(absPath);
@@ -10830,8 +12110,8 @@ function buildMtimeSnapshot(filePaths, workspaceRoot) {
   const snap = {};
   for (const absPath of filePaths) {
     try {
-      const { mtimeMs } = fs28.statSync(absPath);
-      snap[path30.relative(workspaceRoot, absPath)] = mtimeMs;
+      const { mtimeMs } = fs33.statSync(absPath);
+      snap[path33.relative(workspaceRoot, absPath)] = mtimeMs;
     } catch {
     }
   }
@@ -10842,8 +12122,8 @@ function decideIncremental(workspaceRoot, allFilePaths, prevCommitHash, storedMt
   if (prevCommitHash) {
     const changed = getChangedFilesSince(workspaceRoot, prevCommitHash);
     if (changed !== null) {
-      const scanSet = new Set(allFilePaths.map((p) => path30.relative(workspaceRoot, p)));
-      const changedInScan = changed.filter((rel) => scanSet.has(rel)).map((rel) => path30.join(workspaceRoot, rel));
+      const scanSet = new Set(allFilePaths.map((p) => path33.relative(workspaceRoot, p)));
+      const changedInScan = changed.filter((rel) => scanSet.has(rel)).map((rel) => path33.join(workspaceRoot, rel));
       if (total > 0 && changedInScan.length / total > 0.2) {
         return { incremental: false, fallbackReason: `changed files (${changedInScan.length}) > 20% of total (${total})` };
       }
@@ -10864,7 +12144,135 @@ function decideIncremental(workspaceRoot, allFilePaths, prevCommitHash, storedMt
 }
 
 // src/cli/main.ts
+init_graph_from_db();
 init_group_registry();
+init_group_sync();
+function expandGlob(root, pattern) {
+  const parts = pattern.replace(/\/\*\*?$/, "").split("/").filter(Boolean);
+  if (parts.length === 0) return [];
+  const dir = path33.join(root, ...parts);
+  if (!fs33.existsSync(dir)) return [];
+  return fs33.readdirSync(dir).map((entry) => path33.join(dir, entry)).filter((p) => {
+    try {
+      return fs33.statSync(p).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+function resolvePackages(root, patterns) {
+  const packages = [];
+  for (const pattern of patterns) {
+    const dirs = expandGlob(root, pattern);
+    for (const dir of dirs) {
+      const pkgJsonPath = path33.join(dir, "package.json");
+      if (!fs33.existsSync(pkgJsonPath)) continue;
+      try {
+        const pkgJson = JSON.parse(fs33.readFileSync(pkgJsonPath, "utf-8"));
+        const name = pkgJson.name ?? path33.basename(dir);
+        packages.push({ name, path: dir });
+      } catch {
+      }
+    }
+  }
+  return packages;
+}
+async function detectWorkspace(root) {
+  const turboJsonPath = path33.join(root, "turbo.json");
+  if (fs33.existsSync(turboJsonPath)) {
+    let patterns = [];
+    const pkgJsonPath = path33.join(root, "package.json");
+    if (fs33.existsSync(pkgJsonPath)) {
+      try {
+        const pkgJson = JSON.parse(fs33.readFileSync(pkgJsonPath, "utf-8"));
+        if (pkgJson.workspaces) {
+          patterns = Array.isArray(pkgJson.workspaces) ? pkgJson.workspaces : pkgJson.workspaces.packages;
+        }
+      } catch {
+      }
+    }
+    if (patterns.length === 0) {
+      const fallbackDir = path33.join(root, "packages");
+      if (fs33.existsSync(fallbackDir)) patterns = ["packages/*"];
+    }
+    const packages = resolvePackages(root, patterns);
+    return { type: "turborepo", root, packages };
+  }
+  const npmPkgJsonPath = path33.join(root, "package.json");
+  if (fs33.existsSync(npmPkgJsonPath)) {
+    try {
+      const pkgJson = JSON.parse(fs33.readFileSync(npmPkgJsonPath, "utf-8"));
+      if (pkgJson.workspaces) {
+        const patterns = Array.isArray(pkgJson.workspaces) ? pkgJson.workspaces : pkgJson.workspaces.packages;
+        const packages = resolvePackages(root, patterns);
+        return { type: "npm", root, packages };
+      }
+    } catch {
+    }
+  }
+  const pnpmYamlPath = path33.join(root, "pnpm-workspace.yaml");
+  if (fs33.existsSync(pnpmYamlPath)) {
+    const patterns = [];
+    try {
+      const content = fs33.readFileSync(pnpmYamlPath, "utf-8");
+      let inPackages = false;
+      for (const line of content.split("\n")) {
+        if (/^packages\s*:/.test(line)) {
+          inPackages = true;
+          continue;
+        }
+        if (inPackages) {
+          if (/^\s*-\s+/.test(line)) {
+            patterns.push(line.replace(/^\s*-\s+/, "").replace(/['"]/g, "").trim());
+          } else if (line.trim() && !/^\s/.test(line)) {
+            inPackages = false;
+          }
+        }
+      }
+    } catch {
+    }
+    const packages = resolvePackages(root, patterns);
+    return { type: "pnpm", root, packages };
+  }
+  const nxJsonPath = path33.join(root, "nx.json");
+  if (fs33.existsSync(nxJsonPath)) {
+    const packages = [];
+    const scanForProjects = (dir, depth) => {
+      if (depth > 2) return;
+      let entries;
+      try {
+        entries = fs33.readdirSync(dir);
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry === "node_modules" || entry.startsWith(".")) continue;
+        const fullPath = path33.join(dir, entry);
+        try {
+          if (!fs33.statSync(fullPath).isDirectory()) continue;
+        } catch {
+          continue;
+        }
+        const projectJsonPath = path33.join(fullPath, "project.json");
+        if (fs33.existsSync(projectJsonPath)) {
+          try {
+            const proj = JSON.parse(fs33.readFileSync(projectJsonPath, "utf-8"));
+            const name = proj.name ?? path33.basename(fullPath);
+            packages.push({ name, path: fullPath });
+          } catch {
+          }
+        } else {
+          scanForProjects(fullPath, depth + 1);
+        }
+      }
+    };
+    scanForProjects(root, 1);
+    return { type: "nx", root, packages };
+  }
+  return null;
+}
+
+// src/cli/main.ts
 init_users_db();
 var migrations = [
   {
@@ -10957,17 +12365,17 @@ var MigrationRunner = class {
   autoBackupBeforeMigration() {
     try {
       const dbFile = this.db.name;
-      if (!dbFile || !fs28.existsSync(dbFile)) return;
-      const backupDir = path30.join(os12.homedir(), ".code-intel", "backups", "pre-migration");
-      fs28.mkdirSync(backupDir, { recursive: true });
+      if (!dbFile || !fs33.existsSync(dbFile)) return;
+      const backupDir = path33.join(os12.homedir(), ".code-intel", "backups", "pre-migration");
+      fs33.mkdirSync(backupDir, { recursive: true });
       const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const baseName = path30.basename(dbFile, ".db");
-      const backupPath = path30.join(backupDir, `${baseName}-pre-migration-${ts}.db`);
+      const baseName = path33.basename(dbFile, ".db");
+      const backupPath = path33.join(backupDir, `${baseName}-pre-migration-${ts}.db`);
       try {
         this.db.pragma("wal_checkpoint(TRUNCATE)");
       } catch {
       }
-      fs28.copyFileSync(dbFile, backupPath);
+      fs33.copyFileSync(dbFile, backupPath);
     } catch {
     }
   }
@@ -11183,7 +12591,7 @@ 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 = path30.resolve(targetPath);
+  const workspaceRoot = path33.resolve(targetPath);
   if (!options?.silent) console.log(`Analyzing: ${workspaceRoot}`);
   logger_default.info(`analyze started: ${workspaceRoot}`);
   if (options?.force) {
@@ -11204,14 +12612,14 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of wipeFiles) {
       try {
-        if (fs28.existsSync(f)) fs28.unlinkSync(f);
+        if (fs33.existsSync(f)) fs33.unlinkSync(f);
       } catch {
       }
     }
   }
   if (!options?.skipGit) {
-    const gitDir = path30.join(workspaceRoot, ".git");
-    if (!fs28.existsSync(gitDir)) {
+    const gitDir = path33.join(workspaceRoot, ".git");
+    if (!fs33.existsSync(gitDir)) {
       logger_default.warn(`${workspaceRoot} is not a Git repository`);
     }
   }
@@ -11322,17 +12730,17 @@ async function analyzeWorkspace(targetPath, options) {
   const result = await runPipeline(phases, context2);
   if (isIncremental && incrementalChangedFiles && incrementalChangedFiles.length > 0) {
     const dbPath = getDbPath(workspaceRoot);
-    if (fs28.existsSync(dbPath)) {
+    if (fs33.existsSync(dbPath)) {
       try {
         const db = new DbManager(dbPath);
         await db.init();
         for (const absPath of incrementalChangedFiles) {
-          const rel = path30.relative(workspaceRoot, absPath);
+          const rel = path33.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) => path30.relative(workspaceRoot, f))
+          incrementalChangedFiles.map((f) => path33.relative(workspaceRoot, f))
         );
         const nodesToUpsert = [...graph.allNodes()].filter(
           (n) => changedRelPaths.has(n.filePath)
@@ -11357,7 +12765,7 @@ async function analyzeWorkspace(targetPath, options) {
     mergedMtimes = newMtimes;
   }
   const currentCommitHash = getCurrentCommitHash(workspaceRoot) ?? void 0;
-  const repoName = path30.basename(workspaceRoot);
+  const repoName = path33.basename(workspaceRoot);
   const indexVersion = v4();
   saveMetadata(workspaceRoot, {
     indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -11395,7 +12803,7 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of newStaleFiles) {
       try {
-        if (fs28.existsSync(f)) fs28.unlinkSync(f);
+        if (fs33.existsSync(f)) fs33.unlinkSync(f);
       } catch {
       }
     }
@@ -11412,21 +12820,21 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of staleFiles) {
       try {
-        if (fs28.existsSync(f)) fs28.unlinkSync(f);
+        if (fs33.existsSync(f)) fs33.unlinkSync(f);
       } catch {
       }
     }
     for (const f of newStaleFiles) {
       if (f === dbPathNew) continue;
-      if (fs28.existsSync(f)) {
+      if (fs33.existsSync(f)) {
         const dest = f.replace(dbPathNew, dbPath);
         try {
-          fs28.renameSync(f, dest);
+          fs33.renameSync(f, dest);
         } catch {
         }
       }
     }
-    fs28.renameSync(dbPathNew, dbPath);
+    fs33.renameSync(dbPathNew, dbPath);
     stopSpinner();
     logger_default.info(`DB persisted: ${nodeCount} nodes, ${edgeCount} edges`);
     if (!options?.silent) {
@@ -11447,7 +12855,7 @@ async function analyzeWorkspace(targetPath, options) {
       const staleVdb = [vdbPath, `${vdbPath}-shm`, `${vdbPath}-wal`];
       for (const f of staleVdb) {
         try {
-          if (fs28.existsSync(f)) fs28.unlinkSync(f);
+          if (fs33.existsSync(f)) fs33.unlinkSync(f);
         } catch {
         }
       }
@@ -11517,6 +12925,32 @@ async function analyzeWorkspace(targetPath, options) {
   \u2705  Done in ${durStr}  \u2014  ${graph.size.nodes} nodes \xB7 ${graph.size.edges} edges \xB7 ${context2.filePaths.length} files`);
   }
   logger_default.info(`analyze complete: ${graph.size.nodes} nodes, ${graph.size.edges} edges, ${context2.filePaths.length} files, ${result.totalDuration}ms`);
+  if (!options?.noGroupSync) {
+    const registry = loadRegistry();
+    const repoEntry = registry.find((r) => r.path === workspaceRoot);
+    if (repoEntry) {
+      const allGroups = listGroups();
+      for (const g of allGroups) {
+        const group = loadGroup(g.name);
+        if (!group) continue;
+        const isMember = group.members.some((m) => m.registryName === repoEntry.name);
+        if (!isMember) continue;
+        if (!options?.silent) console.log(`  \u2839 Syncing group '${g.name}'\u2026`);
+        try {
+          const { syncGroup: doSyncGroup } = await Promise.resolve().then(() => (init_group_sync(), group_sync_exports));
+          const { saveSyncResult: doSaveSyncResult } = await Promise.resolve().then(() => (init_group_registry(), group_registry_exports));
+          const syncResult = await doSyncGroup(group);
+          doSaveSyncResult(syncResult);
+          group.lastSync = syncResult.syncedAt;
+          const { saveGroup: doSaveGroup } = await Promise.resolve().then(() => (init_group_registry(), group_registry_exports));
+          doSaveGroup(group);
+          if (!options?.silent) console.log(`  \u2705 Group '${g.name}' synced`);
+        } catch (err) {
+          if (!options?.silent) console.warn(`  \u26A0  Group sync failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+  }
   return { graph, result, repoName, workspaceRoot };
 }
 program.command("setup").description("Configure MCP server for your editors (one-time setup)").addHelpText("after", `
@@ -11545,8 +12979,8 @@ program.command("setup").description("Configure MCP server for your editors (one
     const configFile = `${configDir}/claude_desktop_config.json`;
     try {
       let existing = {};
-      if (fs28.existsSync(configFile)) {
-        existing = JSON.parse(fs28.readFileSync(configFile, "utf-8"));
+      if (fs33.existsSync(configFile)) {
+        existing = JSON.parse(fs33.readFileSync(configFile, "utf-8"));
       }
       const merged = {
         ...existing,
@@ -11555,8 +12989,8 @@ program.command("setup").description("Configure MCP server for your editors (one
           ...mcpConfig.mcpServers
         }
       };
-      fs28.mkdirSync(configDir, { recursive: true });
-      fs28.writeFileSync(configFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      fs33.mkdirSync(configDir, { recursive: true });
+      fs33.writeFileSync(configFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
       console.log(`
   \u2705  Written to ${configFile}`);
     } catch (err) {
@@ -11570,7 +13004,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)").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").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.
@@ -11626,10 +13060,10 @@ 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 = path30.resolve(targetPath);
-  const repoName = path30.basename(workspaceRoot);
+  const workspaceRoot = path33.resolve(targetPath);
+  const repoName = path33.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = fs28.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = fs33.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
@@ -11660,10 +13094,10 @@ 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 = path30.resolve(targetPath);
-  const repoName = path30.basename(workspaceRoot);
+  const workspaceRoot = path33.resolve(targetPath);
+  const repoName = path33.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = !options.force && fs28.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = !options.force && fs33.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const meta = loadMetadata(workspaceRoot);
     if (meta.parser === "regex" || meta.parser === void 0) {
@@ -11697,10 +13131,10 @@ 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 = path30.resolve(targetPath);
-  const repoName = path30.basename(workspaceRoot);
+  const workspaceRoot = path33.resolve(targetPath);
+  const repoName = path33.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = !options.force && fs28.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = !options.force && fs33.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   let graph;
   if (existingIndex) {
     const meta = loadMetadata(workspaceRoot);
@@ -11735,7 +13169,7 @@ program.command("watch").description("Start HTTP server + file watcher (auto-rei
         type: "graph:updated",
         indexVersion: meta?.indexVersion ?? "unknown",
         stats: { nodes: graph.size.nodes, edges: graph.size.edges },
-        changedFiles: changedFiles.map((f) => path30.relative(workspaceRoot, f)),
+        changedFiles: changedFiles.map((f) => path33.relative(workspaceRoot, f)),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
@@ -11786,7 +13220,7 @@ program.command("status").description("Show index freshness and statistics for a
     $ code-intel status
     $ code-intel status ./my-project
 `).action((targetPath) => {
-  const workspaceRoot = path30.resolve(targetPath);
+  const workspaceRoot = path33.resolve(targetPath);
   const meta = loadMetadata(workspaceRoot);
   if (!meta) {
     console.log(`
@@ -11810,18 +13244,18 @@ function trashDirName(repoPath) {
   return `.code-intel-trash-${date}`;
 }
 function softDeleteCodeIntel(repoPath) {
-  const codeIntelDir = path30.join(repoPath, ".code-intel");
-  if (!fs28.existsSync(codeIntelDir)) return;
+  const codeIntelDir = path33.join(repoPath, ".code-intel");
+  if (!fs33.existsSync(codeIntelDir)) return;
   const trashName = trashDirName();
-  const trashDir = path30.join(repoPath, trashName);
+  const trashDir = path33.join(repoPath, trashName);
   let dest = trashDir;
   let counter = 1;
-  while (fs28.existsSync(dest)) {
+  while (fs33.existsSync(dest)) {
     dest = `${trashDir}-${counter++}`;
   }
-  fs28.renameSync(codeIntelDir, dest);
-  fs28.writeFileSync(
-    path30.join(dest, "TRASH_META.json"),
+  fs33.renameSync(codeIntelDir, dest);
+  fs33.writeFileSync(
+    path33.join(dest, "TRASH_META.json"),
     JSON.stringify({ deletedAt: (/* @__PURE__ */ new Date()).toISOString(), repoPath, permanent: false }, null, 2)
   );
   console.log(`  \u2713  Moved to trash: ${dest}`);
@@ -11830,15 +13264,15 @@ function softDeleteCodeIntel(repoPath) {
 function purgeStaleTrashes(repoPath) {
   const cutoff = Date.now() - TRASH_TTL_DAYS * 24 * 60 * 60 * 1e3;
   try {
-    for (const entry of fs28.readdirSync(repoPath)) {
+    for (const entry of fs33.readdirSync(repoPath)) {
       if (!entry.startsWith(".code-intel-trash-")) continue;
-      const fullPath = path30.join(repoPath, entry);
-      const metaPath = path30.join(fullPath, "TRASH_META.json");
-      if (fs28.existsSync(metaPath)) {
+      const fullPath = path33.join(repoPath, entry);
+      const metaPath = path33.join(fullPath, "TRASH_META.json");
+      if (fs33.existsSync(metaPath)) {
         try {
-          const meta = JSON.parse(fs28.readFileSync(metaPath, "utf-8"));
+          const meta = JSON.parse(fs33.readFileSync(metaPath, "utf-8"));
           if (new Date(meta.deletedAt).getTime() < cutoff) {
-            fs28.rmSync(fullPath, { recursive: true, force: true });
+            fs33.rmSync(fullPath, { recursive: true, force: true });
             console.log(`  \u2713  Auto-purged stale trash: ${fullPath}`);
           }
         } catch {
@@ -11865,18 +13299,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(path30.resolve("."));
+    if (roots.length === 0) roots.push(path33.resolve("."));
     let found = 0;
     for (const root of roots) {
       try {
-        for (const entry of fs28.readdirSync(root)) {
+        for (const entry of fs33.readdirSync(root)) {
           if (!entry.startsWith(".code-intel-trash-")) continue;
-          const fullPath = path30.join(root, entry);
-          const metaPath = path30.join(fullPath, "TRASH_META.json");
+          const fullPath = path33.join(root, entry);
+          const metaPath = path33.join(fullPath, "TRASH_META.json");
           let deletedAt = "unknown";
-          if (fs28.existsSync(metaPath)) {
+          if (fs33.existsSync(metaPath)) {
             try {
-              deletedAt = JSON.parse(fs28.readFileSync(metaPath, "utf-8")).deletedAt;
+              deletedAt = JSON.parse(fs33.readFileSync(metaPath, "utf-8")).deletedAt;
             } catch {
             }
           }
@@ -11904,9 +13338,9 @@ program.command("clean").description("Soft-delete the knowledge graph index for
     }
     for (const r of repos) {
       if (opts.purge) {
-        const codeIntelDir = path30.join(r.path, ".code-intel");
-        if (fs28.existsSync(codeIntelDir)) {
-          fs28.rmSync(codeIntelDir, { recursive: true, force: true });
+        const codeIntelDir = path33.join(r.path, ".code-intel");
+        if (fs33.existsSync(codeIntelDir)) {
+          fs33.rmSync(codeIntelDir, { recursive: true, force: true });
           console.log(`  \u2713  Hard-deleted ${codeIntelDir}`);
         }
       } else {
@@ -11920,11 +13354,11 @@ program.command("clean").description("Soft-delete the knowledge graph index for
 `);
     return;
   }
-  const workspaceRoot = path30.resolve(targetPath);
+  const workspaceRoot = path33.resolve(targetPath);
   if (opts.purge) {
-    const codeIntelDir = path30.join(workspaceRoot, ".code-intel");
-    if (fs28.existsSync(codeIntelDir)) {
-      fs28.rmSync(codeIntelDir, { recursive: true, force: true });
+    const codeIntelDir = path33.join(workspaceRoot, ".code-intel");
+    if (fs33.existsSync(codeIntelDir)) {
+      fs33.rmSync(codeIntelDir, { recursive: true, force: true });
       console.log(`
   \u2713  Hard-deleted ${codeIntelDir}`);
     }
@@ -11936,16 +13370,16 @@ program.command("clean").description("Soft-delete the knowledge graph index for
   console.log("  Index cleaned.\n");
 });
 async function loadOrAnalyzeWorkspace(targetPath) {
-  const workspaceRoot = path30.resolve(targetPath);
+  const workspaceRoot = path33.resolve(targetPath);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = fs28.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = fs33.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
     await db.init();
     await loadGraphFromDB(graph, db);
     db.close();
-    return { graph, workspaceRoot, repoName: path30.basename(workspaceRoot) };
+    return { graph, workspaceRoot, repoName: path33.basename(workspaceRoot) };
   }
   return analyzeWorkspace(targetPath, { silent: true });
 }
@@ -12373,9 +13807,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 = path30.join(regEntry.path, ".code-intel", "meta.json");
+    const metaPath = path33.join(regEntry.path, ".code-intel", "meta.json");
     try {
-      const meta = JSON.parse(fs28.readFileSync(metaPath, "utf-8"));
+      const meta = JSON.parse(fs33.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)" : "";
@@ -12391,6 +13825,94 @@ 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 = path33.resolve(targetPath ?? ".");
+  const ws = await detectWorkspace(root);
+  if (!ws) {
+    console.error(`
+  \u2717  No workspace config found in: ${root}`);
+    console.error(`     Expected: package.json with workspaces, pnpm-workspace.yaml, nx.json, or turbo.json
+`);
+    process.exit(1);
+  }
+  const groupName = opts.name ?? path33.basename(root);
+  console.log(`
+  \u25C8  Workspace detected: ${ws.type}`);
+  console.log(`     Group name    : ${groupName}`);
+  console.log(`     Packages (${ws.packages.length}):
+`);
+  for (const pkg of ws.packages) {
+    console.log(`       ${pkg.name.padEnd(35)} ${pkg.path}`);
+  }
+  if (!opts.yes) {
+    const answer = await new Promise((resolve) => {
+      process.stdout.write("\n  Proceed? [y/N] ");
+      process.stdin.once("data", (data) => resolve(data.toString().trim().toLowerCase()));
+    });
+    if (answer !== "y" && answer !== "yes") {
+      console.log("\n  Aborted.\n");
+      process.exit(0);
+    }
+  }
+  if (groupExists(groupName)) {
+    console.log(`
+  \u2139  Group "${groupName}" already exists \u2014 will update.`);
+  } else {
+    saveGroup({ name: groupName, createdAt: (/* @__PURE__ */ new Date()).toISOString(), members: [] });
+    console.log(`
+  \u2705  Group "${groupName}" created.`);
+  }
+  const parallel = Math.max(1, parseInt(opts.parallel, 10));
+  const results = [];
+  if (opts.analyze !== false) {
+    console.log(`
+  Analyzing ${ws.packages.length} packages (parallel: ${parallel})\u2026
+`);
+    for (let i = 0; i < ws.packages.length; i += parallel) {
+      const chunk = ws.packages.slice(i, i + parallel);
+      await Promise.all(chunk.map(async (pkg, j) => {
+        const idx = i + j + 1;
+        console.log(`  [${idx}/${ws.packages.length}] Analyzing ${pkg.name}\u2026`);
+        try {
+          await analyzeWorkspace(pkg.path, { silent: true });
+          results.push({ name: pkg.name, status: "\u2705" });
+        } catch (err) {
+          results.push({ name: pkg.name, status: `\u2717 ${err instanceof Error ? err.message : String(err)}` });
+        }
+      }));
+    }
+  } else {
+    for (const pkg of ws.packages) {
+      results.push({ name: pkg.name, status: "--no-analyze" });
+    }
+  }
+  for (const pkg of ws.packages) {
+    try {
+      upsertRepo({ name: pkg.name, path: pkg.path, indexedAt: (/* @__PURE__ */ new Date()).toISOString(), stats: { nodes: 0, edges: 0, files: 0 } });
+      addMember(groupName, { groupPath: pkg.name, registryName: pkg.name });
+    } catch {
+    }
+  }
+  console.log(`
+  \u27F3 Syncing group "${groupName}"\u2026`);
+  try {
+    const group = loadGroup(groupName);
+    const syncResult = await syncGroup(group);
+    saveSyncResult(syncResult);
+    group.lastSync = syncResult.syncedAt;
+    saveGroup(group);
+    console.log(`  \u2705  Sync complete \u2014 ${syncResult.contracts.length} contracts, ${syncResult.links.length} cross-links`);
+  } catch (err) {
+    console.warn(`  \u26A0  Sync failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  console.log(`
+  Summary:
+`);
+  for (const r of results) {
+    console.log(`    ${r.status.padEnd(4)} ${r.name}`);
+  }
+  console.log("");
+});
 var userCmd = program.command("user").description("Manage local user accounts");
 userCmd.command("create <username>").description("Create a new local user account").requiredOption("--role <role>", "Role: admin | analyst | viewer | repo-owner").option("--password <password>", "Password (prompted if omitted)").addHelpText("after", `
   Examples:
@@ -12592,7 +14114,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 = path30.resolve(targetPath);
+  const repoPath = path33.resolve(targetPath);
   const svc = new BackupService();
   try {
     const entry = svc.createBackup(repoPath);
@@ -12621,7 +14143,7 @@ backupCmd.command("list").description("List all available backups").action(() =>
   Backups (${entries.length}):
 `);
   for (const e of entries) {
-    const exists = fs28.existsSync(e.path);
+    const exists = fs33.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}`);
   }
@@ -12634,7 +14156,7 @@ backupCmd.command("restore <id>").description("Restore a backup by ID").option("
 `).action((id, opts) => {
   const svc = new BackupService();
   try {
-    const targetPath = opts.target ? path30.resolve(opts.target) : void 0;
+    const targetPath = opts.target ? path33.resolve(opts.target) : void 0;
     svc.restoreBackup(id, targetPath);
     console.log(`
   \u2705  Backup "${id}" restored successfully.
@@ -12653,8 +14175,8 @@ program.command("migrate").description("Manage database schema migrations").opti
     $ code-intel migrate
     $ code-intel migrate --rollback
 `).action((opts) => {
-  const dbPath = opts.db ?? path30.join(os12.homedir(), ".code-intel", "users.db");
-  if (!fs28.existsSync(dbPath)) {
+  const dbPath = opts.db ?? path33.join(os12.homedir(), ".code-intel", "users.db");
+  if (!fs33.existsSync(dbPath)) {
     console.error(`
   \u2717  Database not found: ${dbPath}
   Run \`code-intel serve\` or \`code-intel user create\` first.
@@ -12769,15 +14291,15 @@ authCmd.command("login").description("Authenticate via OIDC device flow \u2014 o
   }
   try {
     const tokens = await pollDeviceFlow3(config, deviceResponse);
-    const tokenPath = path30.join(os12.homedir(), ".code-intel", "oidc-token.json");
+    const tokenPath = path33.join(os12.homedir(), ".code-intel", "oidc-token.json");
     const tokenData = {
       accessToken: tokens.accessToken,
       refreshToken: tokens.refreshToken,
       server: serverUrl,
       storedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs28.mkdirSync(path30.dirname(tokenPath), { recursive: true });
-    fs28.writeFileSync(tokenPath, JSON.stringify(tokenData, null, 2), { mode: 384 });
+    fs33.mkdirSync(path33.dirname(tokenPath), { recursive: true });
+    fs33.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.
@@ -12790,13 +14312,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 = path30.join(os12.homedir(), ".code-intel", "oidc-token.json");
-  if (!fs28.existsSync(tokenPath)) {
+  const tokenPath = path33.join(os12.homedir(), ".code-intel", "oidc-token.json");
+  if (!fs33.existsSync(tokenPath)) {
     console.log("\n  Not authenticated via OIDC. Run: code-intel auth login\n");
     return;
   }
   try {
-    const data = JSON.parse(fs28.readFileSync(tokenPath, "utf-8"));
+    const data = JSON.parse(fs33.readFileSync(tokenPath, "utf-8"));
     console.log(`
   \u2705  OIDC token stored`);
     console.log(`  Server : ${data.server ?? "unknown"}`);
@@ -12808,9 +14330,9 @@ authCmd.command("status").description("Show the current OIDC authentication stat
   }
 });
 authCmd.command("logout").description("Remove locally stored OIDC token").action(() => {
-  const tokenPath = path30.join(os12.homedir(), ".code-intel", "oidc-token.json");
-  if (fs28.existsSync(tokenPath)) {
-    fs28.unlinkSync(tokenPath);
+  const tokenPath = path33.join(os12.homedir(), ".code-intel", "oidc-token.json");
+  if (fs33.existsSync(tokenPath)) {
+    fs33.unlinkSync(tokenPath);
     console.log("\n  \u2705  OIDC token removed. You are now logged out.\n");
   } else {
     console.log("\n  No stored token found.\n");
@@ -12934,8 +14456,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 = path30.resolve(file);
-  if (!fs28.existsSync(filePath)) {
+  const filePath = path33.resolve(file);
+  if (!fs33.existsSync(filePath)) {
     console.error(`
   \u2717  File not found: ${filePath}
 `);
@@ -12943,7 +14465,7 @@ program.command("config-validate <file>").description("Validate a JSON config fi
   }
   let cfg;
   try {
-    cfg = JSON.parse(fs28.readFileSync(filePath, "utf-8"));
+    cfg = JSON.parse(fs33.readFileSync(filePath, "utf-8"));
   } catch (err) {
     console.error(`
   \u2717  Could not parse JSON: ${err instanceof Error ? err.message : err}
@@ -12964,7 +14486,7 @@ ${err instanceof Error ? err.message : err}
 });
 (function ensurePermissions() {
   try {
-    const dir = path30.join(os12.homedir(), ".code-intel");
+    const dir = path33.join(os12.homedir(), ".code-intel");
     secureMkdir(dir);
     tightenDbFiles(dir);
   } catch {
@@ -12981,22 +14503,22 @@ 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 = path30.resolve(targetPath);
+  const workspaceRoot = path33.resolve(targetPath);
   const dbPath = getDbPath(workspaceRoot);
   const meta = loadMetadata(workspaceRoot);
-  if (!meta || !fs28.existsSync(dbPath)) {
+  if (!meta || !fs33.existsSync(dbPath)) {
     console.error(`
   \u2717  ${workspaceRoot} is not indexed.`);
     console.error("     Run `code-intel analyze` first to build the index.\n");
     process.exit(1);
   }
-  const { computeHealthReport: computeHealthReport2 } = await Promise.resolve().then(() => (init_health_score(), health_score_exports));
+  const { computeHealthReport: computeHealthReport3 } = await Promise.resolve().then(() => (init_health_score(), health_score_exports));
   const graph = createKnowledgeGraph();
   const db = new DbManager(dbPath);
   await db.init();
   await loadGraphFromDB(graph, db);
   db.close();
-  const report = computeHealthReport2(graph);
+  const report = computeHealthReport3(graph);
   if (opts.json) {
     console.log(JSON.stringify({
       score: report.score,
@@ -13069,7 +14591,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 = path30.resolve(opts.path);
+  const workspaceRoot = path33.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);
@@ -13128,14 +14650,14 @@ program.command("query").description("Execute a GQL (Graph Query Language) query
     }
     gqlInput = content;
   } else if (opts.file) {
-    const filePath = path30.resolve(opts.file);
-    if (!fs28.existsSync(filePath)) {
+    const filePath = path33.resolve(opts.file);
+    if (!fs33.existsSync(filePath)) {
       console.error(`
   \u2717  File not found: ${filePath}
 `);
       process.exit(1);
     }
-    gqlInput = fs28.readFileSync(filePath, "utf-8");
+    gqlInput = fs33.readFileSync(filePath, "utf-8");
   } else if (gqlArg) {
     gqlInput = gqlArg;
   } else {
@@ -13249,6 +14771,101 @@ program.command("query").description("Execute a GQL (Graph Query Language) query
 `);
   }
 });
+program.command("pr-impact").description("Compute PR blast radius and risk scores using git diff").option("--base <ref>", "Base git ref (default: main)", "main").option("--head <ref>", "Head git ref (default: HEAD)", "HEAD").option("--fail-on <level>", "Exit code 1 if this risk level found: HIGH|MEDIUM", "").option("--format <fmt>", "Output format: text|json|sarif (default: text)", "text").option("--path <path>", "Repo path (default: current dir)").addHelpText("after", `
+  Computes the blast radius for files changed between two git refs.
+
+  Examples:
+    $ code-intel pr-impact --base main --head HEAD
+    $ code-intel pr-impact --base main --head HEAD --fail-on HIGH
+    $ 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 = path33.resolve(opts.path ?? ".");
+  const { execSync: execSync3 } = await import('child_process');
+  let diff;
+  try {
+    diff = execSync3(`git diff --name-only ${opts.base}..${opts.head}`, {
+      cwd: repoPath,
+      encoding: "utf-8"
+    });
+  } catch (err) {
+    console.error(`
+  \u2717  git diff failed: ${err.message}
+`);
+    process.exit(1);
+  }
+  const changedFiles = diff.trim().split("\n").filter(Boolean);
+  if (changedFiles.length === 0) {
+    if (opts.format === "json") {
+      console.log(JSON.stringify({ changedSymbols: [], impactedSymbols: [], riskSummary: { HIGH: 0, MEDIUM: 0, LOW: 0 }, coverageGaps: [], filesToReview: [], crossRepoImpact: null }, null, 2));
+    } else {
+      console.log("\n  \u25C8  PR Impact Report\n\n  No changed files detected.\n");
+    }
+    return;
+  }
+  const { graph } = await loadOrAnalyzeWorkspace(repoPath);
+  const { computePRImpact: computePRImpact2 } = await Promise.resolve().then(() => (init_pr_impact(), pr_impact_exports));
+  const result = computePRImpact2(graph, changedFiles, 5);
+  const fmt = (opts.format ?? "text").toLowerCase();
+  if (fmt === "json") {
+    console.log(JSON.stringify(result, null, 2));
+  } else if (fmt === "sarif") {
+    const { buildSARIF: buildSARIF2 } = await Promise.resolve().then(() => (init_sarif_builder(), sarif_builder_exports));
+    const sarif = buildSARIF2(result, _pkg.version);
+    console.log(JSON.stringify(sarif, null, 2));
+  } else {
+    const highSymbols = result.changedSymbols.filter((s) => s.risk === "HIGH");
+    const medSymbols = result.changedSymbols.filter((s) => s.risk === "MEDIUM");
+    const lowSymbols = result.changedSymbols.filter((s) => s.risk === "LOW");
+    console.log("\n  \u25C8  PR Impact Report\n");
+    console.log(`  Changed files: ${changedFiles.length}`);
+    console.log(`  High-risk symbols: ${result.riskSummary.HIGH} | Medium: ${result.riskSummary.MEDIUM} | Low: ${result.riskSummary.LOW}
+`);
+    if (highSymbols.length > 0) {
+      console.log("  HIGH RISK:");
+      for (const s of highSymbols) {
+        const testNote = s.testCoverage ? "" : "  no tests";
+        console.log(`    \u25C6 ${s.name.padEnd(24)} callers: ${s.callerCount}${testNote}`);
+      }
+      console.log("");
+    }
+    if (medSymbols.length > 0) {
+      console.log("  MEDIUM RISK:");
+      for (const s of medSymbols) {
+        const testNote = s.testCoverage ? "" : "  no tests";
+        console.log(`    \u25C6 ${s.name.padEnd(24)} callers: ${s.callerCount}${testNote}`);
+      }
+      console.log("");
+    }
+    if (lowSymbols.length > 0) {
+      console.log("  LOW RISK:");
+      for (const s of lowSymbols) {
+        console.log(`    \u25C6 ${s.name.padEnd(24)} callers: ${s.callerCount}`);
+      }
+      console.log("");
+    }
+    if (result.filesToReview.length > 0) {
+      console.log("  Files to review:");
+      for (const f of result.filesToReview) {
+        console.log(`    ${f}`);
+      }
+      console.log("");
+    }
+    if (result.coverageGaps.length > 0) {
+      console.log("  Coverage gaps:");
+      for (const gap of result.coverageGaps) {
+        console.log(`    ${gap}`);
+      }
+      console.log("");
+    }
+  }
+  const failOn = (opts.failOn ?? "").toUpperCase();
+  if (failOn === "HIGH" && result.riskSummary.HIGH > 0) {
+    process.exit(1);
+  } else if (failOn === "MEDIUM" && (result.riskSummary.HIGH > 0 || result.riskSummary.MEDIUM > 0)) {
+    process.exit(1);
+  }
+});
 program.parse();
 //# sourceMappingURL=main.js.map
 //# sourceMappingURL=main.js.map