@vohongtho.infotech/code-intel 1.0.0 → 1.0.2

package/dist/cli/main.js

@@ -7,9 +7,9 @@ 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 os18 from 'os';
 import { Registry, collectDefaultMetrics, Counter, Histogram, Gauge } from 'prom-client';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
@@ -38,6 +38,7 @@ import https from 'https';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import process2 from 'process';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -327,17 +328,17 @@ var init_logger = __esm({
         };
       }
       /** Global log directory: ~/.code-intel/logs */
-      static LOG_DIR = path39.join(os13.homedir(), ".code-intel", "logs");
+      static LOG_DIR = path39.join(os18.homedir(), ".code-intel", "logs");
       static getLogger() {
         if (!_Logger.instance) {
           const isProduction = process.env.NODE_ENV === "production";
           const logLevel = process.env.LOG_LEVEL ?? "info";
           const transports = [];
-          transports.push(new winston.transports.Console());
+          transports.push(new winston.transports.Console({ stderrLevels: ["error", "warn", "info", "http", "verbose", "debug", "silly"] }));
           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 +395,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 +894,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 +954,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 +971,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 +2524,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 {
             }
@@ -3111,7 +3116,7 @@ var init_llm_governance = __esm({
       }
       /** Path to the JSONL log file. */
       getLogPath() {
-        return process.env["CODE_INTEL_GOVERNANCE_LOG_PATH"] ?? path39.join(os13.homedir(), ".code-intel", "llm-governance.jsonl");
+        return process.env["CODE_INTEL_GOVERNANCE_LOG_PATH"] ?? path39.join(os18.homedir(), ".code-intel", "llm-governance.jsonl");
       }
       /**
        * Append an entry to the governance log.
@@ -3127,8 +3132,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 +3143,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 {
@@ -3272,6 +3277,49 @@ var init_anthropic = __esm({
   }
 });
 
+// src/llm/providers/custom.ts
+var custom_exports = {};
+__export(custom_exports, {
+  CustomProvider: () => CustomProvider
+});
+var CustomProvider;
+var init_custom = __esm({
+  "src/llm/providers/custom.ts"() {
+    CustomProvider = class {
+      modelName;
+      baseUrl;
+      apiKey;
+      constructor(baseUrl, model, apiKey = "") {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.modelName = model;
+        this.apiKey = apiKey;
+      }
+      async summarize(prompt2) {
+        const url = `${this.baseUrl}/chat/completions`;
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (this.apiKey) {
+          headers["Authorization"] = `Bearer ${this.apiKey}`;
+        }
+        const body = JSON.stringify({
+          model: this.modelName,
+          messages: [{ role: "user", content: prompt2 }],
+          max_tokens: 200,
+          temperature: 0.3
+        });
+        const res = await fetch(url, { method: "POST", headers, body });
+        if (!res.ok) {
+          const text = await res.text().catch(() => res.statusText);
+          throw new Error(`Custom LLM API error ${res.status}: ${text}`);
+        }
+        const data = await res.json();
+        return data.choices?.[0]?.message?.content?.trim() ?? "";
+      }
+    };
+  }
+});
+
 // src/llm/providers/ollama.ts
 var ollama_exports = {};
 __export(ollama_exports, {
@@ -3315,7 +3363,7 @@ __export(factory_exports, {
   createLLMProvider: () => createLLMProvider
 });
 async function createLLMProvider(config = {}) {
-  const { provider = "ollama", model } = config;
+  const { provider = "ollama", model, baseUrl, apiKey } = config;
   switch (provider) {
     case "openai": {
       const { OpenAIProvider: OpenAIProvider2 } = await Promise.resolve().then(() => (init_openai(), openai_exports));
@@ -3325,6 +3373,13 @@ async function createLLMProvider(config = {}) {
       const { AnthropicProvider: AnthropicProvider2 } = await Promise.resolve().then(() => (init_anthropic(), anthropic_exports));
       return new AnthropicProvider2(model);
     }
+    case "custom": {
+      const { CustomProvider: CustomProvider2 } = await Promise.resolve().then(() => (init_custom(), custom_exports));
+      const url = baseUrl ?? "http://localhost:1234/v1";
+      const mdl = model ?? "default";
+      const key = apiKey ?? "";
+      return new CustomProvider2(url, mdl, key);
+    }
     case "ollama":
     default: {
       const { OllamaProvider: OllamaProvider2 } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
@@ -3478,7 +3533,7 @@ var init_worker_pool = __esm({
       constructor(opts) {
         super();
         this.workerScript = opts.workerScript;
-        this.workerCount = opts.workerCount ?? Math.max(1, os13.cpus().length - 1);
+        this.workerCount = opts.workerCount ?? Math.max(1, os18.cpus().length - 1);
         this.maxQueueSize = opts.maxQueueSize ?? 200;
         this.maxTaskRetries = opts.maxTaskRetries ?? 2;
       }
@@ -3606,20 +3661,20 @@ var init_parse_phase_parallel = __esm({
         if (!context2.fileCache) context2.fileCache = /* @__PURE__ */ new Map();
         if (!context2.fileFunctionIndex) context2.fileFunctionIndex = /* @__PURE__ */ new Map();
         const filePaths = context2.filePaths;
-        const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os13.cpus().length - 1);
+        const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os18.cpus().length - 1);
         const CONCURRENCY = 64;
         for (let i = 0; i < filePaths.length; i += CONCURRENCY) {
           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,8 +3789,8 @@ var init_resolve_phase_parallel = __esm({
         }
         const snapshot = { symbolIndex, fileSymbolIndex, fileIndex, workspaceRoot };
         const workerScript = workerScriptPath2();
-        const workerScriptExists = fs38.existsSync(workerScript);
-        const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os13.cpus().length - 1);
+        const workerScriptExists = fs39.existsSync(workerScript);
+        const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os18.cpus().length - 1);
         if (!workerScriptExists || workerCount === 1) {
           logger_default.info(`[resolve-parallel] falling back to sequential`);
           const { resolvePhase: resolvePhase2 } = await Promise.resolve().then(() => (init_resolve_phase(), resolve_phase_exports));
@@ -4071,6 +4126,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 +4222,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 +4263,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 +4297,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 +4316,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 +4324,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 +4345,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 +4420,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 +4440,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 +4480,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 +4508,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 +4539,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 +4582,7 @@ async function loadGraphToDB(graph, dbManager) {
     } catch {
     }
   }
-  const tmpDir = fs38.mkdtempSync(path39.join(os13.tmpdir(), "code-intel-csv-"));
+  const tmpDir = fs39.mkdtempSync(path39.join(os18.tmpdir(), "code-intel-csv-"));
   try {
     const nodeTableFiles = writeNodeCSVs(graph, tmpDir);
     const edgeGroups = writeEdgeCSV(graph, tmpDir);
@@ -4500,8 +4601,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 +4615,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 +4630,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 +4741,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();
@@ -4667,7 +4768,7 @@ function removeRepo(repoPath) {
 var GLOBAL_DIR, REPOS_FILE;
 var init_repo_registry = __esm({
   "src/storage/repo-registry.ts"() {
-    GLOBAL_DIR = path39.join(os13.homedir(), ".code-intel");
+    GLOBAL_DIR = path39.join(os18.homedir(), ".code-intel");
     REPOS_FILE = path39.join(GLOBAL_DIR, "repos.json");
   }
 });
@@ -4682,12 +4783,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 +4858,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 +4886,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 +4921,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 +4930,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;
@@ -4838,11 +4939,15 @@ function loadSyncResult(groupName) {
 var GROUPS_DIR;
 var init_group_registry = __esm({
   "src/multi-repo/group-registry.ts"() {
-    GROUPS_DIR = path39.join(os13.homedir(), ".code-intel", "groups");
+    GROUPS_DIR = path39.join(os18.homedir(), ".code-intel", "groups");
   }
 });
 
 // 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 +5028,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 +5050,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 +5119,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 +5155,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 +5374,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;
     }
@@ -5393,14 +5498,14 @@ function runPrerequisiteChecks() {
     });
   }
   try {
-    const out = execSync(`df -BM "${os13.homedir()}" 2>/dev/null | tail -1 | awk '{print $4}'`, { encoding: "utf8" });
+    const out = execSync(`df -BM "${os18.homedir()}" 2>/dev/null | tail -1 | awk '{print $4}'`, { encoding: "utf8" });
     const availMB = parseInt(out.trim().replace("M", ""), 10);
     if (Number.isFinite(availMB) && availMB < 500) {
       results.push({
         name: "Disk space",
         ok: false,
         level: "warn",
-        message: `Low disk space: ${availMB} MB available in ${os13.homedir()} (500 MB recommended)`
+        message: `Low disk space: ${availMB} MB available in ${os18.homedir()} (500 MB recommended)`
       });
     }
   } catch {
@@ -5421,6 +5526,7 @@ var init_codes = __esm({
       RATE_LIMIT_EXCEEDED: "CI-1100",
       PAYLOAD_TOO_LARGE: "CI-1101",
       INVALID_REQUEST: "CI-1200",
+      CONFLICT: "CI-1409",
       // Config (CI-2xxx)
       CONFIG_INVALID: "CI-2000",
       CONFIG_NOT_FOUND: "CI-2001",
@@ -5450,10 +5556,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 +5567,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 {
       }
     }
@@ -5490,7 +5596,7 @@ var init_fs_secure = __esm({
   }
 });
 function getUsersDBPath() {
-  return process.env["CODE_INTEL_USERS_DB_PATH"] ?? path39.join(os13.homedir(), ".code-intel", "users.db");
+  return process.env["CODE_INTEL_USERS_DB_PATH"] ?? path39.join(os18.homedir(), ".code-intel", "users.db");
 }
 function getOrCreateUsersDB() {
   if (!_usersDB) {
@@ -5783,17 +5889,17 @@ function getScryptN() {
   return Number.isInteger(v) && v >= 1024 ? v : 1 << 14;
 }
 function getSecretsPath() {
-  return process.env["CODE_INTEL_SECRETS_PATH"] ?? path39.join(os13.homedir(), ".code-intel", ".secrets");
+  return process.env["CODE_INTEL_SECRETS_PATH"] ?? path39.join(os18.homedir(), ".code-intel", ".secrets");
 }
 function getMasterPassword() {
   const fromEnv = process.env["CODE_INTEL_SECRET_KEY"];
   if (fromEnv && fromEnv.length >= 16) return fromEnv;
   let username = "unknown";
   try {
-    username = os13.userInfo().username;
+    username = os18.userInfo().username;
   } catch {
   }
-  return `code-intel-machine:${os13.hostname()}:${username}:${os13.platform()}`;
+  return `code-intel-machine:${os18.hostname()}:${username}:${os18.platform()}`;
 }
 function deriveKey(password, salt) {
   return crypto5.scryptSync(password, salt, KEY_LEN, { N: getScryptN(), r: 8, p: 1 });
@@ -5825,8 +5931,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 +5972,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 +5992,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 +6014,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 +6184,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 +6203,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 +6211,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 +7984,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 +8242,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 +8337,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 +8347,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.`);
@@ -8252,6 +8365,7 @@ async function runInitWizard(opts = {}) {
       { label: "Ollama (local, free, requires Ollama running)", value: "ollama" },
       { label: "OpenAI (requires OPENAI_API_KEY env var)", value: "openai" },
       { label: "Anthropic (requires ANTHROPIC_API_KEY env var)", value: "anthropic" },
+      { label: "Custom (OpenAI-compatible API \u2014 enter URL, token & model)", value: "custom" },
       { label: "Skip (configure later)", value: "none" }
     ], 0);
     cfg.llm.provider = llmProvider;
@@ -8267,6 +8381,19 @@ async function runInitWizard(opts = {}) {
       cfg.llm.model = "llama3";
       cfg.llm.apiKey = "";
       console.log("  Make sure Ollama is running: https://ollama.com");
+    } else if (llmProvider === "custom") {
+      console.log("  Configure your OpenAI-compatible provider (e.g. LM Studio, vLLM, Together, Groq, Azure).\n");
+      const baseUrl = (await prompt(rl, "  API Base URL (e.g. http://localhost:1234/v1): ")).trim();
+      cfg.llm.baseUrl = baseUrl || "http://localhost:1234/v1";
+      const apiKey = (await prompt(rl, "  API Token/Key (leave blank if not required): ")).trim();
+      cfg.llm.apiKey = apiKey || "";
+      const model = (await prompt(rl, "  Model name (e.g. mistral-7b-instruct): ")).trim();
+      cfg.llm.model = model || "default";
+      console.log(`
+  \u2705  Custom provider configured:`);
+      console.log(`     URL:   ${cfg.llm.baseUrl}`);
+      console.log(`     Model: ${cfg.llm.model}`);
+      console.log(`     Token: ${cfg.llm.apiKey ? "(set)" : "(none)"}`);
     } else {
       cfg.llm.apiKey = "";
       console.log("  Skipped. Run `code-intel config set llm.provider openai` later.");
@@ -8331,7 +8458,7 @@ function printNextSteps() {
 var GLOBAL_DIR2, CONFIG_PATH, DEFAULT_CONFIG, EDITORS;
 var init_init_wizard = __esm({
   "src/cli/init-wizard.ts"() {
-    GLOBAL_DIR2 = path39.join(os13.homedir(), ".code-intel");
+    GLOBAL_DIR2 = path39.join(os18.homedir(), ".code-intel");
     CONFIG_PATH = path39.join(GLOBAL_DIR2, "config.json");
     DEFAULT_CONFIG = {
       $schema: "https://code-intel.dev/config-schema.json",
@@ -8644,9 +8771,10 @@ var init_config_manager = __esm({
       /access[_-]?token/i
     ];
     CONFIG_SCHEMA = {
-      "llm.provider": { type: "string", enum: ["openai", "anthropic", "ollama", "none"], default: "ollama", description: "LLM provider for AI summaries" },
+      "llm.provider": { type: "string", enum: ["openai", "anthropic", "ollama", "custom", "none"], default: "ollama", description: "LLM provider for AI summaries" },
       "llm.model": { type: "string", default: "llama3", description: "LLM model name" },
       "llm.apiKey": { type: "string", default: "", description: "API key \u2014 use $ENV_VAR syntax, e.g. $OPENAI_API_KEY" },
+      "llm.baseUrl": { type: "string", default: "", description: "Base URL for custom OpenAI-compatible API (e.g. http://localhost:1234/v1)" },
       "llm.batchSize": { type: "number", minimum: 1, maximum: 100, default: 20, description: "Concurrent LLM calls per batch" },
       "llm.maxTokensPerSummary": { type: "number", minimum: 10, maximum: 2e3, default: 100, description: "Max tokens per AI summary" },
       "embeddings.model": { type: "string", default: "all-MiniLM-L6-v2", description: "Embedding model name" },
@@ -9005,8 +9133,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 +9195,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 +9210,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 +9232,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 +9244,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 +9283,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 +9319,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 +9394,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 +10209,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 +10277,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 +10319,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");
@@ -10015,7 +10461,7 @@ var JobsDB = class {
   }
 };
 function getJobsDBPath() {
-  return path39.join(os13.homedir(), ".code-intel", "jobs.db");
+  return path39.join(os18.homedir(), ".code-intel", "jobs.db");
 }
 var _jobsDB = null;
 function getOrCreateJobsDB() {
@@ -10110,14 +10556,14 @@ var BACKUP_VERSION = "1.0";
 var ALGORITHM = "aes-256-gcm";
 var IV_LENGTH = 16;
 function getBackupDir() {
-  return path39.join(os13.homedir(), ".code-intel", "backups");
+  return path39.join(os18.homedir(), ".code-intel", "backups");
 }
 function getBackupKey() {
   const keyHex = process.env["CODE_INTEL_BACKUP_KEY"];
   if (keyHex && keyHex.length >= 64) {
     return Buffer.from(keyHex.slice(0, 64), "hex");
   }
-  const seed = `code-intel-backup-${os13.hostname()}-${os13.homedir()}`;
+  const seed = `code-intel-backup-${os18.hostname()}-${os18.homedir()}`;
   return crypto5.createHash("sha256").update(seed).digest();
 }
 function encryptBuffer(data, key) {
@@ -10141,7 +10587,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 +10601,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)) {
+    const registryPath = path39.join(os18.homedir(), ".code-intel", "registry.json");
+    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)) {
+    const usersDbPath = path39.join(os18.homedir(), ".code-intel", "users.db");
+    if (fs39.existsSync(usersDbPath)) {
       filesToBackup.push({ name: "users.db", localPath: usersDbPath });
     }
     if (filesToBackup.length === 0) {
@@ -10175,7 +10621,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 +10635,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 +10647,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 +10676,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 +10693,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 +10740,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 +10758,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;
@@ -10329,18 +10775,18 @@ var BackupService = class {
       }
       let destPath;
       if (name === "registry.json" || name === "users.db") {
-        destPath = path39.join(os13.homedir(), ".code-intel", name);
+        destPath = path39.join(os18.homedir(), ".code-intel", name);
       } 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 +10816,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 +10832,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 +11482,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 +11567,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 +11759,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 +11808,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 +11933,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 +12053,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 +12075,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 +12157,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 +12180,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 +12222,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" } });
@@ -11994,6 +12454,97 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     }
     res.json(result);
   });
+  app.post("/api/v1/groups", requireAuth, requireRole("analyst"), (req, res) => {
+    const { name } = req.body;
+    if (!name || !name.trim()) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: "Group name is required" } });
+      return;
+    }
+    const trimmed = name.trim();
+    if (groupExists(trimmed)) {
+      res.status(409).json({ error: { code: ErrorCodes.CONFLICT, message: `Group "${trimmed}" already exists` } });
+      return;
+    }
+    const group = { name: trimmed, createdAt: (/* @__PURE__ */ new Date()).toISOString(), members: [] };
+    saveGroup(group);
+    res.status(201).json(group);
+  });
+  app.delete("/api/v1/groups/:name", requireAuth, requireRole("analyst"), (req, res) => {
+    const groupName = req.params["name"];
+    if (!groupExists(groupName)) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    deleteGroup(groupName);
+    res.status(204).end();
+  });
+  app.patch("/api/v1/groups/:name", requireAuth, requireRole("analyst"), (req, res) => {
+    const groupName = req.params["name"];
+    const group = loadGroup(groupName);
+    if (!group) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    const { name } = req.body;
+    if (!name || !name.trim()) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: "New name is required" } });
+      return;
+    }
+    const newName = name.trim();
+    if (newName !== group.name && groupExists(newName)) {
+      res.status(409).json({ error: { code: ErrorCodes.CONFLICT, message: `Group "${newName}" already exists` } });
+      return;
+    }
+    if (newName !== group.name) {
+      deleteGroup(group.name);
+      group.name = newName;
+    }
+    saveGroup(group);
+    res.json(group);
+  });
+  app.post("/api/v1/groups/:name/members", requireAuth, requireRole("analyst"), (req, res) => {
+    const groupName = req.params["name"];
+    const group = loadGroup(groupName);
+    if (!group) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    const { groupPath, registryName } = req.body;
+    if (!groupPath || !registryName) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: "groupPath and registryName are required" } });
+      return;
+    }
+    const registry = loadRegistry();
+    if (!registry.find((r) => r.name === registryName)) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: `Repo "${registryName}" not found in registry. Run code-intel analyze first.` } });
+      return;
+    }
+    try {
+      const updated = addMember(groupName, { groupPath, registryName });
+      res.json(updated);
+    } catch (err) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: err instanceof Error ? err.message : String(err) } });
+    }
+  });
+  app.delete("/api/v1/groups/:name/members", requireAuth, requireRole("analyst"), (req, res) => {
+    const groupName = req.params["name"];
+    const group = loadGroup(groupName);
+    if (!group) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    const { groupPath } = req.body;
+    if (!groupPath) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: "groupPath is required" } });
+      return;
+    }
+    try {
+      const updated = removeMember(groupName, groupPath);
+      res.json(updated);
+    } catch (err) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: err instanceof Error ? err.message : String(err) } });
+    }
+  });
   app.post("/api/v1/groups/:name/sync", async (req, res) => {
     const group = loadGroup(req.params.name);
     if (!group) {
@@ -12004,8 +12555,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       const result = await syncGroup(group);
       saveSyncResult(result);
       group.lastSync = result.syncedAt;
-      const { saveGroup: saveGroup2 } = await Promise.resolve().then(() => (init_group_registry(), group_registry_exports));
-      saveGroup2(group);
+      saveGroup(group);
       res.json(result);
     } catch (err) {
       res.status(500).json({ error: { code: ErrorCodes.INTERNAL_ERROR, message: err instanceof Error ? err.message : String(err) } });
@@ -12041,7 +12591,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 +12618,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 +12681,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 +12733,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 +12899,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 +13053,7 @@ async function startHttpServer(graph, repoName, port = 4747, workspaceRoot, watc
     });
   });
 }
+init_bm25_index();
 init_storage();
 init_repo_registry();
 init_metadata();
@@ -13029,11 +13580,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 +13623,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 +13661,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 +13675,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 +13706,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 +13724,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 +13736,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 +13890,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 +14018,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 +14056,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 +14071,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 +14079,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 +14108,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 +14122,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 +14185,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 +14216,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 +14228,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 +14251,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 +14259,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 +14286,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 +14299,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 +14313,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 +14330,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 +14371,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 +14379,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 +14392,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 +14404,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 +14436,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 +14463,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 +14531,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 +14546,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 +14564,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 +14572,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
             executionTimeMs: result.executionTimeMs,
             truncated: result.truncated,
             totalCount: result.totalCount
-          }, null, 2)
+          })
         }]
       };
     }
@@ -13971,7 +14586,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 +14595,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 +14605,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 +14630,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 +14657,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 +14672,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 +14704,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 +14718,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 +14732,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 +14770,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 +14778,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 +14790,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 +14806,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 +14819,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 +14840,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 +14910,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 +14919,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,14 +15103,22 @@ 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");
+  upsertFile(path39.join(workspaceRoot, ".clinerules"), block, ".clinerules");
+  upsertFile(path39.join(workspaceRoot, ".windsurfrules"), block, ".windsurfrules");
+  const kilocodeDir = path39.join(workspaceRoot, ".kilocode", "rules");
+  if (!fs39.existsSync(kilocodeDir)) fs39.mkdirSync(kilocodeDir, { recursive: true });
+  upsertFile(path39.join(kilocodeDir, "code-intel-rules.md"), block, "code-intel-rules.md");
+  const agentsDir = path39.join(workspaceRoot, ".agents", "rules");
+  if (!fs39.existsSync(agentsDir)) fs39.mkdirSync(agentsDir, { recursive: true });
+  upsertFile(path39.join(agentsDir, "code-intel-rules.md"), block, "code-intel-rules.md");
 }
 function buildBlock(projectName, stats, skills) {
   const skillTableRows = skills.map(
@@ -14523,6 +15144,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 +15187,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 +15265,7 @@ ${skillTable}
 ${BLOCK_END}`;
 }
 function upsertFile(filePath, block, fileName) {
-  if (!fs38.existsSync(filePath)) {
+  if (!fs39.existsSync(filePath)) {
     const newContent = [
       `# ${fileName}`,
       "",
@@ -14645,17 +15276,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 +15299,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 +15348,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 +15360,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 +15401,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 +15416,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 +15429,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 +15443,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 +15461,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 +15485,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 +15499,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 +15615,9 @@ var MigrationRunner = class {
   autoBackupBeforeMigration() {
     try {
       const dbFile = this.db.name;
-      if (!dbFile || !fs38.existsSync(dbFile)) return;
-      const backupDir = path39.join(os13.homedir(), ".code-intel", "backups", "pre-migration");
-      fs38.mkdirSync(backupDir, { recursive: true });
+      if (!dbFile || !fs39.existsSync(dbFile)) return;
+      const backupDir = path39.join(os18.homedir(), ".code-intel", "backups", "pre-migration");
+      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 +15625,7 @@ var MigrationRunner = class {
         this.db.pragma("wal_checkpoint(TRUNCATE)");
       } catch {
       }
-      fs38.copyFileSync(dbFile, backupPath);
+      fs39.copyFileSync(dbFile, backupPath);
     } catch {
     }
   }
@@ -15141,10 +15772,10 @@ init_tracing();
 init_init_wizard();
 init_config_manager();
 init_codes();
-var GLOBAL_DIR3 = path39.join(os13.homedir(), ".code-intel");
+var GLOBAL_DIR3 = path39.join(os18.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 +15785,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 [];
   }
@@ -15415,10 +16046,10 @@ function autoInstallCompletion() {
   }
   console.log(`  Detected shell: ${shell}`);
   if (shell === "fish") {
-    const dir = path39.join(os13.homedir(), ".config", "fish", "completions");
+    const dir = path39.join(os18.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;
@@ -15428,15 +16059,15 @@ source <(code-intel completion zsh)
 ` : `
 source <(code-intel completion bash)
 `;
-  const rcFile = shell === "zsh" ? path39.join(os13.homedir(), ".zshrc") : path39.join(os13.homedir(), ".bashrc");
+  const rcFile = shell === "zsh" ? path39.join(os18.homedir(), ".zshrc") : path39.join(os18.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}
 `);
@@ -15455,20 +16086,20 @@ function generateCompletion(shell) {
       return fishCompletion();
   }
 }
-var GLOBAL_DIR4 = path39.join(os13.homedir(), ".code-intel");
+var GLOBAL_DIR4 = path39.join(os18.homedir(), ".code-intel");
 var META_PATH = path39.join(GLOBAL_DIR4, "update-meta.json");
 var PACKAGE_NAME = "code-intel";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 function loadMeta() {
   try {
-    return JSON.parse(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);
@@ -15581,14 +16212,170 @@ async function runUpdate(opts = {}) {
     process.exit(1);
   }
 }
+var SOURCE_EXT = /* @__PURE__ */ new Set([
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "py",
+  "pyi",
+  "rs",
+  "go",
+  "java",
+  "kt",
+  "kts",
+  "rb",
+  "cs",
+  "cpp",
+  "cc",
+  "cxx",
+  "c",
+  "h",
+  "hpp",
+  "swift",
+  "scala",
+  "php"
+]);
+var REGEX_META_RE = /[.*+?^${}()|[\]\\]/;
+var SYMBOL_ID_RE = /^[A-Za-z_$][A-Za-z0-9_$.-]*$/;
+function isSymbolLike(term) {
+  return SYMBOL_ID_RE.test(term) && !REGEX_META_RE.test(term);
+}
+function isSourceFile(filePath) {
+  const dot = filePath.lastIndexOf(".");
+  if (dot === -1) return false;
+  return SOURCE_EXT.has(filePath.slice(dot + 1).toLowerCase());
+}
+function fileStem(filePath) {
+  const base = filePath.includes("/") ? filePath.slice(filePath.lastIndexOf("/") + 1) : filePath;
+  const dot = base.lastIndexOf(".");
+  return dot === -1 ? base : base.slice(0, dot);
+}
+function extractGrepSymbol(cmd) {
+  if (/(?:^|\s)-[a-zA-Z]*[cvlLoZ]/.test(cmd)) return null;
+  const quoted = cmd.match(/(?:^|\s)["']([^"']+)["'](?:\s|$)/);
+  if (quoted) {
+    const term = quoted[1];
+    return isSymbolLike(term) ? term : null;
+  }
+  const tokens = cmd.split(/\s+/).slice(1);
+  for (const tok of tokens) {
+    if (tok.startsWith("-")) continue;
+    if (tok.startsWith("/")) continue;
+    if (tok.startsWith("./") || tok.startsWith("../")) continue;
+    if (tok.includes("/")) continue;
+    if (tok === "." || tok === "..") continue;
+    return isSymbolLike(tok) ? tok : null;
+  }
+  return null;
+}
+function rewriteCommand(cmd) {
+  try {
+    const trimmed = cmd.trim();
+    if (!trimmed) return null;
+    if (trimmed.startsWith("code-intel ") || trimmed === "code-intel") return null;
+    if (/(?:&&|\|\||;|\|)/.test(trimmed)) return null;
+    if (/^grep\s/.test(trimmed)) {
+      const sym = extractGrepSymbol(trimmed);
+      if (sym) return `code-intel search "${sym}"`;
+      return null;
+    }
+    if (/^rg\s/.test(trimmed)) {
+      if (/\s--files(?:\s|$)/.test(trimmed)) return null;
+      if (/\s--files-with-matches(?:\s|$)/.test(trimmed)) return null;
+      if (/\s--type-not\b/.test(trimmed)) return null;
+      const sym = extractGrepSymbol(trimmed);
+      if (sym) return `code-intel search "${sym}"`;
+      return null;
+    }
+    if (/^cat\s/.test(trimmed)) {
+      const m = trimmed.match(/^cat\s+(\S+)$/);
+      if (!m) return null;
+      const filePath = m[1];
+      if (filePath === "-") return null;
+      if (filePath.startsWith(">")) return null;
+      if (!isSourceFile(filePath)) return null;
+      return `code-intel inspect ${fileStem(filePath)}`;
+    }
+    if (/^(?:head|tail)\s/.test(trimmed)) {
+      if (/\s-f\b/.test(trimmed)) return null;
+      const m = trimmed.match(
+        /^(?:head|tail)\s+(?:-\d+\s+|-n\s+\d+\s+|--lines=\d+\s+)?(\S+)$/
+      );
+      if (!m) return null;
+      const filePath = m[1];
+      if (!isSourceFile(filePath)) return null;
+      return `code-intel inspect ${fileStem(filePath)}`;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function runRewrite(cmd) {
+  const rewritten = rewriteCommand(cmd.trim());
+  if (rewritten === null) {
+    process2.exit(1);
+  }
+  process2.stdout.write(rewritten);
+  process2.exit(0);
+}
+function runClaudeHook() {
+  process2.on("uncaughtException", () => process2.exit(0));
+  process2.on("unhandledRejection", () => process2.exit(0));
+  let input = "";
+  process2.stdin.setEncoding("utf-8");
+  process2.stdin.on("data", (chunk) => {
+    input += chunk;
+  });
+  process2.stdin.on("end", () => {
+    try {
+      if (!input.trim()) {
+        process2.exit(0);
+      }
+      const parsed = JSON.parse(input);
+      const cmd = parsed?.tool_input?.command;
+      if (typeof cmd !== "string" || !cmd.trim()) {
+        process2.exit(0);
+      }
+      const rewritten = rewriteCommand(cmd);
+      if (rewritten === null || rewritten === cmd) {
+        process2.exit(0);
+      }
+      const response = {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "allow",
+          permissionDecisionReason: "code-intel: semantic search replaces grep/cat",
+          updatedInput: {
+            ...parsed.tool_input,
+            command: rewritten
+          }
+        }
+      };
+      process2.stdout.write(JSON.stringify(response));
+      process2.exit(0);
+    } catch {
+      process2.exit(0);
+    }
+  });
+  process2.stdin.on("error", () => {
+    process2.exit(0);
+  });
+}
 
 // src/cli/main.ts
 var __filename$1 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname(__filename$1);
 var _pkg = JSON.parse(readFileSync(join(__dirname2, "../../package.json"), "utf-8"));
-initTracing();
+var IS_HOOK_MODE = process.argv[2] === "hook";
+if (!IS_HOOK_MODE) {
+  initTracing();
+}
 var debugMode = process.argv.includes("--debug");
-{
+if (!IS_HOOK_MODE) {
   const checks = runPrerequisiteChecks();
   for (const c of checks) {
     const icon = c.level === "error" ? "\u2717" : "\u26A0";
@@ -15596,20 +16383,28 @@ var debugMode = process.argv.includes("--debug");
 `);
   }
 }
-if (!configExists()) {
+if (!IS_HOOK_MODE && !configExists()) {
   process.stderr.write(
     "  \u2139  No config found. Run `code-intel init` to set up your environment.\n"
   );
 }
 process.on("uncaughtException", (err) => {
+  if (IS_HOOK_MODE) {
+    process.exit(0);
+  }
   process.stderr.write(formatCliError(err, debugMode));
   process.exit(1);
 });
 process.on("unhandledRejection", (err) => {
+  if (IS_HOOK_MODE) {
+    process.exit(0);
+  }
   process.stderr.write(formatCliError(err, debugMode));
   process.exit(1);
 });
-backgroundVersionCheck(_pkg.version);
+if (!IS_HOOK_MODE) {
+  backgroundVersionCheck(_pkg.version);
+}
 var program = new Command();
 var BANNER = `
   \u25C8  Code Intelligence Platform  v${_pkg.version}
@@ -15659,6 +16454,8 @@ program.name("code-intel").description("Code Intelligence Platform \u2014 Static
   \u2502  server                                                                                                            \u2502
   \u2502    code-intel mcp [path]                    Launch the MCP stdio server consumed by AI-enabled editors            \u2502
   \u2502    code-intel serve [path] --port <n>       Start the HTTP API and serve the interactive web UI (default :4747)   \u2502
+  \u2502    code-intel serve --detach                Start the server in the background (frees the terminal)               \u2502
+  \u2502    code-intel stop [path]                   Stop a background server started with --detach                        \u2502
   \u2502                                                                                                                    \u2502
   \u2502  registry                                                                                                          \u2502
   \u2502    code-intel list                          Display all repositories that have been indexed                       \u2502
@@ -15688,14 +16485,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 +16540,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`);
     }
   }
@@ -15783,7 +16603,9 @@ async function analyzeWorkspace(targetPath, options) {
       provider: options.llmProvider ?? "ollama",
       model: options.llmModel,
       batchSize: options.llmBatchSize,
-      maxNodesPerRun: options.llmMaxNodes
+      maxNodesPerRun: options.llmMaxNodes,
+      baseUrl: options.llmBaseUrl,
+      apiKey: options.llmApiKey
     } : void 0,
     onProgress: options?.silent ? void 0 : (phase, msg) => {
       if (!options?.silent) {
@@ -15866,8 +16688,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 +16716,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 +16789,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 +16806,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 +16852,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 +16915,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`;
@@ -16216,6 +17039,396 @@ program.command("completion").description("Generate shell completion scripts (ba
   }
   process.stdout.write(generateCompletion(shell));
 });
+var CODE_INTEL_HOOK_CMD = "code-intel-hook claude";
+var CODE_INTEL_CURSOR_HOOK_CMD = "code-intel-hook cursor";
+var CODE_INTEL_GEMINI_HOOK_CMD = "code-intel-hook gemini";
+function hookAlreadyPresent(root) {
+  const entries = root?.hooks?.PreToolUse;
+  if (!Array.isArray(entries)) return false;
+  return entries.some(
+    (entry) => Array.isArray(entry?.hooks) && entry.hooks.some(
+      (h) => typeof h?.command === "string" && (h.command.includes("code-intel-hook") || h.command.includes("code-intel hook"))
+    )
+  );
+}
+function insertHookEntry(root) {
+  const existingHooks = root.hooks ?? {};
+  const existingPreToolUse = Array.isArray(
+    existingHooks.PreToolUse
+  ) ? existingHooks.PreToolUse : [];
+  const newEntry = {
+    matcher: "Bash",
+    hooks: [{ type: "command", command: CODE_INTEL_HOOK_CMD }]
+  };
+  return {
+    ...root,
+    hooks: {
+      ...existingHooks,
+      PreToolUse: [newEntry, ...existingPreToolUse]
+    }
+  };
+}
+function installClaudeHook() {
+  const settingsPath = path39.join(os18.homedir(), ".claude", "settings.json");
+  let root = {};
+  if (fs39.existsSync(settingsPath)) {
+    try {
+      const raw = fs39.readFileSync(settingsPath, "utf-8");
+      root = JSON.parse(raw);
+    } catch (err) {
+      return {
+        result: "skipped",
+        reason: `Could not parse ~/.claude/settings.json: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  if (hookAlreadyPresent(root)) {
+    return { result: "already-present" };
+  }
+  const updated = insertHookEntry(root);
+  if (fs39.existsSync(settingsPath)) {
+    try {
+      fs39.copyFileSync(settingsPath, `${settingsPath}.bak`);
+    } catch {
+      logger_default.warn("  \u26A0   Could not create settings.json backup \u2014 proceeding anyway");
+    }
+  }
+  try {
+    fs39.mkdirSync(path39.dirname(settingsPath), { recursive: true });
+    const tmp = `${settingsPath}.tmp.${Date.now()}`;
+    fs39.writeFileSync(tmp, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+    fs39.renameSync(tmp, settingsPath);
+  } catch (err) {
+    return {
+      result: "skipped",
+      reason: `Could not write ~/.claude/settings.json: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  return { result: "installed" };
+}
+var COPILOT_HOOK_JSON_CONTENT = JSON.stringify({
+  hooks: {
+    PreToolUse: [
+      { type: "command", command: CODE_INTEL_HOOK_CMD.replace("claude", "copilot"), cwd: ".", timeout: 5 }
+    ]
+  }
+}, null, 2) + "\n";
+function installCopilotHook(workspaceRoot = ".") {
+  const githubDir = path39.join(workspaceRoot, ".github");
+  const hooksDir = path39.join(githubDir, "hooks");
+  const hookFile = path39.join(hooksDir, "code-intel-rewrite.json");
+  try {
+    fs39.mkdirSync(hooksDir, { recursive: true });
+    if (fs39.existsSync(hookFile)) {
+      try {
+        const existing = JSON.parse(fs39.readFileSync(hookFile, "utf-8"));
+        const hooks = existing?.hooks?.PreToolUse;
+        if (Array.isArray(hooks) && hooks.some(
+          (h) => typeof h?.command === "string" && h.command.includes("code-intel")
+        )) {
+          return { result: "already-present" };
+        }
+      } catch {
+      }
+    }
+    const tmp = `${hookFile}.tmp.${Date.now()}`;
+    fs39.writeFileSync(tmp, COPILOT_HOOK_JSON_CONTENT, "utf-8");
+    fs39.renameSync(tmp, hookFile);
+    return { result: "installed" };
+  } catch (err) {
+    return { result: "skipped", reason: `Could not write .github/hooks/code-intel-rewrite.json: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+var OPENCODE_PLUGIN_CONTENT = `import type { Plugin } from "@opencode-ai/plugin"
+import { execSync } from "node:child_process"
+
+// code-intel OpenCode plugin \u2014 rewrites symbol-discovery commands to semantic equivalents.
+// Requires: code-intel installed and in PATH.
+// To change rewrite rules, edit hook-rewriter.ts in the code-intel source.
+
+let codeIntelAvailable: boolean | null = null
+
+function checkCodeIntel(): boolean {
+  if (codeIntelAvailable !== null) return codeIntelAvailable
+  try {
+    execSync("which code-intel", { stdio: "ignore" })
+    codeIntelAvailable = true
+  } catch {
+    codeIntelAvailable = false
+  }
+  return codeIntelAvailable
+}
+
+function tryRewrite(command: string): string | null {
+  try {
+    const result = execSync(\`code-intel rewrite \${JSON.stringify(command)}\`, {
+      encoding: "utf-8",
+      timeout: 2000,
+    }).trim()
+    return result && result !== command ? result : null
+  } catch {
+    return null
+  }
+}
+
+export const CodeIntelOpenCodePlugin: Plugin = async ({ $ }) => {
+  if (!checkCodeIntel()) {
+    console.warn("[code-intel] code-intel binary not found in PATH \u2014 plugin disabled")
+    return {}
+  }
+  return {
+    "tool.execute.before": async (input, output) => {
+      const tool = String(input?.tool ?? "").toLowerCase()
+      if (tool !== "bash" && tool !== "shell") return
+      const args = output?.args
+      if (!args || typeof args !== "object") return
+      const command = (args as Record<string, unknown>).command
+      if (typeof command !== "string" || !command) return
+      try {
+        const rewritten = tryRewrite(command)
+        if (rewritten) {
+          ;(args as Record<string, unknown>).command = rewritten
+        }
+      } catch {
+        // non-blocking
+      }
+    },
+  }
+}
+`;
+function installOpenCodePlugin() {
+  const pluginDir = path39.join(os18.homedir(), ".config", "opencode", "plugins");
+  const pluginFile = path39.join(pluginDir, "code-intel.ts");
+  const opencodeCfg = path39.join(os18.homedir(), ".config", "opencode");
+  if (!fs39.existsSync(opencodeCfg)) {
+    return { result: "skipped", reason: "OpenCode not installed (~/.config/opencode not found)" };
+  }
+  if (fs39.existsSync(pluginFile)) {
+    return { result: "already-present" };
+  }
+  try {
+    fs39.mkdirSync(pluginDir, { recursive: true });
+    const tmp = `${pluginFile}.tmp.${Date.now()}`;
+    fs39.writeFileSync(tmp, OPENCODE_PLUGIN_CONTENT, "utf-8");
+    fs39.renameSync(tmp, pluginFile);
+    return { result: "installed" };
+  } catch (err) {
+    return { result: "skipped", reason: `Could not write plugin: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+var OPENCLAW_PLUGIN_CONTENT = `import { execSync } from "node:child_process";
+
+// code-intel OpenClaw plugin \u2014 rewrites symbol-discovery commands to semantic equivalents.
+// Requires: code-intel installed and in PATH.
+// To change rewrite rules, edit hook-rewriter.ts in the code-intel source.
+
+let codeIntelAvailable: boolean | null = null;
+
+function checkCodeIntel(): boolean {
+  if (codeIntelAvailable !== null) return codeIntelAvailable;
+  try {
+    execSync("which code-intel", { stdio: "ignore" });
+    codeIntelAvailable = true;
+  } catch {
+    codeIntelAvailable = false;
+  }
+  return codeIntelAvailable;
+}
+
+function tryRewrite(command: string): string | null {
+  try {
+    const result = execSync(\`code-intel rewrite \${JSON.stringify(command)}\`, {
+      encoding: "utf-8",
+      timeout: 2000,
+    }).trim();
+    return result && result !== command ? result : null;
+  } catch {
+    return null;
+  }
+}
+
+export default function register(api: any) {
+  const pluginConfig = api.config ?? {};
+  const enabled = pluginConfig.enabled !== false;
+  const verbose = pluginConfig.verbose === true;
+
+  if (!enabled) return;
+
+  if (!checkCodeIntel()) {
+    console.warn("[code-intel] code-intel binary not found in PATH \u2014 plugin disabled");
+    return;
+  }
+
+  api.on(
+    "before_tool_call",
+    (event: { toolName: string; params: Record<string, unknown> }) => {
+      if (event.toolName !== "exec") return;
+      const command = event.params?.command;
+      if (typeof command !== "string") return;
+      const rewritten = tryRewrite(command);
+      if (!rewritten) return;
+      if (verbose) console.log(\`[code-intel] \${command} -> \${rewritten}\`);
+      return { params: { ...event.params, command: rewritten } };
+    },
+    { priority: 10 }
+  );
+
+  if (verbose) console.log("[code-intel] OpenClaw plugin registered");
+}
+`;
+function installOpenClawPlugin() {
+  const openclawDir = path39.join(os18.homedir(), ".openclaw");
+  if (!fs39.existsSync(openclawDir)) {
+    return { result: "skipped", reason: "OpenClaw not installed (~/.openclaw directory not found)" };
+  }
+  const pluginDir = path39.join(openclawDir, "extensions", "code-intel");
+  const pluginFile = path39.join(pluginDir, "index.ts");
+  if (fs39.existsSync(pluginFile)) {
+    return { result: "already-present" };
+  }
+  try {
+    fs39.mkdirSync(pluginDir, { recursive: true });
+    const tmp = `${pluginFile}.tmp.${Date.now()}`;
+    fs39.writeFileSync(tmp, OPENCLAW_PLUGIN_CONTENT, "utf-8");
+    fs39.renameSync(tmp, pluginFile);
+    return { result: "installed" };
+  } catch (err) {
+    return { result: "skipped", reason: `Could not write plugin: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+var CODE_INTEL_RULES_CONTENT = `# Code Intelligence \u2014 Tool Policy
+
+## MANDATORY: Use code-intel before any code action
+
+**FORBIDDEN** (never use for symbol/code discovery): \`grep\`, \`rg\`, \`find\`, \`cat\`, \`sed\`, \`ls\`
+
+**REQUIRED workflow**:
+\`\`\`bash
+code-intel search "<concept>"    # replaces grep/rg/find
+code-intel inspect <symbol>      # replaces cat + manual reading
+code-intel impact <symbol>       # replaces manual caller tracing
+\`\`\`
+
+Rules:
+- NEVER open a file cold \u2014 always \`code-intel search\` first
+- NEVER use grep for symbols \u2014 use \`code-intel search\` instead
+- If impact shows \u2265 5 callers \u2192 warn user: HIGH blast radius
+`;
+function installRulesFile(filePath, agentName) {
+  try {
+    const dir = path39.dirname(filePath);
+    if (!fs39.existsSync(dir)) {
+      fs39.mkdirSync(dir, { recursive: true });
+    }
+    if (fs39.existsSync(filePath)) {
+      const existing = fs39.readFileSync(filePath, "utf-8");
+      if (existing.includes("code-intel search") || existing.includes("code-intel inspect")) {
+        return { result: "already-present" };
+      }
+      fs39.appendFileSync(filePath, "\n---\n\n" + CODE_INTEL_RULES_CONTENT);
+      return { result: "installed" };
+    }
+    fs39.writeFileSync(filePath, CODE_INTEL_RULES_CONTENT, "utf-8");
+    return { result: "installed" };
+  } catch (err) {
+    return { result: "skipped", reason: `Could not write ${agentName} rules: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+function cursorHookAlreadyPresent(root) {
+  const hooks = root?.hooks;
+  const preToolUse = hooks?.preToolUse;
+  if (!Array.isArray(preToolUse)) return false;
+  return preToolUse.some((entry) => {
+    const cmd = entry?.command;
+    return typeof cmd === "string" && (cmd.includes("code-intel-hook") || cmd.includes("code-intel hook"));
+  });
+}
+function installCursorHook() {
+  const cursorDir = path39.join(os18.homedir(), ".cursor");
+  const hooksPath = path39.join(cursorDir, "hooks.json");
+  let root = { version: 1 };
+  if (fs39.existsSync(hooksPath)) {
+    try {
+      const raw = fs39.readFileSync(hooksPath, "utf-8");
+      if (raw.trim()) root = JSON.parse(raw);
+    } catch (err) {
+      return { result: "skipped", reason: `Could not parse ~/.cursor/hooks.json: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  } else if (!fs39.existsSync(cursorDir)) {
+    return { result: "skipped", reason: "Cursor not installed (~/.cursor directory not found)" };
+  }
+  if (cursorHookAlreadyPresent(root)) return { result: "already-present" };
+  if (fs39.existsSync(hooksPath)) {
+    try {
+      fs39.copyFileSync(hooksPath, `${hooksPath}.bak`);
+    } catch {
+    }
+  }
+  const existingHooks = root.hooks ?? {};
+  const existingPreToolUse = Array.isArray(existingHooks.preToolUse) ? existingHooks.preToolUse : [];
+  const newEntry = { command: CODE_INTEL_CURSOR_HOOK_CMD, matcher: "Shell" };
+  const updated = { ...root, hooks: { ...existingHooks, preToolUse: [newEntry, ...existingPreToolUse] } };
+  try {
+    fs39.mkdirSync(cursorDir, { recursive: true });
+    const tmp = `${hooksPath}.tmp.${Date.now()}`;
+    fs39.writeFileSync(tmp, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+    fs39.renameSync(tmp, hooksPath);
+  } catch (err) {
+    return { result: "skipped", reason: `Could not write ~/.cursor/hooks.json: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  return { result: "installed" };
+}
+function geminiHookAlreadyPresent(root) {
+  const hooks = root?.hooks;
+  const beforeTool = hooks?.BeforeTool;
+  if (!Array.isArray(beforeTool)) return false;
+  return beforeTool.some((entry) => {
+    const entryHooks = entry?.hooks;
+    if (!Array.isArray(entryHooks)) return false;
+    return entryHooks.some((h) => {
+      const cmd = h?.command;
+      return typeof cmd === "string" && (cmd.includes("code-intel-hook") || cmd.includes("code-intel hook"));
+    });
+  });
+}
+function installGeminiHook() {
+  const geminiDir = path39.join(os18.homedir(), ".gemini");
+  const settingsPath = path39.join(geminiDir, "settings.json");
+  if (!fs39.existsSync(geminiDir)) {
+    return { result: "skipped", reason: "Gemini CLI not installed (~/.gemini directory not found)" };
+  }
+  let root = {};
+  if (fs39.existsSync(settingsPath)) {
+    try {
+      const raw = fs39.readFileSync(settingsPath, "utf-8");
+      if (raw.trim()) root = JSON.parse(raw);
+    } catch (err) {
+      return { result: "skipped", reason: `Could not parse ~/.gemini/settings.json: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+  if (geminiHookAlreadyPresent(root)) return { result: "already-present" };
+  if (fs39.existsSync(settingsPath)) {
+    try {
+      fs39.copyFileSync(settingsPath, `${settingsPath}.bak`);
+    } catch {
+    }
+  }
+  const existingHooks = root.hooks ?? {};
+  const existingBeforeTool = Array.isArray(existingHooks.BeforeTool) ? existingHooks.BeforeTool : [];
+  const newEntry = {
+    matcher: "run_shell_command",
+    hooks: [{ type: "command", command: CODE_INTEL_GEMINI_HOOK_CMD }]
+  };
+  const updated = { ...root, hooks: { ...existingHooks, BeforeTool: [newEntry, ...existingBeforeTool] } };
+  try {
+    const tmp = `${settingsPath}.tmp.${Date.now()}`;
+    fs39.writeFileSync(tmp, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+    fs39.renameSync(tmp, settingsPath);
+  } catch (err) {
+    return { result: "skipped", reason: `Could not write ~/.gemini/settings.json: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  return { result: "installed" };
+}
 program.command("setup").description("Configure MCP server for your editors (one-time setup)").option("--completion", "Auto-install shell completion for the detected shell").addHelpText("after", `
   Configure the code-intel MCP server for Claude Desktop, VS Code, or any
   editor that supports the Model Context Protocol.
@@ -16247,8 +17460,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 +17470,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) {
@@ -16271,8 +17484,129 @@ program.command("setup").description("Configure MCP server for your editors (one
   console.log("  " + JSON.stringify({ servers: { "code-intel": { type: "stdio", command: "npx", args: ["code-intel", "mcp", "."] } } }, null, 2).split("\n").join("\n  "));
   console.log('\n  To verify in VS Code: open Command Palette \u2192 "MCP: List Servers" and confirm code-intel is Running.');
   console.log("\n  Next: run `code-intel analyze` inside your project to build the knowledge graph.\n");
+  const hookResult = installClaudeHook();
+  if (hookResult.result === "installed") {
+    const backupPath = path39.join(os18.homedir(), ".claude", "settings.json.bak");
+    console.log("\n  \u2705  Claude Code hook installed");
+    console.log("     grep/rg/cat on source files \u2192 code-intel search/inspect");
+    if (fs39.existsSync(backupPath)) {
+      console.log(`     Backup: ${backupPath}`);
+    }
+    console.log("\n  \u21BA  Restart Claude Code for the hook to take effect.");
+  } else if (hookResult.result === "already-present") {
+    console.log("\n  \u2705  Claude Code hook already installed");
+  } else {
+    logger_default.warn(`
+  \u26A0   Claude Code hook skipped: ${hookResult.reason}`);
+    console.log("\n  Add manually to ~/.claude/settings.json under hooks.PreToolUse[]:");
+    console.log("  (insert as the FIRST entry so it runs before any existing hooks)\n");
+    console.log("  " + JSON.stringify({
+      matcher: "Bash",
+      hooks: [{ type: "command", command: CODE_INTEL_HOOK_CMD }]
+    }, null, 2).split("\n").join("\n  "));
+  }
+  const cursorResult = installCursorHook();
+  if (cursorResult.result === "installed") {
+    console.log("\n  \u2705  Cursor hook installed");
+    console.log("     grep/rg/cat on source files \u2192 code-intel search/inspect");
+  } else if (cursorResult.result === "already-present") {
+    console.log("\n  \u2705  Cursor hook already installed");
+  } else {
+    console.log(`
+  \u2139   Cursor hook skipped: ${cursorResult.reason}`);
+  }
+  const geminiResult = installGeminiHook();
+  if (geminiResult.result === "installed") {
+    console.log("\n  \u2705  Gemini CLI hook installed");
+    console.log("     grep/rg/cat on source files \u2192 code-intel search/inspect");
+  } else if (geminiResult.result === "already-present") {
+    console.log("\n  \u2705  Gemini CLI hook already installed");
+  } else {
+    console.log(`
+  \u2139   Gemini CLI hook skipped: ${geminiResult.reason}`);
+  }
+  const copilotResult = installCopilotHook(process.cwd());
+  if (copilotResult.result === "installed") {
+    console.log("\n  \u2705  GitHub Copilot hook installed (.github/hooks/code-intel-rewrite.json)");
+    console.log("     grep/rg/cat on source files \u2192 code-intel search/inspect");
+  } else if (copilotResult.result === "already-present") {
+    console.log("\n  \u2705  GitHub Copilot hook already installed");
+  } else {
+    console.log(`
+  \u2139   GitHub Copilot hook skipped: ${copilotResult.reason}`);
+  }
+  const openCodeResult = installOpenCodePlugin();
+  if (openCodeResult.result === "installed") {
+    console.log("\n  \u2705  OpenCode plugin installed (~/.config/opencode/plugins/code-intel.ts)");
+    console.log("     grep/rg/cat on source files \u2192 code-intel search/inspect");
+  } else if (openCodeResult.result === "already-present") {
+    console.log("\n  \u2705  OpenCode plugin already installed");
+  } else {
+    console.log(`
+  \u2139   OpenCode plugin skipped: ${openCodeResult.reason}`);
+  }
+  const openClawResult = installOpenClawPlugin();
+  if (openClawResult.result === "installed") {
+    console.log("\n  \u2705  OpenClaw plugin installed (~/.openclaw/extensions/code-intel/)");
+    console.log("     grep/rg/cat on source files \u2192 code-intel search/inspect");
+  } else if (openClawResult.result === "already-present") {
+    console.log("\n  \u2705  OpenClaw plugin already installed");
+  } else {
+    console.log(`
+  \u2139   OpenClaw plugin skipped: ${openClawResult.reason}`);
+  }
+  console.log("\n  \u2500\u2500\u2500 Prompt-level agents (rules files) \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");
+  const cwd = process.cwd();
+  const clineResult = installRulesFile(path39.join(cwd, ".clinerules"), "Cline");
+  if (clineResult.result === "installed") {
+    console.log("  \u2705  Cline/Roo Code rules installed (.clinerules)");
+  } else if (clineResult.result === "already-present") {
+    console.log("  \u2705  Cline/Roo Code rules already present (.clinerules)");
+  } else {
+    console.log(`  \u2139   Cline/Roo Code rules skipped: ${clineResult.reason}`);
+  }
+  const windsurfResult = installRulesFile(path39.join(cwd, ".windsurfrules"), "Windsurf");
+  if (windsurfResult.result === "installed") {
+    console.log("  \u2705  Windsurf rules installed (.windsurfrules)");
+  } else if (windsurfResult.result === "already-present") {
+    console.log("  \u2705  Windsurf rules already present (.windsurfrules)");
+  } else {
+    console.log(`  \u2139   Windsurf rules skipped: ${windsurfResult.reason}`);
+  }
+  const kiloResult = installRulesFile(
+    path39.join(cwd, ".kilocode", "rules", "code-intel-rules.md"),
+    "Kilo Code"
+  );
+  if (kiloResult.result === "installed") {
+    console.log("  \u2705  Kilo Code rules installed (.kilocode/rules/code-intel-rules.md)");
+  } else if (kiloResult.result === "already-present") {
+    console.log("  \u2705  Kilo Code rules already present");
+  } else {
+    console.log(`  \u2139   Kilo Code rules skipped: ${kiloResult.reason}`);
+  }
+  const antigravityResult = installRulesFile(
+    path39.join(cwd, ".agents", "rules", "code-intel-rules.md"),
+    "Antigravity"
+  );
+  if (antigravityResult.result === "installed") {
+    console.log("  \u2705  Google Antigravity rules installed (.agents/rules/code-intel-rules.md)");
+  } else if (antigravityResult.result === "already-present") {
+    console.log("  \u2705  Google Antigravity rules already present");
+  } else {
+    console.log(`  \u2139   Google Antigravity rules skipped: ${antigravityResult.reason}`);
+  }
+  const codexResult = installRulesFile(path39.join(cwd, "AGENTS.md"), "Codex");
+  if (codexResult.result === "installed") {
+    console.log("  \u2705  Codex CLI rules appended (AGENTS.md)");
+  } else if (codexResult.result === "already-present") {
+    console.log("  \u2705  Codex CLI rules already present (AGENTS.md)");
+  } else {
+    console.log(`  \u2139   Codex CLI rules skipped: ${codexResult.reason}`);
+  }
+  console.log("\n  \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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("\n  \u25C8  Setup complete. Run `code-intel analyze` to build the knowledge graph.\n");
 });
-program.command("analyze").description("Index a repository and build the knowledge graph").argument("[path]", "Path to the repository (default: current directory)", ".").option("--force", "Force full re-index, ignoring cached data").option("--incremental", "Only re-parse files changed since last analysis (git diff or mtime)").option("--parallel", "Use worker threads for parse + resolve phases (faster on multi-core)").option("--skills", "Generate .claude/skills/ SKILL.md files from detected clusters").option("--embeddings", "Build vector embeddings for semantic search (slower, recommended)").option("--skip-embeddings", "Skip embedding generation (faster, text-search only)").option("--skip-agents-md", "Preserve any custom edits inside AGENTS.md / CLAUDE.md").option("--skip-git", "Allow indexing directories that are not Git repositories").option("--verbose", "Log every file skipped due to missing parser support").option("--summarize", "Generate AI summaries for function/class/method/interface nodes (opt-in)").option("--llm-provider <provider>", "LLM provider for --summarize: openai | anthropic | ollama (default: ollama)").option("--llm-model <model>", "LLM model name (e.g. gpt-4o-mini, claude-haiku-4-5, llama3)").option("--llm-batch-size <n>", "Concurrent LLM calls per batch (default: 20)", "20").option("--llm-max-nodes <n>", "Max nodes to summarize per run (cost guard)").option("--no-group-sync", "Skip automatic group sync after analysis").option("--dry-run", "Preview files that would be scanned + estimated time; no DB write").option("--max-memory <MB>", "Limit graph memory (MB); spill node content to free RAM when exceeded").option("--profile", "Write per-phase profiling data to .code-intel/profile.json").addHelpText("after", `
+program.command("analyze").description("Index a repository and build the knowledge graph").argument("[path]", "Path to the repository (default: current directory)", ".").option("--force", "Force full re-index, ignoring cached data").option("--incremental", "Only re-parse files changed since last analysis (git diff or mtime)").option("--parallel", "Use worker threads for parse + resolve phases (faster on multi-core)").option("--skills", "Generate .claude/skills/ SKILL.md files from detected clusters").option("--embeddings", "Build vector embeddings for semantic search (slower, recommended)").option("--skip-embeddings", "Skip embedding generation (faster, text-search only)").option("--skip-agents-md", "Preserve any custom edits inside AGENTS.md / CLAUDE.md").option("--skip-git", "Allow indexing directories that are not Git repositories").option("--verbose", "Log every file skipped due to missing parser support").option("--summarize", "Generate AI summaries for function/class/method/interface nodes (opt-in)").option("--llm-provider <provider>", "LLM provider for --summarize: openai | anthropic | ollama | custom (default: ollama)").option("--llm-model <model>", "LLM model name (e.g. gpt-4o-mini, claude-haiku-4-5, llama3, mistral)").option("--llm-base-url <url>", "Base URL for custom OpenAI-compatible API (e.g. http://localhost:1234/v1)").option("--llm-api-key <key>", "API key/token for the LLM provider (custom or override)").option("--llm-batch-size <n>", "Concurrent LLM calls per batch (default: 20)", "20").option("--llm-max-nodes <n>", "Max nodes to summarize per run (cost guard)").option("--no-group-sync", "Skip automatic group sync after analysis").option("--dry-run", "Preview files that would be scanned + estimated time; no DB write").option("--max-memory <MB>", "Limit graph memory (MB); spill node content to free RAM when exceeded").option("--profile", "Write per-phase profiling data to .code-intel/profile.json").addHelpText("after", `
   Parses your source code with tree-sitter, builds a Knowledge Graph of
   symbols and their relationships, persists it to .code-intel/graph.db,
   and auto-generates AGENTS.md + CLAUDE.md context blocks.
@@ -16292,6 +17626,7 @@ program.command("analyze").description("Index a repository and build the knowled
     $ code-intel analyze --summarize            Generate AI summaries (uses Ollama by default)
     $ code-intel analyze --summarize --llm-provider openai --llm-model gpt-4o-mini
     $ code-intel analyze --summarize --llm-provider anthropic --llm-max-nodes 500
+    $ code-intel analyze --summarize --llm-provider custom --llm-base-url http://localhost:1234/v1 --llm-model mistral --llm-api-key mytoken
     $ code-intel analyze --dry-run             Preview files that would be scanned
 `).action(async (targetPath, opts) => {
   if (opts.dryRun) {
@@ -16338,6 +17673,8 @@ program.command("analyze").description("Index a repository and build the knowled
       const v = parseInt(opts.llmMaxNodes ?? "", 10);
       return Number.isFinite(v) && v >= 1 ? v : void 0;
     })(),
+    llmBaseUrl: opts.llmBaseUrl,
+    llmApiKey: opts.llmApiKey,
     maxMemoryMB: (() => {
       const v = parseInt(opts.maxMemory ?? "", 10);
       return Number.isFinite(v) && v >= 1 ? v : void 0;
@@ -16360,11 +17697,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);
@@ -16377,11 +17714,18 @@ program.command("mcp").description("Start MCP server over stdio \u2014 exposes a
     await startMcpStdio(graph, name, root);
   }
 });
-program.command("serve").description("Start the local HTTP server + web UI for graph exploration").argument("[path]", "Path to analyze (default: current directory)", ".").option("-p, --port <port>", "Port to listen on", "4747").option("--force", "Force re-analysis even if an index already exists").addHelpText("after", `
+program.command("serve").description("Start the local HTTP server + web UI for graph exploration").argument("[path]", "Path to analyze (default: current directory)", ".").option("-p, --port <port>", "Port to listen on", "4747").option("--force", "Force re-analysis even if an index already exists").option("-d, --detach", "Run server in background (detached); PID written to .code-intel/serve.pid").addHelpText("after", `
   If a .code-intel/graph.db index already exists for the path, the server
   loads the persisted graph directly and starts immediately \u2014 no re-analysis.
   Use --force to discard the existing index and re-analyze from scratch.
 
+  Background mode:
+    $ code-intel serve --detach          # start in background
+    $ code-intel serve --detach --port 8080
+    $ code-intel stop                    # stop the background server
+
+  PID file: <path>/.code-intel/serve.pid
+
   The web UI offers:
     \xB7 Force-directed Knowledge Graph with color-coded node types
     \xB7 BM25 text search + optional semantic (vector) search
@@ -16394,15 +17738,54 @@ program.command("serve").description("Start the local HTTP server + web UI for g
     $ code-intel serve ./my-project
     $ code-intel serve --port 8080
     $ code-intel serve --force
+    $ code-intel serve --detach
 `).action(async (targetPath, options) => {
   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;
+  if (options.detach) {
+    const { spawn } = await import('child_process');
+    const pidDir = path39.join(workspaceRoot, ".code-intel");
+    const pidFile = path39.join(pidDir, "serve.pid");
+    if (fs39.existsSync(pidFile)) {
+      const existingPid = parseInt(fs39.readFileSync(pidFile, "utf-8").trim(), 10);
+      try {
+        process.kill(existingPid, 0);
+        console.log(`  \u26A0  Server already running (PID ${existingPid}). Stop it first with: code-intel stop`);
+        process.exit(0);
+      } catch {
+        fs39.unlinkSync(pidFile);
+      }
+    }
+    const selfArgs = ["serve", targetPath, "--port", options.port];
+    if (options.force) selfArgs.push("--force");
+    const logDir = path39.join(os18.homedir(), ".code-intel", "logs");
+    fs39.mkdirSync(logDir, { recursive: true });
+    const logFile = path39.join(logDir, `serve-${Date.now()}.log`);
+    const logFd = fs39.openSync(logFile, "a");
+    const child = spawn(process.execPath, [process.argv[1], ...selfArgs], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: process.env
+    });
+    child.unref();
+    fs39.mkdirSync(pidDir, { recursive: true });
+    fs39.writeFileSync(pidFile, String(child.pid), "utf-8");
+    console.log(`  \u2705  Server started in background`);
+    console.log(`      PID      : ${child.pid}`);
+    console.log(`      Port     : ${options.port}`);
+    console.log(`      URL      : http://localhost:${options.port}`);
+    console.log(`      Log      : ${logFile}`);
+    console.log(`      PID file : ${pidFile}`);
+    console.log(`
+  Stop with: code-intel stop`);
+    process.exit(0);
+  }
+  const existingIndex = !options.force && fs39.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const meta = loadMetadata(workspaceRoot);
     if (meta.parser === "regex" || meta.parser === void 0) {
@@ -16421,10 +17804,81 @@ program.command("serve").description("Start the local HTTP server + web UI for g
       await startHttpServer(lazyGraph, repoName, parseInt(options.port, 10), workspaceRoot);
     }
   } else {
-    logger_default.warn(`  [serve] No index found for: ${workspaceRoot}`);
-    logger_default.warn(`  [serve] Run \`code-intel analyze\` first, then re-run \`code-intel serve\`.`);
+    console.log(`  \u2139  No index found for: ${workspaceRoot}`);
+    const registry = loadRegistry();
+    const available = registry.filter((r) => fs39.existsSync(getDbPath(r.path)) && loadMetadata(r.path) !== null).sort((a, b) => new Date(b.indexedAt).getTime() - new Date(a.indexedAt).getTime());
+    if (available.length > 0) {
+      const fallback = available[0];
+      console.log(`  \u25C8  Falling back to most recently indexed repo: ${fallback.path}`);
+      console.log(`     (${fallback.stats.nodes} nodes \xB7 ${fallback.stats.edges} edges \xB7 indexed ${fallback.indexedAt})`);
+      console.log(`  \u2139  To index this folder run: code-intel analyze
+`);
+      const fallbackMeta = loadMetadata(fallback.path);
+      const fallbackDbPath = getDbPath(fallback.path);
+      if (fallbackMeta.parser === "regex" || fallbackMeta.parser === void 0) {
+        console.log(`  \u26A0  Fallback index was built with regex parser. Starting with empty graph.`);
+        const emptyGraph = createKnowledgeGraph();
+        await startHttpServer(emptyGraph, fallback.name, parseInt(options.port, 10), fallback.path);
+      } else {
+        const lazyGraph = new LazyKnowledgeGraph();
+        const db = new DbManager(fallbackDbPath, true);
+        await db.init();
+        await lazyGraph.init(db, fallbackMeta.stats.nodes, fallbackMeta.stats.edges);
+        setImmediate(() => lazyGraph.warmTopNodes(500).catch(() => {
+        }));
+        await startHttpServer(lazyGraph, fallback.name, parseInt(options.port, 10), fallback.path);
+      }
+      if (available.length > 1) {
+        console.log(`
+  Other indexed repos available (switch via web UI or re-run serve with path):`);
+        for (const r of available.slice(1)) {
+          console.log(`    code-intel serve ${r.path}`);
+        }
+      }
+    } else {
+      console.log(`  \u2139  No indexed repositories found. Starting server with empty graph.`);
+      console.log(`     Run \`code-intel analyze\` to index a repository, then reload the UI.
+`);
+      const emptyGraph = createKnowledgeGraph();
+      await startHttpServer(emptyGraph, repoName, parseInt(options.port, 10), workspaceRoot);
+    }
+  }
+});
+program.command("stop").description("Stop a background server started with `code-intel serve --detach`").argument("[path]", "Project path whose server to stop (default: current directory)", ".").addHelpText("after", `
+  Reads the PID from <path>/.code-intel/serve.pid and sends SIGTERM.
+  The PID file is removed automatically after a successful stop.
+
+  Examples:
+    $ code-intel stop
+    $ code-intel stop ./my-project
+`).action((targetPath) => {
+  const workspaceRoot = path39.resolve(targetPath);
+  const pidFile = path39.join(workspaceRoot, ".code-intel", "serve.pid");
+  if (!fs39.existsSync(pidFile)) {
+    console.log(`  \u2139  No background server found for: ${workspaceRoot}`);
+    console.log(`     (PID file not present: ${pidFile})`);
+    process.exit(0);
+  }
+  const pid = parseInt(fs39.readFileSync(pidFile, "utf-8").trim(), 10);
+  if (isNaN(pid)) {
+    console.error(`  \u2717  Invalid PID file: ${pidFile}`);
+    fs39.unlinkSync(pidFile);
     process.exit(1);
   }
+  try {
+    process.kill(pid, "SIGTERM");
+    fs39.unlinkSync(pidFile);
+    console.log(`  \u2705  Stopped server (PID ${pid})`);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH") {
+      fs39.unlinkSync(pidFile);
+      console.log(`  \u2139  Server (PID ${pid}) was not running. Stale PID file removed.`);
+    } else {
+      console.error(`  \u2717  Failed to stop server (PID ${pid}): ${err.message}`);
+      process.exit(1);
+    }
+  }
 });
 program.command("watch").description("Start HTTP server + file watcher (auto-reindex on file changes)").argument("[path]", "Path to watch (default: current directory)", ".").option("-p, --port <port>", "Port to listen on", "4747").option("--force", "Force re-analysis even if an index already exists").addHelpText("after", `
   Starts the HTTP server and automatically re-indexes changed files.
@@ -16440,11 +17894,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 +18018,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 +18037,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 +18072,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 +18120,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 +18156,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 +18174,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 +18189,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 +18677,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 +19011,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}`);
   }
@@ -17589,8 +19043,8 @@ program.command("migrate").description("Manage database schema migrations").opti
     $ code-intel migrate
     $ code-intel migrate --rollback
 `).action((opts) => {
-  const dbPath = opts.db ?? path39.join(os13.homedir(), ".code-intel", "users.db");
-  if (!fs38.existsSync(dbPath)) {
+  const dbPath = opts.db ?? path39.join(os18.homedir(), ".code-intel", "users.db");
+  if (!fs39.existsSync(dbPath)) {
     console.error(`
   \u2717  Database not found: ${dbPath}
   Run \`code-intel serve\` or \`code-intel user create\` first.
@@ -17705,15 +19159,15 @@ authCmd.command("login").description("Authenticate via OIDC device flow \u2014 o
   }
   try {
     const tokens = await pollDeviceFlow3(config, deviceResponse);
-    const tokenPath = path39.join(os13.homedir(), ".code-intel", "oidc-token.json");
+    const tokenPath = path39.join(os18.homedir(), ".code-intel", "oidc-token.json");
     const tokenData = {
       accessToken: tokens.accessToken,
       refreshToken: tokens.refreshToken,
       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.
@@ -17726,13 +19180,13 @@ authCmd.command("login").description("Authenticate via OIDC device flow \u2014 o
   }
 });
 authCmd.command("status").description("Show the current OIDC authentication status").action(() => {
-  const tokenPath = path39.join(os13.homedir(), ".code-intel", "oidc-token.json");
-  if (!fs38.existsSync(tokenPath)) {
+  const tokenPath = path39.join(os18.homedir(), ".code-intel", "oidc-token.json");
+  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"}`);
@@ -17744,9 +19198,9 @@ 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);
+  const tokenPath = path39.join(os18.homedir(), ".code-intel", "oidc-token.json");
+  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 +19325,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 +19333,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}
@@ -17900,7 +19354,7 @@ ${err instanceof Error ? err.message : err}
 });
 (function ensurePermissions() {
   try {
-    const dir = path39.join(os13.homedir(), ".code-intel");
+    const dir = path39.join(os18.homedir(), ".code-intel");
     secureMkdir(dir);
     tightenDbFiles(dir);
   } catch {
@@ -17920,7 +19374,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 +19519,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 +20053,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 +20090,104 @@ 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("");
+  }
+});
+{
+  const rewriteCmd = new Command("rewrite").description("Rewrite a shell command to its code-intel equivalent (used by hooks)").argument("<cmd>", "Raw shell command to check").addHelpText("after", `
+  Exit codes:
+    0  Rewrite found \u2014 rewritten command printed to stdout
+    1  No code-intel equivalent \u2014 pass through unchanged
+
+  Examples:
+    $ code-intel rewrite 'grep "AuthService" src/'
+    code-intel search "AuthService"
+
+    $ code-intel rewrite 'git status'
+    (no output, exit 1)
+`).action((cmd) => {
+    runRewrite(cmd);
+  });
+  program.addCommand(rewriteCmd, { hidden: true });
+}
+{
+  const hookCmd = new Command("hook").description("Run as a PreToolUse hook for an AI agent (reads/writes JSON on stdin/stdout)").argument("<agent>", "Agent type: claude").action((agent) => {
+    if (agent === "claude") {
+      runClaudeHook();
+    } else {
+      process.stderr.write(`[code-intel] Unknown hook agent: ${agent}
+`);
+      process.exit(0);
+    }
+  });
+  program.addCommand(hookCmd, { hidden: true });
+}
 program.parse();
 //# sourceMappingURL=main.js.map
 //# sourceMappingURL=main.js.map