@vohongtho.infotech/code-intel 0.4.0 → 0.5.0

package/dist/cli/main.js

@@ -7,8 +7,8 @@ import { SEMRESATTRS_DEPLOYMENT_ENVIRONMENT, SEMRESATTRS_SERVICE_NAME } from '@o
 import { SpanStatusCode, trace, context } from '@opentelemetry/api';
 import winston from 'winston';
 import DailyRotateFile from 'winston-daily-rotate-file';
-import fs27, { readFileSync, existsSync } from 'fs';
-import path29, { dirname, join } from 'path';
+import fs28, { readFileSync, existsSync } from 'fs';
+import path30, { dirname, join } from 'path';
 import os12 from 'os';
 import { Registry, collectDefaultMetrics, Counter, Histogram, Gauge } from 'prom-client';
 import { createRequire } from 'module';
@@ -26,6 +26,7 @@ import { Command } from 'commander';
 import { Worker } from 'worker_threads';
 import { EventEmitter } from 'events';
 import express from 'express';
+import compression from 'compression';
 import cors from 'cors';
 import helmet from 'helmet';
 import cookieParser from 'cookie-parser';
@@ -325,7 +326,7 @@ var init_logger = __esm({
         };
       }
       /** Global log directory: ~/.code-intel/logs */
