enigma-cli 1.43.0 → 1.45.0

package/dist/codegraph-hook.js

@@ -0,0 +1,2483 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/util.ts
+import { homedir } from "os";
+import { createHash } from "crypto";
+import { dirname as dirname2, join, relative, resolve, sep } from "path";
+import { existsSync, statSync, readFileSync as readFileSync2, readdirSync } from "fs";
+function isDir(pth) {
+  try {
+    return statSync(pth).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function enigmaHome() {
+  return process.env.ENIGMA_CONFIG_HOME || homedir();
+}
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync2(file, "utf8").replace(/^\uFEFF/, ""));
+  } catch {
+    return null;
+  }
+}
+var init_util = __esm({
+  "src/util.ts"() {
+    "use strict";
+  }
+});
+
+// src/secret-box.ts
+import { join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { randomBytes, createCipheriv, createDecipheriv } from "crypto";
+function keyPath() {
+  return join2(enigmaHome(), ".enigma.key");
+}
+function loadKey() {
+  const path = keyPath();
+  if (existsSync2(path)) {
+    const hex = readFileSync3(path, "utf8").trim();
+    const key2 = Buffer.from(hex, "hex");
+    if (key2.length === KEY_BYTES) return key2;
+  }
+  const key = randomBytes(KEY_BYTES);
+  writeFileSync2(path, key.toString("hex"), { mode: 384 });
+  return key;
+}
+function isEncryptedSecret(value) {
+  return typeof value === "string" && value.startsWith(PREFIX);
+}
+function encryptSecret(plain) {
+  if (!plain) return "";
+  if (isEncryptedSecret(plain)) return plain;
+  const iv = randomBytes(IV_BYTES);
+  const cipher = createCipheriv("aes-256-gcm", loadKey(), iv);
+  const ct = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return `${PREFIX}${iv.toString("base64")}:${tag.toString("base64")}:${ct.toString("base64")}`;
+}
+function decryptSecret(stored) {
+  if (!stored) return "";
+  if (!isEncryptedSecret(stored)) return stored;
+  try {
+    const [ivB64, tagB64, ctB64] = stored.slice(PREFIX.length).split(":");
+    if (!ivB64 || !tagB64 || !ctB64) return "";
+    const decipher = createDecipheriv("aes-256-gcm", loadKey(), Buffer.from(ivB64, "base64"));
+    decipher.setAuthTag(Buffer.from(tagB64, "base64"));
+    return Buffer.concat([decipher.update(Buffer.from(ctB64, "base64")), decipher.final()]).toString("utf8");
+  } catch {
+    return "";
+  }
+}
+var PREFIX, KEY_BYTES, IV_BYTES;
+var init_secret_box = __esm({
+  "src/secret-box.ts"() {
+    "use strict";
+    init_util();
+    PREFIX = "enc:v1:";
+    KEY_BYTES = 32;
+    IV_BYTES = 12;
+  }
+});
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  CONFIG_CHOICES: () => CONFIG_CHOICES,
+  CONFIG_DEFAULTS: () => CONFIG_DEFAULTS,
+  CONFIG_FILE: () => CONFIG_FILE,
+  DASHBOARD_BINDS: () => DASHBOARD_BINDS,
+  DASHBOARD_MODES: () => DASHBOARD_MODES,
+  GATE_SEVERITIES: () => GATE_SEVERITIES,
+  LOGO_COLOR_POLICIES: () => LOGO_COLOR_POLICIES,
+  MINIMAL_CODE_LEVELS: () => MINIMAL_CODE_LEVELS,
+  OUTPUT_STYLES: () => OUTPUT_STYLES,
+  PROMPT_SECRET_MODES: () => PROMPT_SECRET_MODES,
+  RECALL_PROVIDERS: () => RECALL_PROVIDERS,
+  SKILL_UPDATE_POLICIES: () => SKILL_UPDATE_POLICIES,
+  getRecallApiKey: () => getRecallApiKey,
+  readConfig: () => readConfig,
+  readConfigAt: () => readConfigAt,
+  readEnigmaList: () => readEnigmaList,
+  readGlobalConfig: () => readGlobalConfig,
+  readProjectConfig: () => readProjectConfig,
+  setBypassDisabled: () => setBypassDisabled,
+  setEnigmaToggle: () => setEnigmaToggle,
+  setEnigmaValue: () => setEnigmaValue,
+  setEnigmaValueAt: () => setEnigmaValueAt,
+  setPackAccount: () => setPackAccount,
+  setRecallApiKey: () => setRecallApiKey,
+  setSkillAgentOff: () => setSkillAgentOff,
+  setSkillDiscarded: () => setSkillDiscarded,
+  setToolPath: () => setToolPath,
+  unsetEnigmaValueAt: () => unsetEnigmaValueAt,
+  updateEnigmaList: () => updateEnigmaList
+});
+import { join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+function configPath(scope) {
+  if (scope === "local") return join3(process.cwd(), CONFIG_FILE);
+  return join3(enigmaHome(), CONFIG_FILE);
+}
+function mergeConfigFiles(paths) {
+  const sources = [];
+  let config = { ...CONFIG_DEFAULTS };
+  for (const path of paths) {
+    const raw = existsSync3(path) ? readJson(path) : null;
+    if (raw) {
+      config = { ...config, ...raw };
+      sources.push(path);
+    }
+  }
+  return { config, sources };
+}
+function readConfig() {
+  return mergeConfigFiles([configPath("global"), configPath("local")]);
+}
+function readGlobalConfig() {
+  return mergeConfigFiles([configPath("global")]).config;
+}
+function readConfigAt(projectDir2) {
+  return mergeConfigFiles([configPath("global"), join3(projectDir2, CONFIG_FILE)]).config;
+}
+function readProjectConfig(projectDir2) {
+  const path = join3(projectDir2, CONFIG_FILE);
+  return (existsSync3(path) ? readJson(path) : null) || {};
+}
+function writeConfigFile(path, next) {
+  const dir = join3(path, "..");
+  if (!isDir(dir)) mkdirSync2(dir, { recursive: true });
+  writeFileSync3(path, `${JSON.stringify(next, null, 2)}
+`);
+  return path;
+}
+function setEnigmaValue(key, value, scope) {
+  const path = configPath(scope);
+  return writeConfigFile(path, { ...readJson(path) || {}, [key]: value });
+}
+function setEnigmaValueAt(projectDir2, key, value) {
+  const path = join3(projectDir2, CONFIG_FILE);
+  return writeConfigFile(path, { ...readJson(path) || {}, [key]: value });
+}
+function unsetEnigmaValueAt(projectDir2, key) {
+  const path = join3(projectDir2, CONFIG_FILE);
+  const current = readJson(path) || {};
+  delete current[key];
+  return writeConfigFile(path, current);
+}
+function setEnigmaToggle(key, value, scope) {
+  return setEnigmaValue(key, value, scope);
+}
+function getRecallApiKey(config) {
+  return decryptSecret(config.recallApiKey || "");
+}
+function setRecallApiKey(value, scope) {
+  return setEnigmaValue("recallApiKey", value ? encryptSecret(value) : "", scope);
+}
+function setToolPath(tool, binPath, scope = "global") {
+  const path = configPath(scope);
+  const current = readJson(path) || {};
+  const existing = current.toolPaths && typeof current.toolPaths === "object" ? current.toolPaths : {};
+  const next = { ...current, toolPaths: { ...existing, [tool]: binPath } };
+  const dir = join3(path, "..");
+  if (!isDir(dir)) mkdirSync2(dir, { recursive: true });
+  writeFileSync3(path, JSON.stringify(next, null, 2) + "\n");
+  return path;
+}
+function setPackAccount(key, account, scope = "global") {
+  const path = configPath(scope);
+  const current = readJson(path) || {};
+  const existing = current.packAccounts && typeof current.packAccounts === "object" ? { ...current.packAccounts } : {};
+  if (account === null) delete existing[key];
+  else existing[key] = account;
+  const dir = join3(path, "..");
+  if (!isDir(dir)) mkdirSync2(dir, { recursive: true });
+  writeFileSync3(path, `${JSON.stringify({ ...current, packAccounts: existing }, null, 2)}
+`);
+  return path;
+}
+function updateEnigmaList(key, name, include, scope) {
+  const set = new Set((readJson(configPath(scope)) || {})[key] || []);
+  if (include) set.add(name);
+  else set.delete(name);
+  return setEnigmaValue(key, [...set], scope);
+}
+function readEnigmaList(key, scope) {
+  return (readJson(configPath(scope)) || {})[key] || [];
+}
+function updateGlobalList(key, name, include) {
+  updateEnigmaList(key, name, include, "global");
+}
+function setBypassDisabled(name, disabled) {
+  updateGlobalList("bypassDisabled", name, disabled);
+}
+function setSkillDiscarded(name, discarded) {
+  updateGlobalList("discardedSkills", name, discarded);
+}
+function setSkillAgentOff(skill, agent, off) {
+  const path = configPath("global");
+  const current = readJson(path) || {};
+  const existing = current.skillAgentsOff && typeof current.skillAgentsOff === "object" ? current.skillAgentsOff : {};
+  const list = new Set(Array.isArray(existing[skill]) ? existing[skill] : []);
+  if (off) list.add(agent);
+  else list.delete(agent);
+  const nextMap = { ...existing };
+  if (list.size) nextMap[skill] = [...list];
+  else delete nextMap[skill];
+  const next = { ...current, skillAgentsOff: nextMap };
+  const dir = join3(path, "..");
+  if (!isDir(dir)) mkdirSync2(dir, { recursive: true });
+  writeFileSync3(path, JSON.stringify(next, null, 2) + "\n");
+}
+var CONFIG_FILE, OUTPUT_STYLES, MINIMAL_CODE_LEVELS, DASHBOARD_MODES, DASHBOARD_BINDS, PROMPT_SECRET_MODES, SKILL_UPDATE_POLICIES, LOGO_COLOR_POLICIES, RECALL_PROVIDERS, GATE_SEVERITIES, CONFIG_DEFAULTS, CONFIG_CHOICES;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_util();
+    init_secret_box();
+    CONFIG_FILE = ".enigma.json";
+    OUTPUT_STYLES = ["off", "lite", "full", "ultra"];
+    MINIMAL_CODE_LEVELS = ["off", "lite", "full", "ultra"];
+    DASHBOARD_MODES = ["off", "on-demand", "always"];
+    DASHBOARD_BINDS = ["loopback", "lan", "custom"];
+    PROMPT_SECRET_MODES = ["redact", "reject"];
+    SKILL_UPDATE_POLICIES = ["overwrite", "keep"];
+    LOGO_COLOR_POLICIES = ["ask", "adapt-background", "adapt-logo"];
+    RECALL_PROVIDERS = ["claude-local", "anthropic", "openai"];
+    GATE_SEVERITIES = ["error", "warning", "info"];
+    CONFIG_DEFAULTS = {
+      commitEmoji: true,
+      updateNotifier: true,
+      fullscreen: true,
+      parallelSubagents: false,
+      outputStyle: "off",
+      minimalCode: "full",
+      logoColorPolicy: "ask",
+      autoSync: true,
+      statusline: true,
+      statuslineRefresh: 10,
+      claudeTrust: true,
+      kimiTrust: true,
+      remoteSkills: true,
+      skillUpdatePolicy: "overwrite",
+      permissionBypass: true,
+      autoLint: false,
+      guardrails: true,
+      trim: true,
+      verify: true,
+      verifyCommand: "",
+      compress: false,
+      codeGraph: true,
+      gate: true,
+      dashboard: "off",
+      tokenPrice: 0,
+      tokenSpeed: 0,
+      usageStats: false,
+      recall: false,
+      recallLlm: true,
+      recallProvider: "claude-local",
+      recallModel: "",
+      recallApiBase: "",
+      recallApiKey: "",
+      proxy: false,
+      usageApi: false,
+      promptSecretGuard: false,
+      promptSecretMode: "redact",
+      resourceCap: 60,
+      lowMemoryCap: 80,
+      planSessionLimit: 0,
+      planWeeklyLimit: 0,
+      planWeeklySonnetLimit: 0,
+      planWeeklyOpusLimit: 0,
+      planWeeklyReset: "mon 00:00",
+      dashboardLive: true,
+      dashboardPort: 0,
+      dashboardBind: "loopback",
+      dashboardBindAddress: "",
+      apiPort: 8e3,
+      apiAccount: "",
+      apiProfile: "",
+      apiPack: "",
+      toolPaths: {},
+      bypassDisabled: [],
+      discardedSkills: [],
+      skillAgentsOff: {},
+      packs: [],
+      packAccounts: {},
+      gateProtectedBranches: [],
+      gateSeverity: "warning",
+      gateTidyBranches: true,
+      ciWatch: true
+    };
+    CONFIG_CHOICES = {
+      outputStyle: OUTPUT_STYLES,
+      minimalCode: MINIMAL_CODE_LEVELS,
+      dashboard: DASHBOARD_MODES,
+      dashboardBind: DASHBOARD_BINDS,
+      promptSecretMode: PROMPT_SECRET_MODES,
+      skillUpdatePolicy: SKILL_UPDATE_POLICIES,
+      logoColorPolicy: LOGO_COLOR_POLICIES,
+      recallProvider: RECALL_PROVIDERS,
+      gateSeverity: GATE_SEVERITIES
+    };
+  }
+});
+
+// src/codegraph-types.ts
+var WALK_RELATIONS;
+var init_codegraph_types = __esm({
+  "src/codegraph-types.ts"() {
+    "use strict";
+    WALK_RELATIONS = /* @__PURE__ */ new Set(["imports", "calls", "references", "extends", "implements"]);
+  }
+});
+
+// src/codegraph-rank.ts
+function tokenize(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 1 && !STOP.has(t));
+}
+function counts(tokens) {
+  const m = /* @__PURE__ */ new Map();
+  for (const t of tokens) m.set(t, (m.get(t) ?? 0) + 1);
+  return m;
+}
+function computeIdf(bags) {
+  const df = /* @__PURE__ */ new Map();
+  for (const bag of bags) for (const t of bag) df.set(t, (df.get(t) ?? 0) + 1);
+  const idf = /* @__PURE__ */ new Map();
+  for (const [t, d] of df) idf.set(t, Math.log(1 + bags.length / (1 + d)));
+  return idf;
+}
+function overlapScore(query, doc, idf) {
+  let s = 0;
+  for (const [t, qn] of query) {
+    const dn = doc.get(t);
+    if (dn) s += qn * dn * (idf.get(t) ?? 1);
+  }
+  return s;
+}
+function bm25(query, doc, idf, dl, avgdl) {
+  const k1 = 1.2;
+  const b = 0.75;
+  const norm = k1 * (1 - b + b * dl / (avgdl || 1));
+  let s = 0;
+  for (const t of query.keys()) {
+    const tf = doc.get(t);
+    if (tf) s += (idf.get(t) ?? 1) * (tf * (k1 + 1) / (tf + norm));
+  }
+  return s;
+}
+function bagLength(m) {
+  let s = 0;
+  for (const v of m.values()) s += v;
+  return s;
+}
+function hasTerm(f, t) {
+  return f.has(t) || f.has(`${t}s`) || t.endsWith("s") && f.has(t.slice(0, -1));
+}
+function matchedShare(query, fields, idf, defaultIdf) {
+  let matched = 0;
+  let total = 0;
+  for (const t of query.keys()) {
+    const w = idf.get(t) ?? defaultIdf;
+    total += w;
+    if (fields.some((f) => hasTerm(f, t))) matched += w;
+  }
+  return total > 0 ? matched / total : 0;
+}
+function personalizedPageRank(nodeIds, edges, seeds, opts = {}) {
+  const alpha = opts.alpha ?? 0.25;
+  const iters = opts.iters ?? 25;
+  const ids = /* @__PURE__ */ new Set();
+  for (const id of nodeIds) if (!opts.nodeFilter || opts.nodeFilter(id)) ids.add(id);
+  const adj = /* @__PURE__ */ new Map();
+  const link = (a, b) => {
+    const arr = adj.get(a);
+    if (arr) arr.push(b);
+    else adj.set(a, [b]);
+  };
+  for (const [source, target, rel] of edges) {
+    if (!WALK_RELATIONS.has(rel)) continue;
+    if (!ids.has(source) || !ids.has(target)) continue;
+    link(source, target);
+    link(target, source);
+  }
+  let seedTotal = 0;
+  for (const [id, w] of seeds) if (ids.has(id) && w > 0) seedTotal += w;
+  if (seedTotal <= 0) return /* @__PURE__ */ new Map();
+  const restart = /* @__PURE__ */ new Map();
+  for (const [id, w] of seeds) if (ids.has(id) && w > 0) restart.set(id, w / seedTotal);
+  let rank = new Map(restart);
+  for (let i = 0; i < iters; i++) {
+    const next = /* @__PURE__ */ new Map();
+    for (const [id, r] of restart) next.set(id, alpha * r);
+    let dangling = 0;
+    for (const [id, mass] of rank) {
+      const nbrs = adj.get(id);
+      if (!nbrs || nbrs.length === 0) {
+        dangling += mass;
+        continue;
+      }
+      const share = (1 - alpha) * mass / nbrs.length;
+      for (const nb of nbrs) next.set(nb, (next.get(nb) ?? 0) + share);
+    }
+    if (dangling > 0) {
+      const dm = (1 - alpha) * dangling;
+      for (const [sid, r] of restart) next.set(sid, (next.get(sid) ?? 0) + dm * r);
+    }
+    rank = next;
+  }
+  let max = 0;
+  for (const v of rank.values()) if (v > max) max = v;
+  if (max <= 0) return /* @__PURE__ */ new Map();
+  const out = /* @__PURE__ */ new Map();
+  for (const [id, v] of rank) out.set(id, v / max);
+  return out;
+}
+function pathOfId(id) {
+  const hash = id.indexOf("#");
+  return hash === -1 ? id : id.slice(0, hash);
+}
+function inDegree(edges, crossFileOnly = false) {
+  const deg = /* @__PURE__ */ new Map();
+  for (const [source, target, rel] of edges) {
+    if (!WALK_RELATIONS.has(rel)) continue;
+    if (crossFileOnly && pathOfId(source) === pathOfId(target)) continue;
+    deg.set(target, (deg.get(target) ?? 0) + 1);
+  }
+  return deg;
+}
+function isTestPath(path) {
+  return /(^|\/)(tests?|__tests__|spec)\/|(_test|\.test|\.spec)\.[a-z]+$|(^|\/)(test_[^/]+|conftest)\.py$/i.test(path || "");
+}
+var STOP;
+var init_codegraph_rank = __esm({
+  "src/codegraph-rank.ts"() {
+    "use strict";
+    init_codegraph_types();
+    STOP = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "and",
+      "or",
+      "but",
+      "if",
+      "then",
+      "else",
+      "for",
+      "of",
+      "to",
+      "in",
+      "on",
+      "at",
+      "by",
+      "with",
+      "from",
+      "as",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "it",
+      "its",
+      "this",
+      "that",
+      "these",
+      "those",
+      "there",
+      "here",
+      "how",
+      "what",
+      "when",
+      "where",
+      "which",
+      "who",
+      "why",
+      "do",
+      "does",
+      "did",
+      "can",
+      "could",
+      "should",
+      "would",
+      "will",
+      "not",
+      "no",
+      "we",
+      "you",
+      "i",
+      "my",
+      "our",
+      "your",
+      "me",
+      "us",
+      "get",
+      "set",
+      "new",
+      "all",
+      "any",
+      "some",
+      "into",
+      "out"
+    ]);
+  }
+});
+
+// src/codegraph-extract.ts
+import { execFileSync } from "child_process";
+import { extname, join as join4, relative as relative2, resolve as resolve2 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+function symRules(lang) {
+  switch (lang) {
+    case "ts":
+    case "js":
+      return [
+        { kind: "function", re: /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\*?\s+([A-Za-z_$][\w$]*)/gm },
+        { kind: "class", re: /^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/gm },
+        { kind: "interface", re: /^\s*(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)/gm },
+        { kind: "type", re: /^\s*(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\s*[=<]/gm },
+        { kind: "enum", re: /^\s*(?:export\s+)?(?:const\s+)?enum\s+([A-Za-z_$][\w$]*)/gm },
+        { kind: "function", re: /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?(?:function\b|\([^)]*\)\s*(?::[^=]+)?=>|[A-Za-z_$][\w$]*\s*=>)/gm }
+      ];
+    case "python":
+      return [
+        { kind: "function", re: /^\s*(?:async\s+)?def\s+([A-Za-z_]\w*)/gm },
+        { kind: "class", re: /^\s*class\s+([A-Za-z_]\w*)/gm }
+      ];
+    case "go":
+      return [
+        { kind: "function", re: /^\s*func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)/gm },
+        { kind: "struct", re: /^\s*type\s+([A-Za-z_]\w*)\s+struct\b/gm },
+        { kind: "interface", re: /^\s*type\s+([A-Za-z_]\w*)\s+interface\b/gm }
+      ];
+    case "rust":
+      return [
+        { kind: "function", re: /^\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+([A-Za-z_]\w*)/gm },
+        { kind: "struct", re: /^\s*(?:pub(?:\([^)]*\))?\s+)?struct\s+([A-Za-z_]\w*)/gm },
+        { kind: "enum", re: /^\s*(?:pub(?:\([^)]*\))?\s+)?enum\s+([A-Za-z_]\w*)/gm },
+        { kind: "trait", re: /^\s*(?:pub(?:\([^)]*\))?\s+)?trait\s+([A-Za-z_]\w*)/gm }
+      ];
+    case "java":
+    case "csharp":
+    case "kotlin":
+      return [
+        { kind: "class", re: /^\s*(?:[\w@]+\s+)*(?:class|record)\s+([A-Za-z_]\w*)/gm },
+        { kind: "interface", re: /^\s*(?:[\w@]+\s+)*interface\s+([A-Za-z_]\w*)/gm },
+        { kind: "enum", re: /^\s*(?:[\w@]+\s+)*enum\s+([A-Za-z_]\w*)/gm },
+        { kind: "struct", re: /^\s*(?:[\w@]+\s+)*struct\s+([A-Za-z_]\w*)/gm },
+        { kind: "function", re: /^\s*(?:(?:public|private|protected|internal|static|final|abstract|virtual|override|suspend|open|fun)\s+)+[A-Za-z_][\w<>\[\],. ]*?\s+([A-Za-z_]\w*)\s*\(/gm }
+      ];
+    case "ruby":
+      return [
+        { kind: "function", re: /^\s*def\s+(?:self\.)?([A-Za-z_]\w*[!?=]?)/gm },
+        { kind: "class", re: /^\s*class\s+([A-Za-z_]\w*)/gm },
+        { kind: "module", re: /^\s*module\s+([A-Za-z_]\w*)/gm }
+      ];
+    case "php":
+      return [
+        { kind: "function", re: /^\s*(?:(?:public|private|protected|static|abstract|final)\s+)*function\s+([A-Za-z_]\w*)/gm },
+        { kind: "class", re: /^\s*(?:(?:abstract|final)\s+)*class\s+([A-Za-z_]\w*)/gm },
+        { kind: "interface", re: /^\s*interface\s+([A-Za-z_]\w*)/gm },
+        { kind: "trait", re: /^\s*trait\s+([A-Za-z_]\w*)/gm }
+      ];
+    case "c":
+    case "cpp":
+      return [
+        { kind: "struct", re: /^\s*(?:typedef\s+)?struct\s+([A-Za-z_]\w*)/gm },
+        { kind: "class", re: /^\s*class\s+([A-Za-z_]\w*)/gm },
+        { kind: "enum", re: /^\s*enum\s+(?:class\s+)?([A-Za-z_]\w*)/gm },
+        { kind: "function", re: /^[A-Za-z_][\w\s*&:<>]*?\b([A-Za-z_]\w*)\s*\([^;{)]*\)\s*\{/gm }
+      ];
+    default:
+      return [];
+  }
+}
+function importSpecs(lang, content) {
+  const out = /* @__PURE__ */ new Set();
+  const push = (re) => {
+    let m;
+    while (m = re.exec(content)) if (m[1]) out.add(m[1]);
+  };
+  switch (lang) {
+    case "ts":
+    case "js":
+      push(/^\s*import\s+[\s\S]*?\s+from\s+["']([^"']+)["']/gm);
+      push(/^\s*import\s+["']([^"']+)["']/gm);
+      push(/^\s*export\s+[\s\S]*?\s+from\s+["']([^"']+)["']/gm);
+      push(/\brequire\(\s*["']([^"']+)["']\s*\)/g);
+      break;
+    case "python":
+      push(/^\s*import\s+([A-Za-z_][\w.]*)/gm);
+      push(/^\s*from\s+([A-Za-z_.][\w.]*)\s+import\b/gm);
+      break;
+    case "go": {
+      push(/^\s*import\s+"([^"]+)"/gm);
+      const block = /import\s*\(([\s\S]*?)\)/g;
+      let b;
+      while (b = block.exec(content)) {
+        const q = /"([^"]+)"/g;
+        let m;
+        while (m = q.exec(b[1])) out.add(m[1]);
+      }
+      break;
+    }
+    case "rust":
+      push(/^\s*use\s+([A-Za-z_][\w:]*)/gm);
+      break;
+    case "java":
+    case "kotlin":
+      push(/^\s*import\s+(?:static\s+)?([A-Za-z_][\w.]*)/gm);
+      break;
+    case "csharp":
+      push(/^\s*using\s+(?:static\s+)?([A-Za-z_][\w.]*)/gm);
+      break;
+    case "ruby":
+      push(/^\s*require(?:_relative)?\s+["']([^"']+)["']/gm);
+      break;
+    case "php":
+      push(/^\s*use\s+([A-Za-z_\\][\w\\]*)/gm);
+      break;
+    case "c":
+    case "cpp":
+      push(/^\s*#\s*include\s*[<"]([^>"]+)[>"]/gm);
+      break;
+  }
+  return [...out];
+}
+function importBindings(lang, content) {
+  if (lang !== "ts" && lang !== "js" && lang !== "python") return null;
+  const names = /* @__PURE__ */ new Set();
+  const namespaces = [];
+  const addClause = (clause) => {
+    for (const part of clause.split(",")) {
+      const alias = part.trim().split(/\s+as\s+/).pop();
+      if (alias && /^[A-Za-z_$][\w$]*$/.test(alias)) names.add(alias);
+    }
+  };
+  if (lang === "python") {
+    let m2;
+    const from = /^\s*from\s+[\w.]+\s+import\s+\(?([^)\n]+)\)?/gm;
+    while (m2 = from.exec(content)) addClause(m2[1].replace(/\*/g, ""));
+    return { names: [...names], namespaces };
+  }
+  let m;
+  const star = /^\s*import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s+["']([^"']+)["']/gm;
+  while (m = star.exec(content)) namespaces.push([m[1], m[2]]);
+  const requireStar = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*require\(\s*["']([^"']+)["']\s*\)/g;
+  while (m = requireStar.exec(content)) namespaces.push([m[1], m[2]]);
+  const named = /^\s*(?:import|export)\s+(?:type\s+)?([\s\S]*?)\s+from\s+["'][^"']+["']/gm;
+  while (m = named.exec(content)) {
+    const clause = m[1];
+    if (clause.includes("*")) continue;
+    const braced = /\{([\s\S]*?)\}/.exec(clause);
+    if (braced) addClause(braced[1]);
+    const bare = clause.replace(/\{[\s\S]*?\}/g, "").replace(/,/g, " ").trim();
+    if (/^[A-Za-z_$][\w$]*$/.test(bare)) names.add(bare);
+  }
+  const requireNamed = /(?:const|let|var)\s*\{([^}]*)\}\s*=\s*require\(/g;
+  while (m = requireNamed.exec(content)) addClause(m[1].replace(/:/g, " as "));
+  return { names: [...names], namespaces };
+}
+function lineResolver(content) {
+  const nl = [];
+  for (let i = 0; i < content.length; i++) if (content.charCodeAt(i) === 10) nl.push(i);
+  return (idx) => {
+    let lo = 0, hi = nl.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (nl[mid] < idx) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo + 1;
+  };
+}
+function indentOf(line) {
+  let n = 0;
+  while (n < line.length && (line[n] === " " || line[n] === "	")) n++;
+  return n;
+}
+function withoutTrailingComment(line) {
+  const slash = line.indexOf("//");
+  return (slash === -1 ? line : line.slice(0, slash)).trimEnd();
+}
+function braceEnd(lines, startIdx, lang) {
+  const LOOKAHEAD_LINES = 3;
+  let openLine = -1;
+  for (let i = startIdx; i <= Math.min(startIdx + LOOKAHEAD_LINES, lines.length - 1); i++) {
+    if (withoutTrailingComment(lines[i]).endsWith("{")) {
+      openLine = i;
+      break;
+    }
+  }
+  if (openLine === -1) return startIdx + 1;
+  const hashComment = HASH_COMMENT_LANGS.has(lang);
+  const preprocessor = PREPROCESSOR_LANGS.has(lang);
+  let depth = 0;
+  let inBlockComment = false;
+  for (let i = openLine; i < lines.length; i++) {
+    const line = lines[i];
+    const hashEndsLine = hashComment || preprocessor && line.trimStart().startsWith("#");
+    const from = i === openLine ? line.lastIndexOf("{") : 0;
+    let inString = null;
+    for (let c = from; c < line.length; c++) {
+      const ch = line[c];
+      if (inBlockComment) {
+        if (ch === "*" && line[c + 1] === "/") {
+          inBlockComment = false;
+          c++;
+        }
+        continue;
+      }
+      if (inString) {
+        if (ch === "\\") {
+          c++;
+          continue;
+        }
+        if (ch === inString) inString = null;
+        continue;
+      }
+      if (ch === "/" && line[c + 1] === "/") break;
+      if (ch === "#" && hashEndsLine && line[c + 1] !== "{") break;
+      if (ch === "/" && line[c + 1] === "*") {
+        inBlockComment = true;
+        c++;
+        continue;
+      }
+      if (ch === '"' || ch === "'" || ch === "`") {
+        inString = ch;
+        continue;
+      }
+      if (ch === "{") {
+        depth++;
+        continue;
+      }
+      if (ch === "}" && --depth <= 0) return i + 1;
+    }
+  }
+  return lines.length;
+}
+function indentEnd(lines, startIdx) {
+  const base = indentOf(lines[startIdx]);
+  let end = startIdx + 1;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim()) continue;
+    if (indentOf(line) <= base) break;
+    end = i + 1;
+  }
+  return end;
+}
+function clampToSiblings(symbols, lines) {
+  const indentAt = (line) => indentOf(lines[line - 1] ?? "");
+  for (let i = 0; i < symbols.length; i++) {
+    const s = symbols[i];
+    for (let j = i + 1; j < symbols.length; j++) {
+      const next = symbols[j];
+      if (next.line <= s.line) continue;
+      if (indentAt(next.line) > indentAt(s.line)) continue;
+      s.endLine = Math.max(s.line, Math.min(s.endLine, next.line - 1));
+      break;
+    }
+  }
+}
+function signatureOf(line) {
+  const MAX_SIGNATURE = 200;
+  let sig = line.trim();
+  const brace = sig.indexOf("{");
+  if (brace > 0) sig = sig.slice(0, brace).trim();
+  if (sig.endsWith(":")) sig = sig.slice(0, -1).trim();
+  return sig.length > MAX_SIGNATURE ? `${sig.slice(0, MAX_SIGNATURE)}...` : sig;
+}
+function extractFile(lang, content) {
+  const lineAt = lineResolver(content);
+  const lines = content.split("\n");
+  const braced = BRACE_LANGS.has(lang);
+  const symbols = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { kind, re } of symRules(lang)) {
+    let m;
+    re.lastIndex = 0;
+    while (m = re.exec(content)) {
+      const name = m[1];
+      if (!name) continue;
+      const nameIdx = m.index + m[0].lastIndexOf(name);
+      const key = `${name}@${nameIdx}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const line = lineAt(nameIdx);
+      const startIdx = line - 1;
+      const endLine = braced ? braceEnd(lines, startIdx, lang) : indentEnd(lines, startIdx);
+      symbols.push({ name, kind, line, endLine: Math.max(line, endLine), signature: signatureOf(lines[startIdx] ?? "") });
+    }
+  }
+  symbols.sort((a, b) => a.line - b.line || a.name.localeCompare(b.name));
+  if (braced) clampToSiblings(symbols, lines);
+  return { symbols, imports: importSpecs(lang, content) };
+}
+function gitList(root, args) {
+  try {
+    return execFileSync("git", ["-C", root, "ls-files", ...args, "-z"], {
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    });
+  } catch {
+    return null;
+  }
+}
+function gitSourceFiles(root) {
+  const out = gitList(root, ["--cached", "--others", "--exclude-standard"]);
+  if (out === null) return null;
+  const nested = existsSync4(join4(root, ".gitmodules")) ? gitList(root, ["--recurse-submodules"]) : null;
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rel of [...out.split("\0"), ...(nested ?? "").split("\0")]) {
+    if (files.length >= MAX_FILES) break;
+    if (!rel || seen.has(rel)) continue;
+    seen.add(rel);
+    if (!LANG_BY_EXT[extname(rel).toLowerCase()]) continue;
+    if (rel.split("/").some((seg) => seg.startsWith(".") || IGNORE_DIRS.has(seg))) continue;
+    files.push(join4(root, rel));
+  }
+  return files;
+}
+function walk(root) {
+  const tracked = gitSourceFiles(root);
+  if (tracked && tracked.length) return { files: tracked, truncated: tracked.length >= MAX_FILES };
+  const files = [];
+  const queue = [root];
+  let visited = 0;
+  for (let head = 0; head < queue.length && files.length < MAX_FILES && visited < MAX_ENTRIES; head++) {
+    let entries;
+    try {
+      entries = readdirSync2(queue[head], { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (files.length >= MAX_FILES || ++visited >= MAX_ENTRIES) break;
+      if (e.isDirectory()) {
+        if (!e.name.startsWith(".") && !IGNORE_DIRS.has(e.name)) queue.push(join4(queue[head], e.name));
+        continue;
+      }
+      if (!e.isFile()) continue;
+      if (LANG_BY_EXT[extname(e.name).toLowerCase()]) files.push(join4(queue[head], e.name));
+    }
+  }
+  return { files, truncated: files.length >= MAX_FILES || visited >= MAX_ENTRIES };
+}
+function relPath(root, abs) {
+  return relative2(root, abs).split("\\").join("/");
+}
+function scanFiles(rootDir) {
+  const root = resolve2(rootDir || process.cwd());
+  const files = [];
+  const walked = walk(root);
+  let truncated = walked.truncated;
+  for (const abs of walked.files) {
+    let size = 0;
+    let mtimeMs = 0;
+    try {
+      const st = statSync2(abs);
+      size = st.size;
+      mtimeMs = st.mtimeMs;
+    } catch {
+      continue;
+    }
+    if (size > MAX_FILE_BYTES) {
+      truncated = true;
+      continue;
+    }
+    let content;
+    try {
+      content = readFileSync4(abs, "utf8");
+    } catch {
+      continue;
+    }
+    const lang = LANG_BY_EXT[extname(abs).toLowerCase()];
+    const { symbols, imports } = extractFile(lang, content);
+    files.push({
+      path: relPath(root, abs),
+      lang,
+      loc: content ? content.split("\n").length : 0,
+      symbols,
+      imports,
+      bindings: importBindings(lang, content) ?? void 0,
+      chars: content.length,
+      size,
+      mtimeMs
+    });
+  }
+  return { root, files, truncated };
+}
+function statSourceFiles(root) {
+  const out = /* @__PURE__ */ new Map();
+  for (const abs of walk(root).files) {
+    try {
+      const st = statSync2(abs);
+      if (st.size > MAX_FILE_BYTES) continue;
+      out.set(relPath(root, abs), { size: st.size, mtimeMs: st.mtimeMs });
+    } catch {
+    }
+  }
+  return out;
+}
+var IGNORE_DIRS, LANG_BY_EXT, MAX_FILES, MAX_FILE_BYTES, BRACE_LANGS, HASH_COMMENT_LANGS, PREPROCESSOR_LANGS, MAX_ENTRIES;
+var init_codegraph_extract = __esm({
+  "src/codegraph-extract.ts"() {
+    "use strict";
+    IGNORE_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      ".nuxt",
+      "target",
+      "vendor",
+      "__pycache__",
+      ".venv",
+      "venv",
+      "coverage",
+      ".cache",
+      ".idea",
+      ".vscode",
+      ".turbo",
+      ".parcel-cache",
+      ".svelte-kit",
+      "Pods",
+      ".gradle",
+      ".dart_tool"
+    ]);
+    LANG_BY_EXT = {
+      ".ts": "ts",
+      ".tsx": "ts",
+      ".mts": "ts",
+      ".cts": "ts",
+      ".js": "js",
+      ".jsx": "js",
+      ".mjs": "js",
+      ".cjs": "js",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust",
+      ".java": "java",
+      ".rb": "ruby",
+      ".php": "php",
+      ".cs": "csharp",
+      ".kt": "kotlin",
+      ".kts": "kotlin",
+      ".c": "c",
+      ".h": "c",
+      ".cpp": "cpp",
+      ".cc": "cpp",
+      ".cxx": "cpp",
+      ".hpp": "cpp",
+      ".hh": "cpp"
+    };
+    MAX_FILES = 8e3;
+    MAX_FILE_BYTES = 512 * 1024;
+    BRACE_LANGS = /* @__PURE__ */ new Set(["ts", "js", "go", "rust", "java", "csharp", "kotlin", "php", "c", "cpp"]);
+    HASH_COMMENT_LANGS = /* @__PURE__ */ new Set(["php"]);
+    PREPROCESSOR_LANGS = /* @__PURE__ */ new Set(["c", "cpp"]);
+    MAX_ENTRIES = 6e4;
+  }
+});
+
+// src/codegraph.ts
+var codegraph_exports = {};
+__export(codegraph_exports, {
+  GRAPH_VERSION: () => GRAPH_VERSION,
+  WALK_RELATIONS: () => WALK_RELATIONS,
+  codeGraphArchitecture: () => codeGraphArchitecture,
+  codeGraphAvailable: () => codeGraphAvailable,
+  codeGraphProjects: () => codeGraphProjects,
+  codeGraphSchema: () => codeGraphSchema,
+  codeGraphStatus: () => codeGraphStatus,
+  driftCount: () => driftCount,
+  ensureProjectForCwd: () => ensureProjectForCwd,
+  findProjectForCwd: () => findProjectForCwd,
+  graphNodes: () => graphNodes,
+  indexProject: () => indexProject,
+  isCleanDrift: () => isCleanDrift,
+  isManagedPath: () => isManagedPath,
+  listProjects: () => listProjects,
+  loadBodyIndex: () => loadBodyIndex,
+  loadCompatibleGraph: () => loadCompatibleGraph,
+  loadFreshGraph: () => loadFreshGraph,
+  loadGraph: () => loadGraph,
+  probeDrift: () => probeDrift,
+  resetCodeGraph: () => resetCodeGraph,
+  scanFiles: () => scanFiles,
+  searchGraph: () => searchGraph
+});
+import { homedir as homedir2 } from "os";
+import { createHash as createHash2 } from "crypto";
+import { basename, join as join5, resolve as resolve3 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+function storeDir() {
+  return process.env.ENIGMA_CODEGRAPH_DIR || join5(homedir2(), ".enigma", "codegraph");
+}
+function projectsFile() {
+  return join5(storeDir(), "projects.json");
+}
+function graphFile(id) {
+  return join5(storeDir(), `${id}.json`);
+}
+function bodyIndexFile(id) {
+  return join5(storeDir(), `${id}.bodies.json`);
+}
+function readJsonSafe(file, fallback) {
+  try {
+    return existsSync5(file) ? JSON.parse(readFileSync5(file, "utf8")) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(file, value) {
+  mkdirSync3(storeDir(), { recursive: true });
+  writeFileSync4(file, JSON.stringify(value));
+}
+function langFamily(lang) {
+  return LANG_FAMILY[lang] ?? lang;
+}
+function verifyModule(base, known, lang) {
+  if (!base || base.startsWith("..")) return null;
+  if (known.has(base)) return base;
+  const exts = EXT_ORDER[lang] ?? RESOLVE_EXTS;
+  for (const ext of exts) if (known.has(base + ext)) return base + ext;
+  for (const name of INDEX_ORDER[lang] ?? INDEX_NAMES) {
+    for (const ext of exts) if (known.has(`${base}/${name}${ext}`)) return `${base}/${name}${ext}`;
+  }
+  return null;
+}
+function orders(all, byLang) {
+  const out = {};
+  for (const [lang, preferred] of Object.entries(byLang)) out[lang] = [...preferred, ...all.filter((v) => preferred.indexOf(v) === -1)];
+  return out;
+}
+function goModulePath(root) {
+  try {
+    return /^\s*module\s+(\S+)/m.exec(readFileSync5(join5(root, "go.mod"), "utf8"))?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+function createImportResolver(root, known) {
+  const goModule = goModulePath(root);
+  let goByDir = null;
+  const dirOf = (rel) => rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : "";
+  const joinRel = (dir, rest) => [...dir ? [dir] : [], ...rest].join("/");
+  const underRoots = (segments, lang) => {
+    for (const base of MODULE_ROOTS) {
+      const hit = verifyModule(joinRel(base, segments), known, lang);
+      if (hit) return hit;
+    }
+    return null;
+  };
+  const relative4 = (fromRel, spec, lang) => {
+    const abs = resolve3(join5(root, fromRel), "..", spec);
+    return verifyModule(relPath(root, abs), known, lang);
+  };
+  return (fromRel, lang, spec) => {
+    if (lang === "go") {
+      if (!goModule || spec !== goModule && !spec.startsWith(`${goModule}/`)) return [];
+      const dir = spec === goModule ? "" : spec.slice(goModule.length + 1);
+      if (!goByDir) {
+        goByDir = /* @__PURE__ */ new Map();
+        for (const p of known) {
+          if (!p.endsWith(".go")) continue;
+          const d = dirOf(p);
+          const list = goByDir.get(d);
+          if (list) list.push(p);
+          else goByDir.set(d, [p]);
+        }
+      }
+      return goByDir.get(dir) ?? [];
+    }
+    if (lang === "python") {
+      const dots = /^\.+/.exec(spec)?.[0].length ?? 0;
+      const segments = spec.slice(dots).split(".").filter(Boolean);
+      if (dots > 0) {
+        let dir = dirOf(fromRel);
+        for (let up = 1; up < dots; up++) dir = dirOf(dir);
+        return [verifyModule(joinRel(dir, segments), known, lang)].filter((p) => !!p);
+      }
+      return [underRoots(segments, lang)].filter((p) => !!p);
+    }
+    if (spec.startsWith(".")) return [relative4(fromRel, spec, lang)].filter((p) => !!p);
+    const separator = MODULE_SEPARATOR[lang];
+    if (separator) {
+      const segments = spec.split(separator).filter((s) => s && s !== "crate" && s !== "self");
+      return [underRoots(segments, lang) ?? (segments.length > 1 ? underRoots(segments.slice(0, -1), lang) : null)].filter((p) => !!p);
+    }
+    const alias = /^[@~#]\//.test(spec);
+    if (BARE_IS_PACKAGE.has(lang) && !alias && (!spec.includes("/") || spec.startsWith("@"))) return [];
+    const path = spec.replace(/^[@~#]\//, "").replace(/^\/+/, "");
+    return [relative4(fromRel, `./${path}`, lang) ?? underRoots(path.split("/"), lang)].filter((p) => !!p);
+  };
+}
+function symbolId(path, name, taken) {
+  const base = `${path}#${name}`;
+  if (!taken.has(base)) {
+    taken.add(base);
+    return base;
+  }
+  for (let n = 2; ; n++) {
+    const candidate = `${base}~${n}`;
+    if (!taken.has(candidate)) {
+      taken.add(candidate);
+      return candidate;
+    }
+  }
+}
+function mintNodes(files) {
+  const taken = /* @__PURE__ */ new Set();
+  const nodes = [];
+  for (const f of files) {
+    nodes.push({ id: f.path, name: basename(f.path), kind: "file", path: f.path, line: 1, endLine: f.loc, signature: "", chars: f.chars });
+    for (const s of f.symbols) {
+      nodes.push({ id: symbolId(f.path, s.name, taken), name: s.name, kind: s.kind, path: f.path, line: s.line, endLine: s.endLine, signature: s.signature });
+    }
+  }
+  return nodes;
+}
+function enclosingSymbol(spans, line) {
+  let found = null;
+  for (const s of spans) {
+    if (s.line > line) break;
+    if (line <= s.endLine) found = s.id;
+  }
+  return found;
+}
+function inheritanceTargets(signature) {
+  const out = [];
+  const ext = /\bextends\s+([\w$.<>,\s]+?)(?:\s+implements\b|$)/.exec(signature);
+  const impl = /\bimplements\s+([\w$.<>,\s]+)$/.exec(signature);
+  const names = (clause) => clause.split(",").map((s) => s.trim().replace(/<.*$/, "").split(".").pop() || "").filter((s) => s.length >= MIN_REF_NAME);
+  if (ext) for (const n of names(ext[1])) out.push(["extends", n]);
+  if (impl) for (const n of names(impl[1])) out.push(["implements", n]);
+  return out;
+}
+function buildEdges(root, files, importEdges, resolveImport) {
+  const nodes = mintNodes(files);
+  const spansByFile = /* @__PURE__ */ new Map();
+  const defsByName = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.kind === "file") {
+      spansByFile.set(n.path, []);
+      continue;
+    }
+    spansByFile.get(n.path).push({ id: n.id, line: n.line, endLine: n.endLine });
+    if (n.name.length >= MIN_REF_NAME) {
+      let list = defsByName.get(n.name);
+      if (!list) {
+        list = [];
+        defsByName.set(n.name, list);
+      }
+      list.push({ id: n.id, path: n.path });
+    }
+  }
+  for (const spans of spansByFile.values()) spans.sort((a, b) => a.line - b.line);
+  const importsOf = /* @__PURE__ */ new Map();
+  for (const [from, to] of importEdges) {
+    let set = importsOf.get(from);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      importsOf.set(from, set);
+    }
+    set.add(to);
+  }
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (from, to, rel) => {
+    if (edges.length >= MAX_EDGES || from === to) return;
+    const key = `${from}|${to}|${rel}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    edges.push([from, to, rel]);
+  };
+  for (const f of files) {
+    for (const span of spansByFile.get(f.path) ?? []) push(f.path, span.id, "contains");
+    for (const to of importsOf.get(f.path) ?? []) push(f.path, to, "imports");
+  }
+  const known = new Set(files.map((f) => f.path));
+  const langByPath = new Map(files.map((f) => [f.path, f.lang]));
+  const idByPathName = /* @__PURE__ */ new Map();
+  const localDefs = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.kind === "file") {
+      localDefs.set(n.path, /* @__PURE__ */ new Map());
+      continue;
+    }
+    const key = `${n.path}#${n.name}`;
+    if (!idByPathName.has(key)) idByPathName.set(key, n.id);
+    const local = localDefs.get(n.path);
+    local.set(n.name, local.has(n.name) ? null : n.id);
+  }
+  function binderFor(f) {
+    const local = localDefs.get(f.path) ?? /* @__PURE__ */ new Map();
+    const imported = importsOf.get(f.path);
+    const family = langFamily(f.lang);
+    const reachable = (path) => langFamily(langByPath.get(path) ?? "") === family;
+    const unique = (name) => {
+      const candidates = defsByName.get(name)?.filter((c) => imported?.has(c.path) && reachable(c.path));
+      return candidates?.length === 1 ? candidates[0].id : null;
+    };
+    if (!f.bindings) {
+      return (name) => {
+        if (local.has(name)) return local.get(name) ?? null;
+        if (imported?.size) return unique(name);
+        const all = defsByName.get(name)?.filter((c) => reachable(c.path));
+        return all?.length === 1 ? all[0].id : null;
+      };
+    }
+    const bound = new Set(f.bindings.names);
+    const namespaces = /* @__PURE__ */ new Map();
+    for (const [alias, spec] of f.bindings.namespaces) {
+      const [target] = resolveImport(f.path, f.lang, spec);
+      if (target) namespaces.set(alias, target);
+    }
+    return (name, memberOf) => {
+      if (memberOf !== void 0) {
+        const path = namespaces.get(memberOf);
+        return path ? idByPathName.get(`${path}#${name}`) ?? null : null;
+      }
+      if (local.has(name)) return local.get(name) ?? null;
+      return bound.has(name) ? unique(name) : null;
+    };
+  }
+  const bodies = [];
+  for (const f of files) {
+    let content = "";
+    try {
+      content = readFileSync5(join5(root, f.path), "utf8");
+    } catch {
+      continue;
+    }
+    const spans = spansByFile.get(f.path) ?? [];
+    const declLines = new Set(f.symbols.map((s) => s.line));
+    const lines = content.split("\n");
+    indexBodies(bodies, f.path, spans, lines);
+    const bind = binderFor(f);
+    const strict = !!f.bindings;
+    for (const s of f.symbols) {
+      if (s.kind !== "class" && s.kind !== "interface" && s.kind !== "struct") continue;
+      const self = spans.find((sp) => sp.line === s.line);
+      if (!self) continue;
+      for (const [rel, name] of inheritanceTargets(s.signature)) {
+        const target = bind(name);
+        if (target) push(self.id, target, rel);
+      }
+    }
+    for (let i = 0; i < lines.length; i++) {
+      const lineNo = i + 1;
+      if (declLines.has(lineNo)) continue;
+      const line = lines[i];
+      const from = enclosingSymbol(spans, lineNo) ?? f.path;
+      const ident = /[A-Za-z_$][\w$]*/g;
+      let m;
+      while (m = ident.exec(line)) {
+        const name = m[0];
+        if (name.length < MIN_REF_NAME || !defsByName.has(name)) continue;
+        const memberOf = strict ? /([A-Za-z_$][\w$]*)\s*\.\s*$/.exec(line.slice(0, m.index))?.[1] : void 0;
+        const target = bind(name, memberOf);
+        if (!target || target === from) continue;
+        const after = line.slice(m.index + name.length);
+        push(from, target, /^\s*\(/.test(after) ? "calls" : "references");
+      }
+    }
+  }
+  return { edges, bodies };
+}
+function indexBodies(out, path, spans, lines) {
+  const covered = new Uint8Array(lines.length + 1);
+  for (const s of spans) {
+    const text = lines.slice(s.line - 1, s.endLine).join("\n");
+    for (let l = s.line; l <= Math.min(s.endLine, lines.length); l++) covered[l] = 1;
+    const bag = topTokens(text);
+    if (bag.length) out.push([s.id, bag]);
+  }
+  const residual = [];
+  for (let l = 1; l <= lines.length; l++) if (!covered[l]) residual.push(lines[l - 1]);
+  const fileBag = topTokens(residual.join("\n"));
+  if (fileBag.length) out.push([path, fileBag]);
+}
+function topTokens(text) {
+  const m = /* @__PURE__ */ new Map();
+  for (const t of tokenize(text)) m.set(t, (m.get(t) ?? 0) + 1);
+  return [...m.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, MAX_BODY_TOKENS);
+}
+function isManagedPath(dir) {
+  const managed = resolve3(join5(enigmaHome(), ".enigma"));
+  return dir === managed || dir.startsWith(managed + (dir.includes("\\") ? "\\" : "/"));
+}
+function indexProject(rootDir) {
+  const requested = resolve3(rootDir || process.cwd());
+  if (isManagedPath(requested)) {
+    throw new Error(`${requested} is inside enigma's own managed directory - a temporary checkout, not a project to index.`);
+  }
+  const { root, files, truncated } = scanFiles(rootDir);
+  const id = createHash2("sha1").update(root).digest("hex").slice(0, 12);
+  const name = basename(root) || root;
+  const known = new Set(files.map((f) => f.path));
+  const resolveImport = createImportResolver(root, known);
+  const importEdges = [];
+  const externalModules = {};
+  for (const f of files) {
+    for (const spec of f.imports) {
+      const targets = resolveImport(f.path, f.lang, spec);
+      if (!targets.length) {
+        externalModules[spec] = (externalModules[spec] || 0) + 1;
+        continue;
+      }
+      for (const target of targets) if (target !== f.path) importEdges.push([f.path, target]);
+    }
+  }
+  const { edges, bodies } = buildEdges(root, files, importEdges, resolveImport);
+  const graph = { version: GRAPH_VERSION, id, name, root, indexedAt: Date.now(), files, importEdges, edges, externalModules, truncated };
+  writeJson(graphFile(id), graph);
+  writeJson(bodyIndexFile(id), bodies);
+  const symbols = files.reduce((n, f) => n + f.symbols.length, 0);
+  const entry = { id, name, root, indexedAt: graph.indexedAt, files: files.length, symbols, truncated };
+  writeJson(projectsFile(), [...storedProjects().filter((p) => p.id !== id), entry]);
+  return entry;
+}
+function storedProjects() {
+  const stored = readJsonSafe(projectsFile(), []).map((p) => ({ ...p, truncated: p.truncated === true }));
+  const kept = stored.filter((p) => p.root && !isManagedPath(p.root));
+  if (kept.length !== stored.length) {
+    for (const dead of stored.filter((p) => !kept.includes(p))) {
+      rmSync2(graphFile(dead.id), { force: true });
+      rmSync2(bodyIndexFile(dead.id), { force: true });
+    }
+    writeJson(projectsFile(), kept);
+  }
+  return kept;
+}
+function listProjects() {
+  return storedProjects().filter((p) => existsSync5(p.root)).sort((a, b) => b.indexedAt - a.indexedAt);
+}
+function codeGraphProjects() {
+  return listProjects();
+}
+function resolveProject(project) {
+  const all = listProjects();
+  if (!all.length) return null;
+  if (project) {
+    const named = all.find((p) => p.id === project || p.name === project || p.root === project);
+    return named ?? (looksLikePath(project) ? covering(all, resolve3(project)) : null);
+  }
+  return covering(all, resolve3(process.cwd())) ?? all[0];
+}
+function looksLikePath(value) {
+  return value.startsWith(".") || value.includes("/") || value.includes("\\");
+}
+function covering(all, dir) {
+  return all.filter((p) => dir === p.root || dir.startsWith(`${p.root}${dir.includes("\\") ? "\\" : "/"}`)).sort((a, b) => b.root.length - a.root.length)[0] ?? null;
+}
+function projectRootOf(dir) {
+  const start = resolve3(dir);
+  if (ROOT_MARKERS.some((marker) => existsSync5(join5(start, marker)))) return start;
+  const home = resolve3(homedir2());
+  let current = start;
+  for (let up = 0; up < MAX_ROOT_WALK; up++) {
+    const parent = resolve3(current, "..");
+    if (parent === current || parent === home) break;
+    current = parent;
+    if (existsSync5(join5(current, ".git"))) return current;
+  }
+  return start;
+}
+function ensureProjectForCwd(dir) {
+  const covering2 = findProjectForCwd(dir);
+  if (covering2) return covering2;
+  return indexProject(projectRootOf(resolve3(dir || process.cwd()))).id;
+}
+function findProjectForCwd(dir) {
+  return covering(listProjects(), resolve3(dir || process.cwd()))?.id ?? null;
+}
+function loadGraph(project) {
+  const entry = resolveProject(project);
+  if (!entry) return null;
+  return readJsonSafe(graphFile(entry.id), null);
+}
+function loadCompatibleGraph(project) {
+  const graph = loadGraph(project);
+  if (!graph || graph.version === GRAPH_VERSION) return graph;
+  if (!graph.root || !existsSync5(graph.root)) return null;
+  indexProject(graph.root);
+  return loadGraph(graph.id);
+}
+function loadBodyIndex(graphId) {
+  const raw = readJsonSafe(bodyIndexFile(graphId), []);
+  const out = /* @__PURE__ */ new Map();
+  for (const [id, bag] of raw) out.set(id, new Map(bag));
+  return out;
+}
+function isCleanDrift(d) {
+  return d.changed.length === 0 && d.added.length === 0 && d.removed.length === 0;
+}
+function driftCount(d) {
+  return d.changed.length + d.added.length + d.removed.length;
+}
+function probeDrift(graph) {
+  const drift = { changed: [], added: [], removed: [] };
+  const onDisk = statSourceFiles(graph.root);
+  const indexed = new Map(graph.files.map((f) => [f.path, f]));
+  for (const [path, st] of onDisk) {
+    const rec = indexed.get(path);
+    if (!rec) {
+      drift.added.push(path);
+      continue;
+    }
+    if (rec.size !== st.size || rec.mtimeMs !== st.mtimeMs) drift.changed.push(path);
+  }
+  for (const path of indexed.keys()) if (!onDisk.has(path)) drift.removed.push(path);
+  drift.changed.sort();
+  drift.added.sort();
+  drift.removed.sort();
+  return drift;
+}
+function loadFreshGraph(project, refresh = true) {
+  const graph = loadGraph(project);
+  if (!graph) return null;
+  if (!refresh) return graph;
+  if (graph.version !== GRAPH_VERSION || !isCleanDrift(probeDrift(graph))) {
+    indexProject(graph.root);
+    return loadGraph(graph.id);
+  }
+  return graph;
+}
+function graphNodes(graph) {
+  return mintNodes(graph.files);
+}
+function topByCrossFileDegree(g, limit) {
+  const degree = inDegree(g.edges ?? [], true);
+  if (!degree.size) return [];
+  const named = new Map(mintNodes(g.files).map((n) => [n.id, n.name]));
+  return [...degree.entries()].filter(([id]) => id.includes("#")).map(([id, refs]) => ({ name: named.get(id) ?? id, refs })).sort((a, b) => b.refs - a.refs || a.name.localeCompare(b.name)).slice(0, limit);
+}
+function codeGraphArchitecture(project) {
+  const g = loadCompatibleGraph(project);
+  if (!g) return null;
+  const languages = {};
+  const packages = {};
+  for (const f of g.files) {
+    languages[f.lang] = (languages[f.lang] || 0) + 1;
+    const top = f.path.includes("/") ? f.path.slice(0, f.path.indexOf("/")) : ".";
+    packages[top] = (packages[top] || 0) + 1;
+  }
+  const imported = new Set(g.importEdges.map(([, to]) => to));
+  const reach = /* @__PURE__ */ new Map();
+  for (const [from] of g.importEdges) reach.set(from, (reach.get(from) ?? 0) + 1);
+  const named = /(^|\/)(main|index|cli|app|server|bin)\.\w+$/;
+  const entryPoints = g.files.filter((f) => !imported.has(f.path) || named.test(f.path)).sort((a, b) => (reach.get(b.path) ?? 0) - (reach.get(a.path) ?? 0) || Number(named.test(b.path)) - Number(named.test(a.path)) || a.path.localeCompare(b.path)).map((f) => f.path).filter((p, i, a) => a.indexOf(p) === i).slice(0, 15);
+  const hotspots = topByCrossFileDegree(g, 15);
+  const externalModules = Object.entries(g.externalModules).map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count).slice(0, 20);
+  const symbols = g.files.reduce((n, f) => n + f.symbols.length, 0);
+  return { project: g.name, languages, files: g.files.length, symbols, importEdges: g.importEdges.length, entryPoints, hotspots, packages, externalModules };
+}
+function codeGraphSchema(project) {
+  const g = loadCompatibleGraph(project);
+  if (!g) return null;
+  const nodes = { File: g.files.length };
+  for (const f of g.files) for (const s of f.symbols) {
+    const label = s.kind.charAt(0).toUpperCase() + s.kind.slice(1);
+    nodes[label] = (nodes[label] || 0) + 1;
+  }
+  const edges = {};
+  for (const [, , rel] of g.edges ?? []) edges[rel.toUpperCase()] = (edges[rel.toUpperCase()] || 0) + 1;
+  if (!Object.keys(edges).length) edges.IMPORTS = g.importEdges.length;
+  return { nodes, edges };
+}
+function searchGraph(project, opts = {}) {
+  const g = loadCompatibleGraph(project);
+  if (!g) return [];
+  let re = null;
+  if (opts.name) {
+    try {
+      re = new RegExp(opts.name, "i");
+    } catch {
+      re = new RegExp(opts.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+    }
+  }
+  const out = [];
+  const limit = opts.limit ?? 50;
+  for (const f of g.files) for (const s of f.symbols) {
+    if (opts.kind && s.kind !== opts.kind) continue;
+    if (re && !re.test(s.name)) continue;
+    out.push({ name: s.name, kind: s.kind, file: f.path, line: s.line });
+    if (out.length >= limit) return out;
+  }
+  return out;
+}
+function resetCodeGraph() {
+  try {
+    rmSync2(storeDir(), { recursive: true, force: true });
+  } catch {
+  }
+}
+function codeGraphAvailable() {
+  return true;
+}
+function codeGraphStatus() {
+  return { enabled: readConfig().config.codeGraph, available: true, projects: listProjects().length };
+}
+var GRAPH_VERSION, RESOLVE_EXTS, LANG_EXTS, LANG_INDEX, MIN_REF_NAME, MAX_EDGES, LANG_FAMILY, INDEX_NAMES, MODULE_ROOTS, MODULE_SEPARATOR, BARE_IS_PACKAGE, EXT_ORDER, INDEX_ORDER, MAX_BODY_TOKENS, ROOT_MARKERS, MAX_ROOT_WALK;
+var init_codegraph = __esm({
+  "src/codegraph.ts"() {
+    "use strict";
+    init_util();
+    init_config();
+    init_codegraph_rank();
+    init_codegraph_extract();
+    init_codegraph_extract();
+    init_codegraph_types();
+    GRAPH_VERSION = 4;
+    RESOLVE_EXTS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs", ".java", ".rb", ".php", ".cs", ".kt"];
+    LANG_EXTS = {
+      ts: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
+      js: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"],
+      python: [".py"],
+      go: [".go"],
+      rust: [".rs"],
+      java: [".java"],
+      kotlin: [".kt"],
+      ruby: [".rb"],
+      php: [".php"],
+      csharp: [".cs"]
+    };
+    LANG_INDEX = { python: ["__init__"], go: ["mod"], rust: ["mod"] };
+    MIN_REF_NAME = 3;
+    MAX_EDGES = 4e5;
+    LANG_FAMILY = {
+      ts: "js",
+      js: "js",
+      c: "c",
+      cpp: "c",
+      java: "jvm",
+      kotlin: "jvm"
+    };
+    INDEX_NAMES = ["index", "__init__", "mod"];
+    MODULE_ROOTS = ["", "src", "lib", "app", "source", "src/main/java", "src/main/kotlin", "src/test/java"];
+    MODULE_SEPARATOR = { python: ".", java: ".", kotlin: ".", csharp: ".", php: "\\", rust: "::" };
+    BARE_IS_PACKAGE = /* @__PURE__ */ new Set(["ts", "js"]);
+    EXT_ORDER = orders(RESOLVE_EXTS, LANG_EXTS);
+    INDEX_ORDER = orders(INDEX_NAMES, LANG_INDEX);
+    MAX_BODY_TOKENS = 80;
+    ROOT_MARKERS = [".git", "package.json", "go.mod", "pyproject.toml", "Cargo.toml", "pom.xml", "composer.json"];
+    MAX_ROOT_WALK = 6;
+  }
+});
+
+// src/codegraph-query.ts
+var codegraph_query_exports = {};
+__export(codegraph_query_exports, {
+  NOT_INDEXED: () => NOT_INDEXED,
+  codeGraphAsk: () => codeGraphAsk,
+  codeGraphCheck: () => codeGraphCheck,
+  codeGraphGrep: () => codeGraphGrep,
+  codeGraphMap: () => codeGraphMap,
+  codeGraphSkeleton: () => codeGraphSkeleton,
+  codeGraphTrace: () => codeGraphTrace,
+  isCleanDrift: () => isCleanDrift,
+  resolveSymbolNodes: () => resolveSymbolNodes
+});
+import { join as join6 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+function load(opts) {
+  const graph = loadFreshGraph(opts.project, opts.refresh ?? true);
+  if (!graph) return null;
+  const nodes = graphNodes(graph);
+  return { graph, nodes, byId: new Map(nodes.map((n) => [n.id, n])) };
+}
+function normalizePrefix(prefix) {
+  return prefix.split("\\").join("/").replace(/\/+$/, "");
+}
+function underPrefix(path, prefix) {
+  return prefix === "" || path === prefix || path.startsWith(`${prefix}/`);
+}
+function savingsFor(nodes, paths) {
+  const sizes = /* @__PURE__ */ new Map();
+  for (const n of nodes) if (n.kind === "file" && typeof n.chars === "number") sizes.set(n.path, n.chars);
+  let baselineChars = 0;
+  let files = 0;
+  for (const p of new Set(paths)) {
+    const c = sizes.get(p);
+    if (c === void 0) continue;
+    baselineChars += c;
+    files++;
+  }
+  return files > 0 ? { files, baselineChars } : void 0;
+}
+function sliceSpan(root, path, from, to) {
+  try {
+    const lines = readFileSync6(join6(root, path), "utf8").split("\n");
+    const start = Math.max(1, from);
+    const end = Math.min(lines.length, to);
+    const slice = lines.slice(start - 1, end);
+    if (slice.length > MAX_SPAN_LINES) {
+      const head = slice.slice(0, MAX_SPAN_LINES);
+      head.push(`... (+${slice.length - MAX_SPAN_LINES} more lines; open ${path}:${start}-${end})`);
+      return head.join("\n");
+    }
+    return slice.join("\n");
+  } catch {
+    return null;
+  }
+}
+function resolveSymbolNodes(nodes, query, inPrefix) {
+  const lower = query.toLowerCase();
+  const suffixHash = `#${lower}`;
+  const suffixDot = `.${lower}`;
+  const stripOrdinals = (s) => s.replace(/~\d+(?=\.|$)/g, "");
+  let matches = nodes.filter((n) => {
+    if (n.kind === "file") return false;
+    if (n.name.toLowerCase() === lower) return true;
+    const id = n.id.toLowerCase();
+    const hash = id.indexOf("#");
+    const candidate = hash === -1 ? id : id.slice(0, hash + 1) + stripOrdinals(id.slice(hash + 1));
+    return candidate.endsWith(suffixHash) || candidate.endsWith(suffixDot);
+  });
+  if (!matches.length && query.includes(".")) {
+    const last = query.slice(query.lastIndexOf(".") + 1).toLowerCase();
+    if (last) matches = nodes.filter((n) => n.kind !== "file" && n.name.toLowerCase() === last);
+  }
+  if (!matches.length && query.includes(".") && !query.includes("#")) {
+    matches = nodes.filter((n) => n.kind === "file" && (n.path.toLowerCase() === lower || n.path.toLowerCase().endsWith(`/${lower}`)));
+  }
+  if (inPrefix !== void 0) matches = matches.filter((n) => underPrefix(n.path, inPrefix));
+  return matches;
+}
+function toHit(n, score, relation) {
+  return {
+    kind: relation ? relation === "imports" ? "callee" : "symbol" : "symbol",
+    name: n.name,
+    symbolKind: n.kind,
+    path: n.path,
+    line: n.line,
+    endLine: n.endLine,
+    signature: n.signature,
+    score,
+    relation
+  };
+}
+function findSubject(query, nodes, inPrefix) {
+  const words = [...new Set(query.split(/[^A-Za-z0-9_.]+/).filter(Boolean))].sort((a, b) => b.length - a.length);
+  for (const w of words) {
+    const hits = resolveSymbolNodes(nodes, w, inPrefix);
+    if (hits.length) return { subject: hits, tried: w };
+  }
+  return { subject: [], tried: words[0] ?? query };
+}
+function structuralAsk(query, loaded, limit, inPrefix) {
+  const wantsIn = INCOMING.test(query);
+  const wantsOut = OUTGOING.test(query);
+  if (!wantsIn && !wantsOut) return null;
+  const { subject, tried } = findSubject(query, loaded.nodes, inPrefix);
+  const nudge = (name) => `No indexed edges for '${name}'. Showing word matches instead; for exact edges try: enigma codegraph callers ${name}`;
+  if (!subject.length) return { fallthrough: nudge(tried) };
+  const ids = new Set(subject.map((n) => n.id));
+  const outgoing = wantsOut && !wantsIn;
+  const rels = new Set(outgoing ? OUTGOING_RELS : INCOMING_RELS);
+  const hits = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [source, target, rel] of loaded.graph.edges) {
+    if (!rels.has(rel)) continue;
+    const anchor = outgoing ? source : target;
+    const other = outgoing ? target : source;
+    if (!ids.has(anchor) || seen.has(other + rel)) continue;
+    seen.add(other + rel);
+    const node = loaded.byId.get(other);
+    if (!node) continue;
+    if (inPrefix !== void 0 && !underPrefix(node.path, inPrefix)) continue;
+    hits.push({ ...toHit(node, 1, rel), kind: outgoing ? "callee" : "caller" });
+  }
+  if (!hits.length) return { fallthrough: nudge(subject[0].name) };
+  hits.sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line);
+  return {
+    query,
+    mode: "structural",
+    subject: subject[0].name,
+    hits: hits.slice(0, limit),
+    note: outgoing ? `outgoing edges from ${subject[0].name}` : `callers and references of ${subject[0].name}`
+  };
+}
+function lexicalAsk(query, loaded, limit, inPrefix) {
+  const q = new Map([...counts(tokenize(query)).keys()].map((t) => [t, 1]));
+  const bodies = loadBodyIndex(loaded.graph.id);
+  const wantsTests = /\b(tests?|specs?|coverage|assert(?:ion)?s?|fixtures?|mocks?)\b/i.test(query);
+  const testFactor = (path) => !wantsTests && isTestPath(path) ? TEST_PENALTY : 1;
+  const nodes = inPrefix === void 0 ? loaded.nodes : loaded.nodes.filter((n) => underPrefix(n.path, inPrefix));
+  const docs = nodes.map((n) => ({
+    n,
+    name: counts(tokenize(n.name)),
+    path: counts(tokenize(n.path)),
+    body: mergeBags(counts(tokenize(n.signature)), bodies.get(n.id))
+  }));
+  if (!docs.length) {
+    return {
+      query,
+      mode: "empty",
+      hits: [],
+      note: loaded.nodes.length ? `No indexed files under '${inPrefix}'. Check the path, or widen it by dropping --in.` : NOT_INDEXED
+    };
+  }
+  const idf = computeIdf(docs.map((d) => /* @__PURE__ */ new Set([...d.name.keys(), ...d.path.keys(), ...d.body.keys()])));
+  const defaultIdf = Math.log(1 + docs.length);
+  const avgBody = docs.reduce((a, d) => a + bagLength(d.body), 0) / docs.length;
+  const lex = /* @__PURE__ */ new Map();
+  let maxLex = 0;
+  for (const { n, name, path, body } of docs) {
+    const total = (overlapScore(q, name, idf) * 3 + overlapScore(q, path, idf) * 2 + bm25(q, body, idf, bagLength(body), avgBody)) * testFactor(n.path);
+    if (total > 0) {
+      lex.set(n.id, total);
+      maxLex = Math.max(maxLex, total);
+    }
+  }
+  const allowed = inPrefix === void 0 ? void 0 : (id) => underPrefix(loaded.byId.get(id)?.path ?? "", inPrefix);
+  const pr = lex.size ? personalizedPageRank(nodes.map((n) => n.id), loaded.graph.edges, lex, { nodeFilter: allowed }) : /* @__PURE__ */ new Map();
+  const candidates = new Set(lex.keys());
+  for (const [id, p] of pr) if (p >= RESCUE_FLOOR) candidates.add(id);
+  const docById = new Map(docs.map((d) => [d.n.id, d]));
+  const hits = [];
+  const coverageOf = /* @__PURE__ */ new Map();
+  const strengthOf = /* @__PURE__ */ new Map();
+  for (const id of candidates) {
+    const n = loaded.byId.get(id);
+    if (!n) continue;
+    const lexN = maxLex > 0 ? (lex.get(id) ?? 0) / maxLex : 0;
+    const blended = (lexN + GRAPH_WEIGHT * (pr.get(id) ?? 0)) * testFactor(n.path);
+    if (blended <= 0) continue;
+    const hit = toHit(n, blended);
+    const d = docById.get(id);
+    coverageOf.set(hit, d ? matchedShare(q, [d.name, d.path, d.body], idf, defaultIdf) : 0);
+    strengthOf.set(hit, d && n.kind !== "file" ? matchedShare(q, [d.name], idf, defaultIdf) : 0);
+    hits.push(hit);
+  }
+  hits.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path) || a.line - b.line);
+  const top = hits.slice(0, limit);
+  return {
+    query,
+    mode: hits.length ? "lexical" : "empty",
+    hits: top,
+    coverage: hits.length && q.size ? coverageOf.get(hits[0]) : void 0,
+    coverageStrong: hits.length && q.size ? strengthOf.get(hits[0]) : void 0,
+    note: hits.length ? void 0 : "No matching nodes. Try different words, or re-index: enigma codegraph index"
+  };
+}
+function mergeBags(a, b) {
+  if (!b) return a;
+  const out = new Map(a);
+  for (const [t, c] of b) out.set(t, (out.get(t) ?? 0) + c);
+  return out;
+}
+function codeGraphAsk(query, opts = {}) {
+  const loaded = load(opts);
+  if (!loaded) return null;
+  const limit = opts.limit ?? 8;
+  const inPrefix = opts.in === void 0 ? void 0 : normalizePrefix(opts.in);
+  const structural = structuralAsk(query, loaded, limit, inPrefix);
+  let result;
+  if (structural && "hits" in structural) {
+    result = structural;
+  } else {
+    result = lexicalAsk(query, loaded, limit, inPrefix);
+    if (structural) result.note = result.note ? `${structural.fallthrough}
+${result.note}` : structural.fallthrough;
+  }
+  if (opts.source) {
+    for (const h of result.hits) {
+      const code = sliceSpan(loaded.graph.root, h.path, h.line, h.endLine);
+      if (code) h.code = code;
+    }
+    result.saved = savingsFor(loaded.nodes, result.hits.map((h) => h.path));
+  }
+  return result;
+}
+function adjacency(edges, direction) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const [source, target, rel] of edges) {
+    if (!WALK_RELATIONS.has(rel)) continue;
+    const key = direction === "in" ? target : source;
+    const other = direction === "in" ? source : target;
+    const entry = { other, relation: rel };
+    const arr = adj.get(key);
+    if (arr) arr.push(entry);
+    else adj.set(key, [entry]);
+  }
+  return adj;
+}
+function codeGraphTrace(symbol, opts = {}) {
+  const loaded = load(opts);
+  if (!loaded) return null;
+  const direction = opts.direction ?? "in";
+  const depth = Math.max(1, opts.depth ?? 1);
+  const inPrefix = opts.in === void 0 ? void 0 : normalizePrefix(opts.in);
+  const matches = resolveSymbolNodes(loaded.nodes, symbol, inPrefix);
+  if (!matches.length) {
+    return { symbol, direction, depth, matched: [], hits: [], note: `No symbol named '${symbol}' in the graph. Try: enigma codegraph search ${symbol}` };
+  }
+  const seeds = [...matches];
+  for (const m of matches) {
+    if (m.kind !== "file") continue;
+    for (const n of loaded.nodes) if (n.kind !== "file" && n.path === m.path) seeds.push(n);
+  }
+  const adj = adjacency(loaded.graph.edges, direction);
+  const visited = new Set(seeds.map((s) => s.id));
+  const hits = [];
+  let frontier = [...visited];
+  for (let d = 1; d <= depth && frontier.length; d++) {
+    const next = [];
+    for (const current of frontier) {
+      for (const { other, relation } of adj.get(current) ?? []) {
+        if (visited.has(other)) continue;
+        visited.add(other);
+        const node = loaded.byId.get(other);
+        if (!node) continue;
+        if (inPrefix !== void 0 && !underPrefix(node.path, inPrefix)) continue;
+        hits.push({ id: other, name: node.name, kind: node.kind, path: node.path, line: node.line, relation, depth: d });
+        next.push(other);
+      }
+    }
+    frontier = next;
+  }
+  hits.sort((a, b) => a.depth - b.depth || a.path.localeCompare(b.path) || a.line - b.line);
+  return {
+    symbol,
+    direction,
+    depth,
+    matched: matches.map((m) => ({ name: m.name, path: m.path, line: m.line })),
+    hits,
+    note: hits.length ? void 0 : `'${symbol}' resolved, but the graph has no ${direction === "in" ? "inbound" : "outbound"} edges for it.`
+  };
+}
+function codeGraphSkeleton(file, opts = {}) {
+  const loaded = load(opts);
+  if (!loaded) return null;
+  const want = normalizePrefix(file);
+  let defs = loaded.nodes.filter((n) => n.kind !== "file" && n.path === want);
+  if (!defs.length) {
+    const paths = new Set(loaded.nodes.filter((n) => n.path === want || n.path.endsWith(`/${want}`)).map((n) => n.path));
+    if (paths.size > 1) return { file: want, entries: [], note: `Ambiguous. Matches: ${[...paths].sort().join(", ")}` };
+    const [path] = paths;
+    if (path) defs = loaded.nodes.filter((n) => n.kind !== "file" && n.path === path);
+  }
+  if (!defs.length) return { file: want, entries: [], note: "No definitions indexed for this file." };
+  defs.sort((a, b) => a.line - b.line);
+  return {
+    file: defs[0].path,
+    entries: defs.map((n) => ({ name: n.name, kind: n.kind, line: n.line, endLine: n.endLine, signature: n.signature })),
+    saved: savingsFor(loaded.nodes, [defs[0].path])
+  };
+}
+function dirKey(path, depth) {
+  const segments = path.split("/");
+  return segments.slice(0, Math.min(depth, segments.length)).join("/");
+}
+function topHubs(nodes, deg, cap) {
+  return nodes.map((n) => ({ name: n.name, kind: n.kind, path: n.path, line: n.line, inDegree: deg.get(n.id) ?? 0 })).filter((h) => h.inDegree > 0).sort((a, b) => b.inDegree - a.inDegree || a.name.localeCompare(b.name) || a.path.localeCompare(b.path)).slice(0, cap);
+}
+function codeGraphMap(opts = {}) {
+  const loaded = load(opts);
+  if (!loaded) return null;
+  const maxDirs = opts.maxDirs ?? DEFAULT_MAX_DIRS;
+  const inPrefix = opts.in === void 0 ? void 0 : normalizePrefix(opts.in);
+  const nodes = inPrefix === void 0 ? loaded.nodes : loaded.nodes.filter((n) => underPrefix(n.path, inPrefix));
+  const deg = inDegree(loaded.graph.edges, true);
+  const fileNodes = nodes.filter((n) => n.kind === "file");
+  const langByPath = new Map(loaded.graph.files.map((f) => [f.path, f.lang]));
+  const depth1 = /* @__PURE__ */ new Map();
+  for (const n of fileNodes) depth1.set(dirKey(n.path, 1), (depth1.get(dirKey(n.path, 1)) ?? 0) + 1);
+  let splitSegment = null;
+  for (const [seg, count] of depth1) {
+    if (!fileNodes.length || count / fileNodes.length <= SPLIT_THRESHOLD) continue;
+    const subdirs = new Set(fileNodes.filter((n) => dirKey(n.path, 1) === seg && n.path.split("/").length > 2).map((n) => dirKey(n.path, 2)));
+    if (subdirs.size >= 2) splitSegment = seg;
+    break;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    const key = dirKey(n.path, splitSegment !== null && dirKey(n.path, 1) === splitSegment ? 2 : 1);
+    let g = groups.get(key);
+    if (!g) {
+      g = { files: [], symbols: [] };
+      groups.set(key, g);
+    }
+    if (n.kind === "file") g.files.push(n);
+    else g.symbols.push(n);
+  }
+  const filePaths = new Set(fileNodes.map((f) => f.path));
+  const dirs = [...groups.entries()].map(([path, g]) => ({
+    path,
+    files: g.files.length,
+    symbols: g.symbols.length,
+    languages: [...new Set(g.files.map((f) => langByPath.get(f.path)).filter((l) => !!l))].sort(),
+    hubs: topHubs(g.symbols, deg, DEFAULT_HUBS_PER_DIR),
+    isFile: filePaths.has(path)
+  })).sort((a, b) => b.symbols - a.symbols || a.path.localeCompare(b.path));
+  const symbols = nodes.filter((n) => n.kind !== "file");
+  const shown = dirs.slice(0, maxDirs);
+  const hotspots = topHubs(symbols, deg, DEFAULT_HOTSPOTS);
+  const surfaced = [...shown.flatMap((d) => d.hubs.map((h) => h.path)), ...hotspots.map((h) => h.path)];
+  return {
+    totals: {
+      files: fileNodes.length,
+      symbols: symbols.length,
+      edges: loaded.graph.edges.length,
+      languages: [...new Set(fileNodes.map((f) => langByPath.get(f.path)).filter((l) => !!l))].sort()
+    },
+    dirs: shown,
+    hotspots,
+    dropped: Math.max(0, dirs.length - maxDirs),
+    truncated: loaded.graph.truncated === true,
+    saved: savingsFor(loaded.nodes, surfaced)
+  };
+}
+function compileGrep(pattern, opts) {
+  const flags = opts.ignoreCase ? "i" : "";
+  if (opts.fixed) return new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags);
+  try {
+    return new RegExp(pattern, flags);
+  } catch (e) {
+    throw new Error(`invalid regex '${pattern}': ${e.message} - pass --fixed to search for it literally.`);
+  }
+}
+function codeGraphGrep(pattern, opts = {}) {
+  const loaded = load(opts);
+  if (!loaded) return null;
+  const maxHits = opts.maxHits ?? DEFAULT_MAX_HITS;
+  const regex = compileGrep(pattern, opts);
+  const inPrefix = opts.in === void 0 ? void 0 : normalizePrefix(opts.in);
+  const deg = inDegree(loaded.graph.edges, true);
+  const spansByFile = /* @__PURE__ */ new Map();
+  for (const n of loaded.nodes) {
+    if (n.kind === "file") continue;
+    const arr = spansByFile.get(n.path);
+    if (arr) arr.push(n);
+    else spansByFile.set(n.path, [n]);
+  }
+  for (const arr of spansByFile.values()) arr.sort((a, b) => a.line - b.line);
+  const files = loaded.nodes.filter((n) => n.kind === "file" && (inPrefix === void 0 || underPrefix(n.path, inPrefix)));
+  const groups = /* @__PURE__ */ new Map();
+  let collected = 0;
+  let truncatedHits = 0;
+  let truncatedFiles = 0;
+  for (const file of files) {
+    let text;
+    try {
+      text = readFileSync6(join6(loaded.graph.root, file.path), "utf8");
+    } catch {
+      truncatedFiles++;
+      continue;
+    }
+    const spans = spansByFile.get(file.path) ?? [];
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (!regex.test(lines[i])) continue;
+      if (collected >= maxHits) {
+        truncatedHits++;
+        continue;
+      }
+      collected++;
+      const lineNo = i + 1;
+      let sym = null;
+      for (const s of spans) {
+        if (s.line > lineNo) break;
+        if (lineNo <= s.endLine) sym = s;
+      }
+      const key = sym ? sym.id : `file:${file.path}`;
+      let group = groups.get(key);
+      if (!group) {
+        group = {
+          symbol: sym ? { name: sym.name, kind: sym.kind, line: sym.line, endLine: sym.endLine } : null,
+          path: file.path,
+          inDegree: sym ? deg.get(sym.id) ?? 0 : 0,
+          hits: []
+        };
+        groups.set(key, group);
+      }
+      const trimmed = lines[i].trim();
+      group.hits.push({ line: lineNo, text: trimmed.length > MAX_HIT_TEXT ? trimmed.slice(0, MAX_HIT_TEXT) : trimmed });
+    }
+  }
+  const sorted = [...groups.values()].sort((a, b) => b.inDegree - a.inDegree || a.path.localeCompare(b.path) || (a.symbol?.line ?? 0) - (b.symbol?.line ?? 0));
+  return {
+    pattern,
+    filesSearched: files.length,
+    totalHits: collected,
+    groups: sorted,
+    truncated: { files: truncatedFiles, hits: truncatedHits, unindexedFiles: loaded.graph.truncated === true },
+    saved: savingsFor(loaded.nodes, sorted.map((g) => g.path))
+  };
+}
+function codeGraphCheck(project) {
+  const graph = loadFreshGraph(project, false);
+  if (!graph) return null;
+  const drift = probeDrift(graph);
+  return {
+    project: graph.name,
+    root: graph.root,
+    indexedAt: graph.indexedAt,
+    drift,
+    stale: driftCount(drift),
+    truncated: graph.truncated === true
+  };
+}
+var NOT_INDEXED, MAX_SPAN_LINES, INCOMING, OUTGOING, INCOMING_RELS, OUTGOING_RELS, GRAPH_WEIGHT, RESCUE_FLOOR, TEST_PENALTY, DEFAULT_MAX_DIRS, DEFAULT_HUBS_PER_DIR, DEFAULT_HOTSPOTS, SPLIT_THRESHOLD, DEFAULT_MAX_HITS, MAX_HIT_TEXT;
+var init_codegraph_query = __esm({
+  "src/codegraph-query.ts"() {
+    "use strict";
+    init_codegraph();
+    init_codegraph_rank();
+    init_codegraph();
+    NOT_INDEXED = "No project indexed yet. Run: enigma codegraph index";
+    MAX_SPAN_LINES = 80;
+    INCOMING = /\b(caller|callers|calls?\s+into|who\s+calls|what\s+calls|called\s+by|used\s+by|uses|who\s+imports?|what\s+imports?|imported\s+by|importers?)\b/i;
+    OUTGOING = /\b(callee|callees|calls\s+what|imports?|depends\s+on)\b/i;
+    INCOMING_RELS = ["calls", "references", "implements", "extends"];
+    OUTGOING_RELS = ["calls", "references", "imports", "implements", "extends"];
+    GRAPH_WEIGHT = 0.5;
+    RESCUE_FLOOR = 0.15;
+    TEST_PENALTY = 0.35;
+    DEFAULT_MAX_DIRS = 16;
+    DEFAULT_HUBS_PER_DIR = 3;
+    DEFAULT_HOTSPOTS = 12;
+    SPLIT_THRESHOLD = 0.6;
+    DEFAULT_MAX_HITS = 300;
+    MAX_HIT_TEXT = 160;
+  }
+});
+
+// src/codegraph-format.ts
+var codegraph_format_exports = {};
+__export(codegraph_format_exports, {
+  formatAsk: () => formatAsk,
+  formatFreshness: () => formatFreshness,
+  formatGrep: () => formatGrep,
+  formatMap: () => formatMap,
+  formatSkeleton: () => formatSkeleton,
+  formatSubgraph: () => formatSubgraph,
+  formatTrace: () => formatTrace
+});
+function toTokens(chars) {
+  return Math.round(chars / 4);
+}
+function savingsLine(saved, outputChars) {
+  if (!saved) return "";
+  const saved_ = Math.max(0, saved.baselineChars - outputChars);
+  return `
+
+~${toTokens(saved_).toLocaleString("en-US")} tokens saved vs reading ${saved.files} file${saved.files === 1 ? "" : "s"} whole.`;
+}
+function withSavings(body, saved) {
+  return body + savingsLine(saved, body.length);
+}
+function formatAsk(r) {
+  const head = `code graph - "${r.query}" (${r.mode})`;
+  if (!r.hits.length) return `${head}
+
+${r.note ?? "No matches."}
+`;
+  const lines = [head];
+  if (r.note) lines.push("", r.note);
+  lines.push("");
+  for (const h of r.hits) {
+    const where = h.symbolKind === "file" ? h.path : `${h.path}:${h.line}-${h.endLine}`;
+    lines.push(`- ${h.name} - ${h.symbolKind} - ${where}${h.relation ? ` (${h.relation})` : ""}`);
+    if (h.signature) lines.push(`    ${h.signature}`);
+    if (h.code) lines.push("", "```", h.code, "```", "");
+  }
+  if (r.coverage !== void 0 && r.coverage < 0.5) {
+    lines.push("", `Only ${Math.round(r.coverage * 100)}% of the query matched anything indexed - try naming a symbol or file directly.`);
+  }
+  return `${withSavings(lines.join("\n"), r.saved)}
+`;
+}
+function formatTrace(r) {
+  const empty = r.direction === "in" ? "Nothing depends on it." : "It depends on nothing indexed.";
+  const head = `${r.symbol} - ${r.direction === "in" ? "callers and references" : "outgoing dependencies"} (depth ${r.depth})`;
+  if (!r.matched.length || !r.hits.length) return `${head}
+
+${r.note ?? empty}
+`;
+  const lines = [head, ""];
+  lines.push(`defined at: ${r.matched.map((m) => `${m.path}:${m.line}`).join(", ")}`, "");
+  for (const h of r.hits) {
+    lines.push(`- ${h.name} - ${h.kind} - ${h.path}:${h.line} - ${h.relation}${r.depth > 1 ? ` - depth ${h.depth}` : ""}`);
+  }
+  lines.push("", `${r.hits.length} node${r.hits.length === 1 ? "" : "s"}.`);
+  return `${lines.join("\n")}
+`;
+}
+function formatSkeleton(r) {
+  const head = `code graph skeleton - ${r.file}`;
+  if (!r.entries.length) return `${head}
+
+${r.note ?? "No definitions."}
+`;
+  const lines = r.entries.map((e) => `- ${e.line}-${e.endLine}  ${e.kind} ${e.name}${e.signature ? `  ${e.signature}` : ""}`);
+  return `${withSavings([head, "", ...lines].join("\n"), r.saved)}
+`;
+}
+function formatMap(r) {
+  const { totals } = r;
+  const lines = [`repo map - ${totals.files} files - ${totals.symbols} symbols - ${totals.edges} edges - ${totals.languages.join(", ")}`, ""];
+  for (const d of r.dirs) {
+    const label = (d.isFile ? d.path : `${d.path}/`).padEnd(DIR_COL_WIDTH);
+    const hubs = d.hubs.length ? `   hubs: ${d.hubs.map((h) => `${h.name} (${h.path.split("/").pop()}, ${h.inDegree} in)`).join(", ")}` : "";
+    lines.push(`${label}${d.files} files - ${d.symbols} symbols${hubs}`);
+  }
+  if (r.dropped > 0) lines.push(`... +${r.dropped} more director${r.dropped === 1 ? "y" : "ies"} not shown (raise --max-dirs to see them)`);
+  if (r.hotspots.length) {
+    lines.push("", "hotspots:");
+    for (const h of r.hotspots) lines.push(`  ${h.name} - ${h.kind} - ${h.path}:${h.line} - ${h.inDegree} in`);
+  }
+  if (r.truncated) lines.push("", INCOMPLETE_INDEX);
+  return `${withSavings(lines.join("\n"), r.saved)}
+`;
+}
+function formatGrep(r) {
+  const head = `"${r.pattern}" - ${r.totalHits} hit${r.totalHits === 1 ? "" : "s"} in ${r.groups.length} symbol${r.groups.length === 1 ? "" : "s"} (searched ${r.filesSearched} indexed files)`;
+  const notes = [];
+  if (r.truncated.hits > 0) notes.push(`+${r.truncated.hits} more hits past the cap (raise --max-hits).`);
+  if (r.truncated.files > 0) notes.push(`${r.truncated.files} indexed file${r.truncated.files === 1 ? "" : "s"} could not be read.`);
+  if (r.truncated.unindexedFiles) notes.push(INCOMPLETE_INDEX);
+  if (!r.groups.length) return `${head}${notes.length ? `
+
+${notes.join("\n")}` : ""}
+`;
+  const lines = [head, ""];
+  for (const g of r.groups) {
+    const where = g.symbol ? `${g.symbol.name} - ${g.symbol.kind} - ${g.path}:${g.symbol.line}-${g.symbol.endLine} - ${g.inDegree} in` : `${g.path} - module level`;
+    lines.push(where);
+    for (const h of g.hits) lines.push(`  ${h.line}: ${h.text}`);
+    lines.push("");
+  }
+  lines.push(...notes);
+  return `${withSavings(lines.join("\n").trimEnd(), r.saved)}
+`;
+}
+function sliceShare(shown, total) {
+  if (!total || !shown) return "0%";
+  const pct = shown / total * 100;
+  return pct < 1 ? "<1%" : `${Math.round(pct)}%`;
+}
+function formatSubgraph(r) {
+  const what = r.focus ? `around ${r.focus.map((f) => `${f.name} (${f.path}:${f.line})`).join(", ")}` : `${r.scope} overview`;
+  const head = `${r.project} - graph slice: ${what}`;
+  if (!r.nodes.length) return `${head}
+
+${r.note ?? "Nothing to draw."}
+`;
+  const lines = [
+    head,
+    "",
+    // Against the population this scope draws from: a file slice carries import edges only,
+    // so measuring it against the symbol graph's total understates it several times over.
+    `${r.nodes.length} nodes - ${r.edges.length} edges - depth ${r.depth} - ${sliceShare(r.edges.length, r.scope === "files" ? r.totals.importEdges : r.totals.edges)} of the graph's wiring`,
+    ""
+  ];
+  const out = /* @__PURE__ */ new Map();
+  for (const e of r.edges) {
+    const arr = out.get(e.source);
+    if (arr) arr.push(`${e.relation} ${e.target}`);
+    else out.set(e.source, [`${e.relation} ${e.target}`]);
+  }
+  for (const n of r.nodes.slice(0, 40)) {
+    const where = n.kind === "file" ? n.path : `${n.path}:${n.line}`;
+    const links = out.get(n.id) ?? [];
+    lines.push(`- ${n.name} - ${n.kind} - ${where} (${n.inDegree} in${n.hidden ? `, +${n.hidden} hidden` : ""})`);
+    for (const l of links.slice(0, 6)) lines.push(`    -> ${l}`);
+    if (links.length > 6) lines.push(`    -> (+${links.length - 6} more)`);
+  }
+  if (r.nodes.length > 40) lines.push(`  (+${r.nodes.length - 40} more nodes; raise --limit or narrow with --in)`);
+  if (r.truncated) lines.push("", "TRUNCATED: the node cap was reached, so reachable nodes were left out.");
+  if (r.incomplete) lines.push("", INCOMPLETE_INDEX);
+  return `${lines.join("\n")}
+`;
+}
+function formatFreshness(r) {
+  const head = `${r.project} - indexed ${new Date(r.indexedAt).toISOString().replace("T", " ").slice(0, 16)}`;
+  const incomplete = r.truncated ? `
+
+${INCOMPLETE_INDEX}` : "";
+  if (r.stale === 0) return `${head}
+
+The graph matches the working tree.${incomplete}
+`;
+  const lines = [head, "", `${r.stale} file${r.stale === 1 ? "" : "s"} drifted since the last index:`];
+  const show = (label, paths) => {
+    if (!paths.length) return;
+    lines.push(`  ${label}: ${paths.slice(0, 10).join(", ")}${paths.length > 10 ? ` (+${paths.length - 10} more)` : ""}`);
+  };
+  show("changed", r.drift.changed);
+  show("added", r.drift.added);
+  show("removed", r.drift.removed);
+  lines.push("", "Re-index with: enigma codegraph index");
+  return `${lines.join("\n")}${incomplete}
+`;
+}
+var INCOMPLETE_INDEX, DIR_COL_WIDTH;
+var init_codegraph_format = __esm({
+  "src/codegraph-format.ts"() {
+    "use strict";
+    INCOMPLETE_INDEX = "INCOMPLETE: the last scan hit a limit (too many files, or files too large), so some files were never indexed.";
+    DIR_COL_WIDTH = 22;
+  }
+});
+
+// src/codegraph-hook.ts
+import { homedir as homedir3 } from "os";
+import { spawn } from "child_process";
+import { basename as basename2, join as join7, relative as relative3, resolve as resolve4 } from "path";
+
+// src/repo-keyed-file.ts
+import { dirname } from "path";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+var MAX_REPOS = 100;
+function readRepoKeyedFile(path, version) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!parsed || parsed.version !== version || typeof parsed.repos !== "object" || parsed.repos === null) return {};
+    return parsed.repos;
+  } catch {
+    return {};
+  }
+}
+function writeRepoKeyedFile(path, version, repos, recencyOf) {
+  let kept = repos;
+  const entries = Object.entries(repos);
+  if (entries.length > MAX_REPOS) {
+    entries.sort((a, b) => recencyOf(b[1]) - recencyOf(a[1]));
+    kept = Object.fromEntries(entries.slice(0, MAX_REPOS));
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  try {
+    writeFileSync(tmp, `${JSON.stringify({ version, repos: kept })}
+`);
+    renameSync(tmp, path);
+  } catch (err) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+    throw err;
+  }
+}
+
+// src/codegraph-hook.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync7, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
+var MIN_PROMPT_CHARS = 12;
+var PROMPT_HITS = 3;
+var STRONG_FLOOR = 0.25;
+var BROAD_FLOOR = 0.4;
+var INJECTED_CAP = 60;
+var BLAST_CAP = 12;
+function parsePayload(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function projectDir(input) {
+  return resolve4(process.env.CLAUDE_PROJECT_DIR || input.cwd || process.cwd());
+}
+function emit(event, additionalContext) {
+  process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: event, additionalContext } }));
+}
+function stateDir() {
+  return join7(process.env.ENIGMA_CODEGRAPH_DIR || join7(homedir3(), ".enigma", "codegraph"), "sessions");
+}
+function stateFile(dir, sessionId) {
+  const key = `${dir}|${sessionId}`.replace(/[^A-Za-z0-9]/g, "").slice(-40) || "default";
+  return join7(stateDir(), `${key}.json`);
+}
+function readState(dir, sessionId) {
+  try {
+    const parsed = JSON.parse(readFileSync7(stateFile(dir, sessionId), "utf8"));
+    return { injected: Array.isArray(parsed.injected) ? parsed.injected : [], dirty: parsed.dirty === true };
+  } catch {
+    return { injected: [], dirty: false };
+  }
+}
+function writeState(dir, sessionId, state) {
+  try {
+    mkdirSync4(stateDir(), { recursive: true });
+    writeFileSync5(stateFile(dir, sessionId), JSON.stringify({ injected: state.injected.slice(-INJECTED_CAP), dirty: state.dirty }));
+  } catch {
+  }
+}
+var STATUSLINE_SNAPSHOT_VERSION = 2;
+function projectRoot(cg, project, fallback) {
+  try {
+    return cg.listProjects().find((p) => p.id === project)?.root ?? fallback;
+  } catch {
+    return fallback;
+  }
+}
+function writeStatuslineSnapshot(root, symbols, stale) {
+  try {
+    const dir = process.env.ENIGMA_CODEGRAPH_DIR || join7(homedir3(), ".enigma", "codegraph");
+    const target = join7(dir, "statusline.json");
+    const repos = readRepoKeyedFile(target, STATUSLINE_SNAPSHOT_VERSION);
+    repos[root] = { root, symbols, stale, at: Date.now() };
+    writeRepoKeyedFile(target, STATUSLINE_SNAPSHOT_VERSION, repos, (s) => s.at);
+  } catch {
+  }
+}
+async function sessionStart(dir) {
+  const q = await Promise.resolve().then(() => (init_codegraph_query(), codegraph_query_exports));
+  const fmt = await Promise.resolve().then(() => (init_codegraph_format(), codegraph_format_exports));
+  const cg = await Promise.resolve().then(() => (init_codegraph(), codegraph_exports));
+  let project;
+  try {
+    project = cg.ensureProjectForCwd(dir);
+  } catch {
+    return;
+  }
+  const directive = [
+    "[enigma] This repo is indexed as a code graph. To find, understand or change code, ask the graph before grepping - it answers from a prebuilt index with exact file:line. Pick the ONE tool that fits and act on its answer; most tasks need a single call.",
+    `  - enigma_codegraph_ask: where a task's code lives, ranked, with the source inlined. The default for "how does X work" / "where is Y".`,
+    "  - enigma_codegraph_trace: exact edges. Who calls a symbol, or what it calls with direction out. Run it BEFORE changing anything shared.",
+    "  - enigma_codegraph_skeleton: a file's whole API surface, no bodies.",
+    "  - enigma_codegraph_grep: every occurrence, grouped by enclosing symbol - when you need them ALL, not the top matches."
+  ].join("\n");
+  const map = q.codeGraphMap({ project, refresh: false, maxDirs: 8 });
+  const fresh = q.codeGraphCheck(project);
+  const stale = fresh && fresh.stale > 0 ? `
+${fresh.stale} file(s) changed since the last index; the next query refreshes them.` : "";
+  writeStatuslineSnapshot(projectRoot(cg, project, dir), map?.totals.symbols ?? 0, fresh?.stale ?? 0);
+  emit("SessionStart", map ? `${directive}
+
+${fmt.formatMap(map).trimEnd()}${stale}` : directive);
+}
+function coveringProject(cg, dir) {
+  const project = cg.findProjectForCwd(dir);
+  if (project) return project;
+  backgroundIndex(cg, dir);
+  return null;
+}
+var INDEX_COOLDOWN_MS = 6e4;
+function indexMarkerFile(dir) {
+  const key = dir.replace(/[^A-Za-z0-9]/g, "").slice(-40) || "default";
+  return join7(stateDir(), `indexing-${key}`);
+}
+function claimIndex(dir) {
+  const file = indexMarkerFile(dir);
+  try {
+    const age = Date.now() - statSync3(file).mtimeMs;
+    if (age >= 0 && age < INDEX_COOLDOWN_MS) return false;
+  } catch {
+  }
+  try {
+    mkdirSync4(stateDir(), { recursive: true });
+    writeFileSync5(file, String(Date.now()));
+  } catch {
+  }
+  return true;
+}
+function backgroundIndex(cg, dir) {
+  if (cg.isManagedPath(dir) || !claimIndex(dir)) return;
+  try {
+    const child = spawn(process.execPath, [process.argv[1], "codegraph", "index", dir], { detached: true, stdio: "ignore", windowsHide: true });
+    child.unref();
+  } catch {
+  }
+}
+async function prompt(input, dir) {
+  const text = String(input.prompt ?? "").trim();
+  if (text.length < MIN_PROMPT_CHARS) return;
+  const q = await Promise.resolve().then(() => (init_codegraph_query(), codegraph_query_exports));
+  const cg = await Promise.resolve().then(() => (init_codegraph(), codegraph_exports));
+  const project = coveringProject(cg, dir);
+  if (!project) return;
+  const answer = q.codeGraphAsk(text, { project, refresh: false, limit: PROMPT_HITS * 2 });
+  if (!answer || !answer.hits.length) return;
+  if (answer.mode === "lexical" && (answer.coverageStrong ?? 0) < STRONG_FLOOR && (answer.coverage ?? 0) < BROAD_FLOOR) return;
+  const state = readState(dir, input.session_id ?? "default");
+  const seen = new Set(state.injected);
+  const pointer = (h) => `${h.path}:${h.line}`;
+  const fresh = answer.hits.filter((h) => !seen.has(pointer(h))).slice(0, PROMPT_HITS);
+  if (!fresh.length) return;
+  const lines = fresh.map((h) => `  - ${h.name} (${h.symbolKind}) ${h.path}:${h.line}-${h.endLine}`);
+  emit("UserPromptSubmit", `[enigma] Code graph - nodes this task touches (locators; read or ask for the source as needed):
+${lines.join("\n")}`);
+  state.injected = [...state.injected, ...fresh.map(pointer)];
+  writeState(dir, input.session_id ?? "default", state);
+}
+async function postEdit(input, dir) {
+  const file = input.tool_input?.file_path;
+  if (!file) return;
+  const q = await Promise.resolve().then(() => (init_codegraph_query(), codegraph_query_exports));
+  const cg = await Promise.resolve().then(() => (init_codegraph(), codegraph_exports));
+  const project = coveringProject(cg, dir);
+  if (!project) return;
+  const state = readState(dir, input.session_id ?? "default");
+  state.dirty = true;
+  writeState(dir, input.session_id ?? "default", state);
+  const rel = relative3(dir, resolve4(file)).split("\\").join("/");
+  if (!rel || rel.startsWith("..")) return;
+  const trace = q.codeGraphTrace(rel, { project, refresh: false, depth: 1 });
+  if (!trace || !trace.hits.length) return;
+  const shown = trace.hits.slice(0, BLAST_CAP);
+  const more = trace.hits.length - shown.length;
+  const lines = shown.map((h) => `  - ${h.name} (${h.kind}) ${h.path}:${h.line}`);
+  emit("PostToolUse", `[enigma] Blast radius of ${basename2(rel)} - ${trace.hits.length} dependent(s):
+${lines.join("\n")}${more > 0 ? `
+  ... +${more} more` : ""}`);
+}
+async function stop(input, dir) {
+  const sessionId = input.session_id ?? "default";
+  const state = readState(dir, sessionId);
+  if (!state.dirty) return;
+  writeState(dir, sessionId, { ...state, dirty: false });
+  const cg = await Promise.resolve().then(() => (init_codegraph(), codegraph_exports));
+  try {
+    const q = await Promise.resolve().then(() => (init_codegraph_query(), codegraph_query_exports));
+    const project = cg.findProjectForCwd(dir);
+    if (!project) throw new Error("not indexed yet");
+    const fresh = q.codeGraphCheck(project);
+    const map = q.codeGraphMap({ project, refresh: false });
+    writeStatuslineSnapshot(projectRoot(cg, project, dir), map?.totals.symbols ?? 0, fresh?.stale ?? 0);
+  } catch {
+  }
+  backgroundIndex(cg, dir);
+}
+async function runCodeGraphHook(event, payload) {
+  try {
+    const { readConfig: readConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    if (!readConfig2().config.codeGraph) return 0;
+    const input = parsePayload(payload);
+    const dir = projectDir(input);
+    if (!existsSync6(dir)) return 0;
+    if (event === "session-start") await sessionStart(dir);
+    else if (event === "prompt") await prompt(input, dir);
+    else if (event === "post-edit") await postEdit(input, dir);
+    else if (event === "stop") await stop(input, dir);
+  } catch {
+  }
+  return 0;
+}
+export {
+  runCodeGraphHook
+};