@vohongtho.infotech/code-intel 1.0.0 → 1.0.1

package/dist/cli/main.js

@@ -7,7 +7,7 @@ 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 fs38, { readFileSync, existsSync } from 'fs';
+import fs39, { readFileSync, existsSync } from 'fs';
 import path39, { dirname, join } from 'path';
 import os13 from 'os';
 import { Registry, collectDefaultMetrics, Counter, Histogram, Gauge } from 'prom-client';
@@ -336,8 +336,8 @@ var init_logger = __esm({
           transports.push(new winston.transports.Console());
           if (!isProduction) {
             try {
-              if (!fs38.existsSync(_Logger.LOG_DIR)) {
-                fs38.mkdirSync(_Logger.LOG_DIR, { recursive: true });
+              if (!fs39.existsSync(_Logger.LOG_DIR)) {
+                fs39.mkdirSync(_Logger.LOG_DIR, { recursive: true });
               }
               transports.push(
                 new DailyRotateFile({
@@ -394,6 +394,10 @@ var init_logger = __esm({
 });
 
 // src/graph/knowledge-graph.ts
+var knowledge_graph_exports = {};
+__export(knowledge_graph_exports, {
+  createKnowledgeGraph: () => createKnowledgeGraph
+});
 function createKnowledgeGraph() {
   const nodes = /* @__PURE__ */ new Map();
   const edges = /* @__PURE__ */ new Map();
@@ -889,7 +893,7 @@ var init_id_generator = __esm({
 });
 function loadIgnorePatterns(workspaceRoot) {
   try {
-    const raw = fs38.readFileSync(path39.join(workspaceRoot, ".codeintelignore"), "utf-8");
+    const raw = fs39.readFileSync(path39.join(workspaceRoot, ".codeintelignore"), "utf-8");
     const extras = /* @__PURE__ */ new Set();
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -949,7 +953,7 @@ var init_scan_phase = __esm({
         function walk2(dir) {
           let entries;
           try {
-            entries = fs38.readdirSync(dir, { withFileTypes: true });
+            entries = fs39.readdirSync(dir, { withFileTypes: true });
           } catch {
             return;
           }
@@ -966,7 +970,7 @@ var init_scan_phase = __esm({
               if (!extensions.has(ext)) continue;
               const fullPath = path39.join(dir, name);
               try {
-                const stat = fs38.statSync(fullPath);
+                const stat = fs39.statSync(fullPath);
                 if (stat.size > MAX_FILE_SIZE_BYTES) continue;
               } catch {
                 continue;
@@ -2519,7 +2523,7 @@ var init_parse_phase = __esm({
           const batch = filePaths.slice(i, i + CONCURRENCY);
           await Promise.all(batch.map(async (filePath) => {
             try {
-              const source = await fs38.promises.readFile(filePath, "utf-8");
+              const source = await fs39.promises.readFile(filePath, "utf-8");
               context2.fileCache.set(filePath, source);
             } catch {
             }
@@ -3127,8 +3131,8 @@ var init_llm_governance = __esm({
             ...entry
           };
           const logPath = this.getLogPath();
-          fs38.mkdirSync(path39.dirname(logPath), { recursive: true });
-          fs38.appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
+          fs39.mkdirSync(path39.dirname(logPath), { recursive: true });
+          fs39.appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
         } catch {
         }
       }
@@ -3138,7 +3142,7 @@ var init_llm_governance = __esm({
        */
       readLog(limit = 100) {
         try {
-          const raw = fs38.readFileSync(this.getLogPath(), "utf-8");
+          const raw = fs39.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 {
@@ -3612,14 +3616,14 @@ var init_parse_phase_parallel = __esm({
           const batch = filePaths.slice(i, i + CONCURRENCY);
           await Promise.all(batch.map(async (filePath) => {
             try {
-              const source = await fs38.promises.readFile(filePath, "utf-8");
+              const source = await fs39.promises.readFile(filePath, "utf-8");
               context2.fileCache.set(filePath, source);
             } catch {
             }
           }));
         }
         const workerScript = workerScriptPath();
-        const workerScriptExists = fs38.existsSync(workerScript);
+        const workerScriptExists = fs39.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));
@@ -3734,7 +3738,7 @@ var init_resolve_phase_parallel = __esm({
         }
         const snapshot = { symbolIndex, fileSymbolIndex, fileIndex, workspaceRoot };
         const workerScript = workerScriptPath2();
-        const workerScriptExists = fs38.existsSync(workerScript);
+        const workerScriptExists = fs39.existsSync(workerScript);
         const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os13.cpus().length - 1);
         if (!workerScriptExists || workerCount === 1) {
           logger_default.info(`[resolve-parallel] falling back to sequential`);
@@ -4071,6 +4075,41 @@ function nodeToDoc(node) {
     (node.content ?? "").slice(0, 1e3)
   ].join(" ");
 }
+function heapTopK(scores, k) {
+  if (k <= 0) return [];
+  const heap = [];
+  function heapifyUp(i) {
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (heap[parent][1] > heap[i][1]) {
+        [heap[parent], heap[i]] = [heap[i], heap[parent]];
+        i = parent;
+      } else break;
+    }
+  }
+  function heapifyDown(i) {
+    const n = heap.length;
+    while (true) {
+      let smallest = i;
+      const l = 2 * i + 1, r = 2 * i + 2;
+      if (l < n && heap[l][1] < heap[smallest][1]) smallest = l;
+      if (r < n && heap[r][1] < heap[smallest][1]) smallest = r;
+      if (smallest === i) break;
+      [heap[smallest], heap[i]] = [heap[i], heap[smallest]];
+      i = smallest;
+    }
+  }
+  for (const [nodeId, score] of scores) {
+    if (heap.length < k) {
+      heap.push([nodeId, score]);
+      heapifyUp(heap.length - 1);
+    } else if (score > heap[0][1]) {
+      heap[0] = [nodeId, score];
+      heapifyDown(0);
+    }
+  }
+  return heap.sort((a, b) => b[1] - a[1]);
+}
 function getBm25DbPath(workspaceRoot) {
   return path39.join(workspaceRoot, ".code-intel", "bm25.db");
 }
@@ -4132,10 +4171,10 @@ var init_bm25_index = __esm({
             postings.push({ nodeId, tf: count });
           }
         }
-        fs38.mkdirSync(path39.dirname(this.dbPath), { recursive: true });
+        fs39.mkdirSync(path39.dirname(this.dbPath), { recursive: true });
         for (const f of [this.dbPath, `${this.dbPath}-shm`, `${this.dbPath}-wal`]) {
           try {
-            if (fs38.existsSync(f)) fs38.unlinkSync(f);
+            if (fs39.existsSync(f)) fs39.unlinkSync(f);
           } catch {
           }
         }
@@ -4173,7 +4212,7 @@ var init_bm25_index = __esm({
        * Called once on `serve` startup.
        */
       load() {
-        if (!fs38.existsSync(this.dbPath)) return;
+        if (!fs39.existsSync(this.dbPath)) return;
         const db = new Database2(this.dbPath, { readonly: true });
         try {
           const getMeta = db.prepare("SELECT value FROM bm25_meta WHERE key = ?");
@@ -4207,8 +4246,13 @@ var init_bm25_index = __esm({
       }
       // ── Search ──────────────────────────────────────────────────────────────────
       /**
-       * BM25 search. LIMIT pushdown: scores only the posting lists for query terms,
-       * then partial-sorts to return only the top `limit` results.
+       * BM25 search.
+       *
+       * Performance strategy:
+       *  1. Skip ultra-high-df terms (df/N > 0.6) — near-zero IDF, dominate posting
+       *     lists for common words like "function", "return", "export" in large repos.
+       *  2. Min-heap top-K selection — O(n log k) instead of full O(n log n) sort.
+       *     For k=10 and n=30,000 candidates this is ~10× faster than Array.sort.
        */
       search(query, limit) {
         if (!this._loaded || this.invertedIndex.size === 0) return [];
@@ -4221,6 +4265,7 @@ var init_bm25_index = __esm({
           const postings = this.invertedIndex.get(term);
           if (!postings) continue;
           const df = postings.length;
+          if (N > 100 && df / N > 0.6) continue;
           const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
           for (const { nodeId, tf } of postings) {
             const dl = this.docLengths.get(nodeId) ?? avgdl;
@@ -4228,10 +4273,9 @@ var init_bm25_index = __esm({
             scores.set(nodeId, (scores.get(nodeId) ?? 0) + score);
           }
         }
-        const entries = [...scores.entries()];
-        entries.sort((a, b) => b[1] - a[1]);
-        const topK = entries.slice(0, limit);
-        return topK.map(([nodeId, score]) => {
+        if (scores.size === 0) return [];
+        const topEntries = heapTopK(scores, limit);
+        return topEntries.map(([nodeId, score]) => {
           const meta = this.nodeMeta.get(nodeId);
           return {
             nodeId,
@@ -4250,7 +4294,7 @@ var init_bm25_index = __esm({
        * Works even if `load()` was not called (reads affected terms directly from DB).
        */
       updateNodes(nodes) {
-        if (!fs38.existsSync(this.dbPath)) return;
+        if (!fs39.existsSync(this.dbPath)) return;
         if (nodes.length === 0) return;
         const changedIds = new Set(nodes.map((n) => n.id));
         const newTermFreqs = /* @__PURE__ */ new Map();
@@ -4325,6 +4369,12 @@ var init_bm25_index = __esm({
     };
   }
 });
+
+// src/storage/db-manager.ts
+var db_manager_exports = {};
+__export(db_manager_exports, {
+  DbManager: () => DbManager
+});
 var DbManager;
 var init_db_manager = __esm({
   "src/storage/db-manager.ts"() {
@@ -4339,7 +4389,7 @@ var init_db_manager = __esm({
       }
       async init() {
         if (!this.readOnly) {
-          fs38.mkdirSync(path39.dirname(this.dbPath), { recursive: true });
+          fs39.mkdirSync(path39.dirname(this.dbPath), { recursive: true });
         }
         this.db = new Database(this.dbPath, 0, true, this.readOnly);
         await this.db.init();
@@ -4379,7 +4429,7 @@ var init_db_manager = __esm({
   }
 });
 function writeNodeCSVs(graph, outputDir) {
-  fs38.mkdirSync(outputDir, { recursive: true });
+  fs39.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();
@@ -4407,12 +4457,12 @@ function writeNodeCSVs(graph, outputDir) {
     );
   }
   for (const [table, lines] of tableBuffers) {
-    fs38.writeFileSync(tableFilePaths.get(table), lines.join(""), "utf-8");
+    fs39.writeFileSync(tableFilePaths.get(table), lines.join(""), "utf-8");
   }
   return tableFilePaths;
 }
 function writeEdgeCSV(graph, outputDir) {
-  fs38.mkdirSync(outputDir, { recursive: true });
+  fs39.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()) {
@@ -4438,7 +4488,7 @@ function writeEdgeCSV(graph, outputDir) {
   }
   const result = [];
   for (const group of groups.values()) {
-    fs38.writeFileSync(group.filePath, group.lines.join(""), "utf-8");
+    fs39.writeFileSync(group.filePath, group.lines.join(""), "utf-8");
     result.push({ fromTable: group.from, toTable: group.to, filePath: group.filePath });
   }
   return result;
@@ -4481,7 +4531,7 @@ async function loadGraphToDB(graph, dbManager) {
     } catch {
     }
   }
-  const tmpDir = fs38.mkdtempSync(path39.join(os13.tmpdir(), "code-intel-csv-"));
+  const tmpDir = fs39.mkdtempSync(path39.join(os13.tmpdir(), "code-intel-csv-"));
   try {
     const nodeTableFiles = writeNodeCSVs(graph, tmpDir);
     const edgeGroups = writeEdgeCSV(graph, tmpDir);
@@ -4500,8 +4550,8 @@ async function loadGraphToDB(graph, dbManager) {
     }
     let nodeCount = 0;
     for (const [table, csvPath] of nodeTableFiles) {
-      if (!fs38.existsSync(csvPath)) continue;
-      const stat = fs38.statSync(csvPath);
+      if (!fs39.existsSync(csvPath)) continue;
+      const stat = fs39.statSync(csvPath);
       if (stat.size < 50) continue;
       try {
         await dbManager.execute(
@@ -4514,8 +4564,8 @@ async function loadGraphToDB(graph, dbManager) {
     }
     let edgeCount = 0;
     for (const group of edgeGroups) {
-      if (!fs38.existsSync(group.filePath)) continue;
-      const stat = fs38.statSync(group.filePath);
+      if (!fs39.existsSync(group.filePath)) continue;
+      const stat = fs39.statSync(group.filePath);
       if (stat.size < 50) continue;
       try {
         await dbManager.execute(
@@ -4529,7 +4579,7 @@ async function loadGraphToDB(graph, dbManager) {
     return { nodeCount, edgeCount };
   } finally {
     try {
-      fs38.rmSync(tmpDir, { recursive: true, force: true });
+      fs39.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -4640,15 +4690,15 @@ __export(repo_registry_exports, {
 });
 function loadRegistry() {
   try {
-    const data = fs38.readFileSync(REPOS_FILE, "utf-8");
+    const data = fs39.readFileSync(REPOS_FILE, "utf-8");
     return JSON.parse(data);
   } catch {
     return [];
   }
 }
 function saveRegistry(entries) {
-  fs38.mkdirSync(GLOBAL_DIR, { recursive: true });
-  fs38.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
+  fs39.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs39.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
 }
 function upsertRepo(entry) {
   const entries = loadRegistry();
@@ -4682,12 +4732,12 @@ __export(metadata_exports, {
 });
 function saveMetadata(repoDir, metadata) {
   const metaDir = path39.join(repoDir, ".code-intel");
-  fs38.mkdirSync(metaDir, { recursive: true });
-  fs38.writeFileSync(path39.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
+  fs39.mkdirSync(metaDir, { recursive: true });
+  fs39.writeFileSync(path39.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
 }
 function loadMetadata(repoDir) {
   try {
-    const data = fs38.readFileSync(path39.join(repoDir, ".code-intel", "meta.json"), "utf-8");
+    const data = fs39.readFileSync(path39.join(repoDir, ".code-intel", "meta.json"), "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -4757,23 +4807,23 @@ function groupFile(name) {
 }
 function loadGroup(name) {
   try {
-    return JSON.parse(fs38.readFileSync(groupFile(name), "utf-8"));
+    return JSON.parse(fs39.readFileSync(groupFile(name), "utf-8"));
   } catch {
     return null;
   }
 }
 function saveGroup(group) {
-  fs38.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs38.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
+  fs39.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs39.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
 }
 function listGroups() {
   const groups = [];
   try {
-    for (const file of fs38.readdirSync(GROUPS_DIR)) {
+    for (const file of fs39.readdirSync(GROUPS_DIR)) {
       if (!file.endsWith(".json") || file.endsWith(".sync.json")) continue;
       try {
         const g = JSON.parse(
-          fs38.readFileSync(path39.join(GROUPS_DIR, file), "utf-8")
+          fs39.readFileSync(path39.join(GROUPS_DIR, file), "utf-8")
         );
         groups.push(g);
       } catch {
@@ -4785,16 +4835,16 @@ function listGroups() {
 }
 function deleteGroup(name) {
   try {
-    fs38.unlinkSync(groupFile(name));
+    fs39.unlinkSync(groupFile(name));
   } catch {
   }
   try {
-    fs38.unlinkSync(path39.join(GROUPS_DIR, `${name}.sync.json`));
+    fs39.unlinkSync(path39.join(GROUPS_DIR, `${name}.sync.json`));
   } catch {
   }
 }
 function groupExists(name) {
-  return fs38.existsSync(groupFile(name));
+  return fs39.existsSync(groupFile(name));
 }
 function addMember(groupName, member) {
   const group = loadGroup(groupName);
@@ -4820,8 +4870,8 @@ function removeMember(groupName, groupPath) {
   return group;
 }
 function saveSyncResult(result) {
-  fs38.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs38.writeFileSync(
+  fs39.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs39.writeFileSync(
     path39.join(GROUPS_DIR, `${result.groupName}.sync.json`),
     JSON.stringify(result, null, 2) + "\n"
   );
@@ -4829,7 +4879,7 @@ function saveSyncResult(result) {
 function loadSyncResult(groupName) {
   try {
     return JSON.parse(
-      fs38.readFileSync(path39.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
+      fs39.readFileSync(path39.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
     );
   } catch {
     return null;
@@ -4843,6 +4893,10 @@ var init_group_registry = __esm({
 });
 
 // src/multi-repo/graph-from-db.ts
+var graph_from_db_exports = {};
+__export(graph_from_db_exports, {
+  loadGraphFromDB: () => loadGraphFromDB
+});
 function parseRow(row, kind) {
   return {
     id: String(row["id"] ?? ""),
@@ -4923,7 +4977,7 @@ function scanForFiles(root, matcher, maxDepth = 2) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs38.readdirSync(dir, { withFileTypes: true });
+      entries = fs39.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -4945,7 +4999,7 @@ var init_file_scanner = __esm({
 });
 function tryParseFile(filePath) {
   const ext = path39.extname(filePath).toLowerCase();
-  const content = fs38.readFileSync(filePath, "utf-8");
+  const content = fs39.readFileSync(filePath, "utf-8");
   if (ext === ".json") {
     try {
       return JSON.parse(content);
@@ -5014,7 +5068,7 @@ async function parseGraphQLContracts(repoRoot) {
   const files = scanForFiles(repoRoot, (name) => name.endsWith(".graphql") || name.endsWith(".gql"));
   const contracts = [];
   for (const filePath of files) {
-    const content = fs38.readFileSync(filePath, "utf-8");
+    const content = fs39.readFileSync(filePath, "utf-8");
     const typeRegex = /type\s+(\w+)\s*\{([^}]+)\}/g;
     let match;
     while ((match = typeRegex.exec(content)) !== null) {
@@ -5050,7 +5104,7 @@ async function parseProtoContracts(repoRoot) {
   const files = scanForFiles(repoRoot, (name) => name.endsWith(".proto"));
   const contracts = [];
   for (const filePath of files) {
-    const content = fs38.readFileSync(filePath, "utf-8");
+    const content = fs39.readFileSync(filePath, "utf-8");
     const serviceRegex = /service\s+(\w+)\s*\{([^}]+)\}/g;
     let serviceMatch;
     while ((serviceMatch = serviceRegex.exec(content)) !== null) {
@@ -5269,7 +5323,7 @@ async function syncGroup(group) {
       continue;
     }
     const dbPath = path39.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs38.existsSync(dbPath)) {
+    if (!fs39.existsSync(dbPath)) {
       logger_default.warn(`  \u26A0 No index at ${dbPath} \u2014 run \`code-intel analyze ${regEntry.path}\` first`);
       continue;
     }
@@ -5450,10 +5504,10 @@ var init_codes = __esm({
   }
 });
 function secureMkdir(dir) {
-  fs38.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
+  fs39.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
   if (process.platform !== "win32") {
     try {
-      fs38.chmodSync(dir, SECURE_DIR_MODE);
+      fs39.chmodSync(dir, SECURE_DIR_MODE);
     } catch {
     }
   }
@@ -5461,22 +5515,22 @@ function secureMkdir(dir) {
 function secureChmodFile(file) {
   if (process.platform === "win32") return;
   try {
-    fs38.chmodSync(file, SECURE_FILE_MODE);
+    fs39.chmodSync(file, SECURE_FILE_MODE);
   } catch {
   }
 }
 function secureWriteFile(file, data) {
   secureMkdir(path39.dirname(file));
-  fs38.writeFileSync(file, data, { mode: SECURE_FILE_MODE });
+  fs39.writeFileSync(file, data, { mode: SECURE_FILE_MODE });
   secureChmodFile(file);
 }
 function tightenDbFiles(dir) {
   if (process.platform === "win32") return;
-  if (!fs38.existsSync(dir)) return;
-  for (const name of fs38.readdirSync(dir)) {
+  if (!fs39.existsSync(dir)) return;
+  for (const name of fs39.readdirSync(dir)) {
     if (name.endsWith(".db") || name.endsWith(".db-wal") || name.endsWith(".db-shm")) {
       try {
-        fs38.chmodSync(path39.join(dir, name), SECURE_FILE_MODE);
+        fs39.chmodSync(path39.join(dir, name), SECURE_FILE_MODE);
       } catch {
       }
     }
@@ -5825,8 +5879,8 @@ function decryptSecrets(encrypted) {
   return JSON.parse(plaintext.toString("utf8"));
 }
 function loadSecrets(secretsPath = getSecretsPath()) {
-  if (!fs38.existsSync(secretsPath)) return {};
-  const blob = fs38.readFileSync(secretsPath);
+  if (!fs39.existsSync(secretsPath)) return {};
+  const blob = fs39.readFileSync(secretsPath);
   return decryptSecrets(blob);
 }
 function saveSecrets(blob, secretsPath = getSecretsPath()) {
@@ -5866,11 +5920,18 @@ function getSessionTtlMs() {
   const hours = parseInt(process.env["CODE_INTEL_SESSION_TTL_HOURS"] ?? "8", 10);
   return (isNaN(hours) ? 8 : hours) * 60 * 60 * 1e3;
 }
-function createSession(user) {
+function createSession(user, rememberMe = false) {
   const sessionId = v4();
-  const expiresAt = Date.now() + getSessionTtlMs();
-  sessionStore.set(sessionId, { userId: user.id, username: user.username, role: user.role, expiresAt });
-  return sessionId;
+  const ttlMs = rememberMe ? REMEMBER_ME_TTL_MS : getSessionTtlMs();
+  const expiresAt = Date.now() + ttlMs;
+  sessionStore.set(sessionId, {
+    userId: user.id,
+    username: user.username,
+    role: user.role,
+    expiresAt,
+    ttlMs
+  });
+  return { sessionId, ttlMs };
 }
 function getSession(sessionId) {
   const entry = sessionStore.get(sessionId);
@@ -5879,10 +5940,9 @@ function getSession(sessionId) {
     sessionStore.delete(sessionId);
     return null;
   }
-  const ttlMs = getSessionTtlMs();
   const remaining = entry.expiresAt - Date.now();
-  if (remaining < ttlMs * 0.75) {
-    entry.expiresAt = Date.now() + ttlMs;
+  if (remaining < entry.ttlMs * 0.75) {
+    entry.expiresAt = Date.now() + entry.ttlMs;
   }
   return entry;
 }
@@ -5902,7 +5962,7 @@ function authMiddleware(req, res, next) {
     const session = getSession(sessionId);
     if (session) {
       req.user = { id: session.userId, username: session.username, role: session.role, authMethod: "session" };
-      res.setHeader("Set-Cookie", buildSessionCookie(sessionId));
+      res.setHeader("Set-Cookie", buildSessionCookie(sessionId, session.ttlMs));
       next();
       return;
     }
@@ -6072,9 +6132,9 @@ function parseCookies(cookieHeader) {
   }
   return result;
 }
-function buildSessionCookie(sessionId) {
+function buildSessionCookie(sessionId, ttlMs) {
   const isProduction = process.env["NODE_ENV"] === "production";
-  const maxAge = Math.floor(getSessionTtlMs() / 1e3);
+  const maxAge = Math.floor((ttlMs ?? getSessionTtlMs()) / 1e3);
   const parts = [
     `${SESSION_COOKIE_NAME}=${encodeURIComponent(sessionId)}`,
     `HttpOnly`,
@@ -6091,7 +6151,7 @@ function clearSessionCookie() {
 async function verifyPassword(plain, hash) {
   return bcrypt.compare(plain, hash);
 }
-var sessionStore, SESSION_COOKIE_NAME, ROLE_RANK;
+var sessionStore, SESSION_COOKIE_NAME, REMEMBER_ME_TTL_MS, ROLE_RANK;
 var init_middleware = __esm({
   "src/auth/middleware.ts"() {
     init_users_db();
@@ -6099,6 +6159,7 @@ var init_middleware = __esm({
     init_secret_store();
     sessionStore = /* @__PURE__ */ new Map();
     SESSION_COOKIE_NAME = "code_intel_session";
+    REMEMBER_ME_TTL_MS = 12 * 60 * 60 * 1e3;
     ROLE_RANK = {
       viewer: 1,
       "repo-owner": 2,
@@ -7871,7 +7932,7 @@ var init_secret_scanner = __esm({
         const ignorePatterns = [...options?.ignorePatterns ?? []];
         if (options?.workspaceRoot) {
           try {
-            const raw = fs38.readFileSync(path39.join(options.workspaceRoot, ".codeintelignore"), "utf-8");
+            const raw = fs39.readFileSync(path39.join(options.workspaceRoot, ".codeintelignore"), "utf-8");
             for (const line of raw.split("\n")) {
               const trimmed = line.trim();
               if (trimmed && !trimmed.startsWith("#")) ignorePatterns.push(trimmed);
@@ -8129,22 +8190,22 @@ __export(init_wizard_exports, {
   wipeConfig: () => wipeConfig
 });
 function configExists() {
-  return fs38.existsSync(CONFIG_PATH);
+  return fs39.existsSync(CONFIG_PATH);
 }
 function loadConfig() {
   if (!configExists()) return null;
   try {
-    return JSON.parse(fs38.readFileSync(CONFIG_PATH, "utf-8"));
+    return JSON.parse(fs39.readFileSync(CONFIG_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveConfig(cfg) {
-  fs38.mkdirSync(GLOBAL_DIR2, { recursive: true });
-  fs38.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+  fs39.mkdirSync(GLOBAL_DIR2, { recursive: true });
+  fs39.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
 }
 function wipeConfig() {
-  if (fs38.existsSync(CONFIG_PATH)) fs38.unlinkSync(CONFIG_PATH);
+  if (fs39.existsSync(CONFIG_PATH)) fs39.unlinkSync(CONFIG_PATH);
 }
 function commandExists(bin) {
   try {
@@ -8224,8 +8285,8 @@ async function runInitWizard(opts = {}) {
           const mcpFile = path39.resolve(editor.mcpConfigKey);
           try {
             let existing = {};
-            if (fs38.existsSync(mcpFile)) {
-              existing = JSON.parse(fs38.readFileSync(mcpFile, "utf-8"));
+            if (fs39.existsSync(mcpFile)) {
+              existing = JSON.parse(fs39.readFileSync(mcpFile, "utf-8"));
             }
             const merged = {
               ...existing,
@@ -8234,8 +8295,8 @@ async function runInitWizard(opts = {}) {
                 ...mcpConfig.servers
               }
             };
-            fs38.mkdirSync(path39.dirname(mcpFile), { recursive: true });
-            fs38.writeFileSync(mcpFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+            fs39.mkdirSync(path39.dirname(mcpFile), { recursive: true });
+            fs39.writeFileSync(mcpFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
             console.log(`  \u2705  MCP registered for ${name} \u2192 ${editor.mcpConfigKey}`);
           } catch {
             console.log(`  \u26A0   Could not write MCP config for ${name} \u2014 do it manually.`);
@@ -9005,8 +9066,8 @@ var init_file_watcher = __esm({
       readCodeIntelIgnore() {
         const ignoreFile = path39.join(this.workspaceRoot, ".codeintelignore");
         try {
-          if (!fs38.existsSync(ignoreFile)) return [];
-          return fs38.readFileSync(ignoreFile, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+          if (!fs39.existsSync(ignoreFile)) return [];
+          return fs39.readFileSync(ignoreFile, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
         } catch {
           return [];
         }
@@ -9067,7 +9128,7 @@ var init_incremental_indexer = __esm({
           graph.removeNodeCascade(id);
           nodesRemoved++;
         }
-        if (fs38.existsSync(dbPath)) {
+        if (fs39.existsSync(dbPath)) {
           try {
             const db = new DbManager(dbPath);
             await db.init();
@@ -9082,7 +9143,7 @@ var init_incremental_indexer = __esm({
         }
         const existingFiles = changedFiles.filter((f) => {
           try {
-            return fs38.statSync(f).isFile();
+            return fs39.statSync(f).isFile();
           } catch {
             return false;
           }
@@ -9104,7 +9165,7 @@ var init_incremental_indexer = __esm({
           await runPipeline([noopScan, parsePhase, resolvePhase], context2);
         }
         const nodesAdded = Math.max(0, graph.size.nodes - (nodesBeforeParse - nodesRemoved));
-        if (fs38.existsSync(dbPath) && existingFiles.length > 0) {
+        if (fs39.existsSync(dbPath) && existingFiles.length > 0) {
           try {
             const db = new DbManager(dbPath);
             await db.init();
@@ -9116,7 +9177,7 @@ var init_incremental_indexer = __esm({
             db.close();
             try {
               const bm25DbPath = getBm25DbPath(workspaceRoot);
-              if (fs38.existsSync(bm25DbPath)) {
+              if (fs39.existsSync(bm25DbPath)) {
                 const bm25 = new Bm25Index(bm25DbPath);
                 bm25.updateNodes(nodesToUpsert);
                 logger_default.info(`[incremental] BM25 index updated: ${nodesToUpsert.length} nodes`);
@@ -9155,31 +9216,31 @@ function getQueriesDir(workspaceRoot) {
 }
 function ensureQueriesDir(workspaceRoot) {
   const dir = getQueriesDir(workspaceRoot);
-  if (!fs38.existsSync(dir)) {
-    fs38.mkdirSync(dir, { recursive: true });
+  if (!fs39.existsSync(dir)) {
+    fs39.mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 function saveQuery(workspaceRoot, name, gql) {
   const dir = ensureQueriesDir(workspaceRoot);
   const filePath = path39.join(dir, `${name}.gql`);
-  fs38.writeFileSync(filePath, gql, "utf-8");
+  fs39.writeFileSync(filePath, gql, "utf-8");
 }
 function loadQuery(workspaceRoot, name) {
   const dir = getQueriesDir(workspaceRoot);
   const filePath = path39.join(dir, `${name}.gql`);
-  if (!fs38.existsSync(filePath)) return null;
-  return fs38.readFileSync(filePath, "utf-8");
+  if (!fs39.existsSync(filePath)) return null;
+  return fs39.readFileSync(filePath, "utf-8");
 }
 function listQueries(workspaceRoot) {
   const dir = getQueriesDir(workspaceRoot);
-  if (!fs38.existsSync(dir)) return [];
-  const files = fs38.readdirSync(dir).filter((f) => f.endsWith(".gql"));
+  if (!fs39.existsSync(dir)) return [];
+  const files = fs39.readdirSync(dir).filter((f) => f.endsWith(".gql"));
   return files.map((f) => {
     const filePath = path39.join(dir, f);
     const name = f.replace(/\.gql$/, "");
-    const content = fs38.readFileSync(filePath, "utf-8");
-    const stat = fs38.statSync(filePath);
+    const content = fs39.readFileSync(filePath, "utf-8");
+    const stat = fs39.statSync(filePath);
     return {
       name,
       content,
@@ -9191,14 +9252,14 @@ function listQueries(workspaceRoot) {
 function deleteQuery(workspaceRoot, name) {
   const dir = getQueriesDir(workspaceRoot);
   const filePath = path39.join(dir, `${name}.gql`);
-  if (!fs38.existsSync(filePath)) return false;
-  fs38.unlinkSync(filePath);
+  if (!fs39.existsSync(filePath)) return false;
+  fs39.unlinkSync(filePath);
   return true;
 }
 function queryExists(workspaceRoot, name) {
   const dir = getQueriesDir(workspaceRoot);
   const filePath = path39.join(dir, `${name}.gql`);
-  return fs38.existsSync(filePath);
+  return fs39.existsSync(filePath);
 }
 var init_saved_queries = __esm({
   "src/query/saved-queries.ts"() {
@@ -9266,6 +9327,324 @@ var init_sarif_builder = __esm({
   }
 });
 
+// src/context/token-counter.ts
+var token_counter_exports = {};
+__export(token_counter_exports, {
+  estimateTokens: () => estimateTokens,
+  measureBlocks: () => measureBlocks
+});
+function estimateTokens(text) {
+  if (!text) return 0;
+  const words = text.split(/\s+/).filter(Boolean).length;
+  const chars = text.length;
+  return Math.ceil((words * 1.3 + chars * 0.25) / 2);
+}
+function measureBlocks(doc) {
+  const summary = estimateTokens(doc.summary);
+  const logic = estimateTokens(doc.logic);
+  const relation = estimateTokens(doc.relation);
+  const focusCode = estimateTokens(doc.focusCode);
+  return { summary, logic, relation, focusCode, total: summary + logic + relation + focusCode };
+}
+var init_token_counter = __esm({
+  "src/context/token-counter.ts"() {
+  }
+});
+
+// src/context/builder.ts
+var builder_exports = {};
+__export(builder_exports, {
+  build: () => build,
+  detectQueryIntent: () => detectQueryIntent
+});
+function detectQueryIntent(question) {
+  const q = question.toLowerCase();
+  if (/\b(show|code|implement|source|how is written|function body|method body)\b/.test(q)) return "code";
+  if (/\b(who calls|callers?|depends on|blast radius|impact|upstream)\b/.test(q)) return "callers";
+  if (/\b(architecture|overview|structure|design|how is built|system)\b/.test(q)) return "architecture";
+  return "auto";
+}
+function last2Segments(filePath) {
+  const parts = filePath.replace(/\\/g, "/").split("/").filter(Boolean);
+  return parts.slice(-2).join("/");
+}
+function firstSentence(text) {
+  if (!text) return "";
+  const sentence = text.split(/[.!?]/)[0]?.trim() ?? "";
+  const words = sentence.split(/\s+/);
+  return words.slice(0, 15).join(" ");
+}
+function getCluster(graph, nodeId) {
+  for (const edge of graph.findEdgesFrom(nodeId)) {
+    if (edge.kind === "belongs_to") return graph.getNode(edge.target)?.name;
+  }
+  return void 0;
+}
+function dirOf(filePath) {
+  const parts = filePath.replace(/\\/g, "/").split("/").filter(Boolean);
+  return parts.slice(0, -1).join("/") || ".";
+}
+function meaningfulLines(content) {
+  return content.split("\n").filter((l) => {
+    const t = l.trim();
+    return t.length > 0 && !t.startsWith("//") && !t.startsWith("*") && !t.startsWith("#");
+  });
+}
+function adaptiveSnippet(content) {
+  if (!content) return { lines: "", truncated: false };
+  const stripped = content.replace(/^\n+|\n+$/g, "");
+  const rawLines = stripped.split("\n");
+  const ml = meaningfulLines(stripped).length;
+  if (ml <= 10) return { lines: stripped, truncated: false };
+  if (ml <= 25) {
+    const out2 = rawLines.slice(0, 25);
+    const truncated = rawLines.length > 25;
+    return { lines: out2.join("\n") + (truncated ? "\n// ..." : ""), truncated };
+  }
+  const out = rawLines.slice(0, 40);
+  const remaining = rawLines.length - 40;
+  return {
+    lines: out.join("\n") + (remaining > 0 ? `
+// ... (${remaining} more lines)` : ""),
+    truncated: remaining > 0
+  };
+}
+function buildSummaryBlock(nodes, graph, dedup) {
+  if (nodes.length === 0) return "";
+  const byDir = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const dir = dirOf(node.filePath);
+    if (!byDir.has(dir)) byDir.set(dir, []);
+    byDir.get(dir).push(node);
+  }
+  const lines = ["[SUMMARY]"];
+  for (const [dir, group] of byDir) {
+    const useHeader = group.length >= 3;
+    if (useHeader) lines.push(`${dir}/:`);
+    for (const node of group) {
+      const summary = firstSentence(node.metadata?.["summary"]);
+      const callerCount = [...graph.findEdgesTo(node.id)].filter((e) => e.kind === "calls").length;
+      getCluster(graph, node.id);
+      const badges = [];
+      if (callerCount >= 10) badges.push("\u26A0");
+      if (callerCount === 0) badges.push("\u{1F47B}");
+      const badgeStr = badges.join("");
+      const path210 = last2Segments(node.filePath);
+      const line = node.startLine ? `:${node.startLine}` : "";
+      const fullFmt = `${node.name} [${node.kind}] ${path210}${line}${badgeStr ? " " + badgeStr : ""}${summary ? " \u2014 " + summary : ""}`;
+      const formatted = dedup.formatSymbol(node.name, node.filePath, fullFmt);
+      lines.push(useHeader ? `  ${formatted}` : formatted);
+    }
+  }
+  return lines.join("\n");
+}
+function buildLogicBlock(nodes, graph, dedup) {
+  if (nodes.length === 0) return "";
+  const lines = ["[LOGIC]"];
+  const nodeCallees = /* @__PURE__ */ new Map();
+  const calleeUsage = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const callees = [];
+    for (const edge of graph.findEdgesFrom(node.id)) {
+      if (edge.kind === "calls") {
+        const callee = graph.getNode(edge.target);
+        if (callee && callee.name !== node.name) {
+          callees.push(callee.name);
+          calleeUsage.set(callee.name, (calleeUsage.get(callee.name) ?? 0) + 1);
+        }
+      }
+    }
+    nodeCallees.set(node.id, [...new Set(callees)]);
+  }
+  const sharedCallees = new Set(
+    [...calleeUsage.entries()].filter(([, cnt]) => cnt >= 3).map(([name]) => name)
+  );
+  if (sharedCallees.size > 0) {
+    lines.push(`(all above \u2192 ${[...sharedCallees].join(", ")})`);
+  }
+  for (const node of nodes) {
+    const callees = (nodeCallees.get(node.id) ?? []).filter((c) => !sharedCallees.has(c));
+    for (const callee of callees) {
+      dedup.markCallPair(node.name, callee);
+    }
+    if (callees.length === 0) continue;
+    if (callees.length <= 5) {
+      for (const callee of callees) dedup.markInLogic(callee);
+      lines.push(`${node.name} \u2192 ${callees.join(", ")}`);
+    } else {
+      lines.push(`${node.name} \u2192`);
+      for (const callee of callees) {
+        dedup.markInLogic(callee);
+        if (dedup.hasSymbol(callee)) {
+          lines.push(`  ${callee}`);
+        } else {
+          const calleeNode = [...graph.allNodes()].find((n) => n.name === callee);
+          const path40 = calleeNode ? ` (${last2Segments(calleeNode.filePath)})` : "";
+          lines.push(`  ${callee}${path40}`);
+        }
+      }
+    }
+  }
+  return lines.length > 1 ? lines.join("\n") : "";
+}
+function buildRelationBlock(nodes, graph, dedup) {
+  if (nodes.length === 0) return "";
+  const lines = ["[RELATION]"];
+  for (const node of nodes) {
+    const callers = [...graph.findEdgesTo(node.id)].filter((e) => e.kind === "calls").map((e) => graph.getNode(e.source)?.name).filter((n) => Boolean(n));
+    const extendsNodes = [...graph.findEdgesFrom(node.id)].filter((e) => e.kind === "extends").map((e) => graph.getNode(e.target)?.name).filter((n) => Boolean(n));
+    const implementsNodes = [...graph.findEdgesFrom(node.id)].filter((e) => e.kind === "implements").map((e) => graph.getNode(e.target)?.name).filter((n) => Boolean(n));
+    const highBlast = callers.length >= 5;
+    const prefix = highBlast ? "\u26A1 " : "";
+    if (callers.length > 0) {
+      const nonDupCallers = callers.filter(
+        (c) => highBlast || !dedup.hasCallPair(c, node.name)
+      );
+      if (nonDupCallers.length > 0) {
+        const top3 = nonDupCallers.slice(0, 3);
+        const rest = nonDupCallers.length - 3;
+        const callerStr = top3.join(", ") + (rest > 0 ? ` (+${rest} more \u2014 use blast_radius for full list)` : "");
+        lines.push(`${prefix}${node.name} \u2190 ${callerStr}`);
+      }
+    }
+    const heritage = [];
+    if (extendsNodes.length > 0) heritage.push(`extends ${extendsNodes.join(", ")}`);
+    if (implementsNodes.length > 0) heritage.push(`implements ${implementsNodes.join(" \xB7 ")}`);
+    if (heritage.length > 0) lines.push(`${node.name}: ${heritage.join(" \xB7 ")}`);
+  }
+  return lines.length > 1 ? lines.join("\n") : "";
+}
+function buildFocusCodeBlock(seeds, nodes, dedup, signatureOnlyThreshold, tokenBudget) {
+  if (nodes.length === 0) return { text: "", truncated: false };
+  const lines = ["[FOCUS CODE]"];
+  let usedTokens = estimateTokens("[FOCUS CODE]");
+  let truncated = false;
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const seed = seeds.find((s) => s.nodeId === node.id);
+    const score = seed?.refinedScore ?? 1;
+    const content = node.content;
+    const ml = content ? meaningfulLines(content).length : 0;
+    if (ml <= 5 && dedup.isInLogic(node.name)) continue;
+    const header = `// ${node.name} \u2014 ${last2Segments(node.filePath)}${node.startLine ? ":" + node.startLine : ""}`;
+    if (score < signatureOnlyThreshold) {
+      const sig = content?.split("\n").find((l) => l.trim().length > 0) ?? "";
+      const sigLine = sig ? sig.trimEnd() + (sig.includes("{") ? " ... }" : "") : "";
+      const entry2 = `${header}
+// (low relevance)
+${sigLine}`;
+      const toks2 = estimateTokens(entry2);
+      if (usedTokens + toks2 > tokenBudget) {
+        truncated = true;
+        break;
+      }
+      lines.push(entry2);
+      usedTokens += toks2;
+      continue;
+    }
+    const { lines: snippet, truncated: snipTruncated } = adaptiveSnippet(content);
+    const entry = `${header}
+\`\`\`
+${snippet}
+\`\`\``;
+    const toks = estimateTokens(entry);
+    if (usedTokens + toks > tokenBudget) {
+      truncated = true;
+      break;
+    }
+    lines.push(entry);
+    usedTokens += toks;
+    if (snipTruncated) truncated = true;
+  }
+  return { text: lines.length > 1 ? lines.join("\n\n") : "", truncated };
+}
+function build(seeds, graph, options = {}) {
+  const maxTokens = options.maxTokens ?? 6e3;
+  const signatureOnlyThreshold = options.signatureOnlyThreshold ?? 0.3;
+  const intent = options.queryIntent ?? "auto";
+  const budgets = BUDGET_PRESETS[intent];
+  const nodes = seeds.map((s) => graph.getNode(s.nodeId)).filter((n) => n !== void 0);
+  const dedup = new DedupeRegistry();
+  let available = maxTokens;
+  const summaryText = buildSummaryBlock(nodes, graph, dedup);
+  const summaryToks = estimateTokens(summaryText);
+  const summaryUsed = Math.min(summaryToks, Math.min(budgets.summary, available));
+  available -= summaryUsed;
+  const logicText = buildLogicBlock(nodes, graph, dedup);
+  const logicToks = estimateTokens(logicText);
+  const logicBudget = Math.min(budgets.logic, Math.floor(available * 0.35));
+  const logicUsed = Math.min(logicToks, logicBudget);
+  available -= logicUsed;
+  const relationText = buildRelationBlock(nodes, graph, dedup);
+  const relationToks = estimateTokens(relationText);
+  const relationBudget = Math.min(budgets.relation, Math.floor(available * 0.35));
+  const relationUsed = Math.min(relationToks, relationBudget);
+  available -= relationUsed;
+  const focusBudget = available;
+  const { text: focusText, truncated } = buildFocusCodeBlock(
+    seeds,
+    nodes,
+    dedup,
+    signatureOnlyThreshold,
+    focusBudget
+  );
+  return {
+    summary: summaryText,
+    logic: logicText,
+    relation: relationText,
+    focusCode: focusText,
+    truncated,
+    intent
+  };
+}
+var BUDGET_PRESETS, DedupeRegistry;
+var init_builder = __esm({
+  "src/context/builder.ts"() {
+    init_token_counter();
+    BUDGET_PRESETS = {
+      code: { summary: 300, logic: 400, relation: 300, focusCode: 5e3 },
+      callers: { summary: 500, logic: 300, relation: 2500, focusCode: 700 },
+      architecture: { summary: 1200, logic: 800, relation: 800, focusCode: 1200 },
+      auto: { summary: 800, logic: 600, relation: 500, focusCode: 1500 }
+    };
+    DedupeRegistry = class {
+      seenSymbols = /* @__PURE__ */ new Set();
+      seenFilePaths = /* @__PURE__ */ new Set();
+      seenCallPairs = /* @__PURE__ */ new Set();
+      logicSymbols = /* @__PURE__ */ new Set();
+      // B.4.2: symbols referenced in LOGIC
+      /** Returns full format on first mention, name-only on repeats. */
+      formatSymbol(name, filePath, extra) {
+        const key = name;
+        if (this.seenSymbols.has(key)) return name;
+        this.seenSymbols.add(key);
+        this.seenFilePaths.add(filePath);
+        return extra;
+      }
+      hasSymbol(name) {
+        return this.seenSymbols.has(name);
+      }
+      markCallPair(caller, callee) {
+        this.seenCallPairs.add(`${caller}\u2192${callee}`);
+      }
+      hasCallPair(caller, callee) {
+        return this.seenCallPairs.has(`${caller}\u2192${callee}`);
+      }
+      hasFilePath(fp) {
+        return this.seenFilePaths.has(fp);
+      }
+      /** Mark a symbol as referenced in the LOGIC block (B.4.2). */
+      markInLogic(name) {
+        this.logicSymbols.add(name);
+      }
+      /** Returns true only if symbol was referenced in LOGIC (B.4.2). */
+      isInLogic(name) {
+        return this.logicSymbols.has(name);
+      }
+    };
+  }
+});
+
 // src/cli/main.ts
 init_logger();
 init_knowledge_graph();
@@ -9763,7 +10142,7 @@ init_embedder();
 async function hybridSearch(graph, query, limit, options = {}) {
   const { vectorDbPath, bm25Limit = 50, vectorLimit = 50, bm25Results: precomputedBm25 } = options;
   const bm25Promise = precomputedBm25 ? Promise.resolve(precomputedBm25) : Promise.resolve(textSearch(graph, query, bm25Limit));
-  const hasVectorDb = Boolean(vectorDbPath && fs38.existsSync(vectorDbPath));
+  const hasVectorDb = Boolean(vectorDbPath && fs39.existsSync(vectorDbPath));
   if (!hasVectorDb) {
     const bm25Results2 = await bm25Promise;
     return {
@@ -9831,7 +10210,7 @@ async function queryGroup(group, query, limit = 20) {
     const regEntry = registry.find((r) => r.name === member.registryName);
     if (!regEntry) continue;
     const dbPath = path39.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs38.existsSync(dbPath)) continue;
+    if (!fs39.existsSync(dbPath)) continue;
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath, true);
     try {
@@ -9873,7 +10252,7 @@ var STUCK_THRESHOLD_MINUTES = 30;
 var JobsDB = class {
   db;
   constructor(dbPath) {
-    fs38.mkdirSync(path39.dirname(dbPath), { recursive: true });
+    fs39.mkdirSync(path39.dirname(dbPath), { recursive: true });
     this.db = new Database2(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
@@ -10141,7 +10520,7 @@ var BackupService = class {
   constructor(backupDir) {
     this.backupDir = backupDir ?? getBackupDir();
     this.key = getBackupKey();
-    fs38.mkdirSync(this.backupDir, { recursive: true });
+    fs39.mkdirSync(this.backupDir, { recursive: true });
   }
   /**
    * Create a backup for a repository.
@@ -10155,16 +10534,16 @@ var BackupService = class {
     const candidates = ["graph.db", "vector.db", "meta.json"];
     for (const f of candidates) {
       const fp = path39.join(codeIntelDir, f);
-      if (fs38.existsSync(fp)) {
+      if (fs39.existsSync(fp)) {
         filesToBackup.push({ name: f, localPath: fp });
       }
     }
     const registryPath = path39.join(os13.homedir(), ".code-intel", "registry.json");
-    if (fs38.existsSync(registryPath)) {
+    if (fs39.existsSync(registryPath)) {
       filesToBackup.push({ name: "registry.json", localPath: registryPath });
     }
     const usersDbPath = path39.join(os13.homedir(), ".code-intel", "users.db");
-    if (fs38.existsSync(usersDbPath)) {
+    if (fs39.existsSync(usersDbPath)) {
       filesToBackup.push({ name: "users.db", localPath: usersDbPath });
     }
     if (filesToBackup.length === 0) {
@@ -10175,7 +10554,7 @@ var BackupService = class {
       createdAt,
       version: BACKUP_VERSION,
       files: filesToBackup.map((f) => {
-        const data = fs38.readFileSync(f.localPath);
+        const data = fs39.readFileSync(f.localPath);
         return {
           name: f.name,
           sha256: crypto5.createHash("sha256").update(data).digest("hex"),
@@ -10189,7 +10568,7 @@ var BackupService = class {
     manifestLenBuf.writeUInt32BE(manifestBuf.length, 0);
     parts.push(manifestLenBuf, manifestBuf);
     for (const f of filesToBackup) {
-      const data = fs38.readFileSync(f.localPath);
+      const data = fs39.readFileSync(f.localPath);
       const nameBuf = Buffer.from(f.name, "utf-8");
       const nameLenBuf = Buffer.alloc(2);
       nameLenBuf.writeUInt16BE(nameBuf.length, 0);
@@ -10201,7 +10580,7 @@ var BackupService = class {
     const encrypted = encryptBuffer(plaintext, this.key);
     const backupFileName = `backup-${id}.cib`;
     const backupPath = path39.join(this.backupDir, backupFileName);
-    fs38.writeFileSync(backupPath, encrypted);
+    fs39.writeFileSync(backupPath, encrypted);
     const entry = {
       id,
       createdAt,
@@ -10230,7 +10609,7 @@ var BackupService = class {
     if (!cfg) throw new Error("S3 not configured. Set CODE_INTEL_BACKUP_S3_BUCKET, CODE_INTEL_BACKUP_S3_ACCESS_KEY_ID, CODE_INTEL_BACKUP_S3_SECRET_ACCESS_KEY.");
     const fileName = path39.basename(entry.path);
     const s3Key = `${cfg.prefix}${fileName}`;
-    const body = fs38.readFileSync(entry.path);
+    const body = fs39.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)}`);
@@ -10247,8 +10626,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)}`);
     }
-    fs38.mkdirSync(path39.dirname(destPath), { recursive: true });
-    fs38.writeFileSync(destPath, Buffer.from(result.body, "binary"));
+    fs39.mkdirSync(path39.dirname(destPath), { recursive: true });
+    fs39.writeFileSync(destPath, Buffer.from(result.body, "binary"));
   }
   /**
    * List backup objects in S3 with the configured prefix.
@@ -10294,10 +10673,10 @@ var BackupService = class {
     if (!entry) {
       throw new Error(`Backup "${backupId}" not found.`);
     }
-    if (!fs38.existsSync(entry.path)) {
+    if (!fs39.existsSync(entry.path)) {
       throw new Error(`Backup file not found at: ${entry.path}`);
     }
-    const encrypted = fs38.readFileSync(entry.path);
+    const encrypted = fs39.readFileSync(entry.path);
     let plaintext;
     try {
       plaintext = decryptBuffer(encrypted, this.key);
@@ -10312,7 +10691,7 @@ var BackupService = class {
     const manifest = JSON.parse(manifestStr);
     const restoreBase = targetRepoPath ?? entry.repoPath;
     const codeIntelDir = path39.join(restoreBase, ".code-intel");
-    fs38.mkdirSync(codeIntelDir, { recursive: true });
+    fs39.mkdirSync(codeIntelDir, { recursive: true });
     for (const fileEntry of manifest.files) {
       const nameLen = plaintext.readUInt16BE(offset);
       offset += 2;
@@ -10333,14 +10712,14 @@ var BackupService = class {
       } else {
         destPath = path39.join(codeIntelDir, name);
       }
-      fs38.writeFileSync(destPath, data);
+      fs39.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) => fs38.existsSync(e.path)).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    const entries = this._loadIndex().filter((e) => fs39.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);
@@ -10370,7 +10749,7 @@ var BackupService = class {
     for (const e of entries) {
       if (!keep.has(e.id)) {
         try {
-          fs38.unlinkSync(e.path);
+          fs39.unlinkSync(e.path);
           deleted++;
         } catch {
         }
@@ -10386,13 +10765,13 @@ var BackupService = class {
   }
   _loadIndex() {
     try {
-      return JSON.parse(fs38.readFileSync(this._indexPath(), "utf-8"));
+      return JSON.parse(fs39.readFileSync(this._indexPath(), "utf-8"));
     } catch {
       return [];
     }
   }
   _saveIndex(entries) {
-    fs38.writeFileSync(this._indexPath(), JSON.stringify(entries, null, 2));
+    fs39.writeFileSync(this._indexPath(), JSON.stringify(entries, null, 2));
   }
   _appendIndex(entry) {
     const entries = this._loadIndex();
@@ -11036,7 +11415,7 @@ var openApiSpec = {
 var __dirname$1 = path39.dirname(fileURLToPath(import.meta.url));
 var WEB_DIST = (() => {
   const bundled = path39.resolve(__dirname$1, "..", "web");
-  if (fs38.existsSync(bundled)) return bundled;
+  if (fs39.existsSync(bundled)) return bundled;
   return path39.resolve(__dirname$1, "..", "..", "..", "web", "dist");
 })();
 function getAllowedOrigins() {
@@ -11121,8 +11500,8 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       const metaFilePath = path39.join(workspaceRoot, ".code-intel", "meta.json");
       let metaOk = false;
       try {
-        if (fs38.existsSync(metaFilePath)) {
-          const raw = fs38.readFileSync(metaFilePath, "utf-8");
+        if (fs39.existsSync(metaFilePath)) {
+          const raw = fs39.readFileSync(metaFilePath, "utf-8");
           const meta = JSON.parse(raw);
           if (meta?.indexVersion) res.setHeader("X-Index-Version", meta.indexVersion);
         }
@@ -11313,12 +11692,12 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       return;
     }
     const user = db.createUser(username, password, "admin");
-    const sessionId = createSession({ id: user.id, username: user.username, role: user.role });
-    res.setHeader("Set-Cookie", buildSessionCookie(sessionId));
+    const { sessionId, ttlMs } = createSession({ id: user.id, username: user.username, role: user.role });
+    res.setHeader("Set-Cookie", buildSessionCookie(sessionId, ttlMs));
     res.status(201).json({ user: { id: user.id, username: user.username, role: user.role } });
   });
   app.post("/auth/login", async (req, res) => {
-    const { username, password } = req.body;
+    const { username, password, rememberMe } = req.body;
     if (!username || !password) {
       res.status(400).json({
         error: {
@@ -11362,10 +11741,10 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       });
       return;
     }
-    const sessionId = createSession({ id: user.id, username: user.username, role: user.role });
+    const { sessionId, ttlMs } = createSession({ id: user.id, username: user.username, role: user.role }, rememberMe === true);
     db.logAccess(user.id, "/auth/login", "login", "allow", req.ip ?? "unknown");
     authAttemptsTotal.inc({ method: "local", outcome: "success" });
-    res.setHeader("Set-Cookie", buildSessionCookie(sessionId));
+    res.setHeader("Set-Cookie", buildSessionCookie(sessionId, ttlMs));
     res.json({ user: { id: user.id, username: user.username, role: user.role } });
   });
   app.post("/auth/logout", (req, res) => {
@@ -11487,9 +11866,9 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
         authAttemptsTotal.inc({ method: "oidc", outcome: "success" });
         logger_default.info(`[oidc] Auto-provisioned new user: ${finalUsername} (${cfg.defaultRole})`);
       }
-      const sessionId = createSession({ id: user.id, username: user.username, role: user.role });
+      const { sessionId, ttlMs } = createSession({ id: user.id, username: user.username, role: user.role });
       db.logAccess(user.id, "/auth/callback", "oidc-login", "allow", req.ip ?? "unknown");
-      res.setHeader("Set-Cookie", buildSessionCookie(sessionId));
+      res.setHeader("Set-Cookie", buildSessionCookie(sessionId, ttlMs));
       res.redirect(302, "/");
     } catch (err) {
       logger_default.warn("[oidc] Callback failed:", err instanceof Error ? err.message : err);
@@ -11607,7 +11986,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     const entry = registry.find((r) => r.name === requestedRepo || r.path === requestedRepo);
     if (!entry) return null;
     const dbPath = path39.join(entry.path, ".code-intel", "graph.db");
-    if (!fs38.existsSync(dbPath)) return null;
+    if (!fs39.existsSync(dbPath)) return null;
     const repoGraph = createKnowledgeGraph();
     const db = new DbManager(dbPath, true);
     try {
@@ -11629,7 +12008,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       const regEntry = registry.find((r) => r.name === member.registryName);
       if (!regEntry) continue;
       const dbPath = path39.join(regEntry.path, ".code-intel", "graph.db");
-      if (!fs38.existsSync(dbPath)) continue;
+      if (!fs39.existsSync(dbPath)) continue;
       const db = new DbManager(dbPath, true);
       try {
         await db.init();
@@ -11711,7 +12090,21 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     });
   });
   app.post("/api/v1/search", requireToolScope("search"), async (req, res) => {
-    const { query, limit, repo } = req.body;
+    const { query, limit, repo, group } = req.body;
+    if (group) {
+      const grp = loadGroup(group);
+      if (!grp) {
+        res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: `Group '${group}' not found`, hint: "Use /api/v1/groups to list available groups" } });
+        return;
+      }
+      try {
+        const { perRepo, merged } = await queryGroup(grp, query ?? "", limit ?? 20);
+        res.json({ results: merged, perRepo, searchMode: "bm25", group });
+      } catch (err) {
+        res.status(500).json({ error: { code: ErrorCodes.INTERNAL_ERROR, message: err instanceof Error ? err.message : String(err) } });
+      }
+      return;
+    }
     const g = await getGraphForRepo(repo);
     const vdbPath = workspaceRoot ? getVectorDbPath(workspaceRoot) : void 0;
     const bm25 = !repo || repo === repoName ? ensureBm25Index() : null;
@@ -11720,7 +12113,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       vectorDbPath: vdbPath,
       bm25Results: bm25Results ?? void 0
     });
-    res.json({ results, searchMode });
+    res.json({ results, searchMode, repo: repo ?? repoName });
   });
   app.post("/api/v1/vector-search", async (req, res) => {
     const { query, limit = 10 } = req.body;
@@ -11762,7 +12155,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       return;
     }
     try {
-      const content = fs38.readFileSync(file_path, "utf-8");
+      const content = fs39.readFileSync(file_path, "utf-8");
       res.json({ content });
     } catch {
       res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "File not found" } });
@@ -12041,7 +12434,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       const regEntry = registry.find((r) => r.name === member.registryName);
       if (!regEntry) continue;
       const dbPath = path39.join(regEntry.path, ".code-intel", "graph.db");
-      if (!fs38.existsSync(dbPath)) continue;
+      if (!fs39.existsSync(dbPath)) continue;
       const db = new DbManager(dbPath, true);
       try {
         await db.init();
@@ -12068,7 +12461,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       let edgeCount = 0;
       if (regEntry) {
         const dbPath = path39.join(regEntry.path, ".code-intel", "graph.db");
-        if (fs38.existsSync(dbPath)) {
+        if (fs39.existsSync(dbPath)) {
           try {
             const db = new DbManager(dbPath, true);
             await db.init();
@@ -12131,7 +12524,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
             const regEntry = registry.find((r) => r.name === member.registryName);
             if (!regEntry) continue;
             const candidate = path39.resolve(path39.join(regEntry.path, normalizedFile));
-            if (fs38.existsSync(candidate)) {
+            if (fs39.existsSync(candidate)) {
               baseDir = regEntry.path;
               break;
             }
@@ -12183,7 +12576,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     }
     let fileContent;
     try {
-      fileContent = fs38.readFileSync(resolvedFile, "utf-8");
+      fileContent = fs39.readFileSync(resolvedFile, "utf-8");
     } catch {
       res.status(404).json({
         error: {
@@ -12349,7 +12742,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       res.status(500).json({ error: { code: ErrorCodes.INTERNAL_ERROR, message: err instanceof Error ? err.message : String(err), requestId: req.requestId, timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
     }
   });
-  if (fs38.existsSync(WEB_DIST)) {
+  if (fs39.existsSync(WEB_DIST)) {
     app.use(express.static(WEB_DIST));
     app.get("/{*path}", (_req, res) => {
       res.sendFile(path39.join(WEB_DIST, "index.html"));
@@ -12503,6 +12896,7 @@ async function startHttpServer(graph, repoName, port = 4747, workspaceRoot, watc
     });
   });
 }
+init_bm25_index();
 init_storage();
 init_repo_registry();
 init_metadata();
@@ -13029,11 +13423,30 @@ function summarizeCluster(graph, cluster) {
 }
 
 // src/mcp-server/server.ts
+function compact(obj) {
+  return JSON.stringify(obj, (_key, value) => value === null || value === void 0 ? void 0 : value);
+}
 function createMcpServer(graph, repoName, workspaceRoot) {
   const server = new Server(
     { name: "code-intel", version: "0.1.0" },
     { capabilities: { tools: {}, resources: {} } }
   );
+  let bm25Index = null;
+  function ensureBm25Index() {
+    if (bm25Index) return bm25Index;
+    if (!workspaceRoot) return null;
+    try {
+      const idx = new Bm25Index(getBm25DbPath(workspaceRoot));
+      idx.load();
+      bm25Index = idx;
+      return bm25Index;
+    } catch {
+      return null;
+    }
+  }
+  if (workspaceRoot) {
+    setImmediate(() => ensureBm25Index());
+  }
   const _tokenProp = {
     _token: { type: "string", description: "Required if CODE_INTEL_TOKEN is configured" }
   };
@@ -13053,13 +13466,15 @@ function createMcpServer(graph, repoName, workspaceRoot) {
       // ── Search & inspect ─────────────────────────────────────────────────
       {
         name: "search",
-        description: "BM25 keyword search across all indexed symbols \u2014 functions, classes, files, routes, etc.",
+        description: "BM25 keyword search across all indexed symbols \u2014 functions, classes, files, routes, etc. Optionally scope to a specific repo or group.",
         inputSchema: {
           type: "object",
           properties: {
             query: { type: "string", description: "Search query (symbol name, keyword, or partial match)" },
             offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
-            limit: { type: "number", description: "Max results per page (default: 50, max: 500)" },
+            limit: { type: "number", description: "Max results per page (default: 10, max: 500)" },
+            repo: { type: "string", description: "Scope search to a specific indexed repo name (optional; defaults to current repo)" },
+            group: { type: "string", description: "Scope search across all repos in a group via cross-repo RRF merge (optional; overrides repo)" },
             ..._tokenProp
           },
           required: ["query"]
@@ -13089,7 +13504,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
               enum: ["callers", "callees", "both"],
               description: "Which direction to trace \u2014 callers (who depends on it), callees (what it depends on), or both (default: both)"
             },
-            max_hops: { type: "number", description: "Maximum traversal depth (default: 5)" },
+            max_hops: { type: "number", description: "Maximum traversal depth (default: 2, max: 10)" },
             ..._tokenProp
           },
           required: ["target"]
@@ -13103,7 +13518,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
           properties: {
             file_path: { type: "string", description: 'File path (partial match is supported, e.g. "auth/login.ts")' },
             offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
-            limit: { type: "number", description: "Max results per page (default: 50, max: 500)" },
+            limit: { type: "number", description: "Max results per page (default: 10, max: 500)" },
             ..._tokenProp
           },
           required: ["file_path"]
@@ -13134,7 +13549,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
               description: "Filter by node kind: function | class | interface | method | type_alias | constant | enum (optional)"
             },
             offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
-            limit: { type: "number", description: "Max results per page (default: 50, max: 500)" },
+            limit: { type: "number", description: "Max results per page (default: 10, max: 500)" },
             ..._tokenProp
           }
         }
@@ -13152,7 +13567,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
           type: "object",
           properties: {
             offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
-            limit: { type: "number", description: "Max clusters per page (default: 50, max: 500)" },
+            limit: { type: "number", description: "Max clusters per page (default: 10, max: 500)" },
             ..._tokenProp
           }
         }
@@ -13164,7 +13579,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
           type: "object",
           properties: {
             offset: { type: "number", description: "Number of results to skip for pagination (default: 0)" },
-            limit: { type: "number", description: "Max flows per page (default: 50, max: 500)" },
+            limit: { type: "number", description: "Max flows per page (default: 10, max: 500)" },
             ..._tokenProp
           }
         }
@@ -13318,7 +13733,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
             },
             maxHops: {
               type: "number",
-              description: "Maximum BFS depth for blast radius (default: 5)"
+              description: "Maximum BFS depth for blast radius (default: 2, max: 10)"
             },
             ..._tokenProp
           }
@@ -13446,13 +13861,13 @@ function createMcpServer(graph, repoName, workspaceRoot) {
       const providedToken = a._token;
       if (providedToken !== expectedToken) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Unauthorized: invalid or missing CODE_INTEL_TOKEN" }) }],
+          content: [{ type: "text", text: compact({ error: "Unauthorized: invalid or missing CODE_INTEL_TOKEN" }) }],
           isError: true
         };
       }
     }
     const startMs = Date.now();
-    const dispatch = () => dispatchTool(name, a, graph, repoName, workspaceRoot);
+    const dispatch = () => dispatchTool(name, a, graph, repoName, workspaceRoot, ensureBm25Index);
     const MCP_TIMEOUT_MS = parseInt(process.env["CODE_INTEL_MCP_TIMEOUT_MS"] ?? "30000", 10);
     let timeoutHandle = null;
     let timedOut = false;
@@ -13484,7 +13899,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
       mcpToolDurationSeconds.observe({ tool: name }, (Date.now() - startMs) / 1e3);
       if (timedOut) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ truncated: true, reason: `Tool '${name}' timed out after ${MCP_TIMEOUT_MS}ms`, partialResults: [] }) }],
+          content: [{ type: "text", text: compact({ truncated: true, reason: `Tool '${name}' timed out after ${MCP_TIMEOUT_MS}ms`, partialResults: [] }) }],
           isError: false
         };
       }
@@ -13499,7 +13914,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
   registerResources(server, graph, repoName);
   return server;
 }
-async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
+async function dispatchTool(name, a, graph, repoName, workspaceRoot, bm25Resolver) {
   switch (name) {
     // ── repos ──────────────────────────────────────────────────────────────
     case "repos": {
@@ -13507,10 +13922,8 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify(
-            registry.map((r) => ({ name: r.name, path: r.path, indexedAt: r.indexedAt, stats: r.stats })),
-            null,
-            2
+          text: compact(
+            registry.map((r) => ({ name: r.name, path: r.path, indexedAt: r.indexedAt, stats: r.stats }))
           )
         }]
       };
@@ -13538,13 +13951,13 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             repo: repoName,
             stats: graph.size,
             nodeCounts: kindCounts,
             edgeCounts,
             health
-          }, null, 2)
+          })
         }]
       };
     }
@@ -13552,15 +13965,59 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     case "search": {
       const query = a.query;
       const offset = a.offset ?? 0;
-      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const effectiveLimit = Math.min(a.limit ?? 10, 500);
+      if (a.group) {
+        const grp = loadGroup(a.group);
+        if (!grp) {
+          return { content: [{ type: "text", text: `Group "${a.group}" not found. Use list_groups to see available groups.` }] };
+        }
+        const { perRepo, merged } = await queryGroup(grp, query, effectiveLimit + offset);
+        const paged = merged.slice(offset, offset + effectiveLimit);
+        return {
+          content: [{
+            type: "text",
+            text: compact({
+              results: paged,
+              perRepo,
+              searchMode: "bm25-cross-repo",
+              group: a.group,
+              total: merged.length,
+              offset,
+              limit: effectiveLimit,
+              hasMore: offset + effectiveLimit < merged.length
+            })
+          }]
+        };
+      }
+      const repoGraph = a.repo ? await (async () => {
+        const registry = loadRegistry();
+        const entry = registry.find((r) => r.name === a.repo || r.path === a.repo);
+        if (!entry) return graph;
+        const { DbManager: DbMgr } = await Promise.resolve().then(() => (init_db_manager(), db_manager_exports));
+        const { loadGraphFromDB: loadG } = await Promise.resolve().then(() => (init_graph_from_db(), graph_from_db_exports));
+        const { createKnowledgeGraph: createG } = await Promise.resolve().then(() => (init_knowledge_graph(), knowledge_graph_exports));
+        const dbPath = path39.join(entry.path, ".code-intel", "graph.db");
+        if (!fs39.existsSync(dbPath)) return graph;
+        const db = new DbMgr(dbPath, true);
+        await db.init();
+        const g = createG();
+        await loadG(g, db);
+        db.close();
+        return g;
+      })() : graph;
       const vdbPath = workspaceRoot ? getVectorDbPath(workspaceRoot) : void 0;
       const fetchLimit = Math.min(offset + effectiveLimit, 500);
-      const { results: allResults, searchMode } = await hybridSearch(graph, query, fetchLimit, { vectorDbPath: vdbPath });
+      const bm25 = !a.repo || a.repo === repoName ? bm25Resolver ? bm25Resolver() : null : null;
+      const bm25Results = bm25 ? bm25.search(query, fetchLimit * 3) : void 0;
+      const { results: allResults, searchMode } = await hybridSearch(repoGraph, query, fetchLimit, {
+        vectorDbPath: vdbPath,
+        bm25Results: bm25Results ?? void 0
+      });
       const total = allResults.length;
       const results = allResults.slice(offset, offset + effectiveLimit);
       const hasMore = offset + effectiveLimit < total;
       const suggestNextTools = [];
-      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] !== "false";
+      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] === "true";
       if (suggestEnabled && results.length > 0) {
         const topName = results[0].name;
         suggestNextTools.push(
@@ -13571,15 +14028,16 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             results,
             searchMode,
+            repo: a.repo ?? repoName,
             total,
             offset,
             limit: effectiveLimit,
             hasMore,
             ...suggestEnabled ? { suggested_next_tools: suggestNextTools } : {}
-          }, null, 2)
+          })
         }]
       };
     }
@@ -13601,7 +14059,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
         file: graph.getNode(e.target)?.filePath
       }));
       const cluster = incoming.filter((e) => e.kind === "belongs_to").map((e) => graph.getNode(e.target)?.name)[0];
-      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] !== "false";
+      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] === "true";
       const suggestNextTools = [];
       if (suggestEnabled) {
         const topCallerName = callers[0]?.name;
@@ -13613,7 +14071,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             node: {
               id: node.id,
               kind: node.kind,
@@ -13636,7 +14094,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
             cluster,
             content: node.content?.slice(0, 500),
             ...suggestEnabled ? { suggested_next_tools: suggestNextTools } : {}
-          }, null, 2)
+          })
         }]
       };
     }
@@ -13644,7 +14102,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     case "blast_radius": {
       const target = a.target;
       const direction = a.direction ?? "both";
-      const maxHops = a.max_hops ?? 5;
+      const maxHops = a.max_hops ?? 2;
       const node = findNodeByName(graph, target);
       if (!node) return { content: [{ type: "text", text: `Symbol "${target}" not found.` }] };
       const affected = /* @__PURE__ */ new Set();
@@ -13671,7 +14129,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
         return n ? { id, name: n.name, kind: n.kind, filePath: n.filePath } : { id };
       });
       const risk = affected.size > 10 ? "HIGH" : affected.size > 5 ? "MEDIUM" : "LOW";
-      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] !== "false";
+      const suggestEnabled = process.env["CODE_INTEL_SUGGEST_NEXT_TOOLS"] === "true";
       const suggestNextTools = [];
       if (suggestEnabled) {
         const highestRiskSymbol = node.name;
@@ -13684,13 +14142,13 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             target: node.name,
             affectedCount: affected.size,
             riskLevel: risk,
             affected: affectedDetails,
             ...suggestEnabled ? { suggested_next_tools: suggestNextTools } : {}
-          }, null, 2)
+          })
         }]
       };
     }
@@ -13698,7 +14156,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     case "file_symbols": {
       const filePath = a.file_path;
       const offset = a.offset ?? 0;
-      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const effectiveLimit = Math.min(a.limit ?? 10, 500);
       const allMatches = [];
       for (const node of graph.allNodes()) {
         if (node.filePath && node.filePath.includes(filePath)) {
@@ -13715,7 +14173,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ symbols: matches, total, offset, limit: effectiveLimit, hasMore }, null, 2)
+          text: compact({ symbols: matches, total, offset, limit: effectiveLimit, hasMore })
         }]
       };
     }
@@ -13756,7 +14214,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ from: fromName, to: toName, hops: foundPath.length - 1, path: pathDetails }, null, 2)
+          text: compact({ from: fromName, to: toName, hops: foundPath.length - 1, path: pathDetails })
         }]
       };
     }
@@ -13764,7 +14222,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     case "list_exports": {
       const kindFilter = a.kind;
       const offset = a.offset ?? 0;
-      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const effectiveLimit = Math.min(a.limit ?? 10, 500);
       const allExports = [];
       for (const node of graph.allNodes()) {
         if (!node.exported) continue;
@@ -13777,7 +14235,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ exports: exports$1, total, offset, limit: effectiveLimit, hasMore }, null, 2)
+          text: compact({ exports: exports$1, total, offset, limit: effectiveLimit, hasMore })
         }]
       };
     }
@@ -13789,12 +14247,12 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
           routes.push({ name: node.name, filePath: node.filePath, startLine: node.startLine });
         }
       }
-      return { content: [{ type: "text", text: JSON.stringify(routes, null, 2) }] };
+      return { content: [{ type: "text", text: compact(routes) }] };
     }
     // ── clusters ───────────────────────────────────────────────────────────
     case "clusters": {
       const offset = a.offset ?? 0;
-      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const effectiveLimit = Math.min(a.limit ?? 10, 500);
       const allClusters = [];
       for (const node of graph.allNodes()) {
         if (node.kind === "cluster") {
@@ -13821,14 +14279,14 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ clusters, total, offset, limit: effectiveLimit, hasMore }, null, 2)
+          text: compact({ clusters, total, offset, limit: effectiveLimit, hasMore })
         }]
       };
     }
     // ── flows ──────────────────────────────────────────────────────────────
     case "flows": {
       const offset = a.offset ?? 0;
-      const effectiveLimit = Math.min(a.limit ?? 50, 500);
+      const effectiveLimit = Math.min(a.limit ?? 10, 500);
       const allFlows = [];
       for (const node of graph.allNodes()) {
         if (node.kind === "flow") {
@@ -13848,7 +14306,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ flows, total, offset, limit: effectiveLimit, hasMore }, null, 2)
+          text: compact({ flows, total, offset, limit: effectiveLimit, hasMore })
         }]
       };
     }
@@ -13916,14 +14374,14 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             baseRef,
             changedFiles: changedFiles.map((f) => f.filePath),
             directlyChangedSymbols: changedSymbols,
             transitivelyAffectedSymbols: affectedSymbols,
             totalAffected: allAffected.size,
             riskLevel: risk
-          }, null, 2)
+          })
         }]
       };
     }
@@ -13931,14 +14389,14 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
     case "query": {
       const gqlInput = a.gql;
       if (!gqlInput) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: "Missing required parameter: gql" }) }], isError: true };
+        return { content: [{ type: "text", text: compact({ error: "Missing required parameter: gql" }) }], isError: true };
       }
       const { parseGQL: parseGQL2, isGQLParseError: isGQLParseError2 } = await Promise.resolve().then(() => (init_gql_parser(), gql_parser_exports));
       const { executeGQL: executeGQL2 } = await Promise.resolve().then(() => (init_gql_executor(), gql_executor_exports));
       const ast = parseGQL2(gqlInput);
       if (isGQLParseError2(ast)) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: `GQL parse error: ${ast.message}`, pos: ast.pos, expected: ast.expected, got: ast.got }) }],
+          content: [{ type: "text", text: compact({ error: `GQL parse error: ${ast.message}`, pos: ast.pos, expected: ast.expected, got: ast.got }) }],
           isError: true
         };
       }
@@ -13949,7 +14407,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             nodes: result.nodes,
             edges: result.edges,
             groups: result.groups,
@@ -13957,7 +14415,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
             executionTimeMs: result.executionTimeMs,
             truncated: result.truncated,
             totalCount: result.totalCount
-          }, null, 2)
+          })
         }]
       };
     }
@@ -13971,7 +14429,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
         for (const node of graph.allNodes()) {
           if (node.name === nameMatch[1]) results.push(node);
         }
-        return { content: [{ type: "text", text: JSON.stringify({ deprecation: deprecationWarning, results }, null, 2) }] };
+        return { content: [{ type: "text", text: compact({ deprecation: deprecationWarning, results }) }] };
       }
       const kindMatch = q?.match(/:\s*(\w+)/);
       if (kindMatch) {
@@ -13980,9 +14438,9 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
           if (node.kind === kindMatch[1]) results.push(node);
           if (results.length >= 50) break;
         }
-        return { content: [{ type: "text", text: JSON.stringify({ deprecation: deprecationWarning, results }, null, 2) }] };
+        return { content: [{ type: "text", text: compact({ deprecation: deprecationWarning, results }) }] };
       }
-      return { content: [{ type: "text", text: JSON.stringify({ deprecation: deprecationWarning, error: "Query not recognized. Use name='X' or :kind syntax. Or use the query tool with GQL instead." }) }] };
+      return { content: [{ type: "text", text: compact({ deprecation: deprecationWarning, error: "Query not recognized. Use name='X' or :kind syntax. Or use the query tool with GQL instead." }) }] };
     }
     // ── group_list ─────────────────────────────────────────────────────────
     case "group_list": {
@@ -13990,16 +14448,14 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       if (groupName) {
         const group = loadGroup(groupName);
         if (!group) return { content: [{ type: "text", text: `Group "${groupName}" not found.` }] };
-        return { content: [{ type: "text", text: JSON.stringify(group, null, 2) }] };
+        return { content: [{ type: "text", text: compact(group) }] };
       }
       const groups = listGroups();
       return {
         content: [{
           type: "text",
-          text: JSON.stringify(
-            groups.map((g) => ({ name: g.name, createdAt: g.createdAt, lastSync: g.lastSync, memberCount: g.members.length, members: g.members })),
-            null,
-            2
+          text: compact(
+            groups.map((g) => ({ name: g.name, createdAt: g.createdAt, lastSync: g.lastSync, memberCount: g.members.length, members: g.members }))
           )
         }]
       };
@@ -14017,14 +14473,14 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             groupName: result.groupName,
             syncedAt: result.syncedAt,
             memberCount: result.memberCount,
             contractCount: result.contracts.length,
             linkCount: result.links.length,
             topLinks: result.links.slice(0, 20)
-          }, null, 2)
+          })
         }]
       };
     }
@@ -14044,7 +14500,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ syncedAt: result.syncedAt, contracts, links }, null, 2)
+          text: compact({ syncedAt: result.syncedAt, contracts, links })
         }]
       };
     }
@@ -14059,7 +14515,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({ query, merged, perRepo }, null, 2)
+          text: compact({ query, merged, perRepo })
         }]
       };
     }
@@ -14091,12 +14547,12 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             group: groupName,
             lastSync: group.lastSync ?? null,
             syncAgeMinutes: syncAge,
             members: memberStatus
-          }, null, 2)
+          })
         }]
       };
     }
@@ -14105,11 +14561,11 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       const fromName = a.from;
       const toName = a.to;
       const result = explainRelationship(graph, fromName, toName);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return { content: [{ type: "text", text: compact(result) }] };
     }
     // ── pr_impact ──────────────────────────────────────────────────────────
     case "pr_impact": {
-      const maxHops = a.maxHops ?? 5;
+      const maxHops = a.maxHops ?? 2;
       let changedFiles = a.changedFiles ?? [];
       if (a.diff && typeof a.diff === "string") {
         const diffFiles = parseDiffFiles(a.diff);
@@ -14119,37 +14575,37 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
         return {
           content: [{
             type: "text",
-            text: JSON.stringify({ error: 'No changed files provided. Supply "changedFiles" or "diff".' })
+            text: compact({ error: 'No changed files provided. Supply "changedFiles" or "diff".' })
           }]
         };
       }
       const result = computePRImpact(graph, changedFiles, maxHops);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return { content: [{ type: "text", text: compact(result) }] };
     }
     // ── similar_symbols ────────────────────────────────────────────────────
     case "similar_symbols": {
       const symbolName = a.symbol;
       const limit = a.limit ?? 10;
       const result = findSimilarSymbols(graph, symbolName, limit);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return { content: [{ type: "text", text: compact(result) }] };
     }
     // ── health_report ──────────────────────────────────────────────────────
     case "health_report": {
       const scope = a.scope ?? ".";
       const result = computeHealthReport(graph, scope);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return { content: [{ type: "text", text: compact(result) }] };
     }
     // ── suggest_tests ──────────────────────────────────────────────────────
     case "suggest_tests": {
       const sym = a.symbol;
       const result = suggestTests(graph, sym);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return { content: [{ type: "text", text: compact(result) }] };
     }
     // ── cluster_summary ────────────────────────────────────────────────────
     case "cluster_summary": {
       const cluster = a.cluster;
       const result = summarizeCluster(graph, cluster);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return { content: [{ type: "text", text: compact(result) }] };
     }
     case "deprecated_usage": {
       const scope = a.scope;
@@ -14157,7 +14613,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       const detector = new DeprecatedDetector2();
       detector.tagDeprecated(graph);
       const findings = detector.detect(graph, scope);
-      return { content: [{ type: "text", text: JSON.stringify({ findings, total: findings.length }, null, 2) }] };
+      return { content: [{ type: "text", text: compact({ findings, total: findings.length }) }] };
     }
     // ── complexity_hotspots ────────────────────────────────────────────────
     case "complexity_hotspots": {
@@ -14165,7 +14621,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       const scope = a.scope;
       const limit = typeof a.limit === "number" ? a.limit : 20;
       const hotspots = computeComplexity2(graph, scope).slice(0, limit);
-      return { content: [{ type: "text", text: JSON.stringify({ hotspots, total: hotspots.length }, null, 2) }] };
+      return { content: [{ type: "text", text: compact({ hotspots, total: hotspots.length }) }] };
     }
     // ── coverage_gaps ──────────────────────────────────────────────────────
     case "coverage_gaps": {
@@ -14177,12 +14633,12 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
+          text: compact({
             untestedByRisk,
             coveragePct: summary.coveragePct,
             totalExported: summary.totalExported,
             testedExported: summary.testedExported
-          }, null, 2)
+          })
         }]
       };
     }
@@ -14193,7 +14649,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       const scope = a.scope;
       const includeTestFiles = a.includeTestFiles ?? false;
       const findings = scanner.scan(graph, { scope, includeTestFiles });
-      return { content: [{ type: "text", text: JSON.stringify({ findings, total: findings.length }, null, 2) }] };
+      return { content: [{ type: "text", text: compact({ findings, total: findings.length }) }] };
     }
     // ── vulnerability_scan ─────────────────────────────────────────────────
     case "vulnerability_scan": {
@@ -14206,7 +14662,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       const minRank = sevRank[minSev] ?? 1;
       let findings = detector.detect(graph, { scope, types });
       findings = findings.filter((f) => (sevRank[f.severity] ?? 1) >= minRank);
-      return { content: [{ type: "text", text: JSON.stringify({ findings, total: findings.length }, null, 2) }] };
+      return { content: [{ type: "text", text: compact({ findings, total: findings.length }) }] };
     }
     default:
       return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
@@ -14227,21 +14683,21 @@ function registerResources(server, graph, repoName) {
       for (const node of graph.allNodes()) {
         kindCounts[node.kind] = (kindCounts[node.kind] ?? 0) + 1;
       }
-      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify({ repo: repoName, stats: graph.size, nodeCounts: kindCounts }) }] };
+      return { contents: [{ uri, mimeType: "application/json", text: compact({ repo: repoName, stats: graph.size, nodeCounts: kindCounts }) }] };
     }
     if (uri.endsWith("/clusters")) {
       const clusters = [];
       for (const node of graph.allNodes()) {
         if (node.kind === "cluster") clusters.push({ id: node.id, name: node.name, memberCount: node.metadata?.memberCount });
       }
-      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify(clusters) }] };
+      return { contents: [{ uri, mimeType: "application/json", text: compact(clusters) }] };
     }
     if (uri.endsWith("/flows")) {
       const flows = [];
       for (const node of graph.allNodes()) {
         if (node.kind === "flow") flows.push({ id: node.id, name: node.name, steps: node.metadata?.steps, entryPoint: node.metadata?.entryPoint });
       }
-      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify(flows) }] };
+      return { contents: [{ uri, mimeType: "application/json", text: compact(flows) }] };
     }
     throw new Error(`Unknown resource: ${uri}`);
   });
@@ -14297,8 +14753,8 @@ async function writeSkillFiles(graph, workspaceRoot, projectName) {
   const outputDir = path39.join(workspaceRoot, ".claude", "skills", "code-intel");
   const areas = buildAreaMap(graph, workspaceRoot);
   if (areas.length === 0) return { skills: [], outputDir };
-  fs38.rmSync(outputDir, { recursive: true, force: true });
-  fs38.mkdirSync(outputDir, { recursive: true });
+  fs39.rmSync(outputDir, { recursive: true, force: true });
+  fs39.mkdirSync(outputDir, { recursive: true });
   const skills = [];
   const usedNames = /* @__PURE__ */ new Set();
   for (const area of areas) {
@@ -14306,8 +14762,8 @@ async function writeSkillFiles(graph, workspaceRoot, projectName) {
     usedNames.add(kebab);
     const content = renderSkill(area, projectName, kebab);
     const dir = path39.join(outputDir, kebab);
-    fs38.mkdirSync(dir, { recursive: true });
-    fs38.writeFileSync(path39.join(dir, "SKILL.md"), content, "utf-8");
+    fs39.mkdirSync(dir, { recursive: true });
+    fs39.writeFileSync(path39.join(dir, "SKILL.md"), content, "utf-8");
     skills.push({ name: kebab, label: area.label, symbolCount: area.nodes.length, fileCount: area.files.size });
   }
   return { skills, outputDir };
@@ -14490,13 +14946,13 @@ function writeContextFiles(workspaceRoot, projectName, stats, skills) {
   upsertFile(path39.join(workspaceRoot, "AGENTS.md"), block, "AGENTS.md");
   upsertFile(path39.join(workspaceRoot, "CLAUDE.md"), block, "CLAUDE.md");
   const githubDir = path39.join(workspaceRoot, ".github");
-  if (!fs38.existsSync(githubDir)) fs38.mkdirSync(githubDir, { recursive: true });
+  if (!fs39.existsSync(githubDir)) fs39.mkdirSync(githubDir, { recursive: true });
   upsertFile(path39.join(githubDir, "copilot-instructions.md"), block, "copilot-instructions.md");
   const cursorDir = path39.join(workspaceRoot, ".cursor", "rules");
-  if (!fs38.existsSync(cursorDir)) fs38.mkdirSync(cursorDir, { recursive: true });
+  if (!fs39.existsSync(cursorDir)) fs39.mkdirSync(cursorDir, { recursive: true });
   upsertFile(path39.join(cursorDir, "code-intel.mdc"), block, "code-intel.mdc");
   const kiroDir = path39.join(workspaceRoot, ".kiro", "steering");
-  if (!fs38.existsSync(kiroDir)) fs38.mkdirSync(kiroDir, { recursive: true });
+  if (!fs39.existsSync(kiroDir)) fs39.mkdirSync(kiroDir, { recursive: true });
   upsertFile(path39.join(kiroDir, "code-intel.md"), block, "code-intel.md");
 }
 function buildBlock(projectName, stats, skills) {
@@ -14523,6 +14979,14 @@ ${skills.map((s) => `- Working in **${s.label}**? \u2192 Load \`.claude/skills/c
 > \u26A0 This section is auto-managed by \`code-intel analyze\`. Do **not** edit between the markers \u2014 your changes will be overwritten.
 > Add your own notes below the \`${BLOCK_END}\` marker.
 
+<!-- TOOL POLICY: ENFORCED -->
+FORBIDDEN: grep, rg, find, cat, sed, ls (for symbol/code discovery)
+REQUIRED BEFORE ANY CODE ACTION:
+  1. code-intel search "<concept>"    \u2190 replaces grep/rg/find
+  2. code-intel inspect <symbol>      \u2190 replaces cat + manual file reading
+  3. code-intel impact <symbol>       \u2190 replaces manual caller tracing
+<!-- /TOOL POLICY -->
+
 Indexed: **${stats.nodes.toLocaleString()} nodes** | **${stats.edges.toLocaleString()} edges** | **${stats.files} files** | analyzed in ${(stats.duration / 1e3).toFixed(1)}s
 
 > Index stale? Re-run: \`code-intel analyze\`
@@ -14558,7 +15022,9 @@ These rules apply to **every coding agent or AI assistant** working in this repo
 ## Never Do
 
 - NEVER ignore impact warnings \u2014 always report blast radius to the user.
-- NEVER skip \`code-intel search\` before grepping or opening files.
+- **STOP** \u2014 do not call grep, rg, find, cat, sed, or read a file cold.
+  Always run \`code-intel search "<concept>"\` first.
+  Violating this wastes ~3,000 tokens per lookup and degrades session quality.
 - NEVER make changes to a symbol with \u2265 5 callers without running \`code-intel impact\` first.
 - NEVER use find-and-replace for symbol renames.
 
@@ -14634,7 +15100,7 @@ ${skillTable}
 ${BLOCK_END}`;
 }
 function upsertFile(filePath, block, fileName) {
-  if (!fs38.existsSync(filePath)) {
+  if (!fs39.existsSync(filePath)) {
     const newContent = [
       `# ${fileName}`,
       "",
@@ -14645,17 +15111,17 @@ function upsertFile(filePath, block, fileName) {
       "<!-- Add your own custom notes below this line. They will never be overwritten by code-intel. -->",
       ""
     ].join("\n");
-    fs38.writeFileSync(filePath, newContent, "utf-8");
+    fs39.writeFileSync(filePath, newContent, "utf-8");
     return;
   }
-  const existing = fs38.readFileSync(filePath, "utf-8");
+  const existing = fs39.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";
-    fs38.writeFileSync(filePath, updated, "utf-8");
+    fs39.writeFileSync(filePath, updated, "utf-8");
     return;
   }
   const appended = [
@@ -14668,7 +15134,7 @@ function upsertFile(filePath, block, fileName) {
     block,
     ""
   ].join("\n");
-  fs38.writeFileSync(filePath, appended, "utf-8");
+  fs39.writeFileSync(filePath, appended, "utf-8");
 }
 function findLineMarker(content, marker, startFrom = 0) {
   let idx = content.indexOf(marker, startFrom);
@@ -14717,7 +15183,7 @@ function filterChangedByMtime(allFilePaths, workspaceRoot, storedMtimes) {
       continue;
     }
     try {
-      const { mtimeMs } = fs38.statSync(absPath);
+      const { mtimeMs } = fs39.statSync(absPath);
       if (mtimeMs > stored) changed.push(absPath);
     } catch {
       changed.push(absPath);
@@ -14729,7 +15195,7 @@ function buildMtimeSnapshot(filePaths, workspaceRoot) {
   const snap = {};
   for (const absPath of filePaths) {
     try {
-      const { mtimeMs } = fs38.statSync(absPath);
+      const { mtimeMs } = fs39.statSync(absPath);
       snap[path39.relative(workspaceRoot, absPath)] = mtimeMs;
     } catch {
     }
@@ -14770,10 +15236,10 @@ function expandGlob(root, pattern) {
   const parts = pattern.replace(/\/\*\*?$/, "").split("/").filter(Boolean);
   if (parts.length === 0) return [];
   const dir = path39.join(root, ...parts);
-  if (!fs38.existsSync(dir)) return [];
-  return fs38.readdirSync(dir).map((entry) => path39.join(dir, entry)).filter((p) => {
+  if (!fs39.existsSync(dir)) return [];
+  return fs39.readdirSync(dir).map((entry) => path39.join(dir, entry)).filter((p) => {
     try {
-      return fs38.statSync(p).isDirectory();
+      return fs39.statSync(p).isDirectory();
     } catch {
       return false;
     }
@@ -14785,9 +15251,9 @@ function resolvePackages(root, patterns) {
     const dirs = expandGlob(root, pattern);
     for (const dir of dirs) {
       const pkgJsonPath = path39.join(dir, "package.json");
-      if (!fs38.existsSync(pkgJsonPath)) continue;
+      if (!fs39.existsSync(pkgJsonPath)) continue;
       try {
-        const pkgJson = JSON.parse(fs38.readFileSync(pkgJsonPath, "utf-8"));
+        const pkgJson = JSON.parse(fs39.readFileSync(pkgJsonPath, "utf-8"));
         const name = pkgJson.name ?? path39.basename(dir);
         packages.push({ name, path: dir });
       } catch {
@@ -14798,12 +15264,12 @@ function resolvePackages(root, patterns) {
 }
 async function detectWorkspace(root) {
   const turboJsonPath = path39.join(root, "turbo.json");
-  if (fs38.existsSync(turboJsonPath)) {
+  if (fs39.existsSync(turboJsonPath)) {
     let patterns = [];
     const pkgJsonPath = path39.join(root, "package.json");
-    if (fs38.existsSync(pkgJsonPath)) {
+    if (fs39.existsSync(pkgJsonPath)) {
       try {
-        const pkgJson = JSON.parse(fs38.readFileSync(pkgJsonPath, "utf-8"));
+        const pkgJson = JSON.parse(fs39.readFileSync(pkgJsonPath, "utf-8"));
         if (pkgJson.workspaces) {
           patterns = Array.isArray(pkgJson.workspaces) ? pkgJson.workspaces : pkgJson.workspaces.packages;
         }
@@ -14812,15 +15278,15 @@ async function detectWorkspace(root) {
     }
     if (patterns.length === 0) {
       const fallbackDir = path39.join(root, "packages");
-      if (fs38.existsSync(fallbackDir)) patterns = ["packages/*"];
+      if (fs39.existsSync(fallbackDir)) patterns = ["packages/*"];
     }
     const packages = resolvePackages(root, patterns);
     return { type: "turborepo", root, packages };
   }
   const npmPkgJsonPath = path39.join(root, "package.json");
-  if (fs38.existsSync(npmPkgJsonPath)) {
+  if (fs39.existsSync(npmPkgJsonPath)) {
     try {
-      const pkgJson = JSON.parse(fs38.readFileSync(npmPkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs39.readFileSync(npmPkgJsonPath, "utf-8"));
       if (pkgJson.workspaces) {
         const patterns = Array.isArray(pkgJson.workspaces) ? pkgJson.workspaces : pkgJson.workspaces.packages;
         const packages = resolvePackages(root, patterns);
@@ -14830,10 +15296,10 @@ async function detectWorkspace(root) {
     }
   }
   const pnpmYamlPath = path39.join(root, "pnpm-workspace.yaml");
-  if (fs38.existsSync(pnpmYamlPath)) {
+  if (fs39.existsSync(pnpmYamlPath)) {
     const patterns = [];
     try {
-      const content = fs38.readFileSync(pnpmYamlPath, "utf-8");
+      const content = fs39.readFileSync(pnpmYamlPath, "utf-8");
       let inPackages = false;
       for (const line of content.split("\n")) {
         if (/^packages\s*:/.test(line)) {
@@ -14854,13 +15320,13 @@ async function detectWorkspace(root) {
     return { type: "pnpm", root, packages };
   }
   const nxJsonPath = path39.join(root, "nx.json");
-  if (fs38.existsSync(nxJsonPath)) {
+  if (fs39.existsSync(nxJsonPath)) {
     const packages = [];
     const scanForProjects = (dir, depth) => {
       if (depth > 2) return;
       let entries;
       try {
-        entries = fs38.readdirSync(dir);
+        entries = fs39.readdirSync(dir);
       } catch {
         return;
       }
@@ -14868,14 +15334,14 @@ async function detectWorkspace(root) {
         if (entry === "node_modules" || entry.startsWith(".")) continue;
         const fullPath = path39.join(dir, entry);
         try {
-          if (!fs38.statSync(fullPath).isDirectory()) continue;
+          if (!fs39.statSync(fullPath).isDirectory()) continue;
         } catch {
           continue;
         }
         const projectJsonPath = path39.join(fullPath, "project.json");
-        if (fs38.existsSync(projectJsonPath)) {
+        if (fs39.existsSync(projectJsonPath)) {
           try {
-            const proj = JSON.parse(fs38.readFileSync(projectJsonPath, "utf-8"));
+            const proj = JSON.parse(fs39.readFileSync(projectJsonPath, "utf-8"));
             const name = proj.name ?? path39.basename(fullPath);
             packages.push({ name, path: fullPath });
           } catch {
@@ -14984,9 +15450,9 @@ var MigrationRunner = class {
   autoBackupBeforeMigration() {
     try {
       const dbFile = this.db.name;
-      if (!dbFile || !fs38.existsSync(dbFile)) return;
+      if (!dbFile || !fs39.existsSync(dbFile)) return;
       const backupDir = path39.join(os13.homedir(), ".code-intel", "backups", "pre-migration");
-      fs38.mkdirSync(backupDir, { recursive: true });
+      fs39.mkdirSync(backupDir, { recursive: true });
       const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
       const baseName = path39.basename(dbFile, ".db");
       const backupPath = path39.join(backupDir, `${baseName}-pre-migration-${ts}.db`);
@@ -14994,7 +15460,7 @@ var MigrationRunner = class {
         this.db.pragma("wal_checkpoint(TRUNCATE)");
       } catch {
       }
-      fs38.copyFileSync(dbFile, backupPath);
+      fs39.copyFileSync(dbFile, backupPath);
     } catch {
     }
   }
@@ -15144,7 +15610,7 @@ init_codes();
 var GLOBAL_DIR3 = path39.join(os13.homedir(), ".code-intel");
 function loadRepoPaths() {
   try {
-    const data = fs38.readFileSync(path39.join(GLOBAL_DIR3, "repos.json"), "utf-8");
+    const data = fs39.readFileSync(path39.join(GLOBAL_DIR3, "repos.json"), "utf-8");
     const repos = JSON.parse(data);
     return repos.map((r) => r.path);
   } catch {
@@ -15154,7 +15620,7 @@ function loadRepoPaths() {
 function loadGroupNames() {
   const groupsDir = path39.join(GLOBAL_DIR3, "groups");
   try {
-    return fs38.readdirSync(groupsDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
+    return fs39.readdirSync(groupsDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
   } catch {
     return [];
   }
@@ -15417,8 +15883,8 @@ function autoInstallCompletion() {
   if (shell === "fish") {
     const dir = path39.join(os13.homedir(), ".config", "fish", "completions");
     const dest = path39.join(dir, "code-intel.fish");
-    fs38.mkdirSync(dir, { recursive: true });
-    fs38.writeFileSync(dest, fishCompletion(), "utf-8");
+    fs39.mkdirSync(dir, { recursive: true });
+    fs39.writeFileSync(dest, fishCompletion(), "utf-8");
     console.log(`  \u2705  Fish completion installed \u2192 ${dest}
 `);
     return;
@@ -15430,13 +15896,13 @@ source <(code-intel completion bash)
 `;
   const rcFile = shell === "zsh" ? path39.join(os13.homedir(), ".zshrc") : path39.join(os13.homedir(), ".bashrc");
   try {
-    const existing = fs38.existsSync(rcFile) ? fs38.readFileSync(rcFile, "utf-8") : "";
+    const existing = fs39.existsSync(rcFile) ? fs39.readFileSync(rcFile, "utf-8") : "";
     if (existing.includes("code-intel completion")) {
       console.log(`  \u2139  Completion already configured in ${rcFile}
 `);
       return;
     }
-    fs38.appendFileSync(rcFile, script, "utf-8");
+    fs39.appendFileSync(rcFile, script, "utf-8");
     console.log(`  \u2705  ${shell} completion added to ${rcFile}`);
     console.log(`     Restart your shell or run: source ${rcFile}
 `);
@@ -15461,14 +15927,14 @@ var PACKAGE_NAME = "code-intel";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 function loadMeta() {
   try {
-    return JSON.parse(fs38.readFileSync(META_PATH, "utf-8"));
+    return JSON.parse(fs39.readFileSync(META_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveMeta(meta) {
-  fs38.mkdirSync(GLOBAL_DIR4, { recursive: true });
-  fs38.writeFileSync(META_PATH, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+  fs39.mkdirSync(GLOBAL_DIR4, { recursive: true });
+  fs39.writeFileSync(META_PATH, JSON.stringify(meta, null, 2) + "\n", "utf-8");
 }
 function isNewer(current, candidate) {
   const parse = (v) => v.replace(/^v/, "").split(".").map(Number);
@@ -15688,14 +16154,37 @@ program.name("code-intel").description("Code Intelligence Platform \u2014 Static
 
   Docs: https://github.com/vohongtho/code-intel-platform
 `);
+function ensureGitignore(workspaceRoot, silent) {
+  const gitignorePath = path39.join(workspaceRoot, ".gitignore");
+  const entry = ".code-intel/";
+  try {
+    let existing = "";
+    if (fs39.existsSync(gitignorePath)) {
+      existing = fs39.readFileSync(gitignorePath, "utf-8");
+    }
+    const lines = existing.split("\n").map((l) => l.trim());
+    if (lines.includes(".code-intel/") || lines.includes(".code-intel")) {
+      return;
+    }
+    const suffix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    fs39.appendFileSync(gitignorePath, `${suffix}${entry}
+`, "utf-8");
+    logger_default.info(".gitignore updated: added .code-intel/");
+    if (!silent) {
+      console.log(`  \u2713 .gitignore: added .code-intel/`);
+    }
+  } catch (err) {
+    logger_default.warn(`.gitignore update failed: ${err instanceof Error ? err.message : err}`);
+  }
+}
 async function analyzeWorkspace(targetPath, options) {
   const workspaceRoot = path39.resolve(targetPath);
-  if (!fs38.existsSync(workspaceRoot)) {
+  if (!fs39.existsSync(workspaceRoot)) {
     logger_default.error(`Path does not exist: ${workspaceRoot}`);
     console.error(`  \u2717  Path does not exist: ${workspaceRoot}`);
     process.exit(1);
   }
-  if (!fs38.statSync(workspaceRoot).isDirectory()) {
+  if (!fs39.statSync(workspaceRoot).isDirectory()) {
     logger_default.error(`Path is not a directory: ${workspaceRoot}`);
     console.error(`  \u2717  Path is not a directory: ${workspaceRoot}`);
     process.exit(1);
@@ -15720,14 +16209,14 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of wipeFiles) {
       try {
-        if (fs38.existsSync(f)) fs38.unlinkSync(f);
+        if (fs39.existsSync(f)) fs39.unlinkSync(f);
       } catch {
       }
     }
   }
   if (!options?.skipGit) {
     const gitDir = path39.join(workspaceRoot, ".git");
-    if (!fs38.existsSync(gitDir)) {
+    if (!fs39.existsSync(gitDir)) {
       logger_default.warn(`${workspaceRoot} is not a Git repository`);
     }
   }
@@ -15866,8 +16355,8 @@ async function analyzeWorkspace(targetPath, options) {
     };
     const profilePath = path39.join(workspaceRoot, ".code-intel", "profile.json");
     try {
-      fs38.mkdirSync(path39.join(workspaceRoot, ".code-intel"), { recursive: true });
-      fs38.writeFileSync(profilePath, JSON.stringify(profileJson, null, 2));
+      fs39.mkdirSync(path39.join(workspaceRoot, ".code-intel"), { recursive: true });
+      fs39.writeFileSync(profilePath, JSON.stringify(profileJson, null, 2));
       if (!options?.silent) console.log(`  \u2713 Profile written: ${profilePath}`);
     } catch (err) {
       logger_default.warn(`Failed to write profile.json: ${err instanceof Error ? err.message : err}`);
@@ -15894,7 +16383,7 @@ async function analyzeWorkspace(targetPath, options) {
   }
   if (isIncremental && incrementalChangedFiles && incrementalChangedFiles.length > 0) {
     const dbPath = getDbPath(workspaceRoot);
-    if (fs38.existsSync(dbPath)) {
+    if (fs39.existsSync(dbPath)) {
       try {
         const db = new DbManager(dbPath);
         await db.init();
@@ -15967,7 +16456,7 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of newStaleFiles) {
       try {
-        if (fs38.existsSync(f)) fs38.unlinkSync(f);
+        if (fs39.existsSync(f)) fs39.unlinkSync(f);
       } catch {
       }
     }
@@ -15984,21 +16473,21 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of staleFiles) {
       try {
-        if (fs38.existsSync(f)) fs38.unlinkSync(f);
+        if (fs39.existsSync(f)) fs39.unlinkSync(f);
       } catch {
       }
     }
     for (const f of newStaleFiles) {
       if (f === dbPathNew) continue;
-      if (fs38.existsSync(f)) {
+      if (fs39.existsSync(f)) {
         const dest = f.replace(dbPathNew, dbPath);
         try {
-          fs38.renameSync(f, dest);
+          fs39.renameSync(f, dest);
         } catch {
         }
       }
     }
-    fs38.renameSync(dbPathNew, dbPath);
+    fs39.renameSync(dbPathNew, dbPath);
     stopSpinner();
     logger_default.info(`DB persisted: ${nodeCount} nodes, ${edgeCount} edges`);
     if (!options?.silent) {
@@ -16030,7 +16519,7 @@ async function analyzeWorkspace(targetPath, options) {
       const staleVdb = [vdbPath, `${vdbPath}-shm`, `${vdbPath}-wal`];
       for (const f of staleVdb) {
         try {
-          if (fs38.existsSync(f)) fs38.unlinkSync(f);
+          if (fs39.existsSync(f)) fs39.unlinkSync(f);
         } catch {
         }
       }
@@ -16093,6 +16582,7 @@ async function analyzeWorkspace(targetPath, options) {
       logger_default.warn(`Context file write failed: ${err instanceof Error ? err.message : err}`);
     }
   }
+  ensureGitignore(workspaceRoot, options?.silent ?? false);
   if (!options?.silent) {
     const dur = result.totalDuration;
     const durStr = dur >= 1e3 ? `${(dur / 1e3).toFixed(1)}s` : `${dur}ms`;
@@ -16247,8 +16737,8 @@ program.command("setup").description("Configure MCP server for your editors (one
     const configFile = `${configDir}/claude_desktop_config.json`;
     try {
       let existing = {};
-      if (fs38.existsSync(configFile)) {
-        existing = JSON.parse(fs38.readFileSync(configFile, "utf-8"));
+      if (fs39.existsSync(configFile)) {
+        existing = JSON.parse(fs39.readFileSync(configFile, "utf-8"));
       }
       const merged = {
         ...existing,
@@ -16257,8 +16747,8 @@ program.command("setup").description("Configure MCP server for your editors (one
           ...mcpConfig.mcpServers
         }
       };
-      fs38.mkdirSync(configDir, { recursive: true });
-      fs38.writeFileSync(configFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      fs39.mkdirSync(configDir, { recursive: true });
+      fs39.writeFileSync(configFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
       console.log(`
   \u2705  Written to ${configFile}`);
     } catch (err) {
@@ -16360,11 +16850,11 @@ program.command("mcp").description("Start MCP server over stdio \u2014 exposes a
   const workspaceRoot = path39.resolve(targetPath);
   const repoName = path39.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  if (!fs38.existsSync(workspaceRoot) || !fs38.statSync(workspaceRoot).isDirectory()) {
+  if (!fs39.existsSync(workspaceRoot) || !fs39.statSync(workspaceRoot).isDirectory()) {
     console.error(`  \u2717  Path does not exist: ${workspaceRoot}`);
     process.exit(1);
   }
-  const existingIndex = fs38.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = fs39.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath, true);
@@ -16398,11 +16888,11 @@ program.command("serve").description("Start the local HTTP server + web UI for g
   const workspaceRoot = path39.resolve(targetPath);
   const repoName = path39.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  if (!fs38.existsSync(workspaceRoot) || !fs38.statSync(workspaceRoot).isDirectory()) {
+  if (!fs39.existsSync(workspaceRoot) || !fs39.statSync(workspaceRoot).isDirectory()) {
     console.error(`  \u2717  Path does not exist: ${workspaceRoot}`);
     process.exit(1);
   }
-  const existingIndex = !options.force && fs38.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = !options.force && fs39.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const meta = loadMetadata(workspaceRoot);
     if (meta.parser === "regex" || meta.parser === void 0) {
@@ -16440,11 +16930,11 @@ program.command("watch").description("Start HTTP server + file watcher (auto-rei
   const workspaceRoot = path39.resolve(targetPath);
   const repoName = path39.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  if (!fs38.existsSync(workspaceRoot) || !fs38.statSync(workspaceRoot).isDirectory()) {
+  if (!fs39.existsSync(workspaceRoot) || !fs39.statSync(workspaceRoot).isDirectory()) {
     console.error(`  \u2717  Path does not exist: ${workspaceRoot}`);
     process.exit(1);
   }
-  const existingIndex = !options.force && fs38.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = !options.force && fs39.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   let graph;
   if (existingIndex) {
     const meta = loadMetadata(workspaceRoot);
@@ -16564,16 +17054,16 @@ function trashDirName(repoPath) {
 }
 function softDeleteCodeIntel(repoPath) {
   const codeIntelDir = path39.join(repoPath, ".code-intel");
-  if (!fs38.existsSync(codeIntelDir)) return;
+  if (!fs39.existsSync(codeIntelDir)) return;
   const trashName = trashDirName();
   const trashDir = path39.join(repoPath, trashName);
   let dest = trashDir;
   let counter = 1;
-  while (fs38.existsSync(dest)) {
+  while (fs39.existsSync(dest)) {
     dest = `${trashDir}-${counter++}`;
   }
-  fs38.renameSync(codeIntelDir, dest);
-  fs38.writeFileSync(
+  fs39.renameSync(codeIntelDir, dest);
+  fs39.writeFileSync(
     path39.join(dest, "TRASH_META.json"),
     JSON.stringify({ deletedAt: (/* @__PURE__ */ new Date()).toISOString(), repoPath, permanent: false }, null, 2)
   );
@@ -16583,15 +17073,15 @@ function softDeleteCodeIntel(repoPath) {
 function purgeStaleTrashes(repoPath) {
   const cutoff = Date.now() - TRASH_TTL_DAYS * 24 * 60 * 60 * 1e3;
   try {
-    for (const entry of fs38.readdirSync(repoPath)) {
+    for (const entry of fs39.readdirSync(repoPath)) {
       if (!entry.startsWith(".code-intel-trash-")) continue;
       const fullPath = path39.join(repoPath, entry);
       const metaPath = path39.join(fullPath, "TRASH_META.json");
-      if (fs38.existsSync(metaPath)) {
+      if (fs39.existsSync(metaPath)) {
         try {
-          const meta = JSON.parse(fs38.readFileSync(metaPath, "utf-8"));
+          const meta = JSON.parse(fs39.readFileSync(metaPath, "utf-8"));
           if (new Date(meta.deletedAt).getTime() < cutoff) {
-            fs38.rmSync(fullPath, { recursive: true, force: true });
+            fs39.rmSync(fullPath, { recursive: true, force: true });
             console.log(`  \u2713  Auto-purged stale trash: ${fullPath}`);
           }
         } catch {
@@ -16618,18 +17108,18 @@ program.command("clean").description("Soft-delete the knowledge graph index for
   if (opts.dryRun) {
     const showDryRun = (repoPath) => {
       const codeIntelDir = path39.join(path39.resolve(repoPath), ".code-intel");
-      if (!fs38.existsSync(codeIntelDir)) {
+      if (!fs39.existsSync(codeIntelDir)) {
         console.log(`  (no .code-intel/ found at ${repoPath})`);
         return;
       }
       let totalBytes = 0;
       const countDir = (dir) => {
         try {
-          for (const entry of fs38.readdirSync(dir, { withFileTypes: true })) {
+          for (const entry of fs39.readdirSync(dir, { withFileTypes: true })) {
             const full = path39.join(dir, entry.name);
             if (entry.isDirectory()) countDir(full);
             else try {
-              totalBytes += fs38.statSync(full).size;
+              totalBytes += fs39.statSync(full).size;
             } catch {
             }
           }
@@ -16666,14 +17156,14 @@ program.command("clean").description("Soft-delete the knowledge graph index for
     let found = 0;
     for (const root of roots) {
       try {
-        for (const entry of fs38.readdirSync(root)) {
+        for (const entry of fs39.readdirSync(root)) {
           if (!entry.startsWith(".code-intel-trash-")) continue;
           const fullPath = path39.join(root, entry);
           const metaPath = path39.join(fullPath, "TRASH_META.json");
           let deletedAt = "unknown";
-          if (fs38.existsSync(metaPath)) {
+          if (fs39.existsSync(metaPath)) {
             try {
-              deletedAt = JSON.parse(fs38.readFileSync(metaPath, "utf-8")).deletedAt;
+              deletedAt = JSON.parse(fs39.readFileSync(metaPath, "utf-8")).deletedAt;
             } catch {
             }
           }
@@ -16702,8 +17192,8 @@ program.command("clean").description("Soft-delete the knowledge graph index for
     for (const r of repos) {
       if (opts.purge) {
         const codeIntelDir = path39.join(r.path, ".code-intel");
-        if (fs38.existsSync(codeIntelDir)) {
-          fs38.rmSync(codeIntelDir, { recursive: true, force: true });
+        if (fs39.existsSync(codeIntelDir)) {
+          fs39.rmSync(codeIntelDir, { recursive: true, force: true });
           console.log(`  \u2713  Hard-deleted ${codeIntelDir}`);
         }
       } else {
@@ -16720,8 +17210,8 @@ program.command("clean").description("Soft-delete the knowledge graph index for
   const workspaceRoot = path39.resolve(targetPath);
   if (opts.purge) {
     const codeIntelDir = path39.join(workspaceRoot, ".code-intel");
-    if (fs38.existsSync(codeIntelDir)) {
-      fs38.rmSync(codeIntelDir, { recursive: true, force: true });
+    if (fs39.existsSync(codeIntelDir)) {
+      fs39.rmSync(codeIntelDir, { recursive: true, force: true });
       console.log(`
   \u2713  Hard-deleted ${codeIntelDir}`);
     }
@@ -16735,7 +17225,7 @@ program.command("clean").description("Soft-delete the knowledge graph index for
 async function loadOrAnalyzeWorkspace(targetPath) {
   const workspaceRoot = path39.resolve(targetPath);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = fs38.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = fs39.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath, true);
@@ -17223,7 +17713,7 @@ groupCmd.command("status <name>").description("Check index freshness and sync st
     }
     const metaPath = path39.join(regEntry.path, ".code-intel", "meta.json");
     try {
-      const meta = JSON.parse(fs38.readFileSync(metaPath, "utf-8"));
+      const meta = JSON.parse(fs39.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)" : "";
@@ -17557,7 +18047,7 @@ backupCmd.command("list").description("List all available backups").action(() =>
   Backups (${entries.length}):
 `);
   for (const e of entries) {
-    const exists = fs38.existsSync(e.path);
+    const exists = fs39.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}`);
   }
@@ -17590,7 +18080,7 @@ program.command("migrate").description("Manage database schema migrations").opti
     $ code-intel migrate --rollback
 `).action((opts) => {
   const dbPath = opts.db ?? path39.join(os13.homedir(), ".code-intel", "users.db");
-  if (!fs38.existsSync(dbPath)) {
+  if (!fs39.existsSync(dbPath)) {
     console.error(`
   \u2717  Database not found: ${dbPath}
   Run \`code-intel serve\` or \`code-intel user create\` first.
@@ -17712,8 +18202,8 @@ authCmd.command("login").description("Authenticate via OIDC device flow \u2014 o
       server: serverUrl,
       storedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs38.mkdirSync(path39.dirname(tokenPath), { recursive: true });
-    fs38.writeFileSync(tokenPath, JSON.stringify(tokenData, null, 2), { mode: 384 });
+    fs39.mkdirSync(path39.dirname(tokenPath), { recursive: true });
+    fs39.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.
@@ -17727,12 +18217,12 @@ authCmd.command("login").description("Authenticate via OIDC device flow \u2014 o
 });
 authCmd.command("status").description("Show the current OIDC authentication status").action(() => {
   const tokenPath = path39.join(os13.homedir(), ".code-intel", "oidc-token.json");
-  if (!fs38.existsSync(tokenPath)) {
+  if (!fs39.existsSync(tokenPath)) {
     console.log("\n  Not authenticated via OIDC. Run: code-intel auth login\n");
     return;
   }
   try {
-    const data = JSON.parse(fs38.readFileSync(tokenPath, "utf-8"));
+    const data = JSON.parse(fs39.readFileSync(tokenPath, "utf-8"));
     console.log(`
   \u2705  OIDC token stored`);
     console.log(`  Server : ${data.server ?? "unknown"}`);
@@ -17745,8 +18235,8 @@ authCmd.command("status").description("Show the current OIDC authentication stat
 });
 authCmd.command("logout").description("Remove locally stored OIDC token").action(() => {
   const tokenPath = path39.join(os13.homedir(), ".code-intel", "oidc-token.json");
-  if (fs38.existsSync(tokenPath)) {
-    fs38.unlinkSync(tokenPath);
+  if (fs39.existsSync(tokenPath)) {
+    fs39.unlinkSync(tokenPath);
     console.log("\n  \u2705  OIDC token removed. You are now logged out.\n");
   } else {
     console.log("\n  No stored token found.\n");
@@ -17871,7 +18361,7 @@ program.command("config-validate <file>").description("Validate a JSON config fi
     $ code-intel config-validate ~/.code-intel/config.json
 `).action((file) => {
   const filePath = path39.resolve(file);
-  if (!fs38.existsSync(filePath)) {
+  if (!fs39.existsSync(filePath)) {
     console.error(`
   \u2717  File not found: ${filePath}
 `);
@@ -17879,7 +18369,7 @@ program.command("config-validate <file>").description("Validate a JSON config fi
   }
   let cfg;
   try {
-    cfg = JSON.parse(fs38.readFileSync(filePath, "utf-8"));
+    cfg = JSON.parse(fs39.readFileSync(filePath, "utf-8"));
   } catch (err) {
     console.error(`
   \u2717  Could not parse JSON: ${err instanceof Error ? err.message : err}
@@ -17920,7 +18410,7 @@ program.command("health").description("Run code health checks: dead code, circul
   const workspaceRoot = path39.resolve(targetPath);
   const dbPath = getDbPath(workspaceRoot);
   const meta = loadMetadata(workspaceRoot);
-  if (!meta || !fs38.existsSync(dbPath)) {
+  if (!meta || !fs39.existsSync(dbPath)) {
     console.error(`
   \u2717  ${workspaceRoot} is not indexed.`);
     console.error("     Run `code-intel analyze` first to build the index.\n");
@@ -18065,13 +18555,13 @@ program.command("query").description("Execute a GQL (Graph Query Language) query
     gqlInput = content;
   } else if (opts.file) {
     const filePath = path39.resolve(opts.file);
-    if (!fs38.existsSync(filePath)) {
+    if (!fs39.existsSync(filePath)) {
       console.error(`
   \u2717  File not found: ${filePath}
 `);
       process.exit(1);
     }
-    gqlInput = fs38.readFileSync(filePath, "utf-8");
+    gqlInput = fs39.readFileSync(filePath, "utf-8");
   } else if (gqlArg) {
     gqlInput = gqlArg;
   } else {
@@ -18599,7 +19089,7 @@ program.command("doctor").description("Run diagnostics \u2014 check Node.js, git
       continue;
     }
     const vdbPath = getVectorDbPath2(repo.path);
-    if (fs38.existsSync(vdbPath)) {
+    if (fs39.existsSync(vdbPath)) {
       try {
         const Database22 = (await import('better-sqlite3')).default;
         const vdb = new Database22(vdbPath, { readonly: true, fileMustExist: true });
@@ -18636,6 +19126,75 @@ program.command("doctor").description("Run diagnostics \u2014 check Node.js, git
     console.log("  \u2705  All checks passed.\n");
   }
 });
+program.command("context").description("Build a token-efficient context document for a set of seed symbols").argument("<symbols...>", "One or more symbol names to use as seeds").option("-p, --path <path>", "Path to the repository (default: current directory)", ".").option("-l, --limit <n>", "Max seeds to resolve (default: 10)", "10").option("--intent <intent>", "Query intent: code | callers | architecture | auto (default: auto)", "auto").option("--max-tokens <n>", "Max total tokens for output (default: 6000)", "6000").option("--show-context", "Print per-block token breakdown after output").addHelpText("after", `
+  Builds a structured [SUMMARY] / [LOGIC] / [RELATION] / [FOCUS CODE] context
+  document for one or more symbols. Designed to give AI assistants dense,
+  token-efficient context instead of raw file reads.
+
+  Examples:
+    $ code-intel context UserService
+    $ code-intel context createUser login --intent callers
+    $ code-intel context AuthService --show-context
+    $ code-intel context handlePayment --max-tokens 3000 --intent code
+`).action(async (symbols, opts) => {
+  const { graph } = await loadOrAnalyzeWorkspace(opts.path);
+  const { build: build2, detectQueryIntent: detectQueryIntent2 } = await Promise.resolve().then(() => (init_builder(), builder_exports));
+  const { measureBlocks: measureBlocks2 } = await Promise.resolve().then(() => (init_token_counter(), token_counter_exports));
+  const maxSeeds = parseInt(opts.limit, 10);
+  const maxTokens = parseInt(opts.maxTokens, 10);
+  const intent = ["code", "callers", "architecture", "auto"].includes(opts.intent) ? opts.intent : detectQueryIntent2(opts.intent);
+  const seeds = [];
+  for (const symbol of symbols.slice(0, maxSeeds)) {
+    for (const node of graph.allNodes()) {
+      if (node.name === symbol) {
+        seeds.push({ nodeId: node.id, refinedScore: 1 });
+        break;
+      }
+    }
+  }
+  if (seeds.length === 0) {
+    console.log(`
+  No symbols found for: ${symbols.join(", ")}
+`);
+    console.log('  Try: code-intel search "<name>" to find symbol names.\n');
+    return;
+  }
+  const doc = build2(seeds, graph, { maxTokens, queryIntent: intent });
+  console.log("");
+  if (doc.summary) {
+    console.log(doc.summary);
+    console.log("");
+  }
+  if (doc.logic) {
+    console.log(doc.logic);
+    console.log("");
+  }
+  if (doc.relation) {
+    console.log(doc.relation);
+    console.log("");
+  }
+  if (doc.focusCode) {
+    console.log(doc.focusCode);
+    console.log("");
+  }
+  if (doc.truncated) {
+    console.log("  \u26A0  Output was truncated due to token budget. Use --max-tokens to increase.");
+    console.log("");
+  }
+  if (opts.showContext) {
+    const counts = measureBlocks2(doc);
+    console.log("  \u2500\u2500 Token breakdown \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(`  [SUMMARY]    ${String(counts.summary).padStart(5)} tokens`);
+    console.log(`  [LOGIC]      ${String(counts.logic).padStart(5)} tokens`);
+    console.log(`  [RELATION]   ${String(counts.relation).padStart(5)} tokens`);
+    console.log(`  [FOCUS CODE] ${String(counts.focusCode).padStart(5)} tokens`);
+    console.log(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    console.log(`  Total        ${String(counts.total).padStart(5)} tokens  (budget: ${maxTokens})`);
+    console.log(`  Intent       ${doc.intent}`);
+    console.log(`  Truncated    ${doc.truncated}`);
+    console.log("");
+  }
+});
 program.parse();
 //# sourceMappingURL=main.js.map
 //# sourceMappingURL=main.js.map