-      static LOG_DIR = path29.join(os12.homedir(), ".code-intel", "logs");
+      static LOG_DIR = path30.join(os12.homedir(), ".code-intel", "logs");
       static getLogger() {
         if (!_Logger.instance) {
           const isProduction = process.env.NODE_ENV === "production";
@@ -334,12 +335,12 @@ var init_logger = __esm({
           transports.push(new winston.transports.Console());
           if (!isProduction) {
             try {
-              if (!fs27.existsSync(_Logger.LOG_DIR)) {
-                fs27.mkdirSync(_Logger.LOG_DIR, { recursive: true });
+              if (!fs28.existsSync(_Logger.LOG_DIR)) {
+                fs28.mkdirSync(_Logger.LOG_DIR, { recursive: true });
               }
               transports.push(
                 new DailyRotateFile({
-                  filename: path29.join(_Logger.LOG_DIR, "%DATE%-code-intel.log"),
+                  filename: path30.join(_Logger.LOG_DIR, "%DATE%-code-intel.log"),
                   datePattern: "YYYY-MM-DD",
                   maxSize: "20m",
                   maxFiles: "14d"
@@ -414,25 +415,25 @@ function validateDAG(phases) {
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   const phaseMap = new Map(phases.map((p) => [p.name, p]));
-  function dfs(name, path30) {
+  function dfs(name, path31) {
     if (visiting.has(name)) {
-      const cycleStart = path30.indexOf(name);
-      const cycle = path30.slice(cycleStart).concat(name);
+      const cycleStart = path31.indexOf(name);
+      const cycle = path31.slice(cycleStart).concat(name);
       errors.push({ type: "cycle", message: `Cycle detected: ${cycle.join(" \u2192 ")}` });
       return true;
     }
     if (visited.has(name)) return false;
     visiting.add(name);
-    path30.push(name);
+    path31.push(name);
     const phase = phaseMap.get(name);
     if (phase) {
       for (const dep of phase.dependencies) {
-        if (dfs(dep, path30)) return true;
+        if (dfs(dep, path31)) return true;
       }
     }
     visiting.delete(name);
     visited.add(name);
-    path30.pop();
+    path31.pop();
     return false;
   }
   for (const phase of phases) {
@@ -692,11 +693,11 @@ var init_id_generator = __esm({
   }
 });
 function findBundledWasmDir() {
-  const fileDir = path29.dirname(fileURLToPath(import.meta.url));
+  const fileDir = path30.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path29.join(fileDir, "wasm"),
+    path30.join(fileDir, "wasm"),
     // dist/index.js → dist/wasm/
-    path29.join(fileDir, "../wasm")
+    path30.join(fileDir, "../wasm")
     // dist/cli/main.js → dist/wasm/
   ];
   for (const candidate of candidates) {
@@ -737,7 +738,7 @@ function wasmPath(lang) {
   }
   const bundled = BUNDLED_WASM_MAP[lang];
   if (bundled) {
-    const bundledPath = path29.join(_bundledWasmDir, bundled);
+    const bundledPath = path30.join(_bundledWasmDir, bundled);
     if (existsSync(bundledPath)) return bundledPath;
   }
   return null;
@@ -750,14 +751,14 @@ async function initParser() {
 }
 async function getLanguage(lang) {
   if (languageCache.has(lang)) return languageCache.get(lang);
-  const path30 = wasmPath(lang);
-  if (!path30) {
+  const path31 = wasmPath(lang);
+  if (!path31) {
     languageCache.set(lang, null);
     return null;
   }
   try {
     await initParser();
-    const language = await Language.load(path30);
+    const language = await Language.load(path31);
     languageCache.set(lang, language);
     return language;
   } catch {
@@ -2182,7 +2183,7 @@ var init_parse_phase = __esm({
           const batch = filePaths.slice(i, i + CONCURRENCY);
           await Promise.all(batch.map(async (filePath) => {
             try {
-              const source = await fs27.promises.readFile(filePath, "utf-8");
+              const source = await fs28.promises.readFile(filePath, "utf-8");
               context2.fileCache.set(filePath, source);
             } catch {
             }
@@ -2195,14 +2196,14 @@ var init_parse_phase = __esm({
           const lang = detectLanguage(filePath);
           if (!lang) {
             if (context2.verbose) {
-              const relativePath2 = path29.relative(context2.workspaceRoot, filePath);
+              const relativePath2 = path30.relative(context2.workspaceRoot, filePath);
               logger_default.info(`  [parse] skipped (no parser): ${relativePath2}`);
             }
             continue;
           }
           const source = context2.fileCache.get(filePath);
           if (!source) continue;
-          const relativePath = path29.relative(context2.workspaceRoot, filePath);
+          const relativePath = path30.relative(context2.workspaceRoot, filePath);
           const fileNodeId = generateNodeId("file", relativePath, relativePath);
           const fileNode = context2.graph.getNode(fileNodeId);
           if (fileNode) {
@@ -2448,11 +2449,11 @@ var init_resolve_phase = __esm({
         let heritageEdges = 0;
         const fileIndex = /* @__PURE__ */ new Map();
         for (const fp of filePaths) {
-          const rel = path29.relative(workspaceRoot, fp);
+          const rel = path30.relative(workspaceRoot, fp);
           fileIndex.set(rel, fp);
           const noExt = rel.replace(/\.\w+$/, "");
           if (!fileIndex.has(noExt)) fileIndex.set(noExt, fp);
-          const base = path29.basename(rel, path29.extname(rel));
+          const base = path30.basename(rel, path30.extname(rel));
           if (!fileIndex.has(base)) fileIndex.set(base, fp);
         }
         const symbolIndex = /* @__PURE__ */ new Map();
@@ -2483,7 +2484,7 @@ var init_resolve_phase = __esm({
         for (const filePath of filePaths) {
           const lang = detectLanguage(filePath);
           if (!lang) continue;
-          const relativePath = path29.relative(workspaceRoot, filePath);
+          const relativePath = path30.relative(workspaceRoot, filePath);
           const fileNodeId = generateNodeId("file", relativePath, relativePath);
           const source = fileCache.get(filePath);
           if (!source) continue;
@@ -2496,13 +2497,13 @@ var init_resolve_phase = __esm({
             let resolvedRelPath = null;
             if (cleaned.startsWith(".")) {
               const cleanedNoJs = cleaned.replace(/\.(js|jsx)$/, "");
-              const fromDir = path29.dirname(relativePath);
+              const fromDir = path30.dirname(relativePath);
               for (const ext of ["", ".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".go", "/index.ts", "/index.js"]) {
-                const candidate = path29.join(fromDir, cleanedNoJs + ext);
-                const normalized = path29.normalize(candidate);
+                const candidate = path30.join(fromDir, cleanedNoJs + ext);
+                const normalized = path30.normalize(candidate);
                 if (fileIndex.has(normalized)) {
                   const absPath = fileIndex.get(normalized);
-                  resolvedRelPath = path29.relative(workspaceRoot, absPath);
+                  resolvedRelPath = path30.relative(workspaceRoot, absPath);
                   break;
                 }
               }
@@ -2967,7 +2968,7 @@ var init_db_manager = __esm({
         this.dbPath = dbPath;
       }
       async init() {
-        fs27.mkdirSync(path29.dirname(this.dbPath), { recursive: true });
+        fs28.mkdirSync(path30.dirname(this.dbPath), { recursive: true });
         this.db = new Database$1(this.dbPath);
         await this.db.init();
         this.conn = new Connection(this.db);
@@ -3063,7 +3064,7 @@ var init_schema = __esm({
   }
 });
 function writeNodeCSVs(graph, outputDir) {
-  fs27.mkdirSync(outputDir, { recursive: true });
+  fs28.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();
@@ -3071,7 +3072,7 @@ function writeNodeCSVs(graph, outputDir) {
     const table = NODE_TABLE_MAP[node.kind];
     if (!tableBuffers.has(table)) {
       tableBuffers.set(table, [header]);
-      tableFilePaths.set(table, path29.join(outputDir, `${table}.csv`));
+      tableFilePaths.set(table, path30.join(outputDir, `${table}.csv`));
     }
     tableBuffers.get(table).push(
       csvRow([
@@ -3091,12 +3092,12 @@ function writeNodeCSVs(graph, outputDir) {
     );
   }
   for (const [table, lines] of tableBuffers) {
-    fs27.writeFileSync(tableFilePaths.get(table), lines.join(""), "utf-8");
+    fs28.writeFileSync(tableFilePaths.get(table), lines.join(""), "utf-8");
   }
   return tableFilePaths;
 }
 function writeEdgeCSV(graph, outputDir) {
-  fs27.mkdirSync(outputDir, { recursive: true });
+  fs28.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()) {
@@ -3107,7 +3108,7 @@ function writeEdgeCSV(graph, outputDir) {
     const toTable = NODE_TABLE_MAP[targetNode.kind];
     const key = `${fromTable}->${toTable}`;
     if (!groups.has(key)) {
-      const filePath = path29.join(outputDir, `edges_${fromTable}_${toTable}.csv`);
+      const filePath = path30.join(outputDir, `edges_${fromTable}_${toTable}.csv`);
       groups.set(key, { lines: [header], from: fromTable, to: toTable, filePath });
     }
     groups.get(key).lines.push(
@@ -3122,7 +3123,7 @@ function writeEdgeCSV(graph, outputDir) {
   }
   const result = [];
   for (const group of groups.values()) {
-    fs27.writeFileSync(group.filePath, group.lines.join(""), "utf-8");
+    fs28.writeFileSync(group.filePath, group.lines.join(""), "utf-8");
     result.push({ fromTable: group.from, toTable: group.to, filePath: group.filePath });
   }
   return result;
@@ -3165,7 +3166,7 @@ async function loadGraphToDB(graph, dbManager) {
     } catch {
     }
   }
-  const tmpDir = fs27.mkdtempSync(path29.join(os12.tmpdir(), "code-intel-csv-"));
+  const tmpDir = fs28.mkdtempSync(path30.join(os12.tmpdir(), "code-intel-csv-"));
   try {
     const nodeTableFiles = writeNodeCSVs(graph, tmpDir);
     const edgeGroups = writeEdgeCSV(graph, tmpDir);
@@ -3184,8 +3185,8 @@ async function loadGraphToDB(graph, dbManager) {
     }
     let nodeCount = 0;
     for (const [table, csvPath] of nodeTableFiles) {
-      if (!fs27.existsSync(csvPath)) continue;
-      const stat = fs27.statSync(csvPath);
+      if (!fs28.existsSync(csvPath)) continue;
+      const stat = fs28.statSync(csvPath);
       if (stat.size < 50) continue;
       try {
         await dbManager.execute(
@@ -3198,8 +3199,8 @@ async function loadGraphToDB(graph, dbManager) {
     }
     let edgeCount = 0;
     for (const group of edgeGroups) {
-      if (!fs27.existsSync(group.filePath)) continue;
-      const stat = fs27.statSync(group.filePath);
+      if (!fs28.existsSync(group.filePath)) continue;
+      const stat = fs28.statSync(group.filePath);
       if (stat.size < 50) continue;
       try {
         await dbManager.execute(
@@ -3213,7 +3214,7 @@ async function loadGraphToDB(graph, dbManager) {
     return { nodeCount, edgeCount };
   } finally {
     try {
-      fs27.rmSync(tmpDir, { recursive: true, force: true });
+      fs28.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -3315,15 +3316,15 @@ var init_graph_loader = __esm({
 });
 function loadRegistry() {
   try {
-    const data = fs27.readFileSync(REPOS_FILE, "utf-8");
+    const data = fs28.readFileSync(REPOS_FILE, "utf-8");
     return JSON.parse(data);
   } catch {
     return [];
   }
 }
 function saveRegistry(entries) {
-  fs27.mkdirSync(GLOBAL_DIR, { recursive: true });
-  fs27.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
+  fs28.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs28.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
 }
 function upsertRepo(entry) {
   const entries = loadRegistry();
@@ -3342,28 +3343,28 @@ function removeRepo(repoPath) {
 var GLOBAL_DIR, REPOS_FILE;
 var init_repo_registry = __esm({
   "src/storage/repo-registry.ts"() {
-    GLOBAL_DIR = path29.join(os12.homedir(), ".code-intel");
-    REPOS_FILE = path29.join(GLOBAL_DIR, "repos.json");
+    GLOBAL_DIR = path30.join(os12.homedir(), ".code-intel");
+    REPOS_FILE = path30.join(GLOBAL_DIR, "repos.json");
   }
 });
 function saveMetadata(repoDir, metadata) {
-  const metaDir = path29.join(repoDir, ".code-intel");
-  fs27.mkdirSync(metaDir, { recursive: true });
-  fs27.writeFileSync(path29.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
+  const metaDir = path30.join(repoDir, ".code-intel");
+  fs28.mkdirSync(metaDir, { recursive: true });
+  fs28.writeFileSync(path30.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
 }
 function loadMetadata(repoDir) {
   try {
-    const data = fs27.readFileSync(path29.join(repoDir, ".code-intel", "meta.json"), "utf-8");
+    const data = fs28.readFileSync(path30.join(repoDir, ".code-intel", "meta.json"), "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
   }
 }
 function getDbPath(repoDir) {
-  return path29.join(repoDir, ".code-intel", "graph.db");
+  return path30.join(repoDir, ".code-intel", "graph.db");
 }
 function getVectorDbPath(repoDir) {
-  return path29.join(repoDir, ".code-intel", "vector.db");
+  return path30.join(repoDir, ".code-intel", "vector.db");
 }
 var init_metadata = __esm({
   "src/storage/metadata.ts"() {
@@ -3419,27 +3420,27 @@ __export(group_registry_exports, {
   saveSyncResult: () => saveSyncResult
 });
 function groupFile(name) {
-  return path29.join(GROUPS_DIR, `${name}.json`);
+  return path30.join(GROUPS_DIR, `${name}.json`);
 }
 function loadGroup(name) {
   try {
-    return JSON.parse(fs27.readFileSync(groupFile(name), "utf-8"));
+    return JSON.parse(fs28.readFileSync(groupFile(name), "utf-8"));
   } catch {
     return null;
   }
 }
 function saveGroup(group) {
-  fs27.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs27.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
+  fs28.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs28.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
 }
 function listGroups() {
   const groups = [];
   try {
-    for (const file of fs27.readdirSync(GROUPS_DIR)) {
+    for (const file of fs28.readdirSync(GROUPS_DIR)) {
       if (!file.endsWith(".json") || file.endsWith(".sync.json")) continue;
       try {
         const g = JSON.parse(
-          fs27.readFileSync(path29.join(GROUPS_DIR, file), "utf-8")
+          fs28.readFileSync(path30.join(GROUPS_DIR, file), "utf-8")
         );
         groups.push(g);
       } catch {
@@ -3451,16 +3452,16 @@ function listGroups() {
 }
 function deleteGroup(name) {
   try {
-    fs27.unlinkSync(groupFile(name));
+    fs28.unlinkSync(groupFile(name));
   } catch {
   }
   try {
-    fs27.unlinkSync(path29.join(GROUPS_DIR, `${name}.sync.json`));
+    fs28.unlinkSync(path30.join(GROUPS_DIR, `${name}.sync.json`));
   } catch {
   }
 }
 function groupExists(name) {
-  return fs27.existsSync(groupFile(name));
+  return fs28.existsSync(groupFile(name));
 }
 function addMember(groupName, member) {
   const group = loadGroup(groupName);
@@ -3486,16 +3487,16 @@ function removeMember(groupName, groupPath) {
   return group;
 }
 function saveSyncResult(result) {
-  fs27.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs27.writeFileSync(
-    path29.join(GROUPS_DIR, `${result.groupName}.sync.json`),
+  fs28.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs28.writeFileSync(
+    path30.join(GROUPS_DIR, `${result.groupName}.sync.json`),
     JSON.stringify(result, null, 2) + "\n"
   );
 }
 function loadSyncResult(groupName) {
   try {
     return JSON.parse(
-      fs27.readFileSync(path29.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
+      fs28.readFileSync(path30.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
     );
   } catch {
     return null;
@@ -3504,7 +3505,7 @@ function loadSyncResult(groupName) {
 var GROUPS_DIR;
 var init_group_registry = __esm({
   "src/multi-repo/group-registry.ts"() {
-    GROUPS_DIR = path29.join(os12.homedir(), ".code-intel", "groups");
+    GROUPS_DIR = path30.join(os12.homedir(), ".code-intel", "groups");
   }
 });
 
@@ -3541,10 +3542,10 @@ var init_codes = __esm({
   }
 });
 function secureMkdir(dir) {
-  fs27.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
+  fs28.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
   if (process.platform !== "win32") {
     try {
-      fs27.chmodSync(dir, SECURE_DIR_MODE);
+      fs28.chmodSync(dir, SECURE_DIR_MODE);
     } catch {
     }
   }
@@ -3552,22 +3553,22 @@ function secureMkdir(dir) {
 function secureChmodFile(file) {
   if (process.platform === "win32") return;
   try {
-    fs27.chmodSync(file, SECURE_FILE_MODE);
+    fs28.chmodSync(file, SECURE_FILE_MODE);
   } catch {
   }
 }
 function secureWriteFile(file, data) {
-  secureMkdir(path29.dirname(file));
-  fs27.writeFileSync(file, data, { mode: SECURE_FILE_MODE });
+  secureMkdir(path30.dirname(file));
+  fs28.writeFileSync(file, data, { mode: SECURE_FILE_MODE });
   secureChmodFile(file);
 }
 function tightenDbFiles(dir) {
   if (process.platform === "win32") return;
-  if (!fs27.existsSync(dir)) return;
-  for (const name of fs27.readdirSync(dir)) {
+  if (!fs28.existsSync(dir)) return;
+  for (const name of fs28.readdirSync(dir)) {
     if (name.endsWith(".db") || name.endsWith(".db-wal") || name.endsWith(".db-shm")) {
       try {
-        fs27.chmodSync(path29.join(dir, name), SECURE_FILE_MODE);
+        fs28.chmodSync(path30.join(dir, name), SECURE_FILE_MODE);
       } catch {
       }
     }
@@ -3581,7 +3582,7 @@ var init_fs_secure = __esm({
   }
 });
 function getUsersDBPath() {
-  return process.env["CODE_INTEL_USERS_DB_PATH"] ?? path29.join(os12.homedir(), ".code-intel", "users.db");
+  return process.env["CODE_INTEL_USERS_DB_PATH"] ?? path30.join(os12.homedir(), ".code-intel", "users.db");
 }
 function getOrCreateUsersDB() {
   if (!_usersDB) {
@@ -3597,7 +3598,7 @@ var init_users_db = __esm({
     UsersDB = class {
       db;
       constructor(dbPath) {
-        const dir = path29.dirname(dbPath);
+        const dir = path30.dirname(dbPath);
         secureMkdir(dir);
         this.db = new Database(dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -3874,7 +3875,7 @@ function getScryptN() {
   return Number.isInteger(v) && v >= 1024 ? v : 1 << 14;
 }
 function getSecretsPath() {
-  return process.env["CODE_INTEL_SECRETS_PATH"] ?? path29.join(os12.homedir(), ".code-intel", ".secrets");
+  return process.env["CODE_INTEL_SECRETS_PATH"] ?? path30.join(os12.homedir(), ".code-intel", ".secrets");
 }
 function getMasterPassword() {
   const fromEnv = process.env["CODE_INTEL_SECRET_KEY"];
@@ -3916,12 +3917,12 @@ function decryptSecrets(encrypted) {
   return JSON.parse(plaintext.toString("utf8"));
 }
 function loadSecrets(secretsPath = getSecretsPath()) {
-  if (!fs27.existsSync(secretsPath)) return {};
-  const blob = fs27.readFileSync(secretsPath);
+  if (!fs28.existsSync(secretsPath)) return {};
+  const blob = fs28.readFileSync(secretsPath);
   return decryptSecrets(blob);
 }
 function saveSecrets(blob, secretsPath = getSecretsPath()) {
-  secureMkdir(path29.dirname(secretsPath));
+  secureMkdir(path30.dirname(secretsPath));
   const encrypted = encryptSecrets(blob);
   secureWriteFile(secretsPath, encrypted);
   secureChmodFile(secretsPath);
@@ -4395,6 +4396,753 @@ var init_oidc = __esm({
     _cachedIssuer = "";
   }
 });
+
+// src/query/gql-parser.ts
+var gql_parser_exports = {};
+__export(gql_parser_exports, {
+  isGQLParseError: () => isGQLParseError,
+  parseGQL: () => parseGQL
+});
+function isGQLParseError(v) {
+  return v.type === "GQLParseError";
+}
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  const len = input.length;
+  while (i < len) {
+    if (/\s/.test(input[i])) {
+      i++;
+      continue;
+    }
+    if (input[i] === "#") {
+      while (i < len && input[i] !== "\n") i++;
+      continue;
+    }
+    const pos = i;
+    if (input[i] === '"' || input[i] === "'") {
+      const quote = input[i];
+      i++;
+      let str = "";
+      while (i < len && input[i] !== quote) {
+        if (input[i] === "\\") {
+          i++;
+          if (i < len) {
+            const esc = input[i];
+            str += esc === "n" ? "\n" : esc === "t" ? "	" : esc;
+            i++;
+          }
+        } else {
+          str += input[i++];
+        }
+      }
+      if (i >= len) {
+        return { type: "GQLParseError", message: `Unterminated string at position ${pos}`, pos };
+      }
+      i++;
+      tokens.push({ kind: "STRING", value: str, pos });
+      continue;
+    }
+    if (/[0-9]/.test(input[i])) {
+      let num = "";
+      while (i < len && /[0-9]/.test(input[i])) num += input[i++];
+      tokens.push({ kind: "NUMBER", value: num, pos });
+      continue;
+    }
+    if (input[i] === "[") {
+      tokens.push({ kind: "LBRACKET", value: "[", pos });
+      i++;
+      continue;
+    }
+    if (input[i] === "]") {
+      tokens.push({ kind: "RBRACKET", value: "]", pos });
+      i++;
+      continue;
+    }
+    if (input[i] === "*") {
+      tokens.push({ kind: "STAR", value: "*", pos });
+      i++;
+      continue;
+    }
+    if (input[i] === "!" && input[i + 1] === "=") {
+      tokens.push({ kind: "OPERATOR", value: "!=", pos });
+      i += 2;
+      continue;
+    }
+    if (input[i] === "=") {
+      tokens.push({ kind: "OPERATOR", value: "=", pos });
+      i++;
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(input[i])) {
+      let ident = "";
+      while (i < len && /[a-zA-Z0-9_]/.test(input[i])) ident += input[i++];
+      const upper = ident.toUpperCase();
+      if (upper === "CONTAINS" || upper === "STARTS_WITH" || upper === "IN") {
+        tokens.push({ kind: "OPERATOR", value: upper, pos });
+      } else if (KEYWORDS.has(upper)) {
+        tokens.push({ kind: "KEYWORD", value: upper, pos });
+      } else {
+        tokens.push({ kind: "IDENT", value: ident, pos });
+      }
+      continue;
+    }
+    if (input[i] === ",") {
+      i++;
+      continue;
+    }
+    return {
+      type: "GQLParseError",
+      message: `Unexpected character '${input[i]}' at position ${i}`,
+      pos: i
+    };
+  }
+  tokens.push({ kind: "EOF", value: "", pos: len });
+  return tokens;
+}
+function parseGQL(input) {
+  const tokens = tokenize(input.trim());
+  if (!Array.isArray(tokens)) return tokens;
+  const parser = new Parser2(tokens);
+  return parser.parse();
+}
+var KEYWORDS, Parser2;
+var init_gql_parser = __esm({
+  "src/query/gql-parser.ts"() {
+    KEYWORDS = /* @__PURE__ */ new Set([
+      "FIND",
+      "TRAVERSE",
+      "PATH",
+      "COUNT",
+      "WHERE",
+      "FROM",
+      "TO",
+      "IN",
+      "BY",
+      "AND",
+      "NOT",
+      "LIMIT",
+      "OFFSET",
+      "DEPTH",
+      "GROUP",
+      "CONTAINS",
+      "STARTS_WITH",
+      "CALLS",
+      "IMPORTS",
+      "EXTENDS",
+      "IMPLEMENTS",
+      "HAS_MEMBER",
+      "ACCESSES",
+      "OVERRIDES",
+      "BELONGS_TO",
+      "STEP_OF",
+      "HANDLES",
+      "CONTAINS_EDGE",
+      "OUTGOING",
+      "INCOMING",
+      "BOTH"
+    ]);
+    Parser2 = class {
+      tokens;
+      pos = 0;
+      constructor(tokens) {
+        this.tokens = tokens;
+      }
+      peek() {
+        return this.tokens[this.pos];
+      }
+      consume() {
+        return this.tokens[this.pos++];
+      }
+      expect(kind, value) {
+        const tok = this.peek();
+        if (tok.kind !== kind) {
+          return {
+            type: "GQLParseError",
+            message: `Expected ${value ?? kind} but got '${tok.value}' at position ${tok.pos}`,
+            pos: tok.pos,
+            expected: value ?? kind,
+            got: tok.value
+          };
+        }
+        if (value !== void 0 && tok.value !== value) {
+          return {
+            type: "GQLParseError",
+            message: `Expected '${value}' but got '${tok.value}' at position ${tok.pos}`,
+            pos: tok.pos,
+            expected: value,
+            got: tok.value
+          };
+        }
+        return this.consume();
+      }
+      matchKeyword(...values) {
+        const tok = this.peek();
+        return tok.kind === "KEYWORD" && values.includes(tok.value);
+      }
+      optionalKeyword(...values) {
+        if (this.matchKeyword(...values)) {
+          return this.consume();
+        }
+        return null;
+      }
+      /** Parse the node kind filter (IDENT, KEYWORD that's a kind, or STAR) */
+      parseNodeKind() {
+        const tok = this.peek();
+        if (tok.kind === "STAR") {
+          this.consume();
+          return "*";
+        }
+        if (tok.kind === "IDENT" || tok.kind === "KEYWORD") {
+          this.consume();
+          return tok.value.toLowerCase();
+        }
+        return {
+          type: "GQLParseError",
+          message: `Expected node kind or '*' at position ${tok.pos}`,
+          pos: tok.pos
+        };
+      }
+      /** Parse a string value (STRING or IDENT) */
+      parseStringValue() {
+        const tok = this.peek();
+        if (tok.kind === "STRING") {
+          this.consume();
+          return tok.value;
+        }
+        if (tok.kind === "IDENT" || tok.kind === "KEYWORD") {
+          this.consume();
+          return tok.value;
+        }
+        return {
+          type: "GQLParseError",
+          message: `Expected string value at position ${tok.pos}`,
+          pos: tok.pos
+        };
+      }
+      /** Parse an IN list: [ value, value, ... ] */
+      parseInList() {
+        const lb = this.expect("LBRACKET");
+        if (isGQLParseError(lb)) return lb;
+        const values = [];
+        while (!this.matchKeyword() && this.peek().kind !== "RBRACKET" && this.peek().kind !== "EOF") {
+          const v = this.parseStringValue();
+          if (typeof v !== "string") return v;
+          values.push(v);
+        }
+        const rb = this.expect("RBRACKET");
+        if (isGQLParseError(rb)) return rb;
+        return values;
+      }
+      /** Parse a single WHERE expression */
+      parseWhereExpr() {
+        const propTok = this.peek();
+        if (propTok.kind !== "IDENT" && propTok.kind !== "KEYWORD") {
+          return {
+            type: "GQLParseError",
+            message: `Expected property name at position ${propTok.pos}`,
+            pos: propTok.pos
+          };
+        }
+        this.consume();
+        const property = propTok.value.toLowerCase();
+        const opTok = this.peek();
+        if (opTok.kind !== "OPERATOR") {
+          return {
+            type: "GQLParseError",
+            message: `Expected operator (=, !=, CONTAINS, STARTS_WITH, IN) at position ${opTok.pos}`,
+            pos: opTok.pos,
+            expected: "operator",
+            got: opTok.value
+          };
+        }
+        this.consume();
+        const operator = opTok.value;
+        if (operator === "IN") {
+          const list = this.parseInList();
+          if (!Array.isArray(list)) return list;
+          return { property, operator, value: list };
+        }
+        const val = this.parseStringValue();
+        if (typeof val !== "string") return val;
+        return { property, operator, value: val };
+      }
+      /** Parse WHERE clause: WHERE expr (AND expr)* */
+      parseWhereClause() {
+        const kw = this.expect("KEYWORD", "WHERE");
+        if (isGQLParseError(kw)) return kw;
+        const exprs = [];
+        const first = this.parseWhereExpr();
+        if ("type" in first && first.type === "GQLParseError") return first;
+        exprs.push(first);
+        while (this.matchKeyword("AND")) {
+          this.consume();
+          const expr = this.parseWhereExpr();
+          if ("type" in expr && expr.type === "GQLParseError") return expr;
+          exprs.push(expr);
+        }
+        return { exprs };
+      }
+      /** Parse FIND statement */
+      parseFindStatement() {
+        this.consume();
+        const kind = this.parseNodeKind();
+        if (typeof kind !== "string") return kind;
+        let where;
+        if (this.matchKeyword("WHERE")) {
+          const w = this.parseWhereClause();
+          if ("type" in w && w.type === "GQLParseError") return w;
+          where = w;
+        }
+        let limit;
+        let offset;
+        while (this.matchKeyword("LIMIT", "OFFSET")) {
+          const kw = this.consume();
+          const numTok = this.peek();
+          if (numTok.kind !== "NUMBER") {
+            return {
+              type: "GQLParseError",
+              message: `Expected number after ${kw.value} at position ${numTok.pos}`,
+              pos: numTok.pos
+            };
+          }
+          this.consume();
+          const n = parseInt(numTok.value, 10);
+          if (kw.value === "LIMIT") limit = n;
+          else offset = n;
+        }
+        return { type: "FIND", target: kind, where, limit, offset };
+      }
+      /** Parse TRAVERSE statement */
+      parseTraverseStatement() {
+        this.consume();
+        const edgeTok = this.peek();
+        if (edgeTok.kind !== "KEYWORD" && edgeTok.kind !== "IDENT") {
+          return {
+            type: "GQLParseError",
+            message: `Expected edge kind after TRAVERSE at position ${edgeTok.pos}`,
+            pos: edgeTok.pos
+          };
+        }
+        this.consume();
+        const edgeKind = edgeTok.value.toLowerCase();
+        const fromKw = this.expect("KEYWORD", "FROM");
+        if (isGQLParseError(fromKw)) return fromKw;
+        const fromVal = this.parseStringValue();
+        if (typeof fromVal !== "string") return fromVal;
+        let depth;
+        let direction;
+        if (this.matchKeyword("DEPTH")) {
+          this.consume();
+          const numTok = this.peek();
+          if (numTok.kind !== "NUMBER") {
+            return {
+              type: "GQLParseError",
+              message: `Expected number after DEPTH at position ${numTok.pos}`,
+              pos: numTok.pos
+            };
+          }
+          this.consume();
+          depth = parseInt(numTok.value, 10);
+        }
+        if (this.matchKeyword("OUTGOING", "INCOMING", "BOTH")) {
+          direction = this.consume().value;
+        }
+        return { type: "TRAVERSE", edgeKind, from: fromVal, depth, direction };
+      }
+      /** Parse PATH statement */
+      parsePathStatement() {
+        this.consume();
+        const fromKw = this.expect("KEYWORD", "FROM");
+        if (isGQLParseError(fromKw)) return fromKw;
+        const fromVal = this.parseStringValue();
+        if (typeof fromVal !== "string") return fromVal;
+        const toKw = this.expect("KEYWORD", "TO");
+        if (isGQLParseError(toKw)) return toKw;
+        const toVal = this.parseStringValue();
+        if (typeof toVal !== "string") return toVal;
+        return { type: "PATH", from: fromVal, to: toVal };
+      }
+      /** Parse COUNT statement */
+      parseCountStatement() {
+        this.consume();
+        const kind = this.parseNodeKind();
+        if (typeof kind !== "string") return kind;
+        let where;
+        if (this.matchKeyword("WHERE")) {
+          const w = this.parseWhereClause();
+          if ("type" in w && w.type === "GQLParseError") return w;
+          where = w;
+        }
+        let groupBy;
+        if (this.matchKeyword("GROUP")) {
+          this.consume();
+          const byKw = this.expect("KEYWORD", "BY");
+          if (isGQLParseError(byKw)) return byKw;
+          const propTok = this.peek();
+          if (propTok.kind !== "IDENT" && propTok.kind !== "KEYWORD") {
+            return {
+              type: "GQLParseError",
+              message: `Expected property name after GROUP BY at position ${propTok.pos}`,
+              pos: propTok.pos
+            };
+          }
+          this.consume();
+          groupBy = propTok.value.toLowerCase();
+        }
+        return { type: "COUNT", target: kind, where, groupBy };
+      }
+      parse() {
+        const tok = this.peek();
+        if (tok.kind !== "KEYWORD") {
+          return {
+            type: "GQLParseError",
+            message: `Expected FIND, TRAVERSE, PATH, or COUNT at position ${tok.pos}`,
+            pos: tok.pos,
+            expected: "FIND | TRAVERSE | PATH | COUNT",
+            got: tok.value
+          };
+        }
+        let result;
+        switch (tok.value) {
+          case "FIND":
+            result = this.parseFindStatement();
+            break;
+          case "TRAVERSE":
+            result = this.parseTraverseStatement();
+            break;
+          case "PATH":
+            result = this.parsePathStatement();
+            break;
+          case "COUNT":
+            result = this.parseCountStatement();
+            break;
+          default:
+            return {
+              type: "GQLParseError",
+              message: `Unknown statement type '${tok.value}' at position ${tok.pos}`,
+              pos: tok.pos,
+              expected: "FIND | TRAVERSE | PATH | COUNT",
+              got: tok.value
+            };
+        }
+        if (isGQLParseError(result)) return result;
+        const remaining = this.peek();
+        if (remaining.kind !== "EOF") {
+          return {
+            type: "GQLParseError",
+            message: `Unexpected token '${remaining.value}' at position ${remaining.pos}`,
+            pos: remaining.pos,
+            got: remaining.value
+          };
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/query/gql-executor.ts
+var gql_executor_exports = {};
+__export(gql_executor_exports, {
+  executeGQL: () => executeGQL
+});
+function getNodeProperty(node, property) {
+  switch (property) {
+    case "name":
+      return node.name;
+    case "kind":
+      return node.kind;
+    case "filepath":
+    case "filePath":
+      return node.filePath;
+    case "exported":
+      return node.exported;
+    case "language":
+      return node.metadata?.language ?? void 0;
+    case "cluster":
+      return node.metadata?.cluster ?? void 0;
+    default:
+      return node.metadata?.[property] ?? void 0;
+  }
+}
+function evaluateExpr(node, expr) {
+  const val = getNodeProperty(node, expr.property);
+  if (val === void 0) return false;
+  const strVal = String(val).toLowerCase();
+  switch (expr.operator) {
+    case "=":
+      if (typeof expr.value === "string") {
+        return strVal === expr.value.toLowerCase();
+      }
+      return false;
+    case "!=":
+      if (typeof expr.value === "string") {
+        return strVal !== expr.value.toLowerCase();
+      }
+      return true;
+    case "CONTAINS":
+      if (typeof expr.value === "string") {
+        return strVal.includes(expr.value.toLowerCase());
+      }
+      return false;
+    case "STARTS_WITH":
+      if (typeof expr.value === "string") {
+        return strVal.startsWith(expr.value.toLowerCase());
+      }
+      return false;
+    case "IN":
+      if (Array.isArray(expr.value)) {
+        return expr.value.some((v) => strVal === v.toLowerCase());
+      }
+      return false;
+    default:
+      return false;
+  }
+}
+function evaluateWhere(node, where) {
+  return where.exprs.every((expr) => evaluateExpr(node, expr));
+}
+function executeFIND(stmt, graph) {
+  const start = Date.now();
+  const limit = stmt.limit ?? 1e3;
+  const offset = stmt.offset ?? 0;
+  let totalCount = 0;
+  let truncated = false;
+  const allMatching = [];
+  const deadline = start + EXECUTION_TIMEOUT_MS;
+  for (const node of graph.allNodes()) {
+    if (Date.now() > deadline) {
+      truncated = true;
+      break;
+    }
+    if (stmt.target !== "*" && node.kind !== stmt.target) continue;
+    if (stmt.where && !evaluateWhere(node, stmt.where)) continue;
+    allMatching.push(node);
+  }
+  totalCount = allMatching.length;
+  const paginated = allMatching.slice(offset, offset + limit);
+  return {
+    nodes: paginated,
+    executionTimeMs: Date.now() - start,
+    truncated,
+    totalCount
+  };
+}
+function executeTRAVERSE(stmt, graph) {
+  const start = Date.now();
+  const maxDepth = stmt.depth ?? 5;
+  const edgeKind = stmt.edgeKind;
+  const direction = stmt.direction ?? "OUTGOING";
+  const deadline = start + EXECUTION_TIMEOUT_MS;
+  let startNode;
+  for (const node of graph.allNodes()) {
+    if (node.name === stmt.from) {
+      startNode = node;
+      break;
+    }
+  }
+  if (!startNode) {
+    return {
+      nodes: [],
+      edges: [],
+      executionTimeMs: Date.now() - start,
+      truncated: false,
+      totalCount: 0
+    };
+  }
+  const visitedNodes = /* @__PURE__ */ new Set();
+  const visitedEdges = /* @__PURE__ */ new Set();
+  const resultNodes = [];
+  const resultEdges = [];
+  const queue = [{ id: startNode.id, depth: 0 }];
+  visitedNodes.add(startNode.id);
+  resultNodes.push(startNode);
+  let truncated = false;
+  while (queue.length > 0) {
+    if (Date.now() > deadline) {
+      truncated = true;
+      break;
+    }
+    const { id, depth } = queue.shift();
+    if (depth >= maxDepth) continue;
+    const nextEdges = [];
+    if (direction === "OUTGOING" || direction === "BOTH") {
+      for (const edge of graph.findEdgesFrom(id)) {
+        if (!edgeKind || edge.kind === edgeKind) nextEdges.push(edge);
+      }
+    }
+    if (direction === "INCOMING" || direction === "BOTH") {
+      for (const edge of graph.findEdgesTo(id)) {
+        if (!edgeKind || edge.kind === edgeKind) nextEdges.push(edge);
+      }
+    }
+    for (const edge of nextEdges) {
+      if (!visitedEdges.has(edge.id)) {
+        visitedEdges.add(edge.id);
+        resultEdges.push(edge);
+      }
+      const neighborId = direction === "INCOMING" ? edge.source : edge.target;
+      const effectiveNeighborId = direction === "BOTH" ? edge.source === id ? edge.target : edge.source : neighborId;
+      if (!visitedNodes.has(effectiveNeighborId)) {
+        visitedNodes.add(effectiveNeighborId);
+        const neighborNode = graph.getNode(effectiveNeighborId);
+        if (neighborNode) {
+          resultNodes.push(neighborNode);
+          queue.push({ id: effectiveNeighborId, depth: depth + 1 });
+        }
+      }
+    }
+  }
+  return {
+    nodes: resultNodes,
+    edges: resultEdges,
+    executionTimeMs: Date.now() - start,
+    truncated,
+    totalCount: resultNodes.length
+  };
+}
+function executePATH(stmt, graph) {
+  const start = Date.now();
+  const deadline = start + EXECUTION_TIMEOUT_MS;
+  let startNode;
+  let endNode;
+  for (const node of graph.allNodes()) {
+    if (node.name === stmt.from) startNode = node;
+    if (node.name === stmt.to) endNode = node;
+    if (startNode && endNode) break;
+  }
+  if (!startNode || !endNode) {
+    return {
+      path: null,
+      nodes: [],
+      executionTimeMs: Date.now() - start,
+      truncated: false,
+      totalCount: 0
+    };
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const parent = /* @__PURE__ */ new Map();
+  const queue = [startNode.id];
+  visited.add(startNode.id);
+  let found = false;
+  let truncated = false;
+  outer: while (queue.length > 0) {
+    if (Date.now() > deadline) {
+      truncated = true;
+      break;
+    }
+    const current2 = queue.shift();
+    for (const edge of graph.findEdgesFrom(current2)) {
+      const next = edge.target;
+      if (!visited.has(next)) {
+        visited.add(next);
+        parent.set(next, { nodeId: current2, edgeId: edge.id });
+        if (next === endNode.id) {
+          found = true;
+          break outer;
+        }
+        queue.push(next);
+      }
+    }
+    for (const edge of graph.findEdgesTo(current2)) {
+      const next = edge.source;
+      if (!visited.has(next)) {
+        visited.add(next);
+        parent.set(next, { nodeId: current2, edgeId: edge.id });
+        if (next === endNode.id) {
+          found = true;
+          break outer;
+        }
+        queue.push(next);
+      }
+    }
+  }
+  if (!found) {
+    return {
+      path: null,
+      nodes: [],
+      executionTimeMs: Date.now() - start,
+      truncated,
+      totalCount: 0
+    };
+  }
+  const pathNodeIds = [];
+  const pathEdgeIds = [];
+  let current = endNode.id;
+  while (current !== startNode.id) {
+    pathNodeIds.unshift(current);
+    const p = parent.get(current);
+    pathEdgeIds.unshift(p.edgeId);
+    current = p.nodeId;
+  }
+  pathNodeIds.unshift(startNode.id);
+  const pathNodes = pathNodeIds.map((id) => graph.getNode(id)).filter(Boolean);
+  const pathEdges = pathEdgeIds.map((id) => graph.getEdge(id)).filter(Boolean);
+  return {
+    path: pathNodes,
+    nodes: pathNodes,
+    edges: pathEdges,
+    executionTimeMs: Date.now() - start,
+    truncated,
+    totalCount: pathNodes.length
+  };
+}
+function executeCOUNT(stmt, graph) {
+  const start = Date.now();
+  const deadline = start + EXECUTION_TIMEOUT_MS;
+  let truncated = false;
+  const groups = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const node of graph.allNodes()) {
+    if (Date.now() > deadline) {
+      truncated = true;
+      break;
+    }
+    if (stmt.target !== "*" && node.kind !== stmt.target) continue;
+    if (stmt.where && !evaluateWhere(node, stmt.where)) continue;
+    total++;
+    if (stmt.groupBy) {
+      const key = String(getNodeProperty(node, stmt.groupBy) ?? "(none)");
+      groups.set(key, (groups.get(key) ?? 0) + 1);
+    } else {
+      groups.set("total", (groups.get("total") ?? 0) + 1);
+    }
+  }
+  const groupList = [...groups.entries()].map(([key, count]) => ({ key, count }));
+  groupList.sort((a, b) => b.count - a.count);
+  return {
+    groups: groupList,
+    executionTimeMs: Date.now() - start,
+    truncated,
+    totalCount: total
+  };
+}
+function executeGQL(ast, graph) {
+  switch (ast.type) {
+    case "FIND":
+      return executeFIND(ast, graph);
+    case "TRAVERSE":
+      return executeTRAVERSE(ast, graph);
+    case "PATH":
+      return executePATH(ast, graph);
+    case "COUNT":
+      return executeCOUNT(ast, graph);
+    default:
+      return {
+        nodes: [],
+        executionTimeMs: 0,
+        truncated: false,
+        totalCount: 0
+      };
+  }
+}
+var EXECUTION_TIMEOUT_MS;
+var init_gql_executor = __esm({
+  "src/query/gql-executor.ts"() {
+    EXECUTION_TIMEOUT_MS = 1e4;
+  }
+});
 function verifyWebSocketHandshake(req) {
   const cookieHeader = req.headers["cookie"] ?? "";
   const cookies = parseCookies(cookieHeader);
@@ -4874,10 +5622,10 @@ var init_file_watcher = __esm({
       }
       // ── private ─────────────────────────────────────────────────────────────────
       readCodeIntelIgnore() {
-        const ignoreFile = path29.join(this.workspaceRoot, ".codeintelignore");
+        const ignoreFile = path30.join(this.workspaceRoot, ".codeintelignore");
         try {
-          if (!fs27.existsSync(ignoreFile)) return [];
-          return fs27.readFileSync(ignoreFile, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+          if (!fs28.existsSync(ignoreFile)) return [];
+          return fs28.readFileSync(ignoreFile, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
         } catch {
           return [];
         }
@@ -4920,25 +5668,29 @@ var init_incremental_indexer = __esm({
           return { filesProcessed: 0, nodesRemoved: 0, nodesAdded: 0, duration: 0 };
         }
         let nodesRemoved = 0;
+        const nodesByFilePath = /* @__PURE__ */ new Map();
+        for (const node of graph.allNodes()) {
+          if (!node.filePath) continue;
+          const ids = nodesByFilePath.get(node.filePath);
+          if (ids) ids.push(node.id);
+          else nodesByFilePath.set(node.filePath, [node.id]);
+        }
+        const nodeIdsToRemove = /* @__PURE__ */ new Set();
         for (const absPath of changedFiles) {
-          const relPath2 = path29.relative(workspaceRoot, absPath);
-          const toRemove = [];
-          for (const node of graph.allNodes()) {
-            if (node.filePath === relPath2 || node.filePath === absPath) {
-              toRemove.push(node.id);
-            }
-          }
-          for (const id of toRemove) {
-            graph.removeNodeCascade(id);
-            nodesRemoved++;
-          }
+          const relPath2 = path30.relative(workspaceRoot, absPath);
+          for (const id of nodesByFilePath.get(relPath2) ?? []) nodeIdsToRemove.add(id);
+          for (const id of nodesByFilePath.get(absPath) ?? []) nodeIdsToRemove.add(id);
         }
-        if (fs27.existsSync(dbPath)) {
+        for (const id of nodeIdsToRemove) {
+          graph.removeNodeCascade(id);
+          nodesRemoved++;
+        }
+        if (fs28.existsSync(dbPath)) {
           try {
             const db = new DbManager(dbPath);
             await db.init();
             for (const absPath of changedFiles) {
-              const relPath2 = path29.relative(workspaceRoot, absPath);
+              const relPath2 = path30.relative(workspaceRoot, absPath);
               await removeNodesForFile(relPath2, db);
             }
             db.close();
@@ -4948,7 +5700,7 @@ var init_incremental_indexer = __esm({
         }
         const existingFiles = changedFiles.filter((f) => {
           try {
-            return fs27.statSync(f).isFile();
+            return fs28.statSync(f).isFile();
           } catch {
             return false;
           }
@@ -4970,13 +5722,13 @@ var init_incremental_indexer = __esm({
           await runPipeline([noopScan, parsePhase, resolvePhase], context2);
         }
         const nodesAdded = Math.max(0, graph.size.nodes - (nodesBeforeParse - nodesRemoved));
-        if (fs27.existsSync(dbPath) && existingFiles.length > 0) {
+        if (fs28.existsSync(dbPath) && existingFiles.length > 0) {
           try {
             const db = new DbManager(dbPath);
             await db.init();
-            const changedRelPaths = new Set(changedFiles.map((f) => path29.relative(workspaceRoot, f)));
+            const changedRelPaths = new Set(changedFiles.map((f) => path30.relative(workspaceRoot, f)));
             const nodesToUpsert = [...graph.allNodes()].filter(
-              (n) => changedRelPaths.has(n.filePath) || changedRelPaths.has(path29.relative(workspaceRoot, n.filePath))
+              (n) => changedRelPaths.has(n.filePath) || changedRelPaths.has(path30.relative(workspaceRoot, n.filePath))
             );
             await upsertNodes(nodesToUpsert, db);
             db.close();
@@ -4997,6 +5749,70 @@ var init_incremental_indexer = __esm({
   }
 });
 
+// src/query/saved-queries.ts
+var saved_queries_exports = {};
+__export(saved_queries_exports, {
+  deleteQuery: () => deleteQuery,
+  listQueries: () => listQueries,
+  loadQuery: () => loadQuery,
+  queryExists: () => queryExists,
+  saveQuery: () => saveQuery
+});
+function getQueriesDir(workspaceRoot) {
+  return path30.join(workspaceRoot, ".code-intel", "queries");
+}
+function ensureQueriesDir(workspaceRoot) {
+  const dir = getQueriesDir(workspaceRoot);
+  if (!fs28.existsSync(dir)) {
+    fs28.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function saveQuery(workspaceRoot, name, gql) {
+  const dir = ensureQueriesDir(workspaceRoot);
+  const filePath = path30.join(dir, `${name}.gql`);
+  fs28.writeFileSync(filePath, gql, "utf-8");
+}
+function loadQuery(workspaceRoot, name) {
+  const dir = getQueriesDir(workspaceRoot);
+  const filePath = path30.join(dir, `${name}.gql`);
+  if (!fs28.existsSync(filePath)) return null;
+  return fs28.readFileSync(filePath, "utf-8");
+}
+function listQueries(workspaceRoot) {
+  const dir = getQueriesDir(workspaceRoot);
+  if (!fs28.existsSync(dir)) return [];
+  const files = fs28.readdirSync(dir).filter((f) => f.endsWith(".gql"));
+  return files.map((f) => {
+    const filePath = path30.join(dir, f);
+    const name = f.replace(/\.gql$/, "");
+    const content = fs28.readFileSync(filePath, "utf-8");
+    const stat = fs28.statSync(filePath);
+    return {
+      name,
+      content,
+      filePath,
+      savedAt: stat.mtime.toISOString()
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+function deleteQuery(workspaceRoot, name) {
+  const dir = getQueriesDir(workspaceRoot);
+  const filePath = path30.join(dir, `${name}.gql`);
+  if (!fs28.existsSync(filePath)) return false;
+  fs28.unlinkSync(filePath);
+  return true;
+}
+function queryExists(workspaceRoot, name) {
+  const dir = getQueriesDir(workspaceRoot);
+  const filePath = path30.join(dir, `${name}.gql`);
+  return fs28.existsSync(filePath);
+}
+var init_saved_queries = __esm({
+  "src/query/saved-queries.ts"() {
+  }
+});
+
 // src/cli/main.ts
 init_logger();
 
@@ -5160,7 +5976,7 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
 ]);
 function loadIgnorePatterns(workspaceRoot) {
   try {
-    const raw = fs27.readFileSync(path29.join(workspaceRoot, ".codeintelignore"), "utf-8");
+    const raw = fs28.readFileSync(path30.join(workspaceRoot, ".codeintelignore"), "utf-8");
     const extras = /* @__PURE__ */ new Set();
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -5184,7 +6000,7 @@ var scanPhase = {
     function walk2(dir) {
       let entries;
       try {
-        entries = fs27.readdirSync(dir, { withFileTypes: true });
+        entries = fs28.readdirSync(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -5193,15 +6009,15 @@ var scanPhase = {
           if (entry.name.startsWith(".")) continue;
           if (IGNORED_DIRS.has(entry.name)) continue;
           if (extraIgnore.has(entry.name)) continue;
-          walk2(path29.join(dir, entry.name));
+          walk2(path30.join(dir, entry.name));
         } else if (entry.isFile()) {
           const name = entry.name;
           if (IGNORED_FILE_SUFFIXES.some((s) => name.endsWith(s))) continue;
-          const ext = path29.extname(name);
+          const ext = path30.extname(name);
           if (!extensions.has(ext)) continue;
-          const fullPath = path29.join(dir, name);
+          const fullPath = path30.join(dir, name);
           try {
-            const stat = fs27.statSync(fullPath);
+            const stat = fs28.statSync(fullPath);
             if (stat.size > MAX_FILE_SIZE_BYTES) continue;
           } catch {
             continue;
@@ -5228,20 +6044,20 @@ var structurePhase = {
     const dirs = /* @__PURE__ */ new Set();
     let structDone = 0;
     for (const filePath of context2.filePaths) {
-      const relativePath = path29.relative(context2.workspaceRoot, filePath);
+      const relativePath = path30.relative(context2.workspaceRoot, filePath);
       const lang = detectLanguage(filePath);
       context2.graph.addNode({
         id: generateNodeId("file", relativePath, relativePath),
         kind: "file",
-        name: path29.basename(filePath),
+        name: path30.basename(filePath),
         filePath: relativePath,
         metadata: lang ? { language: lang } : void 0
       });
-      let dir = path29.dirname(relativePath);
+      let dir = path30.dirname(relativePath);
       while (dir && dir !== "." && dir !== "") {
         if (dirs.has(dir)) break;
         dirs.add(dir);
-        dir = path29.dirname(dir);
+        dir = path30.dirname(dir);
       }
       structDone++;
       context2.onPhaseProgress?.("structure", structDone, context2.filePaths.length);
@@ -5250,7 +6066,7 @@ var structurePhase = {
       context2.graph.addNode({
         id: generateNodeId("directory", dir, dir),
         kind: "directory",
-        name: path29.basename(dir),
+        name: path30.basename(dir),
         filePath: dir
       });
     }
@@ -5361,22 +6177,22 @@ var flowPhase = {
       const queue = [{ nodeId: ep.id, path: [ep.id] }];
       const visited = /* @__PURE__ */ new Set();
       while (queue.length > 0 && flowCount < maxFlows) {
-        const { nodeId, path: path30 } = queue.shift();
-        if (path30.length > maxDepth) continue;
+        const { nodeId, path: path31 } = queue.shift();
+        if (path31.length > maxDepth) continue;
         const callEdges = [...graph.findEdgesFrom(nodeId)].filter((e) => e.kind === "calls").slice(0, maxBranching);
-        if (callEdges.length === 0 && path30.length >= 3) {
+        if (callEdges.length === 0 && path31.length >= 3) {
           const flowId = generateNodeId("flow", ep.filePath, `flow-${flowCount}`);
           graph.addNode({
             id: flowId,
             kind: "flow",
             name: `${ep.name} flow ${flowCount}`,
             filePath: ep.filePath,
-            metadata: { steps: path30, entryPoint: ep.name }
+            metadata: { steps: path31, entryPoint: ep.name }
           });
-          for (let i = 0; i < path30.length; i++) {
+          for (let i = 0; i < path31.length; i++) {
             graph.addEdge({
-              id: generateEdgeId(path30[i], flowId, `step_of_${i}`),
-              source: path30[i],
+              id: generateEdgeId(path31[i], flowId, `step_of_${i}`),
+              source: path31[i],
               target: flowId,
               kind: "step_of",
               weight: 1,
@@ -5389,7 +6205,7 @@ var flowPhase = {
         for (const edge of callEdges) {
           if (visited.has(edge.target)) continue;
           visited.add(edge.target);
-          queue.push({ nodeId: edge.target, path: [...path30, edge.target] });
+          queue.push({ nodeId: edge.target, path: [...path31, edge.target] });
         }
       }
     }
@@ -5407,7 +6223,7 @@ var LLMGovernanceLogger = class {
   }
   /** Path to the JSONL log file. */
   getLogPath() {
-    return process.env["CODE_INTEL_GOVERNANCE_LOG_PATH"] ?? path29.join(os12.homedir(), ".code-intel", "llm-governance.jsonl");
+    return process.env["CODE_INTEL_GOVERNANCE_LOG_PATH"] ?? path30.join(os12.homedir(), ".code-intel", "llm-governance.jsonl");
   }
   /**
    * Append an entry to the governance log.
@@ -5423,8 +6239,8 @@ var LLMGovernanceLogger = class {
         ...entry
       };
       const logPath = this.getLogPath();
-      fs27.mkdirSync(path29.dirname(logPath), { recursive: true });
-      fs27.appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
+      fs28.mkdirSync(path30.dirname(logPath), { recursive: true });
+      fs28.appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
     } catch {
     }
   }
@@ -5434,7 +6250,7 @@ var LLMGovernanceLogger = class {
    */
   readLog(limit = 100) {
     try {
-      const raw = fs27.readFileSync(this.getLogPath(), "utf-8");
+      const raw = fs28.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 {
@@ -5748,7 +6564,7 @@ var LANG_QUERIES2 = {
 };
 function workerScriptPath() {
   const thisFile = fileURLToPath(import.meta.url);
-  return path29.join(path29.dirname(thisFile), "parse-worker.js");
+  return path30.join(path30.dirname(thisFile), "parse-worker.js");
 }
 var parsePhaseParallel = {
   name: "parse",
@@ -5764,14 +6580,14 @@ var parsePhaseParallel = {
       const batch = filePaths.slice(i, i + CONCURRENCY);
       await Promise.all(batch.map(async (filePath) => {
         try {
-          const source = await fs27.promises.readFile(filePath, "utf-8");
+          const source = await fs28.promises.readFile(filePath, "utf-8");
           context2.fileCache.set(filePath, source);
         } catch {
         }
       }));
     }
     const workerScript = workerScriptPath();
-    const workerScriptExists = fs27.existsSync(workerScript);
+    const workerScriptExists = fs28.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));
@@ -5783,7 +6599,7 @@ var parsePhaseParallel = {
       if (!lang) continue;
       const source = context2.fileCache.get(filePath);
       if (!source) continue;
-      const relativePath = path29.relative(context2.workspaceRoot, filePath);
+      const relativePath = path30.relative(context2.workspaceRoot, filePath);
       const fileNodeId = generateNodeId("file", relativePath, relativePath);
       const fileNode = context2.graph.getNode(fileNodeId);
       if (fileNode) fileNode.content = source.slice(0, 2e3);
@@ -5826,7 +6642,7 @@ var parsePhaseParallel = {
         symbolCount += res.nodes.length;
         if (res.usedTreeSitter) treeSitterCount++;
         else regexCount++;
-        const relativePath = path29.relative(context2.workspaceRoot, res.taskId);
+        const relativePath = path30.relative(context2.workspaceRoot, res.taskId);
         const funcs = res.nodes.filter((n) => n.kind === "function" || n.kind === "method").map((n) => ({ id: n.id, startLine: n.startLine ?? 0, endLine: n.endLine })).sort((a, b) => a.startLine - b.startLine);
         if (funcs.length > 0) context2.fileFunctionIndex.set(relativePath, funcs);
         parseDone++;
@@ -5853,7 +6669,7 @@ init_id_generator();
 init_logger();
 function workerScriptPath2() {
   const thisFile = fileURLToPath(import.meta.url);
-  return path29.join(path29.dirname(thisFile), "resolve-worker.js");
+  return path30.join(path30.dirname(thisFile), "resolve-worker.js");
 }
 var resolvePhaseParallel = {
   name: "resolve",
@@ -5865,11 +6681,11 @@ var resolvePhaseParallel = {
     const fileFunctionIndex = context2.fileFunctionIndex ?? /* @__PURE__ */ new Map();
     const fileIndex = {};
     for (const fp of filePaths) {
-      const rel = path29.relative(workspaceRoot, fp);
+      const rel = path30.relative(workspaceRoot, fp);
       fileIndex[rel] = fp;
       const noExt = rel.replace(/\.\w+$/, "");
       if (!fileIndex[noExt]) fileIndex[noExt] = fp;
-      const base = path29.basename(rel, path29.extname(rel));
+      const base = path30.basename(rel, path30.extname(rel));
       if (!fileIndex[base]) fileIndex[base] = fp;
     }
     const symbolIndex = {};
@@ -5883,7 +6699,7 @@ var resolvePhaseParallel = {
     }
     const snapshot = { symbolIndex, fileSymbolIndex, fileIndex, workspaceRoot };
     const workerScript = workerScriptPath2();
-    const workerScriptExists = fs27.existsSync(workerScript);
+    const workerScriptExists = fs28.existsSync(workerScript);
     const workerCount = parseInt(process.env["PARSE_WORKERS"] ?? "", 10) || Math.max(1, os12.cpus().length - 1);
     if (!workerScriptExists || workerCount === 1) {
       logger_default.info(`[resolve-parallel] falling back to sequential`);
@@ -5896,7 +6712,7 @@ var resolvePhaseParallel = {
       if (!lang) continue;
       const source = fileCache.get(filePath);
       if (!source) continue;
-      const relativePath = path29.relative(workspaceRoot, filePath);
+      const relativePath = path30.relative(workspaceRoot, filePath);
       const fileNodeId = generateNodeId("file", relativePath, relativePath);
       const funcList = fileFunctionIndex.get(relativePath) ?? [];
       tasks.push({ taskId: filePath, filePath, relativePath, fileNodeId, source, funcList });
@@ -6019,7 +6835,7 @@ init_embedder();
 async function hybridSearch(graph, query, limit, options = {}) {
   const { vectorDbPath, bm25Limit = 50, vectorLimit = 50 } = options;
   const bm25Promise = Promise.resolve(textSearch(graph, query, bm25Limit));
-  const hasVectorDb = Boolean(vectorDbPath && fs27.existsSync(vectorDbPath));
+  const hasVectorDb = Boolean(vectorDbPath && fs28.existsSync(vectorDbPath));
   if (!hasVectorDb) {
     const bm25Results2 = await bm25Promise;
     return {
@@ -6273,8 +7089,8 @@ async function syncGroup(group) {
       logger_default.warn(`  \u26A0 Registry entry "${member.registryName}" not found \u2014 skipping ${member.groupPath}`);
       continue;
     }
-    const dbPath = path29.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs27.existsSync(dbPath)) {
+    const dbPath = path30.join(regEntry.path, ".code-intel", "graph.db");
+    if (!fs28.existsSync(dbPath)) {
       logger_default.warn(`  \u26A0 No index at ${dbPath} \u2014 run \`code-intel analyze ${regEntry.path}\` first`);
       continue;
     }
@@ -6311,8 +7127,8 @@ async function queryGroup(group, query, limit = 20) {
   for (const member of group.members) {
     const regEntry = registry.find((r) => r.name === member.registryName);
     if (!regEntry) continue;
-    const dbPath = path29.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs27.existsSync(dbPath)) continue;
+    const dbPath = path30.join(regEntry.path, ".code-intel", "graph.db");
+    if (!fs28.existsSync(dbPath)) continue;
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
     try {
@@ -6352,7 +7168,7 @@ var STUCK_THRESHOLD_MINUTES = 30;
 var JobsDB = class {
   db;
   constructor(dbPath) {
-    fs27.mkdirSync(path29.dirname(dbPath), { recursive: true });
+    fs28.mkdirSync(path30.dirname(dbPath), { recursive: true });
     this.db = new Database(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
@@ -6494,7 +7310,7 @@ var JobsDB = class {
   }
 };
 function getJobsDBPath() {
-  return path29.join(os12.homedir(), ".code-intel", "jobs.db");
+  return path30.join(os12.homedir(), ".code-intel", "jobs.db");
 }
 var _jobsDB = null;
 function getOrCreateJobsDB() {
@@ -6586,7 +7402,7 @@ var BACKUP_VERSION = "1.0";
 var ALGORITHM = "aes-256-gcm";
 var IV_LENGTH = 16;
 function getBackupDir() {
-  return path29.join(os12.homedir(), ".code-intel", "backups");
+  return path30.join(os12.homedir(), ".code-intel", "backups");
 }
 function getBackupKey() {
   const keyHex = process.env["CODE_INTEL_BACKUP_KEY"];
@@ -6617,30 +7433,30 @@ var BackupService = class {
   constructor(backupDir) {
     this.backupDir = backupDir ?? getBackupDir();
     this.key = getBackupKey();
-    fs27.mkdirSync(this.backupDir, { recursive: true });
+    fs28.mkdirSync(this.backupDir, { recursive: true });
   }
   /**
    * Create a backup for a repository.
    * Returns the backup entry.
    */
   createBackup(repoPath) {
-    const codeIntelDir = path29.join(repoPath, ".code-intel");
+    const codeIntelDir = path30.join(repoPath, ".code-intel");
     const id = v4();
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
     const filesToBackup = [];
     const candidates = ["graph.db", "vector.db", "meta.json"];
     for (const f of candidates) {
-      const fp = path29.join(codeIntelDir, f);
-      if (fs27.existsSync(fp)) {
+      const fp = path30.join(codeIntelDir, f);
+      if (fs28.existsSync(fp)) {
         filesToBackup.push({ name: f, localPath: fp });
       }
     }
-    const registryPath = path29.join(os12.homedir(), ".code-intel", "registry.json");
-    if (fs27.existsSync(registryPath)) {
+    const registryPath = path30.join(os12.homedir(), ".code-intel", "registry.json");
+    if (fs28.existsSync(registryPath)) {
       filesToBackup.push({ name: "registry.json", localPath: registryPath });
     }
-    const usersDbPath = path29.join(os12.homedir(), ".code-intel", "users.db");
-    if (fs27.existsSync(usersDbPath)) {
+    const usersDbPath = path30.join(os12.homedir(), ".code-intel", "users.db");
+    if (fs28.existsSync(usersDbPath)) {
       filesToBackup.push({ name: "users.db", localPath: usersDbPath });
     }
     if (filesToBackup.length === 0) {
@@ -6651,7 +7467,7 @@ var BackupService = class {
       createdAt,
       version: BACKUP_VERSION,
       files: filesToBackup.map((f) => {
-        const data = fs27.readFileSync(f.localPath);
+        const data = fs28.readFileSync(f.localPath);
         return {
           name: f.name,
           sha256: crypto5.createHash("sha256").update(data).digest("hex"),
@@ -6665,7 +7481,7 @@ var BackupService = class {
     manifestLenBuf.writeUInt32BE(manifestBuf.length, 0);
     parts.push(manifestLenBuf, manifestBuf);
     for (const f of filesToBackup) {
-      const data = fs27.readFileSync(f.localPath);
+      const data = fs28.readFileSync(f.localPath);
       const nameBuf = Buffer.from(f.name, "utf-8");
       const nameLenBuf = Buffer.alloc(2);
       nameLenBuf.writeUInt16BE(nameBuf.length, 0);
@@ -6676,8 +7492,8 @@ var BackupService = class {
     const plaintext = Buffer.concat(parts);
     const encrypted = encryptBuffer(plaintext, this.key);
     const backupFileName = `backup-${id}.cib`;
-    const backupPath = path29.join(this.backupDir, backupFileName);
-    fs27.writeFileSync(backupPath, encrypted);
+    const backupPath = path30.join(this.backupDir, backupFileName);
+    fs28.writeFileSync(backupPath, encrypted);
     const entry = {
       id,
       createdAt,
@@ -6704,9 +7520,9 @@ var BackupService = class {
   async uploadToS3(entry) {
     const cfg = getS3Config();
     if (!cfg) throw new Error("S3 not configured. Set CODE_INTEL_BACKUP_S3_BUCKET, CODE_INTEL_BACKUP_S3_ACCESS_KEY_ID, CODE_INTEL_BACKUP_S3_SECRET_ACCESS_KEY.");
-    const fileName = path29.basename(entry.path);
+    const fileName = path30.basename(entry.path);
     const s3Key = `${cfg.prefix}${fileName}`;
-    const body = fs27.readFileSync(entry.path);
+    const body = fs28.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)}`);
@@ -6723,8 +7539,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)}`);
     }
-    fs27.mkdirSync(path29.dirname(destPath), { recursive: true });
-    fs27.writeFileSync(destPath, Buffer.from(result.body, "binary"));
+    fs28.mkdirSync(path30.dirname(destPath), { recursive: true });
+    fs28.writeFileSync(destPath, Buffer.from(result.body, "binary"));
   }
   /**
    * List backup objects in S3 with the configured prefix.
@@ -6770,10 +7586,10 @@ var BackupService = class {
     if (!entry) {
       throw new Error(`Backup "${backupId}" not found.`);
     }
-    if (!fs27.existsSync(entry.path)) {
+    if (!fs28.existsSync(entry.path)) {
       throw new Error(`Backup file not found at: ${entry.path}`);
     }
-    const encrypted = fs27.readFileSync(entry.path);
+    const encrypted = fs28.readFileSync(entry.path);
     let plaintext;
     try {
       plaintext = decryptBuffer(encrypted, this.key);
@@ -6787,8 +7603,8 @@ var BackupService = class {
     offset += manifestLen;
     const manifest = JSON.parse(manifestStr);
     const restoreBase = targetRepoPath ?? entry.repoPath;
-    const codeIntelDir = path29.join(restoreBase, ".code-intel");
-    fs27.mkdirSync(codeIntelDir, { recursive: true });
+    const codeIntelDir = path30.join(restoreBase, ".code-intel");
+    fs28.mkdirSync(codeIntelDir, { recursive: true });
     for (const fileEntry of manifest.files) {
       const nameLen = plaintext.readUInt16BE(offset);
       offset += 2;
@@ -6805,18 +7621,18 @@ var BackupService = class {
       }
       let destPath;
       if (name === "registry.json" || name === "users.db") {
-        destPath = path29.join(os12.homedir(), ".code-intel", name);
+        destPath = path30.join(os12.homedir(), ".code-intel", name);
       } else {
-        destPath = path29.join(codeIntelDir, name);
+        destPath = path30.join(codeIntelDir, name);
       }
-      fs27.writeFileSync(destPath, data);
+      fs28.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) => fs27.existsSync(e.path)).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    const entries = this._loadIndex().filter((e) => fs28.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);
@@ -6846,7 +7662,7 @@ var BackupService = class {
     for (const e of entries) {
       if (!keep.has(e.id)) {
         try {
-          fs27.unlinkSync(e.path);
+          fs28.unlinkSync(e.path);
           deleted++;
         } catch {
         }
@@ -6858,17 +7674,17 @@ var BackupService = class {
   }
   // ── Index helpers ──────────────────────────────────────────────────────────
   _indexPath() {
-    return path29.join(this.backupDir, "index.json");
+    return path30.join(this.backupDir, "index.json");
   }
   _loadIndex() {
     try {
-      return JSON.parse(fs27.readFileSync(this._indexPath(), "utf-8"));
+      return JSON.parse(fs28.readFileSync(this._indexPath(), "utf-8"));
     } catch {
       return [];
     }
   }
   _saveIndex(entries) {
-    fs27.writeFileSync(this._indexPath(), JSON.stringify(entries, null, 2));
+    fs28.writeFileSync(this._indexPath(), JSON.stringify(entries, null, 2));
   }
   _appendIndex(entry) {
     const entries = this._loadIndex();
@@ -7207,6 +8023,60 @@ var openApiSpec = {
         }
       }
     },
+    "/source": {
+      get: {
+        tags: ["Files"],
+        summary: "Get source code preview with context around specified lines",
+        description: "Returns the file content around the specified line range (\xB120 lines context), with language detection. Requires viewer role.",
+        security: [{ BearerAuth: [] }, { SessionCookie: [] }],
+        parameters: [
+          {
+            name: "file",
+            in: "query",
+            required: true,
+            description: "Absolute path to the file",
+            schema: { type: "string" }
+          },
+          {
+            name: "startLine",
+            in: "query",
+            required: false,
+            description: "Start line number (1-indexed)",
+            schema: { type: "integer", minimum: 1 }
+          },
+          {
+            name: "endLine",
+            in: "query",
+            required: false,
+            description: "End line number (1-indexed)",
+            schema: { type: "integer", minimum: 1 }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Source code preview",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    content: { type: "string", description: "File content (with context lines)" },
+                    language: { type: "string", description: "Detected programming language", example: "typescript" },
+                    startLine: { type: "integer", description: "Actual start line returned (with context)" },
+                    endLine: { type: "integer", description: "Actual end line returned (with context)" }
+                  },
+                  required: ["content", "language", "startLine", "endLine"]
+                }
+              }
+            }
+          },
+          "400": { description: "Bad request (missing file param or path traversal detected)", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } },
+          "401": { description: "Unauthorized", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } },
+          "403": { description: "Forbidden (file outside indexed repos)", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } },
+          "404": { description: "File not found", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } }
+        }
+      }
+    },
     "/grep": {
       post: {
         tags: ["Files"],
@@ -7320,16 +8190,122 @@ var openApiSpec = {
           "404": { description: "Group not found", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } }
         }
       }
+    },
+    "/query": {
+      post: {
+        tags: ["GQL"],
+        summary: "Execute a GQL (Graph Query Language) query against the knowledge graph",
+        description: "Supports FIND, TRAVERSE, PATH, and COUNT statements. Requires viewer role minimum.",
+        security: [{ BearerAuth: [] }, { SessionCookie: [] }],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  gql: {
+                    type: "string",
+                    description: "GQL query string",
+                    example: 'FIND function WHERE name CONTAINS "auth"'
+                  },
+                  format: {
+                    type: "string",
+                    enum: ["json", "table", "csv"],
+                    default: "json",
+                    description: "Output format"
+                  }
+                },
+                required: ["gql"]
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "GQL execution result",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    nodes: { type: "array", items: { "$ref": "#/components/schemas/CodeNode" } },
+                    edges: { type: "array", items: { type: "object" } },
+                    groups: { type: "array", items: { type: "object", properties: { key: { type: "string" }, count: { type: "integer" } } } },
+                    path: { type: "array", items: { "$ref": "#/components/schemas/CodeNode" }, nullable: true },
+                    executionTimeMs: { type: "number" },
+                    truncated: { type: "boolean" },
+                    totalCount: { type: "integer" }
+                  }
+                }
+              }
+            }
+          },
+          "400": { description: "Missing gql field", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } },
+          "401": { description: "Unauthorized", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } },
+          "403": { description: "Forbidden (insufficient role)", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } },
+          "422": { description: "GQL parse error", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } }
+        }
+      }
+    },
+    "/query/explain": {
+      post: {
+        tags: ["GQL"],
+        summary: "Explain a GQL query \u2014 returns the execution plan without running it",
+        description: "Returns a query plan object describing the steps that would be executed. Requires viewer role minimum.",
+        security: [{ BearerAuth: [] }, { SessionCookie: [] }],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  gql: { type: "string", description: "GQL query string", example: 'FIND function WHERE name CONTAINS "auth"' }
+                },
+                required: ["gql"]
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Query plan",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    plan: {
+                      type: "object",
+                      properties: {
+                        type: { type: "string", enum: ["FIND", "TRAVERSE", "PATH", "COUNT"] },
+                        gql: { type: "string" },
+                        steps: { type: "array", items: { type: "object" } },
+                        estimatedCost: { type: "number" }
+                      }
+                    },
+                    graphSize: { type: "object", properties: { nodes: { type: "integer" }, edges: { type: "integer" } } }
+                  }
+                }
+              }
+            }
+          },
+          "400": { description: "Missing gql field", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } },
+          "401": { description: "Unauthorized", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } },
+          "422": { description: "GQL parse error", content: { "application/json": { schema: { "$ref": "#/components/schemas/ErrorResponse" } } } }
+        }
+      }
     }
   }
 };
 
 // src/http/app.ts
-var __dirname$1 = path29.dirname(fileURLToPath(import.meta.url));
+var __dirname$1 = path30.dirname(fileURLToPath(import.meta.url));
 var WEB_DIST = (() => {
-  const bundled = path29.resolve(__dirname$1, "..", "web");
-  if (fs27.existsSync(bundled)) return bundled;
-  return path29.resolve(__dirname$1, "..", "..", "..", "web", "dist");
+  const bundled = path30.resolve(__dirname$1, "..", "web");
+  if (fs28.existsSync(bundled)) return bundled;
+  return path30.resolve(__dirname$1, "..", "..", "..", "web", "dist");
 })();
 function getAllowedOrigins() {
   const env = process.env["CODE_INTEL_CORS_ORIGINS"];
@@ -7357,6 +8333,7 @@ function createDefaultLimiter() {
 function createApp(graph, repoName, workspaceRoot, watcherState) {
   const app = express();
   app.set("trust proxy", 1);
+  app.use(compression());
   app.use(
     helmet({
       contentSecurityPolicy: false
@@ -7859,8 +8836,8 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     const registry = loadRegistry();
     const entry = registry.find((r) => r.name === requestedRepo || r.path === requestedRepo);
     if (!entry) return null;
-    const dbPath = path29.join(entry.path, ".code-intel", "graph.db");
-    if (!fs27.existsSync(dbPath)) return null;
+    const dbPath = path30.join(entry.path, ".code-intel", "graph.db");
+    if (!fs28.existsSync(dbPath)) return null;
     const repoGraph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
     try {
@@ -7947,7 +8924,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       return;
     }
     try {
-      const content = fs27.readFileSync(file_path, "utf-8");
+      const content = fs28.readFileSync(file_path, "utf-8");
       res.json({ content });
     } catch {
       res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "File not found" } });
@@ -8205,8 +9182,8 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     for (const member of group.members) {
       const regEntry = registry.find((r) => r.name === member.registryName);
       if (!regEntry) continue;
-      const dbPath = path29.join(regEntry.path, ".code-intel", "graph.db");
-      if (!fs27.existsSync(dbPath)) continue;
+      const dbPath = path30.join(regEntry.path, ".code-intel", "graph.db");
+      if (!fs28.existsSync(dbPath)) continue;
       const db = new DbManager(dbPath);
       try {
         await db.init();
@@ -8218,10 +9195,245 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     }
     res.json({ nodes: [...mergedGraph.allNodes()], edges: [...mergedGraph.allEdges()] });
   });
-  if (fs27.existsSync(WEB_DIST)) {
+  app.get("/api/v1/source", requireAuth, requireRole("viewer"), (req, res) => {
+    const { file, startLine: startLineStr, endLine: endLineStr } = req.query;
+    if (!file) {
+      res.status(400).json({
+        error: {
+          code: ErrorCodes.INVALID_REQUEST,
+          message: "Missing required query parameter: file",
+          requestId: req.requestId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      return;
+    }
+    if (file.includes("../")) {
+      res.status(400).json({
+        error: {
+          code: ErrorCodes.INVALID_REQUEST,
+          message: "Path traversal detected",
+          hint: 'File paths must not contain "../"',
+          requestId: req.requestId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      return;
+    }
+    let rawResolved = path30.normalize(file);
+    if (!path30.isAbsolute(rawResolved) && workspaceRoot) {
+      rawResolved = path30.join(workspaceRoot, rawResolved);
+    }
+    const resolvedFile = path30.resolve(rawResolved);
+    function isInsideDir(fileAbs, dir) {
+      const rel = path30.relative(path30.resolve(dir), fileAbs);
+      return !rel.startsWith("..") && !path30.isAbsolute(rel);
+    }
+    if (workspaceRoot) {
+      if (!isInsideDir(resolvedFile, workspaceRoot)) {
+        const registry = loadRegistry();
+        const inKnownRepo = registry.some((r) => isInsideDir(resolvedFile, r.path));
+        if (!inKnownRepo) {
+          res.status(403).json({
+            error: {
+              code: ErrorCodes.FORBIDDEN,
+              message: "Access denied",
+              hint: "File path must be within an indexed repository",
+              requestId: req.requestId,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+          return;
+        }
+      }
+    } else {
+      const registry = loadRegistry();
+      const inKnownRepo = registry.some((r) => isInsideDir(resolvedFile, r.path));
+      if (!inKnownRepo) {
+        res.status(403).json({
+          error: {
+            code: ErrorCodes.FORBIDDEN,
+            message: "Access denied",
+            hint: "File path must be within an indexed repository",
+            requestId: req.requestId,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        });
+        return;
+      }
+    }
+    let fileContent;
+    try {
+      fileContent = fs28.readFileSync(resolvedFile, "utf-8");
+    } catch {
+      res.status(404).json({
+        error: {
+          code: ErrorCodes.NOT_FOUND,
+          message: "File not found",
+          requestId: req.requestId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      return;
+    }
+    const lines = fileContent.split("\n");
+    const parsedStart = startLineStr ? Number.parseInt(startLineStr, 10) : 1;
+    const parsedEnd = endLineStr ? Number.parseInt(endLineStr, 10) : parsedStart;
+    if (!Number.isFinite(parsedStart) || parsedStart < 1 || !Number.isFinite(parsedEnd) || parsedEnd < 1) {
+      res.status(400).json({
+        error: {
+          code: ErrorCodes.INVALID_REQUEST,
+          message: "Invalid startLine or endLine: must be positive integers",
+          requestId: req.requestId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      return;
+    }
+    const startLine = Math.max(1, parsedStart);
+    const endLine = Math.min(lines.length, parsedEnd);
+    const contextStart = Math.max(1, startLine - 20);
+    const contextEnd = Math.min(lines.length, endLine + 20);
+    const content = lines.slice(contextStart - 1, contextEnd).join("\n");
+    const ext = path30.extname(resolvedFile).toLowerCase();
+    const languageMap = {
+      ".ts": "typescript",
+      ".tsx": "typescript",
+      ".js": "javascript",
+      ".jsx": "javascript",
+      ".mjs": "javascript",
+      ".cjs": "javascript",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust",
+      ".java": "java",
+      ".cs": "csharp",
+      ".cpp": "cpp",
+      ".cc": "cpp",
+      ".cxx": "cpp",
+      ".c": "c",
+      ".h": "c",
+      ".hpp": "cpp",
+      ".rb": "ruby",
+      ".php": "php",
+      ".swift": "swift",
+      ".kt": "kotlin",
+      ".kts": "kotlin",
+      ".json": "json",
+      ".yaml": "yaml",
+      ".yml": "yaml",
+      ".md": "markdown",
+      ".sh": "bash",
+      ".bash": "bash",
+      ".zsh": "bash",
+      ".sql": "sql",
+      ".html": "html",
+      ".htm": "html",
+      ".css": "css",
+      ".scss": "scss",
+      ".less": "less",
+      ".xml": "xml",
+      ".toml": "toml"
+    };
+    const language = languageMap[ext] ?? "plaintext";
+    res.json({
+      content,
+      language,
+      startLine: contextStart,
+      endLine: contextEnd
+    });
+  });
+  app.post("/api/v1/query", requireRole("viewer"), async (req, res) => {
+    const { gql, format } = req.body;
+    if (!gql || typeof gql !== "string") {
+      res.status(400).json({
+        error: { code: ErrorCodes.INVALID_REQUEST, message: "Missing required field: gql", requestId: req.requestId, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+      });
+      return;
+    }
+    try {
+      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(gql);
+      if (isGQLParseError2(ast)) {
+        res.status(422).json({
+          error: {
+            code: ErrorCodes.INVALID_REQUEST,
+            message: `GQL parse error: ${ast.message}`,
+            hint: `Position: ${ast.pos}${ast.expected ? `, expected: ${ast.expected}` : ""}${ast.got ? `, got: ${ast.got}` : ""}`,
+            requestId: req.requestId,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        });
+        return;
+      }
+      const result = executeGQL2(ast, graph);
+      const statusCode = result.truncated ? 408 : 200;
+      res.status(statusCode).json({ ...result, format: format ?? "json" });
+    } catch (err) {
+      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() } });
+    }
+  });
+  app.post("/api/v1/query/explain", requireRole("viewer"), async (req, res) => {
+    const { gql } = req.body;
+    if (!gql || typeof gql !== "string") {
+      res.status(400).json({
+        error: { code: ErrorCodes.INVALID_REQUEST, message: "Missing required field: gql", requestId: req.requestId, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+      });
+      return;
+    }
+    try {
+      const { parseGQL: parseGQL2, isGQLParseError: isGQLParseError2 } = await Promise.resolve().then(() => (init_gql_parser(), gql_parser_exports));
+      const ast = parseGQL2(gql);
+      if (isGQLParseError2(ast)) {
+        res.status(422).json({
+          error: {
+            code: ErrorCodes.INVALID_REQUEST,
+            message: `GQL parse error: ${ast.message}`,
+            hint: `Position: ${ast.pos}`,
+            requestId: req.requestId,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        });
+        return;
+      }
+      const plan = { type: ast.type, gql };
+      if (ast.type === "FIND") {
+        plan.steps = [
+          { step: 1, op: "SCAN_NODES", filter: ast.target === "*" ? "all" : `kind=${ast.target}` },
+          ...ast.where ? [{ step: 2, op: "WHERE", conditions: ast.where.exprs.length }] : [],
+          ...ast.limit !== void 0 ? [{ step: 3, op: "LIMIT", value: ast.limit }] : []
+        ];
+        plan.estimatedCost = graph.size.nodes;
+      } else if (ast.type === "TRAVERSE") {
+        plan.steps = [
+          { step: 1, op: "FIND_START_NODE", name: ast.from },
+          { step: 2, op: "BFS", edgeKind: ast.edgeKind, maxDepth: ast.depth ?? 5 }
+        ];
+        plan.estimatedCost = Math.min(graph.size.nodes, Math.pow(4, ast.depth ?? 5));
+      } else if (ast.type === "PATH") {
+        plan.steps = [
+          { step: 1, op: "FIND_NODES", from: ast.from, to: ast.to },
+          { step: 2, op: "BFS_SHORTEST_PATH" }
+        ];
+        plan.estimatedCost = graph.size.nodes + graph.size.edges;
+      } else if (ast.type === "COUNT") {
+        plan.steps = [
+          { step: 1, op: "SCAN_NODES", filter: ast.target === "*" ? "all" : `kind=${ast.target}` },
+          ...ast.where ? [{ step: 2, op: "WHERE", conditions: ast.where.exprs.length }] : [],
+          ...ast.groupBy ? [{ step: 3, op: "GROUP_BY", property: ast.groupBy }] : [{ step: 3, op: "COUNT" }]
+        ];
+        plan.estimatedCost = graph.size.nodes;
+      }
+      res.json({ plan, graphSize: graph.size });
+    } catch (err) {
+      res.status(500).json({ error: { code: ErrorCodes.INTERNAL_ERROR, message: err instanceof Error ? err.message : String(err), requestId: req.requestId, timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+    }
+  });
+  if (fs28.existsSync(WEB_DIST)) {
     app.use(express.static(WEB_DIST));
     app.get("/{*path}", (_req, res) => {
-      res.sendFile(path29.join(WEB_DIST, "index.html"));
+      res.sendFile(path30.join(WEB_DIST, "index.html"));
     });
   }
   app.use("/admin", requireRole("admin"));
@@ -8531,6 +9743,23 @@ function createMcpServer(graph, repoName, workspaceRoot) {
           }
         }
       },
+      // ── query (GQL) ────────────────────────────────────────────────────────
+      {
+        name: "query",
+        description: "Execute a GQL (Graph Query Language) query. Supports FIND, TRAVERSE, PATH, and COUNT. More expressive than raw_query.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            gql: {
+              type: "string",
+              description: 'GQL query string. Examples: "FIND function WHERE name CONTAINS \\"auth\\"", "TRAVERSE CALLS FROM \\"handleLogin\\" DEPTH 3", "PATH FROM \\"createUser\\" TO \\"sendEmail\\"", "COUNT function GROUP BY cluster"'
+            },
+            limit: { type: "number", description: "Override LIMIT in the query (optional)" },
+            ..._tokenProp
+          },
+          required: ["gql"]
+        }
+      },
       // ── Raw query ─────────────────────────────────────────────────────────
       {
         name: "raw_query",
@@ -8711,7 +9940,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       const limit = a.limit ?? 20;
       const vdbPath = workspaceRoot ? getVectorDbPath(workspaceRoot) : void 0;
       const { results, searchMode } = await hybridSearch(graph, query, limit, { vectorDbPath: vdbPath });
-      return { content: [{ type: "text", text: JSON.stringify({ results, searchMode }, null, 2) }] };
+      return { content: [{ type: "text", text: JSON.stringify({ results, searchMode, suggested_next_tools: ["inspect", "query", "blast_radius"] }, null, 2) }] };
     }
     // ── inspect ────────────────────────────────────────────────────────────
     case "inspect": {
@@ -8950,7 +10179,7 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
       for (const { filePath: changedFile, changedLines } of changedFiles) {
         for (const node of graph.allNodes()) {
           if (!node.filePath) continue;
-          const normNode = node.filePath.replace(repoRoot + "/", "").replace(repoRoot + path29.sep, "");
+          const normNode = node.filePath.replace(repoRoot + "/", "").replace(repoRoot + path30.sep, "");
           const normChanged = changedFile.replace(/^a\/|^b\//, "");
           if (!normNode.endsWith(normChanged) && !normChanged.endsWith(normNode)) continue;
           if (node.startLine !== void 0 && node.endLine !== void 0) {
@@ -8999,16 +10228,51 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot) {
         }]
       };
     }
+    // ── query (GQL) ───────────────────────────────────────────────────────────
+    case "query": {
+      const gqlInput = a.gql;
+      if (!gqlInput) {
+        return { content: [{ type: "text", text: JSON.stringify({ 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 }) }],
+          isError: true
+        };
+      }
+      if (a.limit !== void 0 && ast.type === "FIND") {
+        ast.limit = a.limit;
+      }
+      const result = executeGQL2(ast, graph);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            nodes: result.nodes,
+            edges: result.edges,
+            groups: result.groups,
+            path: result.path,
+            executionTimeMs: result.executionTimeMs,
+            truncated: result.truncated,
+            totalCount: result.totalCount
+          }, null, 2)
+        }]
+      };
+    }
     // ── raw_query ──────────────────────────────────────────────────────────
     case "raw_query": {
       const q = a.cypher;
+      const deprecationWarning = "raw_query is deprecated, use query instead";
       const nameMatch = q?.match(/name\s*=\s*['"]([^'"]+)['"]/i);
       if (nameMatch) {
         const results = [];
         for (const node of graph.allNodes()) {
           if (node.name === nameMatch[1]) results.push(node);
         }
-        return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+        return { content: [{ type: "text", text: JSON.stringify({ deprecation: deprecationWarning, results }, null, 2) }] };
       }
       const kindMatch = q?.match(/:\s*(\w+)/);
       if (kindMatch) {
@@ -9017,9 +10281,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(results, null, 2) }] };
+        return { content: [{ type: "text", text: JSON.stringify({ deprecation: deprecationWarning, results }, null, 2) }] };
       }
-      return { content: [{ type: "text", text: "Query not recognized. Use name='X' or :kind syntax." }] };
+      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." }) }] };
     }
     // ── group_list ─────────────────────────────────────────────────────────
     case "group_list": {
@@ -9223,20 +10487,20 @@ function parseDiff(diffText) {
 // src/cli/main.ts
 init_metadata();
 async function writeSkillFiles(graph, workspaceRoot, projectName) {
-  const outputDir = path29.join(workspaceRoot, ".claude", "skills", "code-intel");
+  const outputDir = path30.join(workspaceRoot, ".claude", "skills", "code-intel");
   const areas = buildAreaMap(graph, workspaceRoot);
   if (areas.length === 0) return { skills: [], outputDir };
-  fs27.rmSync(outputDir, { recursive: true, force: true });
-  fs27.mkdirSync(outputDir, { recursive: true });
+  fs28.rmSync(outputDir, { recursive: true, force: true });
+  fs28.mkdirSync(outputDir, { recursive: true });
   const skills = [];
   const usedNames = /* @__PURE__ */ new Set();
   for (const area of areas) {
     const kebab = uniqueKebab(area.label, usedNames);
     usedNames.add(kebab);
     const content = renderSkill(area, projectName, kebab);
-    const dir = path29.join(outputDir, kebab);
-    fs27.mkdirSync(dir, { recursive: true });
-    fs27.writeFileSync(path29.join(dir, "SKILL.md"), content, "utf-8");
+    const dir = path30.join(outputDir, kebab);
+    fs28.mkdirSync(dir, { recursive: true });
+    fs28.writeFileSync(path30.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 };
@@ -9416,8 +10680,8 @@ var BLOCK_START = "<!-- code-intel:start -->";
 var BLOCK_END = "<!-- code-intel:end -->";
 function writeContextFiles(workspaceRoot, projectName, stats, skills) {
   const block = buildBlock(projectName, stats, skills);
-  upsertFile(path29.join(workspaceRoot, "AGENTS.md"), block, "AGENTS.md");
-  upsertFile(path29.join(workspaceRoot, "CLAUDE.md"), block, "CLAUDE.md");
+  upsertFile(path30.join(workspaceRoot, "AGENTS.md"), block, "AGENTS.md");
+  upsertFile(path30.join(workspaceRoot, "CLAUDE.md"), block, "CLAUDE.md");
 }
 function buildBlock(projectName, stats, skills) {
   const skillRows = skills.map(
@@ -9471,7 +10735,7 @@ ${skillTable}
 ${BLOCK_END}`;
 }
 function upsertFile(filePath, block, fileName) {
-  if (!fs27.existsSync(filePath)) {
+  if (!fs28.existsSync(filePath)) {
     const newContent = [
       `# ${fileName}`,
       "",
@@ -9482,17 +10746,17 @@ function upsertFile(filePath, block, fileName) {
       "<!-- Add your own custom notes below this line. They will never be overwritten by code-intel. -->",
       ""
     ].join("\n");
-    fs27.writeFileSync(filePath, newContent, "utf-8");
+    fs28.writeFileSync(filePath, newContent, "utf-8");
     return;
   }
-  const existing = fs27.readFileSync(filePath, "utf-8");
+  const existing = fs28.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";
-    fs27.writeFileSync(filePath, updated, "utf-8");
+    fs28.writeFileSync(filePath, updated, "utf-8");
     return;
   }
   const appended = [
@@ -9505,7 +10769,7 @@ function upsertFile(filePath, block, fileName) {
     block,
     ""
   ].join("\n");
-  fs27.writeFileSync(filePath, appended, "utf-8");
+  fs28.writeFileSync(filePath, appended, "utf-8");
 }
 function findLineMarker(content, marker, startFrom = 0) {
   let idx = content.indexOf(marker, startFrom);
@@ -9547,14 +10811,14 @@ function getChangedFilesSince(workspaceRoot, baseHash) {
 function filterChangedByMtime(allFilePaths, workspaceRoot, storedMtimes) {
   const changed = [];
   for (const absPath of allFilePaths) {
-    const rel = path29.relative(workspaceRoot, absPath);
+    const rel = path30.relative(workspaceRoot, absPath);
     const stored = storedMtimes[rel];
     if (stored === void 0) {
       changed.push(absPath);
       continue;
     }
     try {
-      const { mtimeMs } = fs27.statSync(absPath);
+      const { mtimeMs } = fs28.statSync(absPath);
       if (mtimeMs > stored) changed.push(absPath);
     } catch {
       changed.push(absPath);
@@ -9566,8 +10830,8 @@ function buildMtimeSnapshot(filePaths, workspaceRoot) {
   const snap = {};
   for (const absPath of filePaths) {
     try {
-      const { mtimeMs } = fs27.statSync(absPath);
-      snap[path29.relative(workspaceRoot, absPath)] = mtimeMs;
+      const { mtimeMs } = fs28.statSync(absPath);
+      snap[path30.relative(workspaceRoot, absPath)] = mtimeMs;
     } catch {
     }
   }
@@ -9578,8 +10842,8 @@ function decideIncremental(workspaceRoot, allFilePaths, prevCommitHash, storedMt
   if (prevCommitHash) {
     const changed = getChangedFilesSince(workspaceRoot, prevCommitHash);
     if (changed !== null) {
-      const scanSet = new Set(allFilePaths.map((p) => path29.relative(workspaceRoot, p)));
-      const changedInScan = changed.filter((rel) => scanSet.has(rel)).map((rel) => path29.join(workspaceRoot, rel));
+      const scanSet = new Set(allFilePaths.map((p) => path30.relative(workspaceRoot, p)));
+      const changedInScan = changed.filter((rel) => scanSet.has(rel)).map((rel) => path30.join(workspaceRoot, rel));
       if (total > 0 && changedInScan.length / total > 0.2) {
         return { incremental: false, fallbackReason: `changed files (${changedInScan.length}) > 20% of total (${total})` };
       }
@@ -9693,17 +10957,17 @@ var MigrationRunner = class {
   autoBackupBeforeMigration() {
     try {
       const dbFile = this.db.name;
-      if (!dbFile || !fs27.existsSync(dbFile)) return;
-      const backupDir = path29.join(os12.homedir(), ".code-intel", "backups", "pre-migration");
-      fs27.mkdirSync(backupDir, { recursive: true });
+      if (!dbFile || !fs28.existsSync(dbFile)) return;
+      const backupDir = path30.join(os12.homedir(), ".code-intel", "backups", "pre-migration");
+      fs28.mkdirSync(backupDir, { recursive: true });
       const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const baseName = path29.basename(dbFile, ".db");
-      const backupPath = path29.join(backupDir, `${baseName}-pre-migration-${ts}.db`);
+      const baseName = path30.basename(dbFile, ".db");
+      const backupPath = path30.join(backupDir, `${baseName}-pre-migration-${ts}.db`);
       try {
         this.db.pragma("wal_checkpoint(TRUNCATE)");
       } catch {
       }
-      fs27.copyFileSync(dbFile, backupPath);
+      fs28.copyFileSync(dbFile, backupPath);
     } catch {
     }
   }
@@ -9919,7 +11183,7 @@ program.name("code-intel").description("Code Intelligence Platform \u2014 Static
   Docs: https://github.com/vohongtho/code-intel-platform
 `);
 async function analyzeWorkspace(targetPath, options) {
-  const workspaceRoot = path29.resolve(targetPath);
+  const workspaceRoot = path30.resolve(targetPath);
   if (!options?.silent) console.log(`Analyzing: ${workspaceRoot}`);
   logger_default.info(`analyze started: ${workspaceRoot}`);
   if (options?.force) {
@@ -9940,14 +11204,14 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of wipeFiles) {
       try {
-        if (fs27.existsSync(f)) fs27.unlinkSync(f);
+        if (fs28.existsSync(f)) fs28.unlinkSync(f);
       } catch {
       }
     }
   }
   if (!options?.skipGit) {
-    const gitDir = path29.join(workspaceRoot, ".git");
-    if (!fs27.existsSync(gitDir)) {
+    const gitDir = path30.join(workspaceRoot, ".git");
+    if (!fs28.existsSync(gitDir)) {
       logger_default.warn(`${workspaceRoot} is not a Git repository`);
     }
   }
@@ -10058,17 +11322,17 @@ async function analyzeWorkspace(targetPath, options) {
   const result = await runPipeline(phases, context2);
   if (isIncremental && incrementalChangedFiles && incrementalChangedFiles.length > 0) {
     const dbPath = getDbPath(workspaceRoot);
-    if (fs27.existsSync(dbPath)) {
+    if (fs28.existsSync(dbPath)) {
       try {
         const db = new DbManager(dbPath);
         await db.init();
         for (const absPath of incrementalChangedFiles) {
-          const rel = path29.relative(workspaceRoot, absPath);
+          const rel = path30.relative(workspaceRoot, absPath);
           await removeNodesForFile(rel, db);
         }
         const { upsertNodes: upsertNodesBatch } = await Promise.resolve().then(() => (init_graph_loader(), graph_loader_exports));
         const changedRelPaths = new Set(
-          incrementalChangedFiles.map((f) => path29.relative(workspaceRoot, f))
+          incrementalChangedFiles.map((f) => path30.relative(workspaceRoot, f))
         );
         const nodesToUpsert = [...graph.allNodes()].filter(
           (n) => changedRelPaths.has(n.filePath)
@@ -10093,7 +11357,7 @@ async function analyzeWorkspace(targetPath, options) {
     mergedMtimes = newMtimes;
   }
   const currentCommitHash = getCurrentCommitHash(workspaceRoot) ?? void 0;
-  const repoName = path29.basename(workspaceRoot);
+  const repoName = path30.basename(workspaceRoot);
   const indexVersion = v4();
   saveMetadata(workspaceRoot, {
     indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10131,7 +11395,7 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of newStaleFiles) {
       try {
-        if (fs27.existsSync(f)) fs27.unlinkSync(f);
+        if (fs28.existsSync(f)) fs28.unlinkSync(f);
       } catch {
       }
     }
@@ -10148,21 +11412,21 @@ async function analyzeWorkspace(targetPath, options) {
     ];
     for (const f of staleFiles) {
       try {
-        if (fs27.existsSync(f)) fs27.unlinkSync(f);
+        if (fs28.existsSync(f)) fs28.unlinkSync(f);
       } catch {
       }
     }
     for (const f of newStaleFiles) {
       if (f === dbPathNew) continue;
-      if (fs27.existsSync(f)) {
+      if (fs28.existsSync(f)) {
         const dest = f.replace(dbPathNew, dbPath);
         try {
-          fs27.renameSync(f, dest);
+          fs28.renameSync(f, dest);
         } catch {
         }
       }
     }
-    fs27.renameSync(dbPathNew, dbPath);
+    fs28.renameSync(dbPathNew, dbPath);
     stopSpinner();
     logger_default.info(`DB persisted: ${nodeCount} nodes, ${edgeCount} edges`);
     if (!options?.silent) {
@@ -10183,7 +11447,7 @@ async function analyzeWorkspace(targetPath, options) {
       const staleVdb = [vdbPath, `${vdbPath}-shm`, `${vdbPath}-wal`];
       for (const f of staleVdb) {
         try {
-          if (fs27.existsSync(f)) fs27.unlinkSync(f);
+          if (fs28.existsSync(f)) fs28.unlinkSync(f);
         } catch {
         }
       }
@@ -10281,8 +11545,8 @@ program.command("setup").description("Configure MCP server for your editors (one
     const configFile = `${configDir}/claude_desktop_config.json`;
     try {
       let existing = {};
-      if (fs27.existsSync(configFile)) {
-        existing = JSON.parse(fs27.readFileSync(configFile, "utf-8"));
+      if (fs28.existsSync(configFile)) {
+        existing = JSON.parse(fs28.readFileSync(configFile, "utf-8"));
       }
       const merged = {
         ...existing,
@@ -10291,8 +11555,8 @@ program.command("setup").description("Configure MCP server for your editors (one
           ...mcpConfig.mcpServers
         }
       };
-      fs27.mkdirSync(configDir, { recursive: true });
-      fs27.writeFileSync(configFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      fs28.mkdirSync(configDir, { recursive: true });
+      fs28.writeFileSync(configFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
       console.log(`
   \u2705  Written to ${configFile}`);
     } catch (err) {
@@ -10340,8 +11604,14 @@ program.command("analyze").description("Index a repository and build the knowled
     summarize: opts.summarize,
     llmProvider: opts.llmProvider,
     llmModel: opts.llmModel,
-    llmBatchSize: opts.llmBatchSize ? parseInt(opts.llmBatchSize, 10) : void 0,
-    llmMaxNodes: opts.llmMaxNodes ? parseInt(opts.llmMaxNodes, 10) : void 0
+    llmBatchSize: (() => {
+      const v = parseInt(opts.llmBatchSize ?? "", 10);
+      return Number.isFinite(v) && v >= 1 ? v : void 0;
+    })(),
+    llmMaxNodes: (() => {
+      const v = parseInt(opts.llmMaxNodes ?? "", 10);
+      return Number.isFinite(v) && v >= 1 ? v : void 0;
+    })()
   });
   process.exit(0);
 });
@@ -10356,10 +11626,10 @@ program.command("mcp").description("Start MCP server over stdio \u2014 exposes a
     $ code-intel mcp
     $ code-intel mcp ./my-project
 `).action(async (targetPath) => {
-  const workspaceRoot = path29.resolve(targetPath);
-  const repoName = path29.basename(workspaceRoot);
+  const workspaceRoot = path30.resolve(targetPath);
+  const repoName = path30.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = fs27.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = fs28.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
@@ -10390,10 +11660,10 @@ program.command("serve").description("Start the local HTTP server + web UI for g
     $ code-intel serve --port 8080
     $ code-intel serve --force
 `).action(async (targetPath, options) => {
-  const workspaceRoot = path29.resolve(targetPath);
-  const repoName = path29.basename(workspaceRoot);
+  const workspaceRoot = path30.resolve(targetPath);
+  const repoName = path30.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = !options.force && fs27.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = !options.force && fs28.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const meta = loadMetadata(workspaceRoot);
     if (meta.parser === "regex" || meta.parser === void 0) {
@@ -10427,10 +11697,10 @@ program.command("watch").description("Start HTTP server + file watcher (auto-rei
 `).action(async (targetPath, options) => {
   const { FileWatcher: FileWatcher2 } = await Promise.resolve().then(() => (init_file_watcher(), file_watcher_exports));
   const { IncrementalIndexer: IncrementalIndexer2 } = await Promise.resolve().then(() => (init_incremental_indexer(), incremental_indexer_exports));
-  const workspaceRoot = path29.resolve(targetPath);
-  const repoName = path29.basename(workspaceRoot);
+  const workspaceRoot = path30.resolve(targetPath);
+  const repoName = path30.basename(workspaceRoot);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = !options.force && fs27.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = !options.force && fs28.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   let graph;
   if (existingIndex) {
     const meta = loadMetadata(workspaceRoot);
@@ -10465,7 +11735,7 @@ program.command("watch").description("Start HTTP server + file watcher (auto-rei
         type: "graph:updated",
         indexVersion: meta?.indexVersion ?? "unknown",
         stats: { nodes: graph.size.nodes, edges: graph.size.edges },
-        changedFiles: changedFiles.map((f) => path29.relative(workspaceRoot, f)),
+        changedFiles: changedFiles.map((f) => path30.relative(workspaceRoot, f)),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
@@ -10516,7 +11786,7 @@ program.command("status").description("Show index freshness and statistics for a
     $ code-intel status
     $ code-intel status ./my-project
 `).action((targetPath) => {
-  const workspaceRoot = path29.resolve(targetPath);
+  const workspaceRoot = path30.resolve(targetPath);
   const meta = loadMetadata(workspaceRoot);
   if (!meta) {
     console.log(`
@@ -10540,18 +11810,18 @@ function trashDirName(repoPath) {
   return `.code-intel-trash-${date}`;
 }
 function softDeleteCodeIntel(repoPath) {
-  const codeIntelDir = path29.join(repoPath, ".code-intel");
-  if (!fs27.existsSync(codeIntelDir)) return;
+  const codeIntelDir = path30.join(repoPath, ".code-intel");
+  if (!fs28.existsSync(codeIntelDir)) return;
   const trashName = trashDirName();
-  const trashDir = path29.join(repoPath, trashName);
+  const trashDir = path30.join(repoPath, trashName);
   let dest = trashDir;
   let counter = 1;
-  while (fs27.existsSync(dest)) {
+  while (fs28.existsSync(dest)) {
     dest = `${trashDir}-${counter++}`;
   }
-  fs27.renameSync(codeIntelDir, dest);
-  fs27.writeFileSync(
-    path29.join(dest, "TRASH_META.json"),
+  fs28.renameSync(codeIntelDir, dest);
+  fs28.writeFileSync(
+    path30.join(dest, "TRASH_META.json"),
     JSON.stringify({ deletedAt: (/* @__PURE__ */ new Date()).toISOString(), repoPath, permanent: false }, null, 2)
   );
   console.log(`  \u2713  Moved to trash: ${dest}`);
@@ -10560,15 +11830,15 @@ function softDeleteCodeIntel(repoPath) {
 function purgeStaleTrashes(repoPath) {
   const cutoff = Date.now() - TRASH_TTL_DAYS * 24 * 60 * 60 * 1e3;
   try {
-    for (const entry of fs27.readdirSync(repoPath)) {
+    for (const entry of fs28.readdirSync(repoPath)) {
       if (!entry.startsWith(".code-intel-trash-")) continue;
-      const fullPath = path29.join(repoPath, entry);
-      const metaPath = path29.join(fullPath, "TRASH_META.json");
-      if (fs27.existsSync(metaPath)) {
+      const fullPath = path30.join(repoPath, entry);
+      const metaPath = path30.join(fullPath, "TRASH_META.json");
+      if (fs28.existsSync(metaPath)) {
         try {
-          const meta = JSON.parse(fs27.readFileSync(metaPath, "utf-8"));
+          const meta = JSON.parse(fs28.readFileSync(metaPath, "utf-8"));
           if (new Date(meta.deletedAt).getTime() < cutoff) {
-            fs27.rmSync(fullPath, { recursive: true, force: true });
+            fs28.rmSync(fullPath, { recursive: true, force: true });
             console.log(`  \u2713  Auto-purged stale trash: ${fullPath}`);
           }
         } catch {
@@ -10595,18 +11865,18 @@ program.command("clean").description("Soft-delete the knowledge graph index for
   if (opts.listTrash) {
     const repos = loadRegistry();
     const roots = repos.map((r) => r.path);
-    if (roots.length === 0) roots.push(path29.resolve("."));
+    if (roots.length === 0) roots.push(path30.resolve("."));
     let found = 0;
     for (const root of roots) {
       try {
-        for (const entry of fs27.readdirSync(root)) {
+        for (const entry of fs28.readdirSync(root)) {
           if (!entry.startsWith(".code-intel-trash-")) continue;
-          const fullPath = path29.join(root, entry);
-          const metaPath = path29.join(fullPath, "TRASH_META.json");
+          const fullPath = path30.join(root, entry);
+          const metaPath = path30.join(fullPath, "TRASH_META.json");
           let deletedAt = "unknown";
-          if (fs27.existsSync(metaPath)) {
+          if (fs28.existsSync(metaPath)) {
             try {
-              deletedAt = JSON.parse(fs27.readFileSync(metaPath, "utf-8")).deletedAt;
+              deletedAt = JSON.parse(fs28.readFileSync(metaPath, "utf-8")).deletedAt;
             } catch {
             }
           }
@@ -10634,9 +11904,9 @@ program.command("clean").description("Soft-delete the knowledge graph index for
     }
     for (const r of repos) {
       if (opts.purge) {
-        const codeIntelDir = path29.join(r.path, ".code-intel");
-        if (fs27.existsSync(codeIntelDir)) {
-          fs27.rmSync(codeIntelDir, { recursive: true, force: true });
+        const codeIntelDir = path30.join(r.path, ".code-intel");
+        if (fs28.existsSync(codeIntelDir)) {
+          fs28.rmSync(codeIntelDir, { recursive: true, force: true });
           console.log(`  \u2713  Hard-deleted ${codeIntelDir}`);
         }
       } else {
@@ -10650,11 +11920,11 @@ program.command("clean").description("Soft-delete the knowledge graph index for
 `);
     return;
   }
-  const workspaceRoot = path29.resolve(targetPath);
+  const workspaceRoot = path30.resolve(targetPath);
   if (opts.purge) {
-    const codeIntelDir = path29.join(workspaceRoot, ".code-intel");
-    if (fs27.existsSync(codeIntelDir)) {
-      fs27.rmSync(codeIntelDir, { recursive: true, force: true });
+    const codeIntelDir = path30.join(workspaceRoot, ".code-intel");
+    if (fs28.existsSync(codeIntelDir)) {
+      fs28.rmSync(codeIntelDir, { recursive: true, force: true });
       console.log(`
   \u2713  Hard-deleted ${codeIntelDir}`);
     }
@@ -10666,16 +11936,16 @@ program.command("clean").description("Soft-delete the knowledge graph index for
   console.log("  Index cleaned.\n");
 });
 async function loadOrAnalyzeWorkspace(targetPath) {
-  const workspaceRoot = path29.resolve(targetPath);
+  const workspaceRoot = path30.resolve(targetPath);
   const dbPath = getDbPath(workspaceRoot);
-  const existingIndex = fs27.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
+  const existingIndex = fs28.existsSync(dbPath) && loadMetadata(workspaceRoot) !== null;
   if (existingIndex) {
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
     await db.init();
     await loadGraphFromDB(graph, db);
     db.close();
-    return { graph, workspaceRoot, repoName: path29.basename(workspaceRoot) };
+    return { graph, workspaceRoot, repoName: path30.basename(workspaceRoot) };
   }
   return analyzeWorkspace(targetPath, { silent: true });
 }
@@ -11103,9 +12373,9 @@ groupCmd.command("status <name>").description("Check index freshness and sync st
       console.log(`  \u2717  ${m.groupPath.padEnd(35)} [${m.registryName}]  \u2014 NOT IN REGISTRY`);
       continue;
     }
-    const metaPath = path29.join(regEntry.path, ".code-intel", "meta.json");
+    const metaPath = path30.join(regEntry.path, ".code-intel", "meta.json");
     try {
-      const meta = JSON.parse(fs27.readFileSync(metaPath, "utf-8"));
+      const meta = JSON.parse(fs28.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)" : "";
@@ -11322,7 +12592,7 @@ backupCmd.command("create [path]").description("Create an encrypted backup of th
     $ code-intel backup create
     $ code-intel backup create ./my-project
 `).action((targetPath = ".") => {
-  const repoPath = path29.resolve(targetPath);
+  const repoPath = path30.resolve(targetPath);
   const svc = new BackupService();
   try {
     const entry = svc.createBackup(repoPath);
@@ -11351,7 +12621,7 @@ backupCmd.command("list").description("List all available backups").action(() =>
   Backups (${entries.length}):
 `);
   for (const e of entries) {
-    const exists = fs27.existsSync(e.path);
+    const exists = fs28.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}`);
   }
@@ -11364,7 +12634,7 @@ backupCmd.command("restore <id>").description("Restore a backup by ID").option("
 `).action((id, opts) => {
   const svc = new BackupService();
   try {
-    const targetPath = opts.target ? path29.resolve(opts.target) : void 0;
+    const targetPath = opts.target ? path30.resolve(opts.target) : void 0;
     svc.restoreBackup(id, targetPath);
     console.log(`
   \u2705  Backup "${id}" restored successfully.
@@ -11383,8 +12653,8 @@ program.command("migrate").description("Manage database schema migrations").opti
     $ code-intel migrate
     $ code-intel migrate --rollback
 `).action((opts) => {
-  const dbPath = opts.db ?? path29.join(os12.homedir(), ".code-intel", "users.db");
-  if (!fs27.existsSync(dbPath)) {
+  const dbPath = opts.db ?? path30.join(os12.homedir(), ".code-intel", "users.db");
+  if (!fs28.existsSync(dbPath)) {
     console.error(`
   \u2717  Database not found: ${dbPath}
   Run \`code-intel serve\` or \`code-intel user create\` first.
@@ -11499,15 +12769,15 @@ authCmd.command("login").description("Authenticate via OIDC device flow \u2014 o
   }
   try {
     const tokens = await pollDeviceFlow3(config, deviceResponse);
-    const tokenPath = path29.join(os12.homedir(), ".code-intel", "oidc-token.json");
+    const tokenPath = path30.join(os12.homedir(), ".code-intel", "oidc-token.json");
     const tokenData = {
       accessToken: tokens.accessToken,
       refreshToken: tokens.refreshToken,
       server: serverUrl,
       storedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs27.mkdirSync(path29.dirname(tokenPath), { recursive: true });
-    fs27.writeFileSync(tokenPath, JSON.stringify(tokenData, null, 2), { mode: 384 });
+    fs28.mkdirSync(path30.dirname(tokenPath), { recursive: true });
+    fs28.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.
@@ -11520,13 +12790,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 = path29.join(os12.homedir(), ".code-intel", "oidc-token.json");
-  if (!fs27.existsSync(tokenPath)) {
+  const tokenPath = path30.join(os12.homedir(), ".code-intel", "oidc-token.json");
+  if (!fs28.existsSync(tokenPath)) {
     console.log("\n  Not authenticated via OIDC. Run: code-intel auth login\n");
     return;
   }
   try {
-    const data = JSON.parse(fs27.readFileSync(tokenPath, "utf-8"));
+    const data = JSON.parse(fs28.readFileSync(tokenPath, "utf-8"));
     console.log(`
   \u2705  OIDC token stored`);
     console.log(`  Server : ${data.server ?? "unknown"}`);
@@ -11538,9 +12808,9 @@ authCmd.command("status").description("Show the current OIDC authentication stat
   }
 });
 authCmd.command("logout").description("Remove locally stored OIDC token").action(() => {
-  const tokenPath = path29.join(os12.homedir(), ".code-intel", "oidc-token.json");
-  if (fs27.existsSync(tokenPath)) {
-    fs27.unlinkSync(tokenPath);
+  const tokenPath = path30.join(os12.homedir(), ".code-intel", "oidc-token.json");
+  if (fs28.existsSync(tokenPath)) {
+    fs28.unlinkSync(tokenPath);
     console.log("\n  \u2705  OIDC token removed. You are now logged out.\n");
   } else {
     console.log("\n  No stored token found.\n");
@@ -11664,8 +12934,8 @@ program.command("config-validate <file>").description("Validate a JSON config fi
     $ code-intel config-validate ./config.json
     $ code-intel config-validate ~/.code-intel/config.json
 `).action((file) => {
-  const filePath = path29.resolve(file);
-  if (!fs27.existsSync(filePath)) {
+  const filePath = path30.resolve(file);
+  if (!fs28.existsSync(filePath)) {
     console.error(`
   \u2717  File not found: ${filePath}
 `);
@@ -11673,7 +12943,7 @@ program.command("config-validate <file>").description("Validate a JSON config fi
   }
   let cfg;
   try {
-    cfg = JSON.parse(fs27.readFileSync(filePath, "utf-8"));
+    cfg = JSON.parse(fs28.readFileSync(filePath, "utf-8"));
   } catch (err) {
     console.error(`
   \u2717  Could not parse JSON: ${err instanceof Error ? err.message : err}
@@ -11694,7 +12964,7 @@ ${err instanceof Error ? err.message : err}
 });
 (function ensurePermissions() {
   try {
-    const dir = path29.join(os12.homedir(), ".code-intel");
+    const dir = path30.join(os12.homedir(), ".code-intel");
     secureMkdir(dir);
     tightenDbFiles(dir);
   } catch {
@@ -11711,10 +12981,10 @@ program.command("health").description("Run code health checks: dead code, circul
     $ code-intel health --json
     $ code-intel health --threshold 80
 `).action(async (targetPath, opts) => {
-  const workspaceRoot = path29.resolve(targetPath);
+  const workspaceRoot = path30.resolve(targetPath);
   const dbPath = getDbPath(workspaceRoot);
   const meta = loadMetadata(workspaceRoot);
-  if (!meta || !fs27.existsSync(dbPath)) {
+  if (!meta || !fs28.existsSync(dbPath)) {
     console.error(`
   \u2717  ${workspaceRoot} is not indexed.`);
     console.error("     Run `code-intel analyze` first to build the index.\n");
@@ -11778,6 +13048,207 @@ program.command("health").description("Run code health checks: dead code, circul
     }
   }
 });
+program.command("query").description("Execute a GQL (Graph Query Language) query against the knowledge graph").argument("[gql]", `GQL query string (e.g. "FIND function WHERE name CONTAINS 'auth'")`).option("-f, --file <path>", "Read GQL query from a file").option("--format <format>", "Output format: table|json|csv (default: table)", "table").option("-l, --limit <n>", "Override LIMIT in the query").option("-p, --path <path>", "Path to the repository (default: current directory)", ".").option("--save <name>", "Save the GQL query under a name").option("--run <name>", "Run a saved query by name").option("--list", "List all saved queries").option("--delete <name>", "Delete a saved query by name").addHelpText("after", `
+  Execute GQL queries against the knowledge graph.
+
+  Syntax:
+    FIND function WHERE name CONTAINS "auth"
+    FIND * WHERE kind IN [function, method] LIMIT 50
+    TRAVERSE CALLS FROM "handleLogin" DEPTH 3
+    PATH FROM "createUser" TO "sendEmail"
+    COUNT function GROUP BY cluster
+
+  Examples:
+    $ code-intel query "FIND function WHERE name CONTAINS 'auth'"
+    $ code-intel query --file ./my.gql
+    $ code-intel query "FIND class" --format json
+    $ code-intel query "FIND class" --format csv
+    $ code-intel query "FIND class" --limit 20
+    $ code-intel query --save auth-search "FIND function WHERE name CONTAINS 'auth'"
+    $ code-intel query --run auth-search
+    $ code-intel query --list
+    $ code-intel query --delete auth-search
+`).action(async (gqlArg, opts) => {
+  const workspaceRoot = path30.resolve(opts.path);
+  const { saveQuery: saveQuery2, loadQuery: loadQuery2, listQueries: listQueries2, deleteQuery: deleteQuery2 } = await Promise.resolve().then(() => (init_saved_queries(), saved_queries_exports));
+  if (opts.list) {
+    const queries = listQueries2(workspaceRoot);
+    if (queries.length === 0) {
+      console.log("\n  No saved queries found.");
+      console.log(`  Save one with: code-intel query --save <name> "<gql>"
+`);
+      return;
+    }
+    console.log(`
+  Saved queries (${queries.length}):
+`);
+    for (const q of queries) {
+      console.log(`  \u25C6  ${q.name.padEnd(25)} ${q.content.slice(0, 60)}${q.content.length > 60 ? "\u2026" : ""}`);
+    }
+    console.log("");
+    return;
+  }
+  if (opts.delete) {
+    const { deleteQuery: dq } = await Promise.resolve().then(() => (init_saved_queries(), saved_queries_exports));
+    const deleted = dq(workspaceRoot, opts.delete);
+    if (!deleted) {
+      console.error(`
+  \u2717  Saved query "${opts.delete}" not found.
+`);
+      process.exit(1);
+    }
+    console.log(`
+  \u2705  Deleted saved query "${opts.delete}"
+`);
+    return;
+  }
+  if (opts.save) {
+    const gqlContent = gqlArg;
+    if (!gqlContent) {
+      console.error("\n  \u2717  Provide a GQL query string to save.");
+      console.error('     Example: code-intel query --save my-query "FIND function"\n');
+      process.exit(1);
+    }
+    saveQuery2(workspaceRoot, opts.save, gqlContent);
+    console.log(`
+  \u2705  Saved query "${opts.save}"`);
+    console.log(`     Run with: code-intel query --run ${opts.save}
+`);
+    return;
+  }
+  let gqlInput;
+  if (opts.run) {
+    const content = loadQuery2(workspaceRoot, opts.run);
+    if (!content) {
+      console.error(`
+  \u2717  Saved query "${opts.run}" not found.`);
+      console.error(`     List saved queries with: code-intel query --list
+`);
+      process.exit(1);
+    }
+    gqlInput = content;
+  } else if (opts.file) {
+    const filePath = path30.resolve(opts.file);
+    if (!fs28.existsSync(filePath)) {
+      console.error(`
+  \u2717  File not found: ${filePath}
+`);
+      process.exit(1);
+    }
+    gqlInput = fs28.readFileSync(filePath, "utf-8");
+  } else if (gqlArg) {
+    gqlInput = gqlArg;
+  } else {
+    console.error("\n  \u2717  Provide a GQL query string, --file <path>, or --run <name>.\n");
+    program.help();
+    process.exit(1);
+  }
+  const { parseGQL: parseGQL2, isGQLParseError: isGQLParseError2 } = await Promise.resolve().then(() => (init_gql_parser(), gql_parser_exports));
+  let ast = parseGQL2(gqlInput);
+  if (opts.limit && !isGQLParseError2(ast)) {
+    const limitN = parseInt(opts.limit, 10);
+    if (!isNaN(limitN) && ast.type === "FIND") {
+      ast.limit = limitN;
+    }
+  }
+  if (isGQLParseError2(ast)) {
+    console.error(`
+  \u2717  Parse error: ${ast.message}`);
+    if (ast.pos !== void 0) console.error(`     Position: ${ast.pos}`);
+    console.error("");
+    process.exit(1);
+  }
+  const { graph } = await loadOrAnalyzeWorkspace(opts.path);
+  const { executeGQL: executeGQL2 } = await Promise.resolve().then(() => (init_gql_executor(), gql_executor_exports));
+  const result = executeGQL2(ast, graph);
+  const format = opts.format.toLowerCase();
+  if (result.totalCount === 0 && !result.groups?.length && result.path === null) {
+    console.log(`
+  No results found.
+`);
+    return;
+  }
+  if (result.path !== null && result.path !== void 0) {
+    if (result.path.length === 0) {
+      console.log("\n  No path found.\n");
+      return;
+    }
+    if (format === "json") {
+      console.log(JSON.stringify({ path: result.path, executionTimeMs: result.executionTimeMs }, null, 2));
+    } else if (format === "csv") {
+      console.log("kind,name,filePath");
+      for (const n of result.path) {
+        console.log(`${n.kind},${JSON.stringify(n.name)},${JSON.stringify(n.filePath)}`);
+      }
+    } else {
+      console.log(`
+  Path (${result.path.length} nodes):
+`);
+      for (let i = 0; i < result.path.length; i++) {
+        const n = result.path[i];
+        const arrow = i < result.path.length - 1 ? " \u2192" : "";
+        console.log(`  ${n.kind.padEnd(14)} ${n.name.padEnd(32)} ${n.filePath}${arrow}`);
+      }
+      console.log(`
+  Execution time: ${result.executionTimeMs}ms
+`);
+    }
+    return;
+  }
+  if (result.groups && !result.nodes?.length) {
+    if (format === "json") {
+      console.log(JSON.stringify({ groups: result.groups, totalCount: result.totalCount, executionTimeMs: result.executionTimeMs }, null, 2));
+    } else if (format === "csv") {
+      console.log("key,count");
+      for (const g of result.groups) {
+        console.log(`${JSON.stringify(g.key)},${g.count}`);
+      }
+    } else {
+      console.log(`
+  Count results (total: ${result.totalCount}):
+`);
+      for (const g of result.groups) {
+        console.log(`  ${g.key.padEnd(30)} ${String(g.count).padStart(6)}`);
+      }
+      console.log(`
+  Execution time: ${result.executionTimeMs}ms${result.truncated ? "  \u26A0  (truncated)" : ""}
+`);
+    }
+    return;
+  }
+  const nodes = result.nodes ?? [];
+  if (nodes.length === 0) {
+    console.log("\n  No results found.\n");
+    return;
+  }
+  if (format === "json") {
+    console.log(JSON.stringify({
+      nodes,
+      edges: result.edges,
+      totalCount: result.totalCount,
+      executionTimeMs: result.executionTimeMs,
+      truncated: result.truncated
+    }, null, 2));
+  } else if (format === "csv") {
+    console.log("kind,name,filePath,exported");
+    for (const n of nodes) {
+      console.log(`${n.kind},${JSON.stringify(n.name)},${JSON.stringify(n.filePath)},${n.exported ?? ""}`);
+    }
+  } else {
+    const showing = nodes.length;
+    const total = result.totalCount;
+    const header = result.truncated ? `  (truncated)` : "";
+    console.log(`
+  ${showing} result(s)${total > showing ? ` (of ${total})` : ""}${header}:
+`);
+    for (const n of nodes) {
+      console.log(`  ${n.kind.padEnd(14)} ${n.name.padEnd(32)} ${n.filePath}`);
+    }
+    console.log(`
+  Execution time: ${result.executionTimeMs}ms
+`);
+  }
+});
 program.parse();
 //# sourceMappingURL=main.js.map
 //# sourceMappingURL=main.js.map