@neuralsea/workspace-indexer 0.2.0 → 0.3.2

package/dist/chunk-GGL3XTMV.js

@@ -0,0 +1,4487 @@
+// src/progress.ts
+function toHandler(progress) {
+  if (!progress) return null;
+  if (typeof progress === "function") return progress;
+  if (typeof progress.emit === "function") return (e) => progress.emit(e);
+  return null;
+}
+var IndexerProgressObservable = class {
+  handlers = /* @__PURE__ */ new Set();
+  subscribe(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  on(type, handler) {
+    const wrapped = (e) => {
+      if (e.type !== type) return;
+      handler(e);
+    };
+    return this.subscribe(wrapped);
+  }
+  emit(event) {
+    for (const h of this.handlers) {
+      try {
+        h(event);
+      } catch {
+      }
+    }
+  }
+};
+function asProgressSink(progress) {
+  const handler = toHandler(progress);
+  if (!handler) return null;
+  return { emit: handler };
+}
+
+// src/util.ts
+import crypto from "crypto";
+import os from "os";
+import path from "path";
+function sha256Hex(data) {
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+function defaultCacheDir() {
+  const home = os.homedir();
+  return path.join(home, ".cache", "petri");
+}
+function fromPosixPath(p) {
+  return p.split("/").join(path.sep);
+}
+function estimateTokens(text) {
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function normalise(vec) {
+  let sumSq = 0;
+  for (let i = 0; i < vec.length; i++) sumSq += vec[i] * vec[i];
+  const norm = Math.sqrt(sumSq) || 1;
+  const out = new Float32Array(vec.length);
+  for (let i = 0; i < vec.length; i++) out[i] = vec[i] / norm;
+  return out;
+}
+function dot(a, b) {
+  const n = Math.min(a.length, b.length);
+  let s = 0;
+  for (let i = 0; i < n; i++) s += a[i] * b[i];
+  return s;
+}
+function clamp(x, lo, hi) {
+  return Math.min(hi, Math.max(lo, x));
+}
+function makePreview(text, maxLen = 240) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length <= maxLen ? oneLine : oneLine.slice(0, maxLen - 1) + "\u2026";
+}
+function nowMs() {
+  return Date.now();
+}
+function recencyScore(fileMtimeMs, halfLifeDays = 14) {
+  const ageMs = Math.max(0, nowMs() - fileMtimeMs);
+  const halfLifeMs = halfLifeDays * 24 * 60 * 60 * 1e3;
+  const score = Math.pow(0.5, ageMs / Math.max(1, halfLifeMs));
+  return clamp(score, 0, 1);
+}
+
+// src/optionalTypescript.ts
+import { createRequire } from "module";
+var cached = null;
+var didTryLoad = false;
+function getTypeScript() {
+  if (didTryLoad) return cached;
+  try {
+    const require2 = createRequire(import.meta.url);
+    cached = require2("typescript");
+    didTryLoad = true;
+    return cached;
+  } catch {
+    cached = null;
+    didTryLoad = true;
+    return null;
+  }
+}
+
+// src/chunker.ts
+function languageFromPath(posixPath) {
+  const ext = posixPath.toLowerCase().split(".").pop() ?? "";
+  if (["ts", "tsx"].includes(ext)) return "typescript";
+  if (["js", "jsx", "mjs", "cjs"].includes(ext)) return "javascript";
+  if (["py"].includes(ext)) return "python";
+  if (["go"].includes(ext)) return "go";
+  if (["ctl", "ltl", "isl"].includes(ext)) return ext;
+  if (["ispec"].includes(ext)) return "isl";
+  if (["ca", "cpnexpr"].includes(ext)) return "colour-algebra";
+  if (["rs"].includes(ext)) return "rust";
+  if (["java"].includes(ext)) return "java";
+  if (["kt", "kts"].includes(ext)) return "kotlin";
+  if (["cs"].includes(ext)) return "csharp";
+  if (["md"].includes(ext)) return "markdown";
+  if (["json", "yaml", "yml", "toml"].includes(ext)) return "config";
+  return "text";
+}
+function chunkByLines(sourceText, cfg) {
+  const lines = sourceText.split(/\r?\n/);
+  const out = [];
+  const step = Math.max(1, cfg.maxLines - cfg.overlapLines);
+  for (let start = 0; start < lines.length; start += step) {
+    const end = Math.min(lines.length, start + cfg.maxLines);
+    const text = lines.slice(start, end).join("\n");
+    if (!text.trim()) continue;
+    out.push({
+      startLine: start + 1,
+      endLine: end,
+      text,
+      contentHash: sha256Hex(text),
+      tokens: estimateTokens(text)
+    });
+  }
+  return out;
+}
+function splitIfTooLarge(ch, cfg) {
+  if (ch.text.length <= cfg.maxChars) return [ch];
+  return chunkByLines(ch.text, cfg).map((sub) => ({
+    ...sub,
+    startLine: ch.startLine + (sub.startLine - 1),
+    endLine: ch.startLine + (sub.endLine - 1)
+  }));
+}
+function isTopLevelChunkable(tsMod, stmt) {
+  return tsMod.isFunctionDeclaration(stmt) || tsMod.isClassDeclaration(stmt) || tsMod.isInterfaceDeclaration(stmt) || tsMod.isTypeAliasDeclaration(stmt) || tsMod.isEnumDeclaration(stmt) || tsMod.isModuleDeclaration(stmt) || tsMod.isVariableStatement(stmt) || tsMod.isExportAssignment(stmt) || tsMod.isExportDeclaration(stmt);
+}
+function chunkTypeScriptLike(sourceText, virtualFileName, cfg) {
+  const tsMod = getTypeScript();
+  if (!tsMod) return chunkByLines(sourceText, cfg);
+  const sf = tsMod.createSourceFile(
+    virtualFileName,
+    sourceText,
+    tsMod.ScriptTarget.Latest,
+    true
+  );
+  const chunks = [];
+  for (const stmt of sf.statements) {
+    if (!isTopLevelChunkable(tsMod, stmt)) continue;
+    const startPos = stmt.getFullStart();
+    const endPos = stmt.end;
+    const startLC = tsMod.getLineAndCharacterOfPosition(sf, startPos);
+    const endLC = tsMod.getLineAndCharacterOfPosition(sf, endPos);
+    const text = sourceText.slice(startPos, endPos).trimEnd();
+    if (!text.trim()) continue;
+    const base = {
+      startLine: startLC.line + 1,
+      endLine: endLC.line + 1,
+      text,
+      contentHash: sha256Hex(text),
+      tokens: estimateTokens(text)
+    };
+    chunks.push(...splitIfTooLarge(base, cfg));
+  }
+  if (chunks.length === 0) return chunkByLines(sourceText, cfg);
+  return chunks;
+}
+function chunkSource(posixPath, sourceText, cfg) {
+  const language = languageFromPath(posixPath);
+  if (language === "typescript" || language === "javascript") {
+    return { language, chunks: chunkTypeScriptLike(sourceText, posixPath, cfg) };
+  }
+  return { language, chunks: chunkByLines(sourceText, cfg) };
+}
+
+// src/vector/factory.ts
+import path4 from "path";
+import { pathToFileURL } from "url";
+
+// src/vector/bruteforce.ts
+var BruteForceVectorIndex = class {
+  kind = "bruteforce";
+  metric = "cosine";
+  dimension = 0;
+  ids = [];
+  vecs = [];
+  pos = /* @__PURE__ */ new Map();
+  async init(init) {
+    this.metric = init.metric;
+    this.dimension = init.dimension;
+  }
+  async upsert(points) {
+    for (const p of points) this.upsertOne(p.id, p.vector);
+  }
+  upsertOne(id, vec) {
+    const v = normalise(vec);
+    const existing = this.pos.get(id);
+    if (existing !== void 0) {
+      this.vecs[existing] = v;
+      return;
+    }
+    this.pos.set(id, this.ids.length);
+    this.ids.push(id);
+    this.vecs.push(v);
+  }
+  async remove(ids) {
+    for (const id of ids) this.removeOne(id);
+  }
+  removeOne(id) {
+    const i = this.pos.get(id);
+    if (i === void 0) return;
+    const last = this.ids.length - 1;
+    if (i !== last) {
+      const lastId = this.ids[last];
+      this.ids[i] = lastId;
+      this.vecs[i] = this.vecs[last];
+      this.pos.set(lastId, i);
+    }
+    this.ids.pop();
+    this.vecs.pop();
+    this.pos.delete(id);
+  }
+  async rebuild(points) {
+    this.ids = [];
+    this.vecs = [];
+    this.pos = /* @__PURE__ */ new Map();
+    for (const p of points) this.upsertOne(p.id, p.vector);
+  }
+  async search(query, k) {
+    const q = normalise(query);
+    const top = [];
+    for (let i = 0; i < this.ids.length; i++) {
+      const s = dot(q, this.vecs[i]);
+      if (top.length < k) {
+        top.push({ id: this.ids[i], score: s });
+        top.sort((a, b) => b.score - a.score);
+      } else if (s > top[top.length - 1].score) {
+        top[top.length - 1] = { id: this.ids[i], score: s };
+        top.sort((a, b) => b.score - a.score);
+      }
+    }
+    return top;
+  }
+  async count() {
+    return this.ids.length;
+  }
+  async flush() {
+  }
+  async close() {
+  }
+};
+
+// src/vector/faiss.ts
+import fs from "fs";
+import path2 from "path";
+async function importFaiss() {
+  const modName = "faiss-node";
+  try {
+    const mod = await import(modName);
+    const ns = mod?.Index ? mod : mod?.default;
+    if (!ns?.Index) throw new Error("faiss-node did not export Index");
+    return ns;
+  } catch (e) {
+    const hint = "To use the 'faiss' provider, install the optional dependency: npm i faiss-node";
+    throw new Error(`${String(e?.message ?? e)}
+${hint}`);
+  }
+}
+function safeReadJson(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var FaissVectorIndex = class {
+  kind = "faiss";
+  metric = "cosine";
+  dimension = 0;
+  cfg;
+  index = null;
+  labelToId = [];
+  points = /* @__PURE__ */ new Map();
+  dirty = false;
+  readyForIncremental = false;
+  indexPath = "";
+  mapPath = "";
+  constructor(cfg = {}) {
+    this.cfg = {
+      descriptor: cfg.descriptor ?? "HNSW,Flat",
+      persist: cfg.persist ?? true,
+      persistDebounceMs: cfg.persistDebounceMs ?? 2e3,
+      rebuildStrategy: cfg.rebuildStrategy ?? "lazy"
+    };
+  }
+  async init(init) {
+    this.metric = init.metric;
+    this.dimension = init.dimension;
+    const baseDir = path2.join(init.cacheDir, "vector", init.repoId);
+    fs.mkdirSync(baseDir, { recursive: true });
+    this.indexPath = path2.join(baseDir, `${init.commit}.faiss.idx`);
+    this.mapPath = path2.join(baseDir, `${init.commit}.faiss.map.json`);
+    if (this.cfg.persist && fs.existsSync(this.indexPath) && fs.existsSync(this.mapPath)) {
+      const map = safeReadJson(this.mapPath);
+      if (map && map.version === 1 && map.dimension === this.dimension && map.metric === this.metric) {
+        const { Index } = await importFaiss();
+        this.index = Index.read(this.indexPath);
+        this.labelToId = map.labelToId;
+      }
+    }
+  }
+  async rebuild(points) {
+    this.points = new Map(points.map((p) => [p.id, p.vector]));
+    this.readyForIncremental = true;
+    await this.rebuildFromPoints();
+  }
+  async rebuildFromPoints() {
+    const { Index, MetricType } = await importFaiss();
+    const metric = this.metric === "l2" ? MetricType.METRIC_L2 : MetricType.METRIC_INNER_PRODUCT;
+    const idx = Index.fromFactory(this.dimension, this.cfg.descriptor, metric);
+    const ids = [];
+    const flat = [];
+    for (const [id, v] of this.points.entries()) {
+      ids.push(id);
+      const vec = this.metric === "cosine" ? normalise(v) : v;
+      for (let i = 0; i < vec.length; i++) flat.push(vec[i]);
+    }
+    if (flat.length > 0) {
+      if (typeof idx.isTrained === "function" && !idx.isTrained()) {
+        idx.train(flat);
+      }
+      idx.add(flat);
+    }
+    this.index = idx;
+    this.labelToId = ids;
+    this.dirty = false;
+    if (this.cfg.persist) {
+      const map = {
+        version: 1,
+        dimension: this.dimension,
+        metric: this.metric,
+        labelToId: ids
+      };
+      fs.writeFileSync(this.mapPath, JSON.stringify(map));
+      idx.write(this.indexPath);
+    }
+  }
+  async upsert(points) {
+    if (!this.readyForIncremental) {
+      throw new Error("FAISS provider requires an initial rebuild() before incremental writes.");
+    }
+    for (const p of points) this.points.set(p.id, p.vector);
+    this.dirty = true;
+    if (this.cfg.rebuildStrategy === "eager") await this.rebuildFromPoints();
+  }
+  async remove(ids) {
+    if (!this.readyForIncremental) {
+      throw new Error("FAISS provider requires an initial rebuild() before incremental writes.");
+    }
+    for (const id of ids) this.points.delete(id);
+    this.dirty = true;
+    if (this.cfg.rebuildStrategy === "eager") await this.rebuildFromPoints();
+  }
+  async search(query, k) {
+    if (this.dirty && this.cfg.rebuildStrategy === "lazy") {
+      await this.rebuildFromPoints();
+    }
+    if (!this.index) return [];
+    const q = this.metric === "cosine" ? Array.from(normalise(query)) : Array.from(query);
+    const res = this.index.search(q, k);
+    const out = [];
+    for (let i = 0; i < res.labels.length; i++) {
+      const label = res.labels[i];
+      if (label < 0) continue;
+      const id = this.labelToId[label];
+      if (!id) continue;
+      const d = res.distances[i];
+      const score = this.metric === "l2" ? -d : d;
+      out.push({ id, score });
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out;
+  }
+  async count() {
+    if (this.index && typeof this.index.ntotal === "function") return this.index.ntotal();
+    return this.labelToId.length;
+  }
+  async flush() {
+  }
+  async close() {
+    if (this.dirty && this.cfg.rebuildStrategy === "lazy") {
+      try {
+        await this.rebuildFromPoints();
+      } catch {
+      }
+    }
+    this.index = null;
+  }
+};
+
+// src/vector/hnswlib.ts
+import fs2 from "fs";
+import path3 from "path";
+async function importHnswlib() {
+  const modName = "hnswlib-node";
+  try {
+    const mod = await import(modName);
+    const ns = mod?.HierarchicalNSW ? mod : mod?.default;
+    if (!ns?.HierarchicalNSW) {
+      throw new Error("hnswlib-node did not export HierarchicalNSW");
+    }
+    return ns;
+  } catch (e) {
+    const hint = "To use the 'hnswlib' provider, install the optional dependency: npm i hnswlib-node";
+    throw new Error(`${String(e?.message ?? e)}
+${hint}`);
+  }
+}
+function safeReadJson2(p) {
+  try {
+    return JSON.parse(fs2.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var HnswlibVectorIndex = class {
+  kind = "hnswlib";
+  metric = "cosine";
+  dimension = 0;
+  cfg;
+  index = null;
+  idToLabel = /* @__PURE__ */ new Map();
+  labelToId = /* @__PURE__ */ new Map();
+  nextLabel = 0;
+  indexPath = "";
+  mapPath = "";
+  dirty = false;
+  constructor(cfg = {}) {
+    this.cfg = {
+      maxElements: cfg.maxElements ?? 5e4,
+      m: cfg.m ?? 16,
+      efConstruction: cfg.efConstruction ?? 200,
+      efSearch: cfg.efSearch ?? 64,
+      persist: cfg.persist ?? true,
+      persistDebounceMs: cfg.persistDebounceMs ?? 2e3
+    };
+  }
+  async init(init) {
+    this.metric = init.metric;
+    this.dimension = init.dimension;
+    const baseDir = path3.join(init.cacheDir, "vector", init.repoId);
+    fs2.mkdirSync(baseDir, { recursive: true });
+    this.indexPath = path3.join(baseDir, `${init.commit}.hnsw.dat`);
+    this.mapPath = path3.join(baseDir, `${init.commit}.hnsw.map.json`);
+    if (this.cfg.persist && fs2.existsSync(this.indexPath) && fs2.existsSync(this.mapPath)) {
+      const map = safeReadJson2(this.mapPath);
+      if (map && map.version === 1 && map.dimension === this.dimension && map.metric === this.metric) {
+        const { HierarchicalNSW } = await importHnswlib();
+        const space = this.toHnswSpace(this.metric);
+        const idx = new HierarchicalNSW(space, this.dimension);
+        idx.readIndexSync(this.indexPath, true);
+        if (typeof idx.setEf === "function") idx.setEf(this.cfg.efSearch);
+        this.index = idx;
+        this.idToLabel = new Map(Object.entries(map.idToLabel).map(([id, label]) => [id, label]));
+        this.labelToId = new Map(Array.from(this.idToLabel.entries()).map(([id, label]) => [label, id]));
+        this.nextLabel = Math.max(-1, ...Array.from(this.labelToId.keys())) + 1;
+        return;
+      }
+    }
+    await this.resetEmpty();
+  }
+  async resetEmpty() {
+    const { HierarchicalNSW } = await importHnswlib();
+    const idx = new HierarchicalNSW(this.toHnswSpace(this.metric), this.dimension);
+    idx.initIndex({
+      maxElements: this.cfg.maxElements,
+      m: this.cfg.m,
+      efConstruction: this.cfg.efConstruction,
+      allowReplaceDeleted: true
+    });
+    if (typeof idx.setEf === "function") idx.setEf(this.cfg.efSearch);
+    this.index = idx;
+    this.idToLabel = /* @__PURE__ */ new Map();
+    this.labelToId = /* @__PURE__ */ new Map();
+    this.nextLabel = 0;
+    this.dirty = false;
+  }
+  async rebuild(points) {
+    const desired = Math.max(this.cfg.maxElements, Math.ceil(points.length * 1.1) + 1024);
+    const { HierarchicalNSW } = await importHnswlib();
+    const idx = new HierarchicalNSW(this.toHnswSpace(this.metric), this.dimension);
+    idx.initIndex({
+      maxElements: desired,
+      m: this.cfg.m,
+      efConstruction: this.cfg.efConstruction,
+      allowReplaceDeleted: true
+    });
+    if (typeof idx.setEf === "function") idx.setEf(this.cfg.efSearch);
+    this.index = idx;
+    this.idToLabel = /* @__PURE__ */ new Map();
+    this.labelToId = /* @__PURE__ */ new Map();
+    this.nextLabel = 0;
+    for (const p of points) {
+      const label = this.nextLabel++;
+      this.idToLabel.set(p.id, label);
+      this.labelToId.set(label, p.id);
+      idx.addPoint(Array.from(normalise(p.vector)), label, true);
+    }
+    this.markDirty();
+    await this.flush();
+  }
+  async upsert(points) {
+    if (!this.index) throw new Error("HNSW index not initialised");
+    for (const p of points) {
+      let label = this.idToLabel.get(p.id);
+      if (label === void 0) {
+        label = this.nextLabel++;
+        this.idToLabel.set(p.id, label);
+        this.labelToId.set(label, p.id);
+      } else {
+        if (typeof this.index.unmarkDelete === "function") {
+          try {
+            this.index.unmarkDelete(label);
+          } catch {
+          }
+        }
+      }
+      if (typeof this.index.getMaxElements === "function" && typeof this.index.getCurrentCount === "function") {
+        const max = this.index.getMaxElements();
+        const cur = this.index.getCurrentCount();
+        if (cur + 1 > max && typeof this.index.resizeIndex === "function") {
+          this.index.resizeIndex(Math.ceil((cur + 1) * 1.2) + 1024);
+        }
+      }
+      this.index.addPoint(Array.from(normalise(p.vector)), label, true);
+    }
+    this.markDirty();
+  }
+  async remove(ids) {
+    if (!this.index) throw new Error("HNSW index not initialised");
+    for (const id of ids) {
+      const label = this.idToLabel.get(id);
+      if (label === void 0) continue;
+      if (typeof this.index.markDelete === "function") {
+        try {
+          this.index.markDelete(label);
+        } catch {
+        }
+      }
+    }
+    this.markDirty();
+  }
+  async search(query, k) {
+    if (!this.index) throw new Error("HNSW index not initialised");
+    const q = Array.from(normalise(query));
+    const res = this.index.searchKnn(q, k);
+    const out = [];
+    for (let i = 0; i < res.neighbors.length; i++) {
+      const label = res.neighbors[i];
+      if (label < 0) continue;
+      const id = this.labelToId.get(label);
+      if (!id) continue;
+      const d = res.distances[i];
+      const score = this.metric === "cosine" ? 1 - d : -d;
+      out.push({ id, score });
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out;
+  }
+  async count() {
+    if (!this.index) return 0;
+    if (typeof this.index.getCurrentCount === "function") return this.index.getCurrentCount();
+    return this.idToLabel.size;
+  }
+  markDirty() {
+    if (!this.cfg.persist) return;
+    this.dirty = true;
+  }
+  async flush() {
+    if (!this.cfg.persist) return;
+    if (!this.dirty) return;
+    if (!this.index) return;
+    this.dirty = false;
+    const map = {
+      version: 1,
+      dimension: this.dimension,
+      metric: this.metric,
+      idToLabel: Object.fromEntries(this.idToLabel.entries())
+    };
+    fs2.writeFileSync(this.mapPath, JSON.stringify(map));
+    this.index.writeIndexSync(this.indexPath);
+  }
+  async close() {
+    await this.flush();
+    this.index = null;
+  }
+  toHnswSpace(metric) {
+    if (metric === "l2") return "l2";
+    if (metric === "ip") return "ip";
+    return "cosine";
+  }
+};
+
+// src/vector/qdrant.ts
+import crypto2 from "crypto";
+async function importQdrant() {
+  const modName = "@qdrant/js-client-rest";
+  try {
+    const mod = await import(modName);
+    const ns = mod?.QdrantClient ? mod : mod?.default;
+    if (!ns?.QdrantClient) throw new Error("@qdrant/js-client-rest did not export QdrantClient");
+    return ns;
+  } catch (e) {
+    const hint = "To use the 'qdrant' provider, install the optional dependency: npm i @qdrant/js-client-rest";
+    throw new Error(`${String(e?.message ?? e)}
+${hint}`);
+  }
+}
+var PETRI_UUID_NAMESPACE = "b0f67f3b-2c75-44b8-9b4d-8f71a8a2f3f2";
+function uuidToBytes(uuid) {
+  const hex = uuid.replace(/-/g, "");
+  if (hex.length !== 32) throw new Error(`Invalid UUID: ${uuid}`);
+  const out = new Uint8Array(16);
+  for (let i = 0; i < 16; i++) out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+function bytesToUuid(b) {
+  const hex = Array.from(b).map((x) => x.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function uuidv5(name, namespace) {
+  const ns = uuidToBytes(namespace);
+  const nameBytes = Buffer.from(name, "utf8");
+  const hash = crypto2.createHash("sha1").update(ns).update(nameBytes).digest();
+  const out = new Uint8Array(hash.subarray(0, 16));
+  out[6] = out[6] & 15 | 80;
+  out[8] = out[8] & 63 | 128;
+  return bytesToUuid(out);
+}
+function sanitizeCollection(s) {
+  return s.toLowerCase().replace(/[^a-z0-9_\-]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").slice(0, 60);
+}
+var QdrantVectorIndex = class {
+  kind = "qdrant";
+  metric = "cosine";
+  dimension = 0;
+  cfg;
+  client = null;
+  collection = "";
+  commit = "";
+  collectionMode = "commit";
+  constructor(cfg = {}) {
+    this.cfg = {
+      url: cfg.url ?? "",
+      host: cfg.host ?? "localhost",
+      port: cfg.port ?? 6333,
+      apiKey: cfg.apiKey ?? "",
+      collectionPrefix: cfg.collectionPrefix ?? "petri",
+      collectionMode: cfg.collectionMode ?? "commit",
+      recreateOnRebuild: cfg.recreateOnRebuild ?? true
+    };
+  }
+  async init(init) {
+    this.metric = init.metric;
+    this.dimension = init.dimension;
+    this.commit = init.commit;
+    this.collectionMode = this.cfg.collectionMode;
+    const { QdrantClient } = await importQdrant();
+    const args = this.cfg.url ? { url: this.cfg.url, apiKey: this.cfg.apiKey || void 0 } : { host: this.cfg.host, port: this.cfg.port, apiKey: this.cfg.apiKey || void 0 };
+    this.client = new QdrantClient(args);
+    const repoPart = sanitizeCollection(init.repoId);
+    const metricPart = this.metric === "cosine" ? "cos" : this.metric;
+    const dimPart = String(this.dimension);
+    const commitPart = init.commit.slice(0, 8);
+    const prefix = sanitizeCollection(this.cfg.collectionPrefix);
+    this.collection = this.collectionMode === "commit" ? sanitizeCollection(`${prefix}_${repoPart}_${commitPart}_${dimPart}_${metricPart}`) : sanitizeCollection(`${prefix}_${repoPart}_${dimPart}_${metricPart}`);
+    await this.ensureCollection();
+  }
+  pointId(chunkId) {
+    const name = this.collectionMode === "commit" ? chunkId : `${this.commit}:${chunkId}`;
+    return uuidv5(name, PETRI_UUID_NAMESPACE);
+  }
+  commitFilter() {
+    return {
+      must: [{ key: "commit", match: { value: this.commit } }]
+    };
+  }
+  distanceName(metric) {
+    if (metric === "l2") return "Euclid";
+    if (metric === "ip") return "Dot";
+    return "Cosine";
+  }
+  async ensureCollection() {
+    if (!this.client) throw new Error("Qdrant client not initialised");
+    const existing = await this.client.getCollections();
+    const names = (existing?.collections ?? existing?.result?.collections ?? []).map((c) => c.name);
+    if (names.includes(this.collection)) return;
+    await this.client.createCollection(this.collection, {
+      vectors: { size: this.dimension, distance: this.distanceName(this.metric) }
+    });
+  }
+  async rebuild(points) {
+    if (!this.client) throw new Error("Qdrant client not initialised");
+    if (this.collectionMode === "commit") {
+      if (this.cfg.recreateOnRebuild) {
+        try {
+          await this.client.deleteCollection(this.collection);
+        } catch {
+        }
+      } else {
+        try {
+          await this.client.delete(this.collection, { filter: {} });
+        } catch {
+        }
+      }
+      await this.ensureCollection();
+    } else {
+      try {
+        await this.client.delete(this.collection, { filter: this.commitFilter() });
+      } catch {
+      }
+    }
+    const batchSize = 256;
+    for (let i = 0; i < points.length; i += batchSize) {
+      const batch = points.slice(i, i + batchSize);
+      await this.upsert(batch);
+    }
+  }
+  async upsert(points) {
+    if (!this.client) throw new Error("Qdrant client not initialised");
+    if (points.length === 0) return;
+    const qPoints = points.map((p) => {
+      const payload = { ...p.payload ?? {}, cid: p.id };
+      if (this.collectionMode === "repo") payload.commit = this.commit;
+      return {
+        id: this.pointId(p.id),
+        vector: Array.from(normalise(p.vector)),
+        payload
+      };
+    });
+    await this.client.upsert(this.collection, { points: qPoints });
+  }
+  async remove(ids) {
+    if (!this.client) throw new Error("Qdrant client not initialised");
+    if (ids.length === 0) return;
+    const pointIds = ids.map((id) => this.pointId(id));
+    await this.client.delete(this.collection, { points: pointIds });
+  }
+  async search(query, k) {
+    if (!this.client) throw new Error("Qdrant client not initialised");
+    const q = Array.from(normalise(query));
+    const req = {
+      query: q,
+      limit: k,
+      with_payload: true
+    };
+    if (this.collectionMode === "repo") req.filter = this.commitFilter();
+    let res;
+    if (typeof this.client.query === "function") {
+      res = await this.client.query(this.collection, req);
+    } else if (typeof this.client.search === "function") {
+      res = await this.client.search(this.collection, { vector: q, limit: k, with_payload: true, filter: req.filter });
+    } else {
+      throw new Error("Qdrant client missing query/search method");
+    }
+    const hits = res?.points ?? res?.result ?? res ?? [];
+    const out = [];
+    for (const h of hits) {
+      const payload = h.payload ?? h?.payloads;
+      const cid = payload?.cid;
+      if (!cid) continue;
+      const score = typeof h.score === "number" ? h.score : typeof h?.result?.score === "number" ? h.result.score : 0;
+      out.push({ id: String(cid), score });
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out;
+  }
+  async count() {
+    if (!this.client) return 0;
+    try {
+      if (this.collectionMode === "repo" && typeof this.client.count === "function") {
+        const res = await this.client.count(this.collection, { filter: this.commitFilter(), exact: false });
+        return Number(res?.count ?? res?.result?.count ?? 0);
+      }
+      const info = await this.client.getCollection(this.collection);
+      const c = info?.points_count ?? info?.result?.points_count;
+      if (typeof c === "number") return c;
+    } catch {
+    }
+    return 0;
+  }
+  async flush() {
+  }
+  async close() {
+    this.client = null;
+  }
+};
+
+// src/vector/factory.ts
+function isVectorIndex(obj) {
+  return obj && typeof obj.init === "function" && typeof obj.rebuild === "function" && typeof obj.upsert === "function" && typeof obj.remove === "function" && typeof obj.search === "function" && typeof obj.count === "function" && typeof obj.flush === "function" && typeof obj.close === "function";
+}
+async function createVectorIndex(vector) {
+  const provider = vector?.provider ?? "bruteforce";
+  if (provider === "bruteforce") return new BruteForceVectorIndex();
+  if (provider === "hnswlib") return new HnswlibVectorIndex(vector?.hnswlib);
+  if (provider === "qdrant") return new QdrantVectorIndex(vector?.qdrant);
+  if (provider === "faiss") return new FaissVectorIndex(vector?.faiss);
+  if (provider === "custom") {
+    const c = vector?.custom;
+    if (!c?.module) {
+      throw new Error("vector.provider=custom requires vector.custom.module");
+    }
+    const abs = path4.isAbsolute(c.module) ? c.module : path4.resolve(process.cwd(), c.module);
+    const url = pathToFileURL(abs).href;
+    const mod = await import(url);
+    const expName = c.export ?? "default";
+    const exp = mod[expName] ?? mod.default ?? mod;
+    const instance = typeof exp === "function" ? (
+      // If it's a class, `new` works; if it's a factory function, it should return a VectorIndex.
+      (() => {
+        try {
+          return new exp(c.options);
+        } catch {
+          return exp(c.options);
+        }
+      })()
+    ) : exp;
+    if (!isVectorIndex(instance)) {
+      throw new Error(
+        `Custom vector provider '${abs}' export '${expName}' did not produce a VectorIndex implementation.`
+      );
+    }
+    return instance;
+  }
+  if (provider === "auto") {
+    if (vector?.qdrant?.url || vector?.qdrant?.host) {
+      try {
+        const q = "@qdrant/js-client-rest";
+        await import(q);
+        return new QdrantVectorIndex(vector.qdrant);
+      } catch {
+      }
+    }
+    try {
+      const modName = "hnswlib-node";
+      await import(modName);
+      return new HnswlibVectorIndex(vector?.hnswlib);
+    } catch {
+      return new BruteForceVectorIndex();
+    }
+  }
+  return new BruteForceVectorIndex();
+}
+
+// src/symbolGraph/util.ts
+function stableSymbolId(input) {
+  const r = input.range;
+  const key = `repoRoot:${input.repoRoot}
+path:${input.path}
+lang:${input.language}
+kind:${input.kind}
+name:${input.name}
+range:${r.startLine}:${r.startCharacter}-${r.endLine}:${r.endCharacter}`;
+  return sha256Hex(key).slice(0, 32);
+}
+
+// src/ann/noop.ts
+var NoopAnnIndex = class {
+  id = "noop";
+  kind = "noop";
+  async init(_init) {
+  }
+  async upsert(_points) {
+  }
+  async remove(_ids) {
+  }
+  async search(_query, _k) {
+    return [];
+  }
+  async flush() {
+  }
+  async close() {
+  }
+};
+
+// src/ann/factory.ts
+function createAnnIndex(config) {
+  const provider = config?.provider ?? "noop";
+  if (provider === "noop") return new NoopAnnIndex();
+  if (provider === "faiss-pq") {
+    throw new Error("ANN provider 'faiss-pq' is not implemented yet (use provider=noop for now).");
+  }
+  return new NoopAnnIndex();
+}
+
+// src/indexer/repoIndexer.ts
+import fs9 from "fs";
+import path12 from "path";
+import pLimit from "p-limit";
+
+// src/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function git(repoRoot, args) {
+  const { stdout } = await execFileAsync("git", args, { cwd: repoRoot, encoding: "utf8" });
+  return stdout;
+}
+async function getHeadCommit(repoRoot) {
+  return (await git(repoRoot, ["rev-parse", "HEAD"])).trim();
+}
+async function getBranchName(repoRoot) {
+  return (await git(repoRoot, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+}
+async function listWorkingFiles(repoRoot) {
+  const out = await git(repoRoot, ["ls-files", "-z", "--cached", "--others", "--exclude-standard"]);
+  const parts = out.split("\0").map((s) => s.trim()).filter(Boolean);
+  const seen = /* @__PURE__ */ new Set();
+  const files = [];
+  for (const p of parts) {
+    if (!seen.has(p)) {
+      seen.add(p);
+      files.push(p);
+    }
+  }
+  return files;
+}
+async function listChangedFiles(repoRoot, baseRef = "HEAD~1") {
+  const out = await git(repoRoot, ["diff", "--name-only", "-z", `${baseRef}...HEAD`]);
+  return out.split("\0").map((s) => s.trim()).filter(Boolean);
+}
+
+// src/ignore.ts
+import fs3 from "fs";
+import path5 from "path";
+import ignore from "ignore";
+function loadExtraIgnore(repoRoot, ignoreFiles) {
+  const ig = ignore();
+  for (const name of ignoreFiles) {
+    const p = path5.join(repoRoot, name);
+    if (!fs3.existsSync(p)) continue;
+    const raw = fs3.readFileSync(p, "utf8");
+    ig.add(raw.split(/\r?\n/));
+  }
+  return (posixRelPath) => ig.ignores(posixRelPath);
+}
+
+// src/store/embeddingCache.ts
+import fs4 from "fs";
+import path6 from "path";
+import Database from "better-sqlite3";
+var EmbeddingCache = class {
+  db;
+  constructor(cacheFilePath) {
+    fs4.mkdirSync(path6.dirname(cacheFilePath), { recursive: true });
+    this.db = new Database(cacheFilePath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS embedding_cache (
+        provider_id TEXT NOT NULL,
+        content_hash TEXT NOT NULL,
+        embedding BLOB NOT NULL,
+        dim INTEGER NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY(provider_id, content_hash)
+      );
+    `);
+  }
+  get(providerId, contentHash) {
+    const row = this.db.prepare(
+      `SELECT embedding, dim FROM embedding_cache WHERE provider_id = ? AND content_hash = ?`
+    ).get(providerId, contentHash);
+    if (!row) return null;
+    const buf = row.embedding;
+    const view = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+    return new Float32Array(view);
+  }
+  put(providerId, contentHash, embedding) {
+    const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+    this.db.prepare(
+      `INSERT OR REPLACE INTO embedding_cache(provider_id, content_hash, embedding, dim, created_at)
+       VALUES (?, ?, ?, ?, ?)`
+    ).run(providerId, contentHash, buf, embedding.length, Date.now());
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/store/repoStore.ts
+import fs5 from "fs";
+import path7 from "path";
+import Database2 from "better-sqlite3";
+var RepoStore = class {
+  db;
+  constructor(dbPath) {
+    fs5.mkdirSync(path7.dirname(dbPath), { recursive: true });
+    this.db = new Database2(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS meta (
+        k TEXT PRIMARY KEY,
+        v TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS files (
+        path TEXT PRIMARY KEY,
+        hash TEXT NOT NULL,
+        mtime INTEGER NOT NULL,
+        language TEXT NOT NULL,
+        size INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS chunks (
+        id TEXT PRIMARY KEY,
+        path TEXT NOT NULL,
+        language TEXT NOT NULL,
+        kind TEXT NOT NULL DEFAULT 'chunk',
+        start_line INTEGER NOT NULL,
+        end_line INTEGER NOT NULL,
+        content_hash TEXT NOT NULL,
+        tokens INTEGER NOT NULL,
+        file_mtime INTEGER NOT NULL,
+        text TEXT NOT NULL,
+        embedding BLOB NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_chunks_path ON chunks(path);
+      CREATE INDEX IF NOT EXISTS idx_chunks_kind_path ON chunks(kind, path);
+
+      CREATE TABLE IF NOT EXISTS edges (
+        from_path TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        value TEXT NOT NULL,
+        PRIMARY KEY(from_path, kind, value)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(from_path);
+    `);
+    try {
+      this.db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+          id UNINDEXED,
+          path,
+          language,
+          kind,
+          text,
+          tokenize='unicode61'
+        );
+      `);
+      this.setMeta("fts", "1");
+    } catch {
+      this.setMeta("fts", "0");
+    }
+    if (this.getMeta("storeVersion") === null) this.setMeta("storeVersion", "0");
+  }
+  /** Monotonically increases whenever the chunk-store is mutated. */
+  getStoreVersion() {
+    const v = this.getMeta("storeVersion");
+    return v ? Number(v) : 0;
+  }
+  /** Internal: bump store version (call inside the same transaction that mutates chunks). */
+  bumpStoreVersion() {
+    const next = this.getStoreVersion() + 1;
+    this.setMeta("storeVersion", String(next));
+  }
+  /** Vector index sync marker (per backend kind). */
+  getVectorIndexVersion(kind) {
+    const v = this.getMeta(`vector.${kind}.storeVersion`);
+    return v ? Number(v) : 0;
+  }
+  setVectorIndexVersion(kind, storeVersion) {
+    this.setMeta(`vector.${kind}.storeVersion`, String(storeVersion));
+  }
+  setMeta(k, v) {
+    this.db.prepare(`INSERT OR REPLACE INTO meta(k, v) VALUES (?, ?)`).run(k, v);
+  }
+  getMeta(k) {
+    const row = this.db.prepare(`SELECT v FROM meta WHERE k = ?`).get(k);
+    return row?.v ?? null;
+  }
+  getFileHash(posixPath) {
+    const row = this.db.prepare(`SELECT hash FROM files WHERE path = ?`).get(posixPath);
+    return row?.hash ?? null;
+  }
+  getFileMtime(posixPath) {
+    const row = this.db.prepare(`SELECT mtime FROM files WHERE path = ?`).get(posixPath);
+    return row?.mtime ?? null;
+  }
+  upsertFile(posixPath, hash, mtime, language, size) {
+    this.db.prepare(`
+      INSERT INTO files(path, hash, mtime, language, size)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(path) DO UPDATE SET
+        hash = excluded.hash,
+        mtime = excluded.mtime,
+        language = excluded.language,
+        size = excluded.size
+    `).run(posixPath, hash, mtime, language, size);
+  }
+  deleteFile(posixPath) {
+    const tx = this.db.transaction(() => {
+      this.db.prepare(`DELETE FROM chunks WHERE path = ?`).run(posixPath);
+      this.db.prepare(`DELETE FROM chunks_fts WHERE path = ?`).run(posixPath);
+      this.db.prepare(`DELETE FROM edges WHERE from_path = ?`).run(posixPath);
+      this.db.prepare(`DELETE FROM files WHERE path = ?`).run(posixPath);
+      this.bumpStoreVersion();
+    });
+    tx();
+  }
+  replaceChunksForFile(posixPath, rows) {
+    const tx = this.db.transaction(() => {
+      this.db.prepare(`DELETE FROM chunks WHERE path = ?`).run(posixPath);
+      this.db.prepare(`DELETE FROM chunks_fts WHERE path = ?`).run(posixPath);
+      const ins = this.db.prepare(`
+        INSERT INTO chunks(id, path, language, kind, start_line, end_line, content_hash, tokens, file_mtime, text, embedding)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      const insFts = this.db.prepare(`
+        INSERT INTO chunks_fts(id, path, language, kind, text)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+      for (const r of rows) {
+        const buf = Buffer.from(r.embedding.buffer, r.embedding.byteOffset, r.embedding.byteLength);
+        ins.run(r.id, posixPath, r.language, r.kind, r.startLine, r.endLine, r.contentHash, r.tokens, r.fileMtime, r.text, buf);
+        insFts.run(r.id, posixPath, r.language, r.kind, r.ftsText);
+      }
+      this.bumpStoreVersion();
+    });
+    tx();
+  }
+  setEdges(fromPath, kind, values) {
+    const tx = this.db.transaction(() => {
+      this.db.prepare(`DELETE FROM edges WHERE from_path = ? AND kind = ?`).run(fromPath, kind);
+      const ins = this.db.prepare(`INSERT OR REPLACE INTO edges(from_path, kind, value) VALUES (?, ?, ?)`);
+      for (const v of values) ins.run(fromPath, kind, v);
+    });
+    tx();
+  }
+  listEdges(fromPath, kind) {
+    const rows = this.db.prepare(`SELECT value FROM edges WHERE from_path = ? AND kind = ?`).all(fromPath, kind);
+    return rows.map((r) => r.value);
+  }
+  listAllFiles() {
+    const rows = this.db.prepare(`SELECT path FROM files`).all();
+    return rows.map((r) => r.path);
+  }
+  countChunks() {
+    const row = this.db.prepare(`SELECT COUNT(*) AS c FROM chunks`).get();
+    return row.c;
+  }
+  /**
+   * Returns the embedding dimension if any chunks exist, otherwise null.
+   * Efficient (doesn't load all embeddings).
+   */
+  getAnyEmbeddingDimension() {
+    const row = this.db.prepare(`SELECT embedding FROM chunks LIMIT 1`).get();
+    if (!row) return null;
+    return Math.floor(row.embedding.byteLength / 4);
+  }
+  loadAllChunkEmbeddings() {
+    const rows = this.db.prepare(`SELECT id, embedding FROM chunks`).all();
+    return rows.map((r) => {
+      const view = new Float32Array(r.embedding.buffer, r.embedding.byteOffset, r.embedding.byteLength / 4);
+      return { id: r.id, embedding: new Float32Array(view) };
+    });
+  }
+  getChunkById(id) {
+    const row = this.db.prepare(`SELECT * FROM chunks WHERE id = ?`).get(id);
+    return row ?? null;
+  }
+  listChunksForFile(posixPath, kind) {
+    if (kind) {
+      return this.db.prepare(`SELECT id, start_line, end_line, kind FROM chunks WHERE path = ? AND kind = ? ORDER BY start_line ASC`).all(posixPath, kind);
+    }
+    return this.db.prepare(`SELECT id, start_line, end_line, kind FROM chunks WHERE path = ? ORDER BY kind DESC, start_line ASC`).all(posixPath);
+  }
+  /**
+   * Best-effort lexical search using SQLite FTS5.
+   * Returns ids with bm25 values (lower is better).
+   */
+  searchFts(ftq, limit, includePaths) {
+    try {
+      if (this.getMeta("fts") !== "1") return [];
+      if (includePaths && includePaths.length > 0) {
+        const placeholders = includePaths.map(() => "?").join(", ");
+        const sql2 = `
+          SELECT id, bm25(chunks_fts) AS bm25
+          FROM chunks_fts
+          WHERE chunks_fts MATCH ? AND path IN (${placeholders})
+          ORDER BY bm25 ASC
+          LIMIT ?
+        `;
+        const args = [ftq, ...includePaths, limit];
+        return this.db.prepare(sql2).all(...args);
+      }
+      const sql = `
+        SELECT id, bm25(chunks_fts) AS bm25
+        FROM chunks_fts
+        WHERE chunks_fts MATCH ?
+        ORDER BY bm25 ASC
+        LIMIT ?
+      `;
+      return this.db.prepare(sql).all(ftq, limit);
+    } catch {
+      return [];
+    }
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/indexer/repoIndexer/config.ts
+function resolveIndexerConfig(config = {}) {
+  const cacheDir = config.cacheDir ?? defaultCacheDir();
+  return {
+    cacheDir,
+    includeExtensions: config.includeExtensions ?? [
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".py",
+      ".go",
+      ".ca",
+      ".cpnexpr",
+      ".ispec",
+      ".isl",
+      ".ltl",
+      ".ctl",
+      ".rs",
+      ".java",
+      ".kt",
+      ".kts",
+      ".cs",
+      ".md",
+      ".json",
+      ".yml",
+      ".yaml",
+      ".toml"
+    ],
+    maxFileBytes: config.maxFileBytes ?? 2e6,
+    chunk: {
+      maxChars: config.chunk?.maxChars ?? 12e3,
+      maxLines: config.chunk?.maxLines ?? 240,
+      overlapLines: config.chunk?.overlapLines ?? 40
+    },
+    embed: {
+      batchSize: config.embed?.batchSize ?? 32,
+      concurrency: config.embed?.concurrency ?? 4
+    },
+    watch: {
+      debounceMs: config.watch?.debounceMs ?? 250
+    },
+    ignoreFiles: config.ignoreFiles ?? [".petriignore", ".augmentignore"],
+    redact: {
+      enabled: config.redact?.enabled ?? true,
+      skipPathSubstrings: config.redact?.skipPathSubstrings ?? [".env", "id_rsa", ".pem", ".p12", "secrets"],
+      patterns: config.redact?.patterns ?? [
+        {
+          name: "private_key_block",
+          regex: /-----BEGIN [A-Z ]+PRIVATE KEY-----[\s\S]*?-----END [A-Z ]+PRIVATE KEY-----/g,
+          replaceWith: "[REDACTED_PRIVATE_KEY]"
+        },
+        {
+          name: "aws_access_key_id",
+          regex: /\bAKIA[0-9A-Z]{16}\b/g,
+          replaceWith: "[REDACTED_AWS_KEY]"
+        }
+      ]
+    },
+    storage: {
+      storeText: config.storage?.storeText ?? true,
+      ftsMode: config.storage?.ftsMode ?? "full"
+    },
+    vector: {
+      provider: config.vector?.provider ?? "bruteforce",
+      metric: config.vector?.metric ?? "cosine",
+      hnswlib: config.vector?.hnswlib,
+      qdrant: config.vector?.qdrant,
+      faiss: config.vector?.faiss,
+      custom: config.vector?.custom
+    },
+    profiles: config.profiles ?? {}
+  };
+}
+
+// src/indexer/repoIndexer/utils.ts
+import fs6 from "fs";
+import path8 from "path";
+function repoIdFromRoot(repoRoot) {
+  return sha256Hex(path8.resolve(repoRoot)).slice(0, 16);
+}
+function looksBinary(buf) {
+  let nul = 0;
+  const n = Math.min(buf.length, 4096);
+  for (let i = 0; i < n; i++) if (buf[i] === 0) nul++;
+  return nul > 2;
+}
+
+// src/indexer/repoIndexer/vectorManager.ts
+var VectorManager = class {
+  constructor(vectorConfig, vectorMetric, flushDebounceMs, onFlush) {
+    this.vectorConfig = vectorConfig;
+    this.vectorMetric = vectorMetric;
+    this.flushDebounceMs = flushDebounceMs;
+    this.onFlush = onFlush;
+  }
+  vec = null;
+  flushTimer = null;
+  flushInFlight = null;
+  get() {
+    return this.vec;
+  }
+  async close() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.vec) {
+      try {
+        await this.vec.close();
+      } catch {
+      }
+      this.vec = null;
+    }
+    this.flushInFlight = null;
+  }
+  async ensure(init) {
+    if (this.vec && this.vec.dimension === init.dimension) return this.vec;
+    await this.close();
+    const vec = await createVectorIndex(this.vectorConfig);
+    await vec.init({
+      repoId: init.repoId,
+      repoRoot: init.repoRoot,
+      commit: init.commit,
+      branch: init.branch,
+      cacheDir: init.cacheDir,
+      dimension: init.dimension,
+      metric: this.vectorMetric
+    });
+    this.vec = vec;
+    return vec;
+  }
+  scheduleFlush() {
+    if (!this.vec) return;
+    const ms = this.flushDebounceMs(this.vec.kind);
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (ms <= 0) {
+      void this.flushNow();
+      return;
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      void this.flushNow();
+    }, ms);
+  }
+  async flushNow() {
+    if (!this.vec) return;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.flushInFlight) return this.flushInFlight;
+    const work = (async () => {
+      await this.onFlush(this.vec);
+    })();
+    this.flushInFlight = work.finally(() => {
+      this.flushInFlight = null;
+    });
+    return this.flushInFlight;
+  }
+};
+
+// src/indexer/repoIndexer/fileIndexer.ts
+import fs7 from "fs";
+import path9 from "path";
+
+// src/relations.ts
+function extractTsRelations(virtualFileName, sourceText) {
+  const tsMod = getTypeScript();
+  if (!tsMod) return { imports: [], exports: [] };
+  const sf = tsMod.createSourceFile(virtualFileName, sourceText, tsMod.ScriptTarget.Latest, true);
+  const imports = [];
+  const exports = [];
+  const isExported2 = (node) => {
+    if (!tsMod.canHaveModifiers(node)) return false;
+    const mods = tsMod.getModifiers(node);
+    return !!mods?.some((m) => m.kind === tsMod.SyntaxKind.ExportKeyword);
+  };
+  for (const stmt of sf.statements) {
+    if (tsMod.isImportDeclaration(stmt) && tsMod.isStringLiteral(stmt.moduleSpecifier)) {
+      imports.push(stmt.moduleSpecifier.text);
+    }
+    if (tsMod.isExportDeclaration(stmt)) {
+      if (stmt.exportClause && tsMod.isNamedExports(stmt.exportClause)) {
+        for (const el of stmt.exportClause.elements) exports.push(el.name.text);
+      } else {
+        exports.push("*");
+      }
+    }
+    if (tsMod.isFunctionDeclaration(stmt) && isExported2(stmt) && stmt.name) {
+      exports.push(stmt.name.text);
+    }
+    if (tsMod.isClassDeclaration(stmt) && isExported2(stmt) && stmt.name) {
+      exports.push(stmt.name.text);
+    }
+    if (tsMod.isVariableStatement(stmt) && isExported2(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (tsMod.isIdentifier(decl.name)) exports.push(decl.name.text);
+      }
+    }
+  }
+  return { imports, exports };
+}
+
+// src/synopsis.ts
+function isExported(tsMod, node) {
+  if (!tsMod.canHaveModifiers(node)) return false;
+  const mods = tsMod.getModifiers(node);
+  return !!mods?.some((m) => m.kind === tsMod.SyntaxKind.ExportKeyword);
+}
+function leadingCommentExcerpt(sourceText, maxChars = 600) {
+  const t = sourceText.trimStart();
+  const block = t.match(/^\/\*[\s\S]*?\*\//);
+  if (block) return block[0].slice(0, maxChars);
+  const lines = t.split(/\r?\n/);
+  const commentLines = [];
+  for (const line of lines) {
+    const m = line.match(/^\s*\/\/(.*)$/);
+    if (!m) break;
+    commentLines.push(line.trim());
+    if (commentLines.join("\n").length >= maxChars) break;
+  }
+  if (commentLines.length) return commentLines.join("\n").slice(0, maxChars);
+  return "";
+}
+function uniq(xs) {
+  const out = [];
+  const s = /* @__PURE__ */ new Set();
+  for (const x of xs) {
+    if (!x) continue;
+    if (s.has(x)) continue;
+    s.add(x);
+    out.push(x);
+  }
+  return out;
+}
+function renderGenericSynopsis(input) {
+  const lead = leadingCommentExcerpt(input.sourceText);
+  const parts = [];
+  parts.push(`File synopsis`);
+  parts.push(`path: ${input.posixPath}`);
+  parts.push(`language: ${input.language}`);
+  if (lead) parts.push(`comment: ${lead.replace(/\s+/g, " ").trim()}`);
+  return parts.join("\n").slice(0, 1200);
+}
+function buildTsLikeSynopsis(input) {
+  const tsMod = getTypeScript();
+  if (!tsMod) return renderGenericSynopsis(input);
+  const lead = leadingCommentExcerpt(input.sourceText);
+  const sf = tsMod.createSourceFile(input.posixPath, input.sourceText, tsMod.ScriptTarget.Latest, true);
+  const imports = [];
+  const exports = [];
+  const topLevel = [];
+  for (const stmt of sf.statements) {
+    if (tsMod.isImportDeclaration(stmt) && tsMod.isStringLiteral(stmt.moduleSpecifier)) {
+      imports.push(stmt.moduleSpecifier.text);
+    }
+    const isExportedStmt = isExported(tsMod, stmt);
+    if (tsMod.isFunctionDeclaration(stmt) && stmt.name) topLevel.push(`fn ${stmt.name.text}${isExportedStmt ? " (export)" : ""}`);
+    if (tsMod.isClassDeclaration(stmt) && stmt.name) topLevel.push(`class ${stmt.name.text}${isExportedStmt ? " (export)" : ""}`);
+    if (tsMod.isInterfaceDeclaration(stmt) && stmt.name) topLevel.push(`interface ${stmt.name.text}${isExportedStmt ? " (export)" : ""}`);
+    if (tsMod.isTypeAliasDeclaration(stmt) && stmt.name) topLevel.push(`type ${stmt.name.text}${isExportedStmt ? " (export)" : ""}`);
+    if (tsMod.isEnumDeclaration(stmt) && stmt.name) topLevel.push(`enum ${stmt.name.text}${isExportedStmt ? " (export)" : ""}`);
+    if (tsMod.isModuleDeclaration(stmt) && stmt.name && tsMod.isIdentifier(stmt.name)) topLevel.push(`namespace ${stmt.name.text}${isExportedStmt ? " (export)" : ""}`);
+    if (tsMod.isVariableStatement(stmt)) {
+      const isExp = isExported(tsMod, stmt);
+      for (const decl of stmt.declarationList.declarations) {
+        if (tsMod.isIdentifier(decl.name)) topLevel.push(`var ${decl.name.text}${isExp ? " (export)" : ""}`);
+      }
+    }
+    if (tsMod.isExportDeclaration(stmt)) {
+      if (stmt.exportClause && tsMod.isNamedExports(stmt.exportClause)) {
+        for (const el of stmt.exportClause.elements) exports.push(el.name.text);
+      } else {
+        exports.push("*");
+      }
+    }
+    if ((tsMod.isFunctionDeclaration(stmt) || tsMod.isClassDeclaration(stmt)) && isExportedStmt && stmt.name) {
+      exports.push(stmt.name.text);
+    }
+  }
+  const importsU = uniq(imports).slice(0, 30);
+  const exportsU = uniq(exports).slice(0, 40);
+  const topU = uniq(topLevel).slice(0, 60);
+  const parts = [];
+  parts.push(`File synopsis`);
+  parts.push(`path: ${input.posixPath}`);
+  parts.push(`language: ${input.language}`);
+  if (importsU.length) parts.push(`imports: ${importsU.join(", ")}`);
+  if (exportsU.length) parts.push(`exports: ${exportsU.join(", ")}`);
+  if (topU.length) parts.push(`top-level: ${topU.join(" | ")}`);
+  if (lead) parts.push(`comment: ${lead.replace(/\s+/g, " ").trim()}`);
+  return parts.join("\n").slice(0, 1800);
+}
+var builtInStrategies = [
+  {
+    name: "ts-like",
+    supports: ({ language }) => language === "typescript" || language === "javascript",
+    build: buildTsLikeSynopsis
+  },
+  {
+    name: "markdown",
+    supports: ({ language }) => language === "markdown",
+    build: (input) => {
+      const lead = leadingCommentExcerpt(input.sourceText);
+      const parts = [];
+      parts.push(`File synopsis`);
+      parts.push(`path: ${input.posixPath}`);
+      parts.push(`language: ${input.language}`);
+      if (lead) parts.push(`comment: ${lead.replace(/\s+/g, " ").trim()}`);
+      const headings = input.sourceText.split(/\r?\n/).filter((l) => /^#{1,3}\s+/.test(l)).slice(0, 12);
+      if (headings.length) parts.push(`headings: ${headings.map((h) => h.replace(/\s+/g, " ").trim()).join(" | ")}`);
+      return parts.join("\n").slice(0, 1200);
+    }
+  },
+  {
+    name: "generic",
+    supports: () => true,
+    build: renderGenericSynopsis
+  }
+];
+var customStrategies = [];
+function buildSynopsis(posixPath, language, sourceText) {
+  const input = { posixPath, language, sourceText };
+  const all = [...customStrategies, ...builtInStrategies];
+  const strategy = all.find((s) => s.supports(input)) ?? builtInStrategies[builtInStrategies.length - 1];
+  try {
+    return strategy.build(input);
+  } catch {
+    return renderGenericSynopsis(input);
+  }
+}
+
+// src/retrieval/tokens.ts
+function uniq2(xs) {
+  const out = [];
+  const s = /* @__PURE__ */ new Set();
+  for (const x of xs) {
+    if (!x) continue;
+    if (s.has(x)) continue;
+    s.add(x);
+    out.push(x);
+  }
+  return out;
+}
+function extractLexicalTokens(text, maxTokens = 2500) {
+  const toks = text.match(/[A-Za-z_][A-Za-z0-9_]{1,}/g) ?? [];
+  const u = uniq2(toks).slice(0, maxTokens);
+  return u.join(" ");
+}
+
+// src/indexer/repoIndexer/fileIndexer.ts
+var RepoFileIndexer = class {
+  constructor(repoRoot, repoId, embedder, config, store, embeddingCache, emit, ensureVectorUpToDate, workspaceStore, symbolGraphProvider, graphStore, getHead, rawConfig) {
+    this.repoRoot = repoRoot;
+    this.repoId = repoId;
+    this.embedder = embedder;
+    this.config = config;
+    this.store = store;
+    this.embeddingCache = embeddingCache;
+    this.emit = emit;
+    this.ensureVectorUpToDate = ensureVectorUpToDate;
+    this.workspaceStore = workspaceStore;
+    this.symbolGraphProvider = symbolGraphProvider;
+    this.graphStore = graphStore;
+    this.getHead = getHead;
+    this.rawConfig = rawConfig;
+  }
+  shouldIndexPath(posixRelPath, fileIgnore) {
+    const lower = posixRelPath.toLowerCase();
+    const ext = "." + (lower.split(".").pop() ?? "");
+    if (!this.config.includeExtensions.includes(ext)) return false;
+    if (this.config.redact.enabled) {
+      for (const s of this.config.redact.skipPathSubstrings) {
+        if (lower.includes(s.toLowerCase())) return false;
+      }
+    }
+    if (fileIgnore && fileIgnore(posixRelPath)) return false;
+    return true;
+  }
+  applyRedactions(text) {
+    if (!this.config.redact.enabled) return text;
+    let t = text;
+    for (const p of this.config.redact.patterns) t = t.replace(p.regex, p.replaceWith);
+    return t;
+  }
+  async indexFile(posixRelPath, fileIgnore) {
+    const startedAt = Date.now();
+    if (!this.shouldIndexPath(posixRelPath, fileIgnore)) {
+      this.emit({ type: "repo/index/file/skip", repoRoot: this.repoRoot, path: posixRelPath, reason: "filtered" });
+      return;
+    }
+    this.emit({ type: "repo/index/file/start", repoRoot: this.repoRoot, path: posixRelPath });
+    const abs = path9.join(this.repoRoot, fromPosixPath(posixRelPath));
+    let stat;
+    try {
+      stat = fs7.statSync(abs);
+    } catch {
+      this.emit({ type: "repo/index/file/skip", repoRoot: this.repoRoot, path: posixRelPath, reason: "missing" });
+      return;
+    }
+    if (!stat.isFile()) {
+      this.emit({ type: "repo/index/file/skip", repoRoot: this.repoRoot, path: posixRelPath, reason: "not_a_file" });
+      return;
+    }
+    if (stat.size > this.config.maxFileBytes) {
+      this.emit({ type: "repo/index/file/skip", repoRoot: this.repoRoot, path: posixRelPath, reason: "too_large" });
+      return;
+    }
+    const buf = fs7.readFileSync(abs);
+    if (looksBinary(buf)) {
+      this.emit({ type: "repo/index/file/skip", repoRoot: this.repoRoot, path: posixRelPath, reason: "binary" });
+      return;
+    }
+    const raw = buf.toString("utf8");
+    const redacted = this.applyRedactions(raw);
+    const fileHash = sha256Hex(redacted);
+    const prev = this.store.getFileHash(posixRelPath);
+    if (prev === fileHash) {
+      this.emit({ type: "repo/index/file/skip", repoRoot: this.repoRoot, path: posixRelPath, reason: "unchanged" });
+      return;
+    }
+    const { language, chunks } = chunkSource(posixRelPath, redacted, this.config.chunk);
+    let imports = [];
+    let exports = [];
+    if (language === "typescript" || language === "javascript") {
+      const rel = extractTsRelations(posixRelPath, redacted);
+      imports = rel.imports;
+      exports = rel.exports;
+      this.store.setEdges(posixRelPath, "import", rel.imports);
+      this.store.setEdges(posixRelPath, "export", rel.exports);
+      this.workspaceStore?.setEdges(this.repoId, posixRelPath, "import", rel.imports);
+      this.workspaceStore?.setEdges(this.repoId, posixRelPath, "export", rel.exports);
+    } else {
+      this.store.setEdges(posixRelPath, "import", []);
+      this.store.setEdges(posixRelPath, "export", []);
+      this.workspaceStore?.setEdges(this.repoId, posixRelPath, "import", []);
+      this.workspaceStore?.setEdges(this.repoId, posixRelPath, "export", []);
+    }
+    const synopsisText = buildSynopsis(posixRelPath, language, redacted);
+    const synopsis = synopsisText.trim() ? [
+      {
+        startLine: 1,
+        endLine: 1,
+        text: synopsisText,
+        contentHash: sha256Hex(synopsisText),
+        tokens: Math.max(1, Math.ceil(synopsisText.length / 4)),
+        kind: "synopsis"
+      }
+    ] : [];
+    const headerLines = Math.min(80, this.config.chunk.maxLines);
+    const headerText = redacted.split(/\r?\n/).slice(0, headerLines).join("\n").trimEnd();
+    const headerChunk = headerText.trim() ? [
+      {
+        startLine: 1,
+        endLine: headerLines,
+        text: headerText,
+        contentHash: sha256Hex(headerText),
+        tokens: Math.max(1, Math.ceil(headerText.length / 4)),
+        kind: "chunk"
+      }
+    ] : [];
+    const combined = [...synopsis, ...headerChunk, ...chunks.map((c) => ({ ...c, kind: "chunk" }))];
+    const embedTexts = [];
+    const embedPlan = [];
+    const embeddings = combined.map(() => null);
+    for (let i = 0; i < combined.length; i++) {
+      const ch = combined[i];
+      const cached2 = this.embeddingCache.get(this.embedder.id, ch.contentHash);
+      if (cached2) {
+        embeddings[i] = cached2;
+        continue;
+      }
+      embedTexts.push(
+        `repo:${path9.basename(this.repoRoot)}
+path:${posixRelPath}
+language:${language}
+kind:${ch.kind}
+lines:${ch.startLine}-${ch.endLine}
+---
+${ch.text}`
+      );
+      embedPlan.push({ chunkIdx: i, contentHash: ch.contentHash });
+    }
+    const batchSize = this.config.embed.batchSize;
+    for (let start = 0; start < embedTexts.length; start += batchSize) {
+      const end = Math.min(embedTexts.length, start + batchSize);
+      const batch = embedTexts.slice(start, end);
+      this.emit({
+        type: "repo/index/embed/batch",
+        repoRoot: this.repoRoot,
+        batchSize: batch.length,
+        batchIndex: Math.floor(start / batchSize),
+        batchesTotal: Math.ceil(embedTexts.length / batchSize)
+      });
+      const vecs = await this.embedder.embed(batch);
+      for (let j = 0; j < vecs.length; j++) {
+        const plan = embedPlan[start + j];
+        embeddings[plan.chunkIdx] = vecs[j];
+        this.embeddingCache.put(this.embedder.id, plan.contentHash, vecs[j]);
+      }
+    }
+    const fileMtime = stat.mtimeMs;
+    const ftsMode = this.config.storage.ftsMode;
+    const storeText = this.config.storage.storeText;
+    const oldChunkIds = this.store.listChunksForFile(posixRelPath).map((r) => r.id);
+    const points = [];
+    const rows = combined.map((ch, i) => {
+      const id = sha256Hex(
+        `${this.repoId}:${posixRelPath}:${ch.kind}:${ch.startLine}:${ch.endLine}:${ch.contentHash}`
+      ).slice(0, 32);
+      const emb = embeddings[i];
+      if (!emb) throw new Error("Embedding missing unexpectedly");
+      points.push({ id, vector: emb });
+      const textToStore = ch.kind === "synopsis" ? ch.text : storeText ? ch.text : "";
+      const ftsText = ftsMode === "off" ? "" : ftsMode === "tokens" ? extractLexicalTokens(ch.text) : ch.text;
+      return {
+        id,
+        language,
+        kind: ch.kind,
+        startLine: ch.startLine,
+        endLine: ch.endLine,
+        contentHash: ch.contentHash,
+        text: textToStore,
+        ftsText,
+        tokens: ch.tokens,
+        fileMtime,
+        embedding: emb
+      };
+    });
+    this.store.upsertFile(posixRelPath, fileHash, fileMtime, language, stat.size);
+    this.store.replaceChunksForFile(posixRelPath, rows);
+    this.workspaceStore?.upsertFile(this.repoId, posixRelPath, fileHash, fileMtime, language, stat.size);
+    this.workspaceStore?.replaceChunksForFile(this.repoId, this.repoRoot, posixRelPath, rows);
+    const symbolOut = await this.indexSymbolsIfEnabled(posixRelPath, language, redacted, fileHash);
+    const head = this.getHead();
+    if (this.graphStore && head) {
+      await this.graphStore.replaceFileGraph({
+        repoId: this.repoId,
+        repoRoot: this.repoRoot,
+        commit: head.commit,
+        branch: head.branch,
+        path: posixRelPath,
+        language,
+        imports,
+        exports,
+        symbols: symbolOut?.symbols ?? [],
+        symbolEdges: (symbolOut?.edges ?? []).map((e) => ({ fromId: e.fromId, toId: e.toId, kind: e.kind }))
+      }).catch(() => void 0);
+    }
+    await this.ensureVectorUpToDate(points, oldChunkIds);
+    this.emit({
+      type: "repo/index/file/done",
+      repoRoot: this.repoRoot,
+      path: posixRelPath,
+      chunkCount: combined.length,
+      ms: Date.now() - startedAt
+    });
+  }
+  async deleteFile(posixRelPath) {
+    const chunkIds = this.store.listChunksForFile(posixRelPath).map((r) => r.id);
+    this.store.deleteFile(posixRelPath);
+    this.workspaceStore?.deleteFile(this.repoId, posixRelPath);
+    await this.graphStore?.deleteFile({ repoId: this.repoId, path: posixRelPath }).catch(() => void 0);
+    await this.ensureVectorUpToDate([], chunkIds);
+  }
+  async indexSymbolsIfEnabled(posixRelPath, language, redactedText, contentHash) {
+    if (!this.symbolGraphProvider) return null;
+    if (!this.symbolGraphProvider.supports(language)) return null;
+    let out;
+    try {
+      out = await this.symbolGraphProvider.indexDocument({
+        repoRoot: this.repoRoot,
+        path: posixRelPath,
+        language,
+        text: redactedText,
+        contentHash
+      });
+    } catch {
+      return null;
+    }
+    const symbols = out.symbols.map((s) => {
+      const id = s.id || stableSymbolId({
+        repoRoot: this.repoRoot,
+        path: posixRelPath,
+        language,
+        kind: s.kind,
+        name: s.name,
+        range: s.range
+      });
+      return {
+        id,
+        language,
+        name: s.name,
+        kind: s.kind,
+        range: s.range,
+        containerName: s.containerName,
+        detail: s.detail
+      };
+    });
+    const knownIds = new Set(symbols.map((s) => s.id));
+    const edges = out.edges.filter((e) => knownIds.has(e.fromId)).map((e) => ({ fromId: e.fromId, toId: e.toId, kind: e.kind, toPath: e.toPath }));
+    if (this.workspaceStore) {
+      const symbolRows = symbols.map((s) => ({
+        id: s.id,
+        language: s.language,
+        name: s.name,
+        kind: s.kind,
+        startLine: s.range.startLine,
+        startCharacter: s.range.startCharacter,
+        endLine: s.range.endLine,
+        endCharacter: s.range.endCharacter,
+        containerName: s.containerName,
+        detail: s.detail
+      }));
+      this.workspaceStore.replaceSymbolsForFile(
+        this.repoId,
+        this.repoRoot,
+        posixRelPath,
+        symbolRows,
+        edges.map((e) => ({ ...e, fromPath: posixRelPath, toPath: e.toPath ?? posixRelPath }))
+      );
+    }
+    return { symbols, edges };
+  }
+};
+
+// src/indexer/repoIndexer/retriever.ts
+import fs8 from "fs";
+import path10 from "path";
+
+// src/retrieval/fts.ts
+function ftsQueryFromText(input) {
+  const tokens = (input.match(/[A-Za-z0-9_]{2,}/g) ?? []).slice(0, 24);
+  if (tokens.length === 0) return "";
+  const parts = tokens.map((t) => {
+    const safe = t.replace(/"/g, '""');
+    return `${safe}*`;
+  });
+  return parts.join(" OR ");
+}
+function bm25ToScore01(bm25) {
+  if (!Number.isFinite(bm25)) return 0;
+  const s = 1 / (1 + Math.max(0, bm25));
+  return clamp(s, 0, 1);
+}
+function vectorCosineToScore01(cosine) {
+  if (!Number.isFinite(cosine)) return 0;
+  return clamp((cosine + 1) / 2, 0, 1);
+}
+
+// src/indexer/repoIndexer/retriever.ts
+var RepoRetriever = class {
+  constructor(repoRoot, repoId, getStore, getVectorIndex, getAnnIndex, ensureOpen, ensureVectorReady, ftsMode) {
+    this.repoRoot = repoRoot;
+    this.repoId = repoId;
+    this.getStore = getStore;
+    this.getVectorIndex = getVectorIndex;
+    this.getAnnIndex = getAnnIndex;
+    this.ensureOpen = ensureOpen;
+    this.ensureVectorReady = ensureVectorReady;
+    this.ftsMode = ftsMode;
+  }
+  chunkCache = /* @__PURE__ */ new Map();
+  getChunkRowCached(id) {
+    const cached2 = this.chunkCache.get(id);
+    if (cached2) return cached2;
+    const store = this.getStore();
+    if (!store) return null;
+    const row = store.getChunkById(id);
+    if (row) this.chunkCache.set(id, row);
+    return row ?? null;
+  }
+  clearCache() {
+    this.chunkCache.clear();
+  }
+  async vectorCandidates(queryEmbedding, k, includePaths) {
+    await this.ensureOpen();
+    await this.ensureVectorReady();
+    const vec = this.getVectorIndex();
+    if (!vec) return [];
+    if (!includePaths || includePaths.length === 0) {
+      try {
+        const annHits = await this.getAnnIndex().search(queryEmbedding, k);
+        if (annHits.length > 0) return annHits;
+      } catch {
+      }
+    }
+    if (!includePaths || includePaths.length === 0) {
+      return await vec.search(queryEmbedding, k);
+    }
+    const tries = [k * 5, k * 15, k * 40].map((x) => Math.max(k, x));
+    for (const kk of tries) {
+      const cand2 = await vec.search(queryEmbedding, kk);
+      const filtered2 = [];
+      for (const c of cand2) {
+        const row = this.getChunkRowCached(c.id);
+        if (row && includePaths.includes(row.path)) filtered2.push(c);
+        if (filtered2.length >= k) break;
+      }
+      if (filtered2.length >= k) return filtered2.slice(0, k);
+    }
+    const cand = await vec.search(queryEmbedding, tries[tries.length - 1]);
+    const filtered = cand.filter((c) => {
+      const row = this.getChunkRowCached(c.id);
+      return row ? includePaths.includes(row.path) : false;
+    });
+    return filtered.slice(0, k);
+  }
+  async lexicalCandidates(queryText, k, includePaths) {
+    await this.ensureOpen();
+    const store = this.getStore();
+    if (!store) throw new Error("RepoStore not initialised");
+    if (this.ftsMode() === "off") return [];
+    const ftq = ftsQueryFromText(queryText);
+    if (!ftq) return [];
+    const rows = store.searchFts(ftq, k, includePaths);
+    return rows.map((r) => ({ id: r.id, score: bm25ToScore01(r.bm25) }));
+  }
+  readChunkTextFallback(row) {
+    const abs = path10.join(this.repoRoot, fromPosixPath(row.path));
+    try {
+      const raw = fs8.readFileSync(abs, "utf8");
+      const lines = raw.split(/\r?\n/);
+      const start = Math.max(1, row.start_line);
+      const end = Math.max(start, row.end_line);
+      return lines.slice(start - 1, end).join("\n");
+    } catch {
+      return "";
+    }
+  }
+  getChunkRecord(id) {
+    const row = this.getChunkRowCached(id);
+    if (!row) return null;
+    const text = row.text && row.text.trim().length > 0 ? row.text : this.readChunkTextFallback(row);
+    return {
+      id: row.id,
+      repoId: this.repoId,
+      repoRoot: this.repoRoot,
+      path: row.path,
+      language: row.language,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      contentHash: row.content_hash,
+      text,
+      tokens: row.tokens,
+      fileMtimeMs: row.file_mtime,
+      kind: row.kind === "synopsis" ? "synopsis" : "chunk"
+    };
+  }
+  getChunkMeta(id) {
+    const row = this.getChunkRowCached(id);
+    if (!row) return null;
+    return {
+      id: row.id,
+      repoId: this.repoId,
+      repoRoot: this.repoRoot,
+      path: row.path,
+      language: row.language,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      contentHash: row.content_hash,
+      tokens: row.tokens,
+      fileMtimeMs: row.file_mtime,
+      kind: row.kind === "synopsis" ? "synopsis" : "chunk"
+    };
+  }
+  getChunkText(id) {
+    const row = this.getChunkRowCached(id);
+    if (!row) return "";
+    return row.text && row.text.trim().length > 0 ? row.text : this.readChunkTextFallback(row);
+  }
+  getChunkPreview(id) {
+    const r = this.getChunkRecord(id);
+    return r ? makePreview(r.text) : "";
+  }
+  async expandContext(chunkId, opts) {
+    await this.ensureOpen();
+    const store = this.getStore();
+    if (!store) throw new Error("RepoStore not initialised");
+    const row = this.getChunkRowCached(chunkId);
+    if (!row) return [];
+    const out = [];
+    if (opts.includeFileSynopsis) {
+      const synopsis = store.listChunksForFile(row.path, "synopsis")[0];
+      if (synopsis) out.push({ id: synopsis.id, reason: "file synopsis" });
+    }
+    const adj = Math.max(0, opts.adjacentChunks);
+    if (adj > 0) {
+      const fileChunks = store.listChunksForFile(row.path).filter((c) => c.kind !== "synopsis");
+      const idx = fileChunks.findIndex((c) => c.id === chunkId);
+      if (idx >= 0) {
+        for (let d = 1; d <= adj; d++) {
+          for (const j of [idx - d, idx + d]) {
+            if (j < 0 || j >= fileChunks.length) continue;
+            out.push({ id: fileChunks[j].id, reason: `adjacent chunk (\xB1${d})` });
+          }
+        }
+      }
+    }
+    const follow = Math.max(0, opts.followImports);
+    if (follow > 0) {
+      const imports = store.listEdges(row.path, "import").filter((s) => s.startsWith("."));
+      for (const spec of imports.slice(0, follow)) {
+        const candidates = [
+          spec,
+          `${spec}.ts`,
+          `${spec}.tsx`,
+          `${spec}.js`,
+          `${spec}.jsx`,
+          `${spec}/index.ts`,
+          `${spec}/index.tsx`,
+          `${spec}/index.js`,
+          `${spec}/index.jsx`
+        ].map((s) => path10.posix.normalize(path10.posix.join(path10.posix.dirname(row.path), s)));
+        for (const c of candidates) {
+          const syn = store.listChunksForFile(c, "synopsis")[0];
+          if (syn) {
+            out.push({ id: syn.id, reason: `imported file synopsis (${spec})` });
+            break;
+          }
+          const header = store.listChunksForFile(c).find((x) => x.kind !== "synopsis");
+          if (header) {
+            out.push({ id: header.id, reason: `imported file header (${spec})` });
+            break;
+          }
+        }
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = [];
+    for (const x of out) {
+      if (seen.has(x.id)) continue;
+      seen.add(x.id);
+      deduped.push(x);
+    }
+    return deduped;
+  }
+};
+
+// src/indexer/repoIndexer/watcher.ts
+import path11 from "path";
+import chokidar from "chokidar";
+var RepoWatcher = class {
+  constructor(repoRoot, debounceMs, ignored, onHeadChanged, onFileChanged, onFileAdded, onFileDeleted, onWatchEvent) {
+    this.repoRoot = repoRoot;
+    this.debounceMs = debounceMs;
+    this.ignored = ignored;
+    this.onHeadChanged = onHeadChanged;
+    this.onFileChanged = onFileChanged;
+    this.onFileAdded = onFileAdded;
+    this.onFileDeleted = onFileDeleted;
+    this.onWatchEvent = onWatchEvent;
+  }
+  watcher = null;
+  async start() {
+    if (this.watcher) return;
+    let timer = null;
+    const schedule = (fn) => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(fn, this.debounceMs);
+    };
+    const headPath = path11.join(this.repoRoot, ".git", "HEAD");
+    this.watcher = chokidar.watch([this.repoRoot, headPath], {
+      ignoreInitial: true,
+      ignored: this.ignored
+    });
+    this.watcher.on("change", (p) => {
+      const rel = path11.relative(this.repoRoot, p);
+      const posix = rel.split(path11.sep).join("/");
+      if (posix === ".git/HEAD") {
+        this.onWatchEvent?.("head", posix);
+        schedule(() => this.onHeadChanged());
+        return;
+      }
+      this.onWatchEvent?.("change", posix);
+      schedule(() => this.onFileChanged(posix));
+    });
+    this.watcher.on("add", (p) => {
+      const rel = path11.relative(this.repoRoot, p);
+      const posix = rel.split(path11.sep).join("/");
+      this.onWatchEvent?.("add", posix);
+      schedule(() => this.onFileAdded(posix));
+    });
+    this.watcher.on("unlink", (p) => {
+      const rel = path11.relative(this.repoRoot, p);
+      const posix = rel.split(path11.sep).join("/");
+      this.onWatchEvent?.("unlink", posix);
+      schedule(() => this.onFileDeleted(posix));
+    });
+  }
+  async close() {
+    await this.watcher?.close().catch(() => void 0);
+    this.watcher = null;
+  }
+};
+
+// src/indexer/repoIndexer.ts
+var RepoIndexer = class {
+  constructor(repoRoot, embedder, config = {}, workspaceStore, graphStore) {
+    this.embedder = embedder;
+    this.repoRoot = path12.resolve(repoRoot);
+    this.repoId = repoIdFromRoot(this.repoRoot);
+    this.rawConfig = { ...config };
+    if (!this.rawConfig.cacheDir) this.rawConfig.cacheDir = defaultCacheDir();
+    this.config = resolveIndexerConfig(this.rawConfig);
+    this.progress = asProgressSink(this.rawConfig.progress);
+    this.symbolGraphProvider = this.rawConfig.symbolGraphProvider ?? null;
+    this.workspaceStore = workspaceStore ?? null;
+    this.graphStore = graphStore ?? null;
+    this.ann = createAnnIndex(this.rawConfig.ann);
+    this.embeddingCache = new EmbeddingCache(path12.join(this.config.cacheDir, "embedding-cache.sqlite"));
+    this.vector = new VectorManager(
+      this.config.vector,
+      this.vectorMetric(),
+      (kind) => this.vectorFlushDebounceMs(kind),
+      async (vec) => {
+        this.emitProgress({ type: "repo/vector/flush", repoRoot: this.repoRoot, kind: vec.kind });
+        await vec.flush();
+        const sv = this.store.getStoreVersion();
+        this.store.setVectorIndexVersion(vec.kind, sv);
+      }
+    );
+    this.retriever = new RepoRetriever(
+      this.repoRoot,
+      this.repoId,
+      () => this.store,
+      () => this.vector.get(),
+      () => this.ann,
+      async () => this.openForCurrentHead(),
+      async () => {
+        if (!this.store) throw new Error("RepoStore not initialised");
+        if (!this.vector.get()) {
+          const dim = this.embedder.dimension ?? this.store.getAnyEmbeddingDimension();
+          if (dim) await this.ensureVectorIndex(dim);
+        }
+      },
+      () => this.config.storage.ftsMode
+    );
+  }
+  repoRoot;
+  repoId;
+  rawConfig;
+  config;
+  progress;
+  embeddingCache;
+  symbolGraphProvider;
+  store = null;
+  workspaceStore = null;
+  graphStore = null;
+  vector;
+  ann;
+  retriever;
+  fileIndexer = null;
+  watcher = null;
+  currentCommit = null;
+  currentBranch = null;
+  fileIgnore = null;
+  serial = pLimit(1);
+  emitProgress(event) {
+    try {
+      this.progress?.emit(event);
+    } catch {
+    }
+  }
+  getCommit() {
+    return this.currentCommit;
+  }
+  getBranch() {
+    return this.currentBranch;
+  }
+  getStore() {
+    return this.store;
+  }
+  dbPathForCommit(commit) {
+    return path12.join(this.config.cacheDir, "index", this.repoId, `${commit}.sqlite`);
+  }
+  vectorMetric() {
+    return this.config.vector.metric ?? "cosine";
+  }
+  vectorFlushDebounceMs(kind) {
+    if (kind === "hnswlib") return this.config.vector.hnswlib?.persistDebounceMs ?? 2e3;
+    if (kind === "faiss") return this.config.vector.faiss?.persistDebounceMs ?? 2e3;
+    return 0;
+  }
+  async ensureVectorIndex(dimension) {
+    if (!this.currentCommit || !this.currentBranch) return null;
+    if (!this.store) return null;
+    return await this.vector.ensure({
+      repoId: this.repoId,
+      repoRoot: this.repoRoot,
+      commit: this.currentCommit,
+      branch: this.currentBranch,
+      cacheDir: this.config.cacheDir,
+      dimension
+    });
+  }
+  async openForCurrentHead() {
+    const commit = await getHeadCommit(this.repoRoot);
+    const branch = await getBranchName(this.repoRoot);
+    if (this.currentCommit === commit && this.store) return;
+    this.currentCommit = commit;
+    this.currentBranch = branch;
+    this.retriever.clearCache();
+    await this.vector.close();
+    if (this.store) this.store.close();
+    this.fileIgnore = loadExtraIgnore(this.repoRoot, this.config.ignoreFiles);
+    this.store = new RepoStore(this.dbPathForCommit(commit));
+    this.store.setMeta("repoRoot", this.repoRoot);
+    this.store.setMeta("repoId", this.repoId);
+    this.store.setMeta("commit", commit);
+    this.store.setMeta("branch", branch);
+    this.store.setMeta("embedderId", this.embedder.id);
+    this.emitProgress({ type: "repo/open", repoRoot: this.repoRoot, repoId: this.repoId, commit, branch });
+    this.workspaceStore?.setRepoHead(this.repoId, this.repoRoot, commit, branch);
+    await this.graphStore?.setRepoHead({ repoId: this.repoId, repoRoot: this.repoRoot, commit, branch }).catch(() => void 0);
+    await this.ann.init({
+      repoId: this.repoId,
+      repoRoot: this.repoRoot,
+      commit,
+      branch,
+      cacheDir: this.config.cacheDir,
+      dimension: this.embedder.dimension ?? (this.store.getAnyEmbeddingDimension() ?? 0),
+      metric: this.vectorMetric(),
+      embedderId: this.embedder.id
+    }).catch(() => void 0);
+    this.fileIndexer = new RepoFileIndexer(
+      this.repoRoot,
+      this.repoId,
+      this.embedder,
+      this.config,
+      this.store,
+      this.embeddingCache,
+      (e) => this.emitProgress(e),
+      async (points, oldChunkIds) => {
+        const vec2 = this.vector.get();
+        if (!vec2 && points.length > 0) {
+          const dim2 = points[0].vector.length;
+          await this.ensureVectorIndex(dim2);
+        }
+        const v = this.vector.get();
+        if (!v) return;
+        if (oldChunkIds.length > 0) {
+          this.emitProgress({ type: "repo/index/vector/remove", repoRoot: this.repoRoot, ids: oldChunkIds.length });
+          await this.ann.remove(oldChunkIds).catch(() => void 0);
+          await v.remove(oldChunkIds);
+        }
+        if (points.length > 0) {
+          this.emitProgress({ type: "repo/index/vector/upsert", repoRoot: this.repoRoot, points: points.length });
+          await this.ann.upsert(points).catch(() => void 0);
+          await v.upsert(points);
+        }
+        this.vector.scheduleFlush();
+      },
+      this.workspaceStore,
+      this.symbolGraphProvider,
+      this.graphStore,
+      () => this.currentCommit && this.currentBranch ? { commit: this.currentCommit, branch: this.currentBranch } : null,
+      this.rawConfig
+    );
+    const dim = this.embedder.dimension ?? this.store.getAnyEmbeddingDimension();
+    if (!dim) return;
+    const vec = await this.ensureVectorIndex(dim);
+    if (!vec) return;
+    const storeCount = this.store.countChunks();
+    const storeVersion = this.store.getStoreVersion();
+    const vecVersion = this.store.getVectorIndexVersion(vec.kind);
+    const vecCount = await vec.count();
+    if (storeCount > 0 && (vecVersion !== storeVersion || vecCount !== storeCount || vec.kind === "faiss")) {
+      const startedAt = Date.now();
+      this.emitProgress({ type: "repo/vector/rebuild/start", repoRoot: this.repoRoot, kind: vec.kind, points: storeCount });
+      await vec.rebuild(this.store.loadAllChunkEmbeddings().map((e) => ({ id: e.id, vector: e.embedding })));
+      await this.vector.flushNow();
+      this.emitProgress({ type: "repo/vector/rebuild/done", repoRoot: this.repoRoot, kind: vec.kind, ms: Date.now() - startedAt });
+    }
+  }
+  async indexAll() {
+    const startedAt = Date.now();
+    await this.openForCurrentHead();
+    if (!this.store || !this.fileIndexer) throw new Error("RepoStore not initialised");
+    const files = (await listWorkingFiles(this.repoRoot)).filter((p) => this.fileIndexer.shouldIndexPath(p, this.fileIgnore));
+    this.emitProgress({ type: "repo/index/start", repoRoot: this.repoRoot, fileCount: files.length });
+    const currentSet = new Set(files);
+    for (const known of this.store.listAllFiles()) {
+      if (!currentSet.has(known)) {
+        await this.deleteFile(known);
+      }
+    }
+    const limit = pLimit(this.config.embed.concurrency);
+    await Promise.all(files.map((f) => limit(() => this.indexFile(f))));
+    if (this.vector.get()) await this.vector.flushNow();
+    this.emitProgress({
+      type: "repo/index/done",
+      repoRoot: this.repoRoot,
+      fileCount: files.length,
+      ms: Date.now() - startedAt
+    });
+  }
+  async indexFile(posixRelPath) {
+    return this.serial(async () => {
+      await this.openForCurrentHead();
+      if (!this.store || !this.fileIndexer) throw new Error("RepoStore not initialised");
+      const abs = path12.join(this.repoRoot, posixRelPath.split("/").join(path12.sep));
+      if (!fs9.existsSync(abs)) {
+        await this.deleteFile(posixRelPath);
+        return;
+      }
+      await this.fileIndexer.indexFile(posixRelPath, this.fileIgnore);
+    });
+  }
+  async deleteFile(posixRelPath) {
+    return this.serial(async () => {
+      await this.openForCurrentHead();
+      if (!this.store || !this.fileIndexer) return;
+      await this.fileIndexer.deleteFile(posixRelPath);
+    });
+  }
+  async vectorCandidates(queryEmbedding, k, includePaths) {
+    return await this.retriever.vectorCandidates(queryEmbedding, k, includePaths);
+  }
+  async lexicalCandidates(queryText, k, includePaths) {
+    return await this.retriever.lexicalCandidates(queryText, k, includePaths);
+  }
+  getChunkRecord(id) {
+    return this.retriever.getChunkRecord(id);
+  }
+  getChunkMeta(id) {
+    return this.retriever.getChunkMeta(id);
+  }
+  getChunkText(id) {
+    return this.retriever.getChunkText(id);
+  }
+  getChunkPreview(id) {
+    return this.retriever.getChunkPreview(id);
+  }
+  async getRepresentativeChunkIdForFile(posixPath, preferSynopsis = true) {
+    await this.openForCurrentHead();
+    if (!this.store) return null;
+    const syn = preferSynopsis ? this.store.listChunksForFile(posixPath, "synopsis")[0] : void 0;
+    if (syn?.id) return syn.id;
+    const any = this.store.listChunksForFile(posixPath).find((c) => c.kind !== "synopsis");
+    return any?.id ?? null;
+  }
+  async expandContext(chunkId, opts) {
+    return await this.retriever.expandContext(chunkId, opts);
+  }
+  /**
+   * Staged symbol-graph expansion: compute expensive cross-file edges only for the specified files.
+   * Safe to call repeatedly; provider caching should avoid redundant work.
+   */
+  async warmSymbolGraphEdges(posixPaths, opts) {
+    await this.openForCurrentHead();
+    if (!this.fileIndexer) return;
+    if (!this.store) return;
+    if (!this.workspaceStore) return;
+    const provider = this.symbolGraphProvider;
+    if (!provider?.expandDocumentEdges) return;
+    const maxFiles = opts?.maxFiles ?? 6;
+    const uniq3 = Array.from(new Set(posixPaths)).slice(0, maxFiles);
+    for (const p of uniq3) {
+      if (opts?.signal?.aborted) return;
+      const abs = path12.join(this.repoRoot, p.split("/").join(path12.sep));
+      let text = "";
+      try {
+        text = fs9.readFileSync(abs, "utf8");
+      } catch {
+        continue;
+      }
+      const contentHash = this.store.getFileHash(p) ?? void 0;
+      const lang = languageFromPath(p);
+      const edges = await provider.expandDocumentEdges({ repoRoot: this.repoRoot, path: p, language: lang, text, contentHash }, { signal: opts?.signal }).catch(() => []);
+      const normalized = (Array.isArray(edges) ? edges : []).map((e) => ({
+        fromId: e.fromId,
+        toId: e.toId,
+        kind: e.kind,
+        toPath: String(e.toPath ?? "")
+      }));
+      this.workspaceStore.replaceSymbolEdgesFromFile(this.repoId, p, normalized);
+      await this.graphStore?.replaceOutgoingSymbolEdgesFromFile?.({
+        repoId: this.repoId,
+        fromPath: p,
+        edges: normalized.map((e) => ({ fromId: e.fromId, toId: e.toId, kind: e.kind, toPath: e.toPath }))
+      }).catch(() => void 0);
+    }
+  }
+  async watch() {
+    await this.openForCurrentHead();
+    this.emitProgress({ type: "repo/watch/start", repoRoot: this.repoRoot });
+    const ignored = (p) => {
+      const rel = path12.relative(this.repoRoot, p);
+      if (!rel) return false;
+      const posix = rel.split(path12.sep).join("/");
+      if (posix.startsWith(".git/")) return true;
+      if (posix.includes("node_modules/")) return true;
+      if (posix.includes("/.cache/")) return true;
+      return false;
+    };
+    this.watcher = new RepoWatcher(
+      this.repoRoot,
+      this.config.watch.debounceMs,
+      ignored,
+      () => void this.indexAll().catch(() => void 0),
+      (p) => void this.indexFile(p).catch(() => void 0),
+      (p) => void this.indexFile(p).catch(() => void 0),
+      (p) => void this.deleteFile(p).catch(() => void 0),
+      (event, p) => this.emitProgress({ type: "repo/watch/event", repoRoot: this.repoRoot, event, path: p })
+    );
+    await this.watcher.start();
+  }
+  async closeAsync() {
+    if (this.vector.get() && this.store) {
+      try {
+        await this.vector.flushNow();
+      } catch {
+      }
+    }
+    await this.vector.close();
+    await this.ann.close().catch(() => void 0);
+    await this.watcher?.close().catch(() => void 0);
+    this.watcher = null;
+    this.store?.close();
+    this.store = null;
+    this.fileIndexer = null;
+    this.embeddingCache.close();
+    this.retriever.clearCache();
+  }
+  close() {
+    void this.closeAsync();
+  }
+};
+
+// src/profiles.ts
+var DEFAULT_PROFILES = {
+  search: {
+    name: "search",
+    k: 10,
+    weights: { vector: 0.65, lexical: 0.35, recency: 0 },
+    expand: { adjacentChunks: 0, followImports: 0, includeFileSynopsis: false },
+    candidates: { vectorK: 25, lexicalK: 25, maxMergedCandidates: 60 }
+  },
+  refactor: {
+    name: "refactor",
+    k: 15,
+    weights: { vector: 0.55, lexical: 0.35, recency: 0.1 },
+    expand: { adjacentChunks: 1, followImports: 2, includeFileSynopsis: true },
+    candidates: { vectorK: 60, lexicalK: 40, maxMergedCandidates: 140 }
+  },
+  review: {
+    name: "review",
+    k: 20,
+    weights: { vector: 0.45, lexical: 0.35, recency: 0.2 },
+    expand: { adjacentChunks: 1, followImports: 1, includeFileSynopsis: true },
+    candidates: { vectorK: 80, lexicalK: 60, maxMergedCandidates: 180 }
+  },
+  architecture: {
+    name: "architecture",
+    k: 20,
+    weights: { vector: 0.7, lexical: 0.2, recency: 0.1 },
+    expand: { adjacentChunks: 0, followImports: 3, includeFileSynopsis: true },
+    candidates: { vectorK: 120, lexicalK: 40, maxMergedCandidates: 220 }
+  },
+  rca: {
+    name: "rca",
+    k: 25,
+    weights: { vector: 0.5, lexical: 0.25, recency: 0.25 },
+    expand: { adjacentChunks: 2, followImports: 1, includeFileSynopsis: true },
+    candidates: { vectorK: 140, lexicalK: 80, maxMergedCandidates: 260 }
+  },
+  custom: {
+    name: "custom",
+    k: 10,
+    weights: { vector: 0.65, lexical: 0.35, recency: 0 },
+    expand: { adjacentChunks: 0, followImports: 0, includeFileSynopsis: false },
+    candidates: { vectorK: 25, lexicalK: 25, maxMergedCandidates: 60 }
+  }
+};
+function deepMergeProfile(base, patch) {
+  if (!patch) return base;
+  const merged = {
+    ...base,
+    ...patch,
+    weights: { ...base.weights, ...patch.weights ?? {} },
+    expand: { ...base.expand, ...patch.expand ?? {} },
+    candidates: { ...base.candidates, ...patch.candidates ?? {} }
+  };
+  return merged;
+}
+
+// src/indexer/repoDiscovery.ts
+import fs10 from "fs";
+import path13 from "path";
+function toPosix(p) {
+  return p.split(path13.sep).join("/");
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function globToRegExp(glob) {
+  const parts = toPosix(glob).split("/");
+  const reParts = parts.map((part) => {
+    if (part === "**") return "(?:.*)";
+    const seg = escapeRegExp(part).replace(/\\\*/g, "[^/]*");
+    return seg;
+  });
+  return new RegExp(`^${reParts.join("\\/")}$`);
+}
+function globToSearchRegExp(glob) {
+  let g = toPosix(glob);
+  if (g.startsWith("./")) g = g.slice(2);
+  if (g.startsWith("**/")) g = g.slice(3);
+  const parts = g.split("/");
+  const reParts = parts.map((part) => {
+    if (part === "**") return "(?:.*)";
+    const seg = escapeRegExp(part).replace(/\\\*/g, "[^/]*");
+    return seg;
+  });
+  return new RegExp(reParts.join("\\/"));
+}
+function excludedByAny(globs, relPosix) {
+  if (!globs || globs.length === 0) return false;
+  const p = relPosix.endsWith("/") ? relPosix : `${relPosix}/`;
+  for (const g of globs) {
+    if (globToSearchRegExp(g).test(p)) return true;
+  }
+  return false;
+}
+function defaultExcludes() {
+  return [
+    "**/.git/**",
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.cache/**",
+    "**/.next/**",
+    "**/target/**",
+    "**/.venv/**",
+    "**/vendor/**"
+  ];
+}
+function isGitRoot(dir) {
+  const p = path13.join(dir, ".git");
+  if (!fs10.existsSync(p)) return false;
+  const st = fs10.statSync(p);
+  return st.isDirectory() || st.isFile();
+}
+function parseGitmodules(repoRoot) {
+  const gm = path13.join(repoRoot, ".gitmodules");
+  if (!fs10.existsSync(gm)) return [];
+  let raw = "";
+  try {
+    raw = fs10.readFileSync(gm, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const m = line.match(/^\s*path\s*=\s*(.+)\s*$/);
+    if (!m) continue;
+    const rel = m[1].trim();
+    if (!rel) continue;
+    out.push(path13.resolve(repoRoot, rel));
+  }
+  return out;
+}
+function discoverGitRepos(workspaceRoot, opts = {}) {
+  const root = path13.resolve(workspaceRoot);
+  const include = opts.include && opts.include.length > 0 ? opts.include : ["**"];
+  const exclude = [...defaultExcludes(), ...opts.exclude ?? []];
+  const maxDepth = opts.maxDepth ?? 6;
+  const stopAtRepoRoot = opts.stopAtRepoRoot ?? true;
+  const includeSubmodules = opts.includeSubmodules ?? true;
+  const repos = /* @__PURE__ */ new Set();
+  const stack = [{ dir: root, depth: 0 }];
+  while (stack.length) {
+    const { dir, depth } = stack.pop();
+    if (depth > maxDepth) continue;
+    const rel = path13.relative(root, dir) || ".";
+    const relPosix = toPosix(rel);
+    if (excludedByAny(exclude, relPosix === "." ? "" : relPosix)) continue;
+    if (isGitRoot(dir)) {
+      repos.add(dir);
+      if (includeSubmodules) {
+        for (const sub of parseGitmodules(dir)) {
+          if (fs10.existsSync(sub) && isGitRoot(sub)) repos.add(sub);
+        }
+      }
+      if (stopAtRepoRoot) continue;
+    }
+    let entries;
+    try {
+      entries = fs10.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (e.name === ".git") continue;
+      if (e.name.startsWith(".")) continue;
+      const child = path13.join(dir, e.name);
+      const childRel = path13.relative(root, child) || ".";
+      const childRelPosix = toPosix(childRel);
+      if (excludedByAny(exclude, childRelPosix === "." ? "" : childRelPosix)) continue;
+      stack.push({ dir: child, depth: depth + 1 });
+    }
+  }
+  const arr = Array.from(repos);
+  arr.sort((a, b) => {
+    const da = path13.relative(root, a).split(path13.sep).length;
+    const db = path13.relative(root, b).split(path13.sep).length;
+    if (da !== db) return da - db;
+    return a.localeCompare(b);
+  });
+  return arr;
+}
+function pickRepoOverride(base, repoRoot, workspaceRoot, overrides) {
+  if (!overrides || overrides.length === 0) return base;
+  const rel = toPosix(path13.relative(path13.resolve(workspaceRoot), path13.resolve(repoRoot)) || ".");
+  const matches = overrides.filter((o) => globToRegExp(o.match).test(rel));
+  if (matches.length === 0) return base;
+  const out = deepClone(base);
+  for (const m of matches) {
+    mergeIndexerConfig(out, m.config);
+  }
+  return out;
+}
+function isObj(x) {
+  return !!x && typeof x === "object" && !Array.isArray(x);
+}
+function deepClone(value) {
+  if (value === null || value === void 0) return value;
+  if (value instanceof RegExp) return value;
+  if (Array.isArray(value)) return value.map((v) => deepClone(v));
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = deepClone(v);
+    return out;
+  }
+  return value;
+}
+function mergeIndexerConfig(target, patch) {
+  for (const [k, v] of Object.entries(patch ?? {})) {
+    if (v === void 0) continue;
+    if (isObj(v) && isObj(target[k])) {
+      mergeIndexerConfig(target[k], v);
+      continue;
+    }
+    target[k] = v;
+  }
+}
+
+// src/store/workspaceStore.ts
+import fs12 from "fs";
+import path15 from "path";
+
+// src/store/workspace/unitOfWork.ts
+var UnitOfWork = class {
+  constructor(db) {
+    this.db = db;
+  }
+  run(fn) {
+    const tx = this.db.transaction(fn);
+    return tx();
+  }
+};
+
+// src/store/workspace/repositories/meta.ts
+var MetaRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  set(k, v) {
+    this.db.prepare(`INSERT OR REPLACE INTO meta(k, v) VALUES (?, ?)`).run(k, v);
+  }
+  get(k) {
+    const row = this.db.prepare(`SELECT v FROM meta WHERE k = ?`).get(k);
+    return row?.v ?? null;
+  }
+  getSchemaVersion() {
+    const v = this.get("schema_version");
+    const n = v ? Number(v) : NaN;
+    return Number.isFinite(n) ? n : 0;
+  }
+  setSchemaVersion(v) {
+    this.set("schema_version", String(v));
+  }
+};
+
+// src/store/workspace/repositories/repoHeads.ts
+var RepoHeadsRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  getHeadCommit(repoId) {
+    const row = this.db.prepare(`SELECT head_commit FROM repos WHERE repo_id = ?`).get(repoId);
+    return row?.head_commit ?? null;
+  }
+  upsertHead(repoId, repoRoot, commit, branch) {
+    this.db.prepare(`
+      INSERT INTO repos(repo_id, repo_root, head_commit, head_branch, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(repo_id) DO UPDATE SET
+        repo_root = excluded.repo_root,
+        head_commit = excluded.head_commit,
+        head_branch = excluded.head_branch,
+        updated_at = excluded.updated_at
+    `).run(repoId, repoRoot, commit, branch, Date.now());
+  }
+};
+
+// src/store/workspace/repositories/files.ts
+var FilesRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  upsert(repoId, posixPath, hash, mtime, language, size) {
+    this.db.prepare(`
+      INSERT INTO files(repo_id, path, hash, mtime, language, size)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(repo_id, path) DO UPDATE SET
+        hash = excluded.hash,
+        mtime = excluded.mtime,
+        language = excluded.language,
+        size = excluded.size
+    `).run(repoId, posixPath, hash, mtime, language, size);
+  }
+  delete(repoId, posixPath) {
+    this.db.prepare(`DELETE FROM files WHERE repo_id = ? AND path = ?`).run(repoId, posixPath);
+  }
+  deleteAllForRepo(repoId) {
+    this.db.prepare(`DELETE FROM files WHERE repo_id = ?`).run(repoId);
+  }
+};
+
+// src/store/workspace/repositories/chunks.ts
+var ChunksRepository = class {
+  constructor(db, fts) {
+    this.db = db;
+    this.fts = fts;
+  }
+  deleteFile(repoId, posixPath) {
+    this.db.prepare(`DELETE FROM chunks WHERE repo_id = ? AND path = ?`).run(repoId, posixPath);
+    this.fts.clearFile(repoId, posixPath);
+  }
+  deleteAllForRepo(repoId) {
+    this.db.prepare(`DELETE FROM chunks WHERE repo_id = ?`).run(repoId);
+    this.fts.clearRepo(repoId);
+  }
+  replaceForFile(repoId, repoRoot, posixPath, rows) {
+    this.deleteFile(repoId, posixPath);
+    const ins = this.db.prepare(`
+      INSERT INTO chunks(id, repo_id, repo_root, path, language, kind, start_line, end_line, content_hash, tokens, file_mtime, text, embedding)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    for (const r of rows) {
+      const buf = Buffer.from(r.embedding.buffer, r.embedding.byteOffset, r.embedding.byteLength);
+      ins.run(r.id, repoId, repoRoot, posixPath, r.language, r.kind, r.startLine, r.endLine, r.contentHash, r.tokens, r.fileMtime, r.text, buf);
+      this.fts.insertChunk({ id: r.id, repoId, repoRoot, path: posixPath, language: r.language, kind: r.kind, text: r.ftsText });
+    }
+  }
+  getById(id) {
+    const row = this.db.prepare(`SELECT * FROM chunks WHERE id = ?`).get(id);
+    return row ?? null;
+  }
+  listForFile(repoId, posixPath, kind) {
+    if (kind) {
+      return this.db.prepare(`SELECT id, start_line, end_line, kind FROM chunks WHERE repo_id = ? AND path = ? AND kind = ? ORDER BY start_line ASC`).all(repoId, posixPath, kind);
+    }
+    return this.db.prepare(`SELECT id, start_line, end_line, kind FROM chunks WHERE repo_id = ? AND path = ? ORDER BY kind DESC, start_line ASC`).all(repoId, posixPath);
+  }
+};
+
+// src/store/workspace/repositories/edges.ts
+var EdgesRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  set(repoId, fromPath, kind, values) {
+    this.db.prepare(`DELETE FROM edges WHERE repo_id = ? AND from_path = ? AND kind = ?`).run(repoId, fromPath, kind);
+    const ins = this.db.prepare(`INSERT OR REPLACE INTO edges(repo_id, from_path, kind, value) VALUES (?, ?, ?, ?)`);
+    for (const v of values) ins.run(repoId, fromPath, kind, v);
+  }
+  list(repoId, fromPath, kind) {
+    const rows = this.db.prepare(`SELECT value FROM edges WHERE repo_id = ? AND from_path = ? AND kind = ?`).all(repoId, fromPath, kind);
+    return rows.map((r) => r.value);
+  }
+  deleteFile(repoId, posixPath) {
+    this.db.prepare(`DELETE FROM edges WHERE repo_id = ? AND from_path = ?`).run(repoId, posixPath);
+  }
+  deleteAllForRepo(repoId) {
+    this.db.prepare(`DELETE FROM edges WHERE repo_id = ?`).run(repoId);
+  }
+};
+
+// src/store/workspace/repositories/symbols.ts
+var SymbolsRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  replaceForFile(repoId, repoRoot, posixPath, rows, edges) {
+    this.db.prepare(`DELETE FROM symbols WHERE repo_id = ? AND path = ?`).run(repoId, posixPath);
+    this.db.prepare(`DELETE FROM symbol_edges WHERE repo_id = ? AND from_path = ?`).run(repoId, posixPath);
+    const ins = this.db.prepare(`
+      INSERT OR REPLACE INTO symbols(
+        id, repo_id, repo_root, path, language, name, kind,
+        start_line, start_char, end_line, end_char, container_name, detail
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    for (const r of rows) {
+      ins.run(
+        r.id,
+        repoId,
+        repoRoot,
+        posixPath,
+        r.language,
+        r.name,
+        r.kind,
+        r.startLine,
+        r.startCharacter,
+        r.endLine,
+        r.endCharacter,
+        r.containerName ?? "",
+        r.detail ?? ""
+      );
+    }
+    const insE = this.db.prepare(`
+      INSERT OR REPLACE INTO symbol_edges(repo_id, from_id, to_id, kind, from_path, to_path)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    for (const e of edges) {
+      insE.run(repoId, e.fromId, e.toId, e.kind, e.fromPath, e.toPath);
+    }
+  }
+  replaceEdgesFromFile(repoId, fromPath, edges) {
+    this.db.prepare(`DELETE FROM symbol_edges WHERE repo_id = ? AND from_path = ?`).run(repoId, fromPath);
+    const insE = this.db.prepare(`
+      INSERT OR REPLACE INTO symbol_edges(repo_id, from_id, to_id, kind, from_path, to_path)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    for (const e of edges) {
+      insE.run(repoId, e.fromId, e.toId, e.kind, fromPath, e.toPath);
+    }
+  }
+  deleteFile(repoId, posixPath) {
+    this.db.prepare(`DELETE FROM symbols WHERE repo_id = ? AND path = ?`).run(repoId, posixPath);
+    this.db.prepare(`DELETE FROM symbol_edges WHERE repo_id = ? AND (from_path = ? OR to_path = ?)`).run(repoId, posixPath, posixPath);
+  }
+  deleteAllForRepo(repoId) {
+    this.db.prepare(`DELETE FROM symbols WHERE repo_id = ?`).run(repoId);
+    this.db.prepare(`DELETE FROM symbol_edges WHERE repo_id = ?`).run(repoId);
+  }
+};
+
+// src/store/workspace/repositories/repoLinks.ts
+var RepoLinksRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  replaceFromRepo(fromRepoId, links) {
+    this.db.prepare(`DELETE FROM repo_links WHERE from_repo_id = ?`).run(fromRepoId);
+    const ins = this.db.prepare(`INSERT OR REPLACE INTO repo_links(from_repo_id, to_repo_id, kind, detail) VALUES (?, ?, ?, ?)`);
+    for (const l of links) {
+      ins.run(fromRepoId, l.toRepoId, l.kind, l.detail ?? "");
+    }
+  }
+  listFromRepo(fromRepoId) {
+    const rows = this.db.prepare(`SELECT to_repo_id AS toRepoId, kind, detail FROM repo_links WHERE from_repo_id = ? ORDER BY kind ASC, to_repo_id ASC`).all(fromRepoId);
+    return rows;
+  }
+};
+
+// src/store/workspace/factory.ts
+import fs11 from "fs";
+import path14 from "path";
+
+// src/store/workspace/db.ts
+import Database3 from "better-sqlite3";
+var BetterSqlite3Adapter = class {
+  db;
+  constructor(dbPath) {
+    this.db = new Database3(dbPath);
+  }
+  pragma(sql) {
+    this.db.pragma(sql);
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
+  transaction(fn) {
+    return this.db.transaction(fn);
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/store/workspace/fts.ts
+var NoopFtsStrategy = class {
+  enabled = false;
+  init(_db) {
+  }
+  clearRepo(_repoId) {
+  }
+  clearFile(_repoId, _posixPath) {
+  }
+  insertChunk(_args) {
+  }
+  search(_ftq, _limit, _repoIds) {
+    return [];
+  }
+};
+var Fts5Strategy = class {
+  constructor(db) {
+    this.db = db;
+  }
+  enabled = true;
+  ins = null;
+  init(db) {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+        id UNINDEXED,
+        repo_id UNINDEXED,
+        repo_root UNINDEXED,
+        path,
+        language,
+        kind,
+        text,
+        tokenize='unicode61'
+      );
+    `);
+  }
+  clearRepo(repoId) {
+    this.db.prepare(`DELETE FROM chunks_fts WHERE repo_id = ?`).run(repoId);
+  }
+  clearFile(repoId, posixPath) {
+    this.db.prepare(`DELETE FROM chunks_fts WHERE repo_id = ? AND path = ?`).run(repoId, posixPath);
+  }
+  insertChunk(args) {
+    if (!this.ins) {
+      this.ins = this.db.prepare(`INSERT INTO chunks_fts(id, repo_id, repo_root, path, language, kind, text) VALUES (?, ?, ?, ?, ?, ?, ?)`);
+    }
+    this.ins.run(args.id, args.repoId, args.repoRoot, args.path, args.language, args.kind, args.text);
+  }
+  search(ftq, limit, repoIds) {
+    if (repoIds && repoIds.length > 0) {
+      const placeholders = repoIds.map(() => "?").join(", ");
+      const sql2 = `
+        SELECT id, bm25(chunks_fts) AS bm25
+        FROM chunks_fts
+        WHERE chunks_fts MATCH ? AND repo_id IN (${placeholders})
+        ORDER BY bm25 ASC
+        LIMIT ?
+      `;
+      return this.db.prepare(sql2).all(ftq, ...repoIds, limit);
+    }
+    const sql = `
+      SELECT id, bm25(chunks_fts) AS bm25
+      FROM chunks_fts
+      WHERE chunks_fts MATCH ?
+      ORDER BY bm25 ASC
+      LIMIT ?
+    `;
+    return this.db.prepare(sql).all(ftq, limit);
+  }
+};
+
+// src/store/workspace/migrations.ts
+var WORKSPACE_SCHEMA_LATEST = 2;
+var WORKSPACE_MIGRATIONS = [
+  {
+    version: 2,
+    name: "repo_links",
+    up: (db) => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS repo_links (
+          from_repo_id TEXT NOT NULL,
+          to_repo_id TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          detail TEXT NOT NULL DEFAULT '',
+          PRIMARY KEY(from_repo_id, to_repo_id, kind)
+        );
+        CREATE INDEX IF NOT EXISTS idx_repo_links_from ON repo_links(from_repo_id);
+        CREATE INDEX IF NOT EXISTS idx_repo_links_to ON repo_links(to_repo_id);
+      `);
+    }
+  }
+];
+var WorkspaceMigrator = class {
+  constructor(db, meta) {
+    this.db = db;
+    this.meta = meta;
+  }
+  get version() {
+    return this.meta.getSchemaVersion();
+  }
+  migrateToLatest() {
+    let v = this.meta.getSchemaVersion();
+    if (v === 0) {
+      this.meta.setSchemaVersion(1);
+      v = 1;
+    }
+    const pending = WORKSPACE_MIGRATIONS.filter((m) => m.version > v).sort((a, b) => a.version - b.version);
+    for (const m of pending) {
+      m.up(this.db);
+      this.meta.setSchemaVersion(m.version);
+      v = m.version;
+    }
+    if (v !== WORKSPACE_SCHEMA_LATEST) {
+      this.meta.setSchemaVersion(WORKSPACE_SCHEMA_LATEST);
+    }
+  }
+};
+
+// src/store/workspace/factory.ts
+function createWorkspaceDb(dbPath) {
+  fs11.mkdirSync(path14.dirname(dbPath), { recursive: true });
+  const db = new BetterSqlite3Adapter(dbPath);
+  db.pragma("journal_mode = WAL");
+  return db;
+}
+function createWorkspaceBaseSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS meta (
+      k TEXT PRIMARY KEY,
+      v TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS repos (
+      repo_id TEXT PRIMARY KEY,
+      repo_root TEXT NOT NULL,
+      head_commit TEXT NOT NULL,
+      head_branch TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_repos_root ON repos(repo_root);
+
+    CREATE TABLE IF NOT EXISTS files (
+      repo_id TEXT NOT NULL,
+      path TEXT NOT NULL,
+      hash TEXT NOT NULL,
+      mtime INTEGER NOT NULL,
+      language TEXT NOT NULL,
+      size INTEGER NOT NULL,
+      PRIMARY KEY(repo_id, path)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_files_repo ON files(repo_id);
+
+    CREATE TABLE IF NOT EXISTS chunks (
+      id TEXT PRIMARY KEY,
+      repo_id TEXT NOT NULL,
+      repo_root TEXT NOT NULL,
+      path TEXT NOT NULL,
+      language TEXT NOT NULL,
+      kind TEXT NOT NULL DEFAULT 'chunk',
+      start_line INTEGER NOT NULL,
+      end_line INTEGER NOT NULL,
+      content_hash TEXT NOT NULL,
+      tokens INTEGER NOT NULL,
+      file_mtime INTEGER NOT NULL,
+      text TEXT NOT NULL,
+      embedding BLOB NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_chunks_repo_path ON chunks(repo_id, path);
+    CREATE INDEX IF NOT EXISTS idx_chunks_kind_repo_path ON chunks(kind, repo_id, path);
+
+    CREATE TABLE IF NOT EXISTS edges (
+      repo_id TEXT NOT NULL,
+      from_path TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      value TEXT NOT NULL,
+      PRIMARY KEY(repo_id, from_path, kind, value)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_edges_repo_from ON edges(repo_id, from_path);
+
+    CREATE TABLE IF NOT EXISTS symbols (
+      id TEXT PRIMARY KEY,
+      repo_id TEXT NOT NULL,
+      repo_root TEXT NOT NULL,
+      path TEXT NOT NULL,
+      language TEXT NOT NULL,
+      name TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      start_line INTEGER NOT NULL,
+      start_char INTEGER NOT NULL,
+      end_line INTEGER NOT NULL,
+      end_char INTEGER NOT NULL,
+      container_name TEXT NOT NULL DEFAULT '',
+      detail TEXT NOT NULL DEFAULT ''
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_symbols_repo_path ON symbols(repo_id, path);
+    CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+
+    CREATE TABLE IF NOT EXISTS symbol_edges (
+      repo_id TEXT NOT NULL,
+      from_id TEXT NOT NULL,
+      to_id TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      from_path TEXT NOT NULL,
+      to_path TEXT NOT NULL,
+      PRIMARY KEY(repo_id, from_id, to_id, kind)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_symbol_edges_from ON symbol_edges(repo_id, from_id);
+    CREATE INDEX IF NOT EXISTS idx_symbol_edges_paths ON symbol_edges(repo_id, from_path);
+  `);
+}
+function createWorkspaceFts(db, meta, opts = {}) {
+  if (opts.fts === "off") {
+    meta.set("fts", "0");
+    return new NoopFtsStrategy();
+  }
+  try {
+    const fts = new Fts5Strategy(db);
+    fts.init(db);
+    meta.set("fts", "1");
+    return fts;
+  } catch {
+    meta.set("fts", "0");
+    return new NoopFtsStrategy();
+  }
+}
+function migrateWorkspaceDb(db, meta) {
+  const migrator = new WorkspaceMigrator(db, meta);
+  migrator.migrateToLatest();
+}
+
+// src/store/workspaceStore.ts
+var WorkspaceStore = class {
+  constructor(dbPath, opts = {}) {
+    this.dbPath = dbPath;
+    this.opts = opts;
+    this.db = createWorkspaceDb(dbPath);
+    this.uow = new UnitOfWork(this.db);
+    createWorkspaceBaseSchema(this.db);
+    this.meta = new MetaRepository(this.db);
+    migrateWorkspaceDb(this.db, this.meta);
+    const fts = createWorkspaceFts(this.db, this.meta, opts);
+    this.repoHeads = new RepoHeadsRepository(this.db);
+    this.files = new FilesRepository(this.db);
+    this.edges = new EdgesRepository(this.db);
+    this.repoLinks = new RepoLinksRepository(this.db);
+    this.chunks = new ChunksRepository(this.db, fts);
+    this.symbols = new SymbolsRepository(this.db);
+  }
+  db;
+  uow;
+  meta;
+  repoHeads;
+  files;
+  edges;
+  repoLinks;
+  symbols;
+  chunks;
+  opts;
+  setMeta(k, v) {
+    this.meta.set(k, v);
+  }
+  getMeta(k) {
+    return this.meta.get(k);
+  }
+  /**
+   * Set repo head. If commit changes, clears prior rows for that repo_id to keep the workspace index "current".
+   */
+  setRepoHead(repoId, repoRoot, commit, branch) {
+    const prevCommit = this.repoHeads.getHeadCommit(repoId);
+    this.uow.run(() => {
+      if (prevCommit && prevCommit !== commit) {
+        this.chunks.deleteAllForRepo(repoId);
+        this.edges.deleteAllForRepo(repoId);
+        this.files.deleteAllForRepo(repoId);
+        this.symbols.deleteAllForRepo(repoId);
+      }
+      this.repoHeads.upsertHead(repoId, repoRoot, commit, branch);
+    });
+  }
+  deleteFile(repoId, posixPath) {
+    this.uow.run(() => {
+      this.chunks.deleteFile(repoId, posixPath);
+      this.edges.deleteFile(repoId, posixPath);
+      this.files.delete(repoId, posixPath);
+      this.symbols.deleteFile(repoId, posixPath);
+    });
+  }
+  upsertFile(repoId, posixPath, hash, mtime, language, size) {
+    this.files.upsert(repoId, posixPath, hash, mtime, language, size);
+  }
+  replaceChunksForFile(repoId, repoRoot, posixPath, rows) {
+    this.uow.run(() => {
+      this.chunks.replaceForFile(repoId, repoRoot, posixPath, rows);
+    });
+  }
+  setEdges(repoId, fromPath, kind, values) {
+    this.uow.run(() => {
+      this.edges.set(repoId, fromPath, kind, values);
+    });
+  }
+  replaceSymbolsForFile(repoId, repoRoot, posixPath, rows, edges) {
+    this.uow.run(() => {
+      this.symbols.replaceForFile(repoId, repoRoot, posixPath, rows, edges);
+    });
+  }
+  replaceSymbolEdgesFromFile(repoId, fromPath, edges) {
+    this.uow.run(() => {
+      this.symbols.replaceEdgesFromFile(repoId, fromPath, edges);
+    });
+  }
+  replaceRepoLinks(fromRepoId, links) {
+    this.uow.run(() => {
+      this.repoLinks.replaceFromRepo(fromRepoId, links);
+    });
+  }
+  listRepoLinks(fromRepoId) {
+    return this.repoLinks.listFromRepo(fromRepoId);
+  }
+  listChunksForFile(repoId, posixPath, kind) {
+    return this.chunks.listForFile(repoId, posixPath, kind);
+  }
+  listEdges(repoId, fromPath, kind) {
+    return this.edges.list(repoId, fromPath, kind);
+  }
+  getChunkById(id) {
+    return this.chunks.getById(id);
+  }
+  searchFts(ftq, limit, repoIds) {
+    try {
+      const fts = this.getMeta("fts");
+      if (fts !== "1") return [];
+      return this.chunks.fts.search(ftq, limit, repoIds);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * If text is omitted from storage, fall back to slicing from disk.
+   * The chunk boundaries are approximate; the stored row includes start/end line.
+   */
+  getChunkTextFallback(row) {
+    const abs = path15.join(row.repo_root, row.path.split("/").join(path15.sep));
+    try {
+      const raw = fs12.readFileSync(abs, "utf8");
+      const lines = raw.split(/\r?\n/);
+      const start = Math.max(1, row.start_line);
+      const end = Math.max(start, row.end_line);
+      return lines.slice(start - 1, end).join("\n");
+    } catch {
+      return "";
+    }
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/graph/neo4j.ts
+import { createRequire as createRequire2 } from "module";
+async function runSession(driver, database, fn) {
+  const session = driver.session(database ? { database } : void 0);
+  try {
+    await fn(session);
+  } finally {
+    await session.close().catch(() => void 0);
+  }
+}
+function lp(prefix, label) {
+  const safe = prefix.replace(/[^A-Za-z0-9_]/g, "") || "Petri";
+  return `${safe}_${label}`;
+}
+var Neo4jGraphStore = class {
+  constructor(driver, cfg) {
+    this.driver = driver;
+    this.cfg = cfg;
+    this.labelPrefix = cfg.labelPrefix ?? "Petri";
+  }
+  id = "neo4j";
+  labelPrefix;
+  schemaVersionLatest = 2;
+  labels() {
+    return {
+      Repo: lp(this.labelPrefix, "Repo"),
+      File: lp(this.labelPrefix, "File"),
+      Symbol: lp(this.labelPrefix, "Symbol"),
+      External: lp(this.labelPrefix, "External"),
+      Schema: lp(this.labelPrefix, "Schema")
+    };
+  }
+  async init() {
+    const { Schema } = this.labels();
+    await runSession(this.driver, this.cfg.database, async (s) => {
+      await s.run(
+        `MERGE (m:${Schema} {key:$key})
+         ON CREATE SET m.version=0, m.created_at=timestamp(), m.updated_at=timestamp()
+         RETURN m.version AS version`,
+        { key: "schema" }
+      );
+    });
+    await this.runMigrations().catch(() => void 0);
+  }
+  async getSchemaVersion() {
+    const { Schema } = this.labels();
+    let version = 0;
+    await runSession(this.driver, this.cfg.database, async (s) => {
+      const res = await s.run(`MATCH (m:${Schema} {key:$key}) RETURN m.version AS version`, { key: "schema" });
+      const v = res?.records?.[0]?.get?.("version");
+      const n = typeof v?.toNumber === "function" ? v.toNumber() : Number(v);
+      version = Number.isFinite(n) ? n : 0;
+    });
+    return version;
+  }
+  async setSchemaVersion(v) {
+    const { Schema } = this.labels();
+    await runSession(this.driver, this.cfg.database, async (s) => {
+      await s.run(
+        `MERGE (m:${Schema} {key:$key})
+         SET m.version=$v, m.updated_at=timestamp()`,
+        { key: "schema", v }
+      );
+    });
+  }
+  async runMigrations() {
+    const { Repo, File, Symbol, External } = this.labels();
+    let v = await this.getSchemaVersion();
+    if (v < 1) {
+      await runSession(this.driver, this.cfg.database, async (s) => {
+        const stmts = [
+          `CREATE CONSTRAINT ${Repo}_repo_id IF NOT EXISTS FOR (r:${Repo}) REQUIRE r.repo_id IS UNIQUE`,
+          `CREATE CONSTRAINT ${Symbol}_id IF NOT EXISTS FOR (s:${Symbol}) REQUIRE s.id IS UNIQUE`,
+          `CREATE CONSTRAINT ${External}_key IF NOT EXISTS FOR (e:${External}) REQUIRE (e.repo_id, e.kind, e.value) IS NODE KEY`,
+          `CREATE CONSTRAINT ${File}_key IF NOT EXISTS FOR (f:${File}) REQUIRE (f.repo_id, f.path) IS NODE KEY`
+        ];
+        for (const q of stmts) {
+          try {
+            await s.run(q);
+          } catch {
+          }
+        }
+      });
+      await this.setSchemaVersion(1);
+      v = 1;
+    }
+    if (v < 2) {
+      await runSession(this.driver, this.cfg.database, async (s) => {
+        const stmts = [
+          `CREATE INDEX ${Symbol}_repo_path IF NOT EXISTS FOR (s:${Symbol}) ON (s.repo_id, s.path)`,
+          `CREATE INDEX ${File}_repo IF NOT EXISTS FOR (f:${File}) ON (f.repo_id)`,
+          `CREATE INDEX ${External}_repo IF NOT EXISTS FOR (e:${External}) ON (e.repo_id)`
+        ];
+        for (const q of stmts) {
+          try {
+            await s.run(q);
+          } catch {
+          }
+        }
+      });
+      await this.setSchemaVersion(2);
+      v = 2;
+    }
+    if (v !== this.schemaVersionLatest) {
+      await this.setSchemaVersion(this.schemaVersionLatest);
+    }
+  }
+  async setRepoHead(args) {
+    const { Repo, File, Symbol, External } = this.labels();
+    const { repoId, repoRoot, commit, branch } = args;
+    await runSession(this.driver, this.cfg.database, async (s) => {
+      const prev = await s.run(
+        `MERGE (r:${Repo} {repo_id:$repoId})
+         ON CREATE SET r.repo_root=$repoRoot, r.commit=$commit, r.branch=$branch, r.updated_at=timestamp()
+         ON MATCH SET r.repo_root=$repoRoot, r.branch=$branch, r.updated_at=timestamp()
+         RETURN r.commit AS commit`,
+        { repoId, repoRoot, commit, branch }
+      );
+      const prevCommit = prev?.records?.[0]?.get?.("commit");
+      const prevCommitStr = typeof prevCommit === "string" ? prevCommit : `${prevCommit ?? ""}`;
+      if (prevCommitStr && prevCommitStr !== commit) {
+        await s.run(`MATCH (s:${Symbol} {repo_id:$repoId}) DETACH DELETE s`, { repoId });
+        await s.run(
+          `MATCH (f:${File} {repo_id:$repoId})
+           DETACH DELETE f`,
+          { repoId }
+        );
+        await s.run(
+          `MATCH (e:${External} {repo_id:$repoId})
+           WHERE NOT (()-[:FILE_EDGE]->(e))
+           DELETE e`,
+          { repoId }
+        ).catch(() => void 0);
+        await s.run(`MATCH (r:${Repo} {repo_id:$repoId}) SET r.commit=$commit`, { repoId, commit });
+      } else {
+        await s.run(`MATCH (r:${Repo} {repo_id:$repoId}) SET r.commit=$commit`, { repoId, commit });
+      }
+    });
+  }
+  async deleteFile(args) {
+    const { File, Symbol } = this.labels();
+    await runSession(this.driver, this.cfg.database, async (s) => {
+      await s.run(`MATCH (s:${Symbol} {repo_id:$repoId, path:$path}) DETACH DELETE s`, args);
+      await s.run(`MATCH (f:${File} {repo_id:$repoId, path:$path}) DETACH DELETE f`, args);
+    });
+  }
+  async replaceOutgoingSymbolEdgesFromFile(args) {
+    const { Symbol } = this.labels();
+    const kinds = args.edges.length > 0 ? Array.from(new Set(args.edges.map((e) => e.kind))) : ["definition", "reference", "implementation", "typeDefinition"];
+    const keep = args.edges.map((e) => `${e.fromId}|${e.kind}|${e.toId}`);
+    await runSession(this.driver, this.cfg.database, async (s) => {
+      await s.run(
+        `UNWIND $edges AS e
+         MERGE (a:${Symbol} {id:e.fromId})
+         MERGE (b:${Symbol} {id:e.toId})
+         ON CREATE SET b.repo_id=$repoId, b.path=coalesce(e.toPath, '')
+         SET b.repo_id = coalesce(b.repo_id, $repoId),
+             b.path = CASE WHEN coalesce(b.path, '') = '' AND e.toPath IS NOT NULL THEN e.toPath ELSE b.path END
+         MERGE (a)-[:SYMBOL_EDGE {kind:e.kind}]->(b)`,
+        { repoId: args.repoId, edges: args.edges }
+      ).catch(() => void 0);
+      if (keep.length === 0) {
+        await s.run(
+          `MATCH (a:${Symbol} {repo_id:$repoId, path:$fromPath})-[r:SYMBOL_EDGE]->()
+           WHERE r.kind IN $kinds
+           DELETE r`,
+          { repoId: args.repoId, fromPath: args.fromPath, kinds }
+        ).catch(() => void 0);
+        return;
+      }
+      await s.run(
+        `MATCH (a:${Symbol} {repo_id:$repoId, path:$fromPath})-[r:SYMBOL_EDGE]->(b:${Symbol})
+         WHERE r.kind IN $kinds
+           AND NOT (a.id + '|' + r.kind + '|' + b.id) IN $keep
+         DELETE r`,
+        { repoId: args.repoId, fromPath: args.fromPath, kinds, keep }
+      ).catch(() => void 0);
+    });
+  }
+  async replaceFileGraph(update) {
+    const { Repo, File, Symbol, External } = this.labels();
+    const symbols = update.symbols.map((s) => ({
+      id: s.id,
+      name: s.name,
+      kind: s.kind,
+      language: s.language,
+      start_line: s.range.startLine,
+      start_char: s.range.startCharacter,
+      end_line: s.range.endLine,
+      end_char: s.range.endCharacter,
+      container_name: s.containerName ?? "",
+      detail: s.detail ?? ""
+    }));
+    const symbolEdges = update.symbolEdges.map((e) => ({ fromId: e.fromId, toId: e.toId, kind: e.kind }));
+    const managedSymbolEdgeKinds = Array.from(new Set(symbolEdges.map((e) => e.kind)));
+    const symbolEdgeKeep = symbolEdges.map((e) => `${e.fromId}|${e.kind}|${e.toId}`);
+    await runSession(this.driver, this.cfg.database, async (s) => {
+      await s.run(
+        `MERGE (r:${Repo} {repo_id:$repoId})
+         SET r.repo_root=$repoRoot, r.commit=$commit, r.branch=$branch, r.updated_at=timestamp()
+         MERGE (f:${File} {repo_id:$repoId, path:$path})
+         SET f.repo_root=$repoRoot, f.language=$language, f.updated_at=timestamp()
+         MERGE (r)-[:HAS_FILE]->(f)`,
+        { repoId: update.repoId, repoRoot: update.repoRoot, commit: update.commit, branch: update.branch, path: update.path, language: update.language }
+      );
+      const fileEdges = [
+        ...update.imports.map((v) => ({ kind: "import", value: v })),
+        ...update.exports.map((v) => ({ kind: "export", value: v }))
+      ];
+      const fileEdgeKeep = fileEdges.map((e) => `${e.kind}|${e.value}`);
+      await s.run(
+        `MATCH (f:${File} {repo_id:$repoId, path:$path})
+         UNWIND $edges AS e
+         MERGE (x:${External} {repo_id:$repoId, kind:e.kind, value:e.value})
+         MERGE (f)-[:FILE_EDGE {kind:e.kind}]->(x)`,
+        { repoId: update.repoId, path: update.path, edges: fileEdges }
+      ).catch(() => void 0);
+      await s.run(
+        `MATCH (f:${File} {repo_id:$repoId, path:$path})-[r:FILE_EDGE]->(x:${External})
+         WHERE NOT (r.kind + '|' + x.value) IN $keep
+         DELETE r`,
+        { repoId: update.repoId, path: update.path, keep: fileEdgeKeep }
+      ).catch(() => void 0);
+      if (symbols.length) {
+        await s.run(
+          `MATCH (f:${File} {repo_id:$repoId, path:$path})
+           UNWIND $symbols AS s
+           MERGE (n:${Symbol} {id:s.id})
+           ON CREATE SET n.repo_id=$repoId
+           SET n.repo_root=$repoRoot, n.path=$path,
+               n.language=s.language, n.name=s.name, n.kind=s.kind,
+               n.start_line=s.start_line, n.start_char=s.start_char, n.end_line=s.end_line, n.end_char=s.end_char,
+               n.container_name=s.container_name, n.detail=s.detail
+           MERGE (f)-[:CONTAINS]->(n)`,
+          { repoId: update.repoId, repoRoot: update.repoRoot, path: update.path, symbols }
+        );
+        const ids = symbols.map((s2) => s2.id);
+        await s.run(
+          `MATCH (f:${File} {repo_id:$repoId, path:$path})-[r:CONTAINS]->(n:${Symbol})
+           WHERE NOT n.id IN $ids
+           DELETE r`,
+          { repoId: update.repoId, path: update.path, ids }
+        ).catch(() => void 0);
+        await s.run(
+          `MATCH (n:${Symbol} {repo_id:$repoId, path:$path})
+           WHERE NOT n.id IN $ids
+           DETACH DELETE n`,
+          { repoId: update.repoId, path: update.path, ids }
+        ).catch(() => void 0);
+      } else {
+        await s.run(
+          `MATCH (f:${File} {repo_id:$repoId, path:$path})-[r:CONTAINS]->() DELETE r`,
+          { repoId: update.repoId, path: update.path }
+        ).catch(() => void 0);
+        await s.run(
+          `MATCH (n:${Symbol} {repo_id:$repoId, path:$path}) DETACH DELETE n`,
+          { repoId: update.repoId, path: update.path }
+        ).catch(() => void 0);
+      }
+      if (symbolEdges.length) {
+        await s.run(
+          `UNWIND $edges AS e
+           MERGE (a:${Symbol} {id:e.fromId})
+           MERGE (b:${Symbol} {id:e.toId})
+           MERGE (a)-[:SYMBOL_EDGE {kind:e.kind}]->(b)`,
+          { edges: symbolEdges }
+        ).catch(() => void 0);
+        if (managedSymbolEdgeKinds.length > 0) {
+          await s.run(
+            `MATCH (a:${Symbol} {repo_id:$repoId, path:$path})-[r:SYMBOL_EDGE]->(b:${Symbol})
+             WHERE r.kind IN $kinds
+               AND NOT (a.id + '|' + r.kind + '|' + b.id) IN $keep
+             DELETE r`,
+            { repoId: update.repoId, path: update.path, kinds: managedSymbolEdgeKinds, keep: symbolEdgeKeep }
+          ).catch(() => void 0);
+        }
+      }
+    });
+  }
+  async replaceRepoLinks(args) {
+    const { Repo } = this.labels();
+    const byFrom = /* @__PURE__ */ new Map();
+    for (const l of args.links) {
+      const arr = byFrom.get(l.fromRepoId) ?? [];
+      arr.push({ toRepoId: l.toRepoId, kind: l.kind, detail: l.detail });
+      byFrom.set(l.fromRepoId, arr);
+    }
+    for (const [fromRepoId, links] of byFrom) {
+      const keep = links.map((l) => `${l.toRepoId}|${l.kind}`);
+      await runSession(this.driver, this.cfg.database, async (s) => {
+        await s.run(
+          `UNWIND $links AS l
+           MERGE (a:${Repo} {repo_id:$fromRepoId})
+           MERGE (b:${Repo} {repo_id:l.toRepoId})
+           MERGE (a)-[r:REPO_LINK {kind:l.kind}]->(b)
+           SET r.detail = coalesce(l.detail, '')`,
+          { fromRepoId, links }
+        ).catch(() => void 0);
+        if (keep.length === 0) {
+          await s.run(`MATCH (a:${Repo} {repo_id:$fromRepoId})-[r:REPO_LINK]->() DELETE r`, { fromRepoId }).catch(() => void 0);
+          return;
+        }
+        await s.run(
+          `MATCH (a:${Repo} {repo_id:$fromRepoId})-[r:REPO_LINK]->(b:${Repo})
+           WHERE NOT (b.repo_id + '|' + r.kind) IN $keep
+           DELETE r`,
+          { fromRepoId, keep }
+        ).catch(() => void 0);
+      });
+    }
+  }
+  async neighborFiles(args) {
+    const { File, Symbol } = this.labels();
+    const limit = args.limit ?? 20;
+    const kinds = args.kinds && args.kinds.length > 0 ? args.kinds : null;
+    const rows = [];
+    await runSession(this.driver, this.cfg.database, async (s) => {
+      const res = await s.run(
+        `UNWIND $seeds AS seed
+         MATCH (f:${File} {repo_id:seed.repoId, path:seed.path})-[:CONTAINS]->(a:${Symbol})-[e:SYMBOL_EDGE]->(b:${Symbol})<-[:CONTAINS]-(g:${File})
+         WHERE (g.repo_id <> seed.repoId OR g.path <> seed.path)
+           AND ($kinds IS NULL OR e.kind IN $kinds)
+         RETURN g.repo_id AS repoId, g.path AS path, count(*) AS weight
+         ORDER BY weight DESC
+         LIMIT $limit`,
+        { seeds: args.seeds, kinds, limit }
+      );
+      for (const r of res?.records ?? []) {
+        const repoId = String(r.get("repoId"));
+        const p = String(r.get("path"));
+        const wRaw = r.get("weight");
+        const w = typeof wRaw?.toNumber === "function" ? wRaw.toNumber() : Number(wRaw);
+        rows.push({ repoId, path: p, weight: Number.isFinite(w) ? w : 0 });
+      }
+    });
+    return rows;
+  }
+  async shortestFilePath(args) {
+    const { File } = this.labels();
+    const maxRels = args.maxRels ?? 16;
+    let out = null;
+    await runSession(this.driver, this.cfg.database, async (s) => {
+      const res = await s.run(
+        `MATCH (a:${File} {repo_id:$aRepoId, path:$aPath})
+         MATCH (b:${File} {repo_id:$bRepoId, path:$bPath})
+         MATCH p = shortestPath((a)-[:CONTAINS|SYMBOL_EDGE*..${maxRels}]-(b))
+         RETURN [n IN nodes(p) WHERE n:${File} | {repoId:n.repo_id, path:n.path}] AS files`,
+        { aRepoId: args.from.repoId, aPath: args.from.path, bRepoId: args.to.repoId, bPath: args.to.path }
+      ).catch(() => null);
+      const files = res?.records?.[0]?.get?.("files");
+      if (!Array.isArray(files)) return;
+      out = files.map((x) => ({ repoId: String(x.repoId), path: String(x.path) }));
+    });
+    return out;
+  }
+  async extractFileSubgraph(args) {
+    const { File, Symbol } = this.labels();
+    const limitEdges = args.limitEdges ?? 200;
+    const nodes = /* @__PURE__ */ new Map();
+    const edges = [];
+    await runSession(this.driver, this.cfg.database, async (s) => {
+      const res = await s.run(
+        `UNWIND $seeds AS seed
+         MATCH (f:${File} {repo_id:seed.repoId, path:seed.path})-[:CONTAINS]->(a:${Symbol})-[e:SYMBOL_EDGE]->(b:${Symbol})<-[:CONTAINS]-(g:${File})
+         RETURN f.repo_id AS fromRepoId, f.path AS fromPath, g.repo_id AS toRepoId, g.path AS toPath, e.kind AS kind
+         LIMIT $limit`,
+        { seeds: args.seeds, limit: limitEdges }
+      );
+      for (const r of res?.records ?? []) {
+        const from = { repoId: String(r.get("fromRepoId")), path: String(r.get("fromPath")) };
+        const to = { repoId: String(r.get("toRepoId")), path: String(r.get("toPath")) };
+        const kind = String(r.get("kind"));
+        nodes.set(`${from.repoId}:${from.path}`, from);
+        nodes.set(`${to.repoId}:${to.path}`, to);
+        edges.push({ from, to, kind });
+      }
+    });
+    return { nodes: Array.from(nodes.values()), edges };
+  }
+  async close() {
+    await this.driver.close().catch(() => void 0);
+  }
+};
+async function createNeo4jGraphStore(cfg) {
+  try {
+    const require2 = createRequire2(import.meta.url);
+    const neo4j = require2("neo4j-driver");
+    const driver = neo4j.driver(cfg.uri, neo4j.auth.basic(cfg.user, cfg.password));
+    const store = new Neo4jGraphStore(driver, cfg);
+    await store.init();
+    return store;
+  } catch (e) {
+    const hint = "To enable Neo4j graph storage, install: npm i neo4j-driver";
+    throw new Error(`${String(e?.message ?? e)}
+${hint}`);
+  }
+}
+
+// src/indexer/workspaceLinker.ts
+import fs13 from "fs";
+import path16 from "path";
+function readText(absPath) {
+  try {
+    return fs13.readFileSync(absPath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function readJson(absPath) {
+  const raw = readText(absPath);
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function normalizeWorkspacePackageName(spec) {
+  if (!spec) return "";
+  if (spec.startsWith("@")) {
+    const parts = spec.split("/");
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : spec;
+  }
+  return spec.split("/")[0];
+}
+var NestedRepoLinkStrategy = class {
+  id = "nested";
+  collect(ctx) {
+    const out = [];
+    const sorted = ctx.repos.slice().sort((a, b) => a.absRoot.length - b.absRoot.length);
+    for (const child of sorted) {
+      for (const parent of sorted) {
+        if (child.repoId === parent.repoId) continue;
+        if (child.absRoot.startsWith(parent.absRoot + path16.sep)) {
+          out.push({
+            fromRepoId: child.repoId,
+            toRepoId: parent.repoId,
+            kind: "nested",
+            detail: "repo root is nested under another repo root"
+          });
+          break;
+        }
+      }
+    }
+    return out;
+  }
+};
+var NpmDependencyLinkStrategy = class {
+  id = "npm";
+  collect(ctx) {
+    const out = [];
+    const depSections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+    for (const r of ctx.repos) {
+      const pkg = readJson(path16.join(r.absRoot, "package.json"));
+      if (!pkg) continue;
+      for (const sec of depSections) {
+        const deps = pkg?.[sec];
+        if (!deps || typeof deps !== "object") continue;
+        for (const k of Object.keys(deps)) {
+          const name = normalizeWorkspacePackageName(k);
+          const toRepoId = ctx.npmNameToRepoId.get(name);
+          if (!toRepoId) continue;
+          if (toRepoId === r.repoId) continue;
+          out.push({ fromRepoId: r.repoId, toRepoId, kind: "npm", detail: `${sec}:${name}` });
+        }
+      }
+    }
+    return out;
+  }
+};
+function parseGoModule(absRepoRoot) {
+  const raw = readText(path16.join(absRepoRoot, "go.mod"));
+  if (!raw) return null;
+  const m = raw.match(/^\s*module\s+(.+)\s*$/m);
+  return m ? String(m[1]).trim() : null;
+}
+function parseGoRequires(absRepoRoot) {
+  const raw = readText(path16.join(absRepoRoot, "go.mod"));
+  if (!raw) return [];
+  const out = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const t = line.trim();
+    if (!t || t.startsWith("//")) continue;
+    const m = t.match(/^require\s+([^\s]+)\s+/);
+    if (m) out.push(m[1]);
+  }
+  return out;
+}
+var GoModuleLinkStrategy = class {
+  id = "go";
+  collect(ctx) {
+    const out = [];
+    for (const r of ctx.repos) {
+      const requires = parseGoRequires(r.absRoot);
+      if (requires.length === 0) continue;
+      for (const mod of requires) {
+        const toRepoId = ctx.goModuleToRepoId.get(mod);
+        if (!toRepoId) continue;
+        if (toRepoId === r.repoId) continue;
+        out.push({ fromRepoId: r.repoId, toRepoId, kind: "go", detail: `require:${mod}` });
+      }
+    }
+    return out;
+  }
+};
+function isSkippableDir(name) {
+  return name === ".git" || name === "node_modules" || name === "dist" || name === "out" || name === "build" || name === "coverage" || name === ".cache" || name === ".vscode";
+}
+function walkFiles(root, opts, onFile) {
+  const maxDepth = Math.max(0, opts.maxDepth);
+  const maxFiles = Math.max(1, opts.maxFiles);
+  let seen = 0;
+  const visit = (dir, depth) => {
+    if (seen >= maxFiles) return;
+    if (depth > maxDepth) return;
+    let ents = [];
+    try {
+      ents = fs13.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of ents) {
+      if (seen >= maxFiles) return;
+      const abs = path16.join(dir, e.name);
+      if (opts.shouldVisit && !opts.shouldVisit(abs, e)) continue;
+      if (e.isDirectory()) {
+        if (isSkippableDir(e.name)) continue;
+        visit(abs, depth + 1);
+      } else if (e.isFile()) {
+        seen++;
+        onFile(abs);
+      }
+    }
+  };
+  visit(root, 0);
+}
+function collectVsCodeLanguagesForRepo(absRepoRoot) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  walkFiles(
+    absRepoRoot,
+    {
+      maxDepth: 6,
+      maxFiles: 2e4,
+      shouldVisit: (_abs, dirent) => !(dirent.isDirectory() && isSkippableDir(dirent.name))
+    },
+    (absPath) => {
+      if (path16.basename(absPath) !== "package.json") return;
+      const pkg = readJson(absPath);
+      const langs = pkg?.contributes?.languages;
+      if (!Array.isArray(langs)) return;
+      for (const l of langs) {
+        const id = typeof l?.id === "string" ? l.id : null;
+        if (!id) continue;
+        const extsRaw = Array.isArray(l?.extensions) ? l.extensions : [];
+        const extensions = extsRaw.filter((x) => typeof x === "string" && x.startsWith("."));
+        const key = `${id}::${extensions.sort().join(",")}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push({ id, extensions });
+      }
+    }
+  );
+  return out;
+}
+function repoUsedExtensions(absRepoRoot, exts) {
+  const used = /* @__PURE__ */ new Set();
+  if (exts.size === 0) return used;
+  walkFiles(
+    absRepoRoot,
+    {
+      maxDepth: 7,
+      maxFiles: 5e4,
+      shouldVisit: (_abs, dirent) => !(dirent.isDirectory() && isSkippableDir(dirent.name))
+    },
+    (absPath) => {
+      const ext = path16.extname(absPath).toLowerCase();
+      if (!ext) return;
+      if (exts.has(ext)) used.add(ext);
+    }
+  );
+  return used;
+}
+var VsCodeContributesLanguageLinkStrategy = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  id = "vscode-language";
+  collect(ctx) {
+    const target = this.opts.targetLanguageIds ? new Set(this.opts.targetLanguageIds) : null;
+    const providers = /* @__PURE__ */ new Map();
+    for (const r of ctx.repos) {
+      const langs = collectVsCodeLanguagesForRepo(r.absRoot);
+      for (const l of langs) {
+        if (target && !target.has(l.id)) continue;
+        const arr = providers.get(l.id) ?? [];
+        arr.push({ repoId: r.repoId, languageId: l.id, extensions: l.extensions });
+        providers.set(l.id, arr);
+      }
+    }
+    const extToProvider = /* @__PURE__ */ new Map();
+    const allExts = /* @__PURE__ */ new Set();
+    for (const [languageId, provs] of providers) {
+      const sorted = provs.slice().sort((a, b) => a.repoId.localeCompare(b.repoId));
+      for (const p of sorted) {
+        for (const ext of p.extensions) {
+          allExts.add(ext.toLowerCase());
+          if (!extToProvider.has(ext.toLowerCase())) {
+            extToProvider.set(ext.toLowerCase(), { languageId, repoId: p.repoId });
+          }
+        }
+      }
+    }
+    const out = [];
+    for (const r of ctx.repos) {
+      const usedExts = repoUsedExtensions(r.absRoot, allExts);
+      for (const ext of usedExts) {
+        const provider = extToProvider.get(ext);
+        if (!provider) continue;
+        if (provider.repoId === r.repoId) continue;
+        out.push({
+          fromRepoId: r.repoId,
+          toRepoId: provider.repoId,
+          kind: "vscode-language",
+          detail: `${provider.languageId}:${ext}`
+        });
+      }
+    }
+    return out;
+  }
+};
+var WorkspaceLinker = class _WorkspaceLinker {
+  constructor(strategies = _WorkspaceLinker.defaultStrategies()) {
+    this.strategies = strategies;
+  }
+  static defaultStrategies() {
+    return [
+      new NestedRepoLinkStrategy(),
+      new NpmDependencyLinkStrategy(),
+      new GoModuleLinkStrategy(),
+      // Covers Petri languages (ctl/ltl/isl/colour-algebra) and any other VS Code language extension repos in the workspace.
+      new VsCodeContributesLanguageLinkStrategy({ targetLanguageIds: ["ctl", "ltl", "isl", "colour-algebra"] })
+    ];
+  }
+  buildContext(workspaceRoot, repoRoots) {
+    const repos = repoRoots.map((repoRoot) => ({
+      repoRoot,
+      repoId: repoIdFromRoot(repoRoot),
+      absRoot: path16.resolve(repoRoot)
+    }));
+    const npmNameToRepoId = /* @__PURE__ */ new Map();
+    const goModuleToRepoId = /* @__PURE__ */ new Map();
+    for (const r of repos) {
+      const pkg = readJson(path16.join(r.absRoot, "package.json"));
+      const name = typeof pkg?.name === "string" ? pkg.name : null;
+      if (name) npmNameToRepoId.set(name, r.repoId);
+      const mod = parseGoModule(r.absRoot);
+      if (mod) goModuleToRepoId.set(mod, r.repoId);
+    }
+    return { workspaceRoot, repos, npmNameToRepoId, goModuleToRepoId };
+  }
+  buildLinks(ctx) {
+    const out = [];
+    for (const s of this.strategies) {
+      try {
+        out.push(...s.collect(ctx));
+      } catch {
+      }
+    }
+    return out;
+  }
+};
+function groupByFrom(links) {
+  const byFrom = /* @__PURE__ */ new Map();
+  for (const l of links) {
+    const arr = byFrom.get(l.fromRepoId) ?? [];
+    arr.push({ toRepoId: l.toRepoId, kind: l.kind, detail: l.detail });
+    byFrom.set(l.fromRepoId, arr);
+  }
+  return byFrom;
+}
+async function linkWorkspaceRepos(args) {
+  const linker = new WorkspaceLinker(args.strategies ?? WorkspaceLinker.defaultStrategies());
+  const ctx = linker.buildContext(args.workspaceRoot, args.repoRoots);
+  const links = linker.buildLinks(ctx);
+  const byFrom = groupByFrom(links);
+  if (args.workspaceStore) {
+    for (const r of ctx.repos) {
+      args.workspaceStore.replaceRepoLinks(r.repoId, byFrom.get(r.repoId) ?? []);
+    }
+  }
+  if (args.graphStore?.replaceRepoLinks) {
+    await args.graphStore.replaceRepoLinks({ links });
+  }
+  return { repos: ctx.repos, links };
+}
+
+// src/indexer/workspaceIndexer.ts
+import path17 from "path";
+function halfLifeDaysForProfile(profileName) {
+  if (profileName === "rca") return 7;
+  if (profileName === "review") return 14;
+  if (profileName === "refactor") return 21;
+  return 30;
+}
+var WorkspaceIndexer = class {
+  constructor(workspaceRoot, embedder, config = {}) {
+    this.workspaceRoot = workspaceRoot;
+    this.embedder = embedder;
+    this.config = { ...config };
+    if (!this.config.cacheDir) this.config.cacheDir = defaultCacheDir();
+    this.progress = asProgressSink(this.config.progress);
+    const wsId = sha256Hex(path17.resolve(this.workspaceRoot)).slice(0, 16);
+    const dbPath = path17.join(this.config.cacheDir, "workspace", wsId, "workspace.sqlite");
+    this.workspaceStore = new WorkspaceStore(dbPath);
+    this.workspaceStore.setMeta("workspaceRoot", path17.resolve(this.workspaceRoot));
+  }
+  repos = [];
+  config;
+  progress = asProgressSink();
+  workspaceStore = null;
+  graphStore = null;
+  emitProgress(event) {
+    try {
+      this.progress?.emit(event);
+    } catch {
+    }
+  }
+  async open() {
+    if (!this.graphStore && this.config.workspace?.graph?.provider === "neo4j") {
+      try {
+        const n = this.config.workspace.graph.neo4j;
+        this.graphStore = await createNeo4jGraphStore({
+          uri: n.uri,
+          user: n.user,
+          password: n.password,
+          database: n.database,
+          labelPrefix: n.labelPrefix
+        });
+      } catch (e) {
+        this.emitProgress({
+          type: "error",
+          scope: "workspace",
+          message: String(e?.message ?? e),
+          stack: e?.stack ? String(e.stack) : void 0
+        });
+        this.graphStore = null;
+      }
+    }
+    const d = this.config.workspace?.discovery ?? {};
+    const repoRoots = discoverGitRepos(this.workspaceRoot, {
+      include: d.include,
+      exclude: d.exclude,
+      maxDepth: d.maxDepth,
+      stopAtRepoRoot: d.stopAtRepoRoot,
+      includeSubmodules: d.includeSubmodules
+    });
+    this.emitProgress({ type: "workspace/open", workspaceRoot: this.workspaceRoot, repoRoots });
+    this.repos = repoRoots.map((r) => {
+      const cfg = pickRepoOverride(this.config, r, this.workspaceRoot, this.config.workspace?.repoOverrides);
+      return new RepoIndexer(r, this.embedder, cfg, this.workspaceStore ?? void 0, this.graphStore ?? void 0);
+    });
+    try {
+      await linkWorkspaceRepos({
+        workspaceRoot: this.workspaceRoot,
+        repoRoots,
+        workspaceStore: this.workspaceStore,
+        graphStore: this.graphStore
+      });
+    } catch {
+    }
+  }
+  async indexAll() {
+    if (this.repos.length === 0) await this.open();
+    const startedAt = Date.now();
+    this.emitProgress({ type: "workspace/index/start", workspaceRoot: this.workspaceRoot, repoCount: this.repos.length });
+    await Promise.all(this.repos.map((r) => r.indexAll()));
+    this.emitProgress({
+      type: "workspace/index/done",
+      workspaceRoot: this.workspaceRoot,
+      repoCount: this.repos.length,
+      ms: Date.now() - startedAt
+    });
+  }
+  async watch() {
+    if (this.repos.length === 0) await this.open();
+    const startedAt = Date.now();
+    this.emitProgress({ type: "workspace/watch/start", workspaceRoot: this.workspaceRoot, repoCount: this.repos.length });
+    await Promise.all(this.repos.map((r) => r.watch()));
+    this.emitProgress({
+      type: "workspace/watch/done",
+      workspaceRoot: this.workspaceRoot,
+      repoCount: this.repos.length,
+      ms: Date.now() - startedAt
+    });
+  }
+  getRepoIndexers() {
+    return this.repos.slice();
+  }
+  resolveProfile(opts) {
+    const name = opts?.profile ?? "search";
+    const base = DEFAULT_PROFILES[name] ?? DEFAULT_PROFILES.search;
+    const configPatch = this.config.profiles?.[name] ?? {};
+    const merged1 = deepMergeProfile(base, configPatch);
+    const merged2 = deepMergeProfile(merged1, opts?.profileOverrides);
+    const w = merged2.weights;
+    const sum = Math.max(1e-6, w.vector + w.lexical + w.recency);
+    merged2.weights = { vector: w.vector / sum, lexical: w.lexical / sum, recency: w.recency / sum };
+    return merged2;
+  }
+  async retrieve(query, opts = {}) {
+    if (this.repos.length === 0) await this.open();
+    const profile = this.resolveProfile(opts);
+    const startedAt = Date.now();
+    this.emitProgress({ type: "workspace/retrieve/start", workspaceRoot: this.workspaceRoot, profile: profile.name, query });
+    const qVec = (await this.embedder.embed([query]))[0];
+    const vectorK = profile.candidates?.vectorK ?? Math.max(profile.k * 3, 30);
+    const lexicalK = profile.candidates?.lexicalK ?? Math.max(profile.k * 3, 30);
+    const maxMerged = profile.candidates?.maxMergedCandidates ?? Math.max(profile.k * 8, 120);
+    const repoFilters = opts.filters?.repoRoots;
+    const langFilter = opts.filters?.language;
+    const pathPrefix = opts.filters?.pathPrefix;
+    const candidates = [];
+    let vecCount = 0;
+    let lexCount = 0;
+    const canUseWorkspaceLex = !!this.workspaceStore && this.config.storage?.ftsMode !== "off" && !opts.scope?.includePaths && !opts.scope?.changedOnly;
+    const workspaceLexByRepoRoot = /* @__PURE__ */ new Map();
+    if (canUseWorkspaceLex && profile.weights.lexical > 0) {
+      const ftq = ftsQueryFromText(query);
+      const allowRoots = repoFilters ? new Set(repoFilters.map((r) => path17.resolve(r))) : null;
+      const repoIds = allowRoots ? this.repos.filter((r) => allowRoots.has(path17.resolve(r.repoRoot))).map((r) => r.repoId) : void 0;
+      if (ftq) {
+        const rows = this.workspaceStore.searchFts(ftq, lexicalK, repoIds);
+        lexCount += rows.length;
+        for (const r of rows) {
+          const row = this.workspaceStore.getChunkById(r.id);
+          if (!row) continue;
+          const rootKey = path17.resolve(row.repo_root);
+          const arr = workspaceLexByRepoRoot.get(rootKey) ?? [];
+          arr.push({ id: r.id, score: bm25ToScore01(r.bm25) });
+          workspaceLexByRepoRoot.set(rootKey, arr);
+        }
+      }
+    }
+    for (const repo of this.repos) {
+      if (repoFilters && !repoFilters.includes(repo.repoRoot)) continue;
+      let includePaths = opts.scope?.includePaths?.slice();
+      if (opts.scope?.changedOnly) {
+        try {
+          const changed = await listChangedFiles(repo.repoRoot, opts.scope.baseRef ?? "HEAD~1");
+          includePaths = includePaths ? includePaths.filter((p) => changed.includes(p)) : changed;
+        } catch {
+        }
+      }
+      const [vHits, lHits] = await Promise.all([
+        repo.vectorCandidates(qVec, vectorK, includePaths),
+        canUseWorkspaceLex ? Promise.resolve(workspaceLexByRepoRoot.get(path17.resolve(repo.repoRoot)) ?? []) : repo.lexicalCandidates(query, lexicalK, includePaths)
+      ]);
+      vecCount += vHits.length;
+      if (!canUseWorkspaceLex) lexCount += lHits.length;
+      const m = /* @__PURE__ */ new Map();
+      for (const vh of vHits) {
+        const id = vh.id;
+        const vector01 = vectorCosineToScore01(vh.score);
+        m.set(id, { repo, id, vector01, combined: 0 });
+      }
+      for (const lh of lHits) {
+        const id = lh.id;
+        const prev = m.get(id);
+        if (prev) prev.lexical01 = lh.score;
+        else m.set(id, { repo, id, lexical01: lh.score, combined: 0 });
+      }
+      const halfLife = halfLifeDaysForProfile(profile.name);
+      for (const c of m.values()) {
+        const meta = repo.getChunkMeta(c.id);
+        if (!meta) continue;
+        if (langFilter && meta.language !== langFilter) continue;
+        if (pathPrefix && !meta.path.startsWith(pathPrefix)) continue;
+        c.recency01 = profile.weights.recency > 0 ? recencyScore(meta.fileMtimeMs, halfLife) : 0;
+        let kindFactor = 1;
+        if (meta.kind === "synopsis" && profile.name === "search") kindFactor = 0.85;
+        if (meta.kind === "synopsis" && profile.name === "architecture") kindFactor = 1.05;
+        const v = c.vector01 ?? 0;
+        const l = c.lexical01 ?? 0;
+        const r = c.recency01 ?? 0;
+        c.combined = clamp(
+          kindFactor * (profile.weights.vector * v + profile.weights.lexical * l + profile.weights.recency * r),
+          0,
+          1
+        );
+        candidates.push(c);
+      }
+    }
+    candidates.sort((a, b) => b.combined - a.combined);
+    const merged = candidates.slice(0, maxMerged);
+    const top = merged.slice(0, profile.k);
+    const hits = top.map((c) => {
+      const meta = c.repo.getChunkMeta(c.id);
+      const preview = makePreview(c.repo.getChunkText(c.id));
+      return {
+        score: c.combined,
+        scoreBreakdown: { vector: c.vector01, lexical: c.lexical01, recency: c.recency01 },
+        chunk: { ...meta, preview }
+      };
+    });
+    try {
+      const byRepo = /* @__PURE__ */ new Map();
+      for (const h of hits) {
+        const s = byRepo.get(h.chunk.repoRoot) ?? /* @__PURE__ */ new Set();
+        s.add(h.chunk.path);
+        byRepo.set(h.chunk.repoRoot, s);
+      }
+      for (const [repoRoot, paths] of byRepo) {
+        const repo = this.repos.find((r) => r.repoRoot === repoRoot);
+        if (!repo) continue;
+        await repo.warmSymbolGraphEdges(Array.from(paths), { maxFiles: 6 });
+      }
+    } catch {
+    }
+    let graphNeighborFiles = [];
+    try {
+      if (this.graphStore?.neighborFiles) {
+        const seeds = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const h of hits) {
+          const repo = this.repos.find((r) => r.repoRoot === h.chunk.repoRoot);
+          if (!repo) continue;
+          const key = `${repo.repoId}:${h.chunk.path}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          seeds.push({ repoId: repo.repoId, path: h.chunk.path });
+          if (seeds.length >= 4) break;
+        }
+        if (seeds.length > 0) {
+          graphNeighborFiles = await this.graphStore.neighborFiles({
+            seeds,
+            limit: profile.name === "architecture" ? 16 : 10,
+            kinds: ["definition", "reference", "implementation", "typeDefinition"]
+          });
+        }
+      }
+    } catch {
+      graphNeighborFiles = [];
+    }
+    const contextBlocks = [];
+    const seenKey = /* @__PURE__ */ new Set();
+    const addBlock = (repoRoot, path19, startLine, endLine, text, reason) => {
+      const key = `${repoRoot}:${path19}:${startLine}:${endLine}:${text.length}:${reason}`;
+      if (seenKey.has(key)) return;
+      seenKey.add(key);
+      if (!text.trim()) return;
+      contextBlocks.push({ repoRoot, path: path19, startLine, endLine, text, reason });
+    };
+    try {
+      const byRepoId = /* @__PURE__ */ new Map();
+      for (const r of this.repos) byRepoId.set(r.repoId, r);
+      for (const n of graphNeighborFiles.slice(0, 10)) {
+        const repo = byRepoId.get(n.repoId);
+        if (!repo) continue;
+        const chunkId = await repo.getRepresentativeChunkIdForFile(n.path, true);
+        if (!chunkId) continue;
+        const meta = repo.getChunkMeta(chunkId);
+        if (!meta) continue;
+        const text = repo.getChunkText(chunkId);
+        addBlock(meta.repoRoot, meta.path, meta.startLine, meta.endLine, text, `graph neighbor (${n.weight})`);
+      }
+    } catch {
+    }
+    for (const h of hits) {
+      const repo = this.repos.find((r) => r.repoRoot === h.chunk.repoRoot);
+      if (!repo) continue;
+      const text = repo.getChunkText(h.chunk.id);
+      addBlock(h.chunk.repoRoot, h.chunk.path, h.chunk.startLine, h.chunk.endLine, text, "primary hit");
+      const expanded = await repo.expandContext(h.chunk.id, {
+        adjacentChunks: profile.expand.adjacentChunks ?? 0,
+        followImports: profile.expand.followImports ?? 0,
+        includeFileSynopsis: profile.expand.includeFileSynopsis ?? false
+      });
+      for (const ex of expanded) {
+        const meta = repo.getChunkMeta(ex.id);
+        if (!meta) continue;
+        const t = repo.getChunkText(ex.id);
+        addBlock(meta.repoRoot, meta.path, meta.startLine, meta.endLine, t, ex.reason);
+      }
+    }
+    const bundle = {
+      hits,
+      context: contextBlocks,
+      stats: {
+        profile: profile.name,
+        reposSearched: this.repos.length,
+        candidates: {
+          vector: vecCount,
+          lexical: lexCount,
+          merged: merged.length,
+          returned: hits.length
+        }
+      }
+    };
+    this.emitProgress({
+      type: "workspace/retrieve/done",
+      workspaceRoot: this.workspaceRoot,
+      profile: profile.name,
+      ms: Date.now() - startedAt,
+      hits: hits.length,
+      candidates: { vector: vecCount, lexical: lexCount, merged: merged.length }
+    });
+    return bundle;
+  }
+  async search(query, k = 10) {
+    const bundle = await this.retrieve(query, { profile: "search", profileOverrides: { k } });
+    return bundle.hits;
+  }
+  async closeAsync() {
+    for (const r of this.repos) {
+      await r.closeAsync().catch(() => void 0);
+    }
+    this.repos = [];
+    this.workspaceStore?.close();
+    this.workspaceStore = null;
+    await this.graphStore?.close().catch(() => void 0);
+    this.graphStore = null;
+  }
+  close() {
+    void this.closeAsync();
+  }
+};
+
+// src/embeddings/ollama.ts
+import pLimit2 from "p-limit";
+var OllamaEmbeddingsProvider = class {
+  id;
+  dimension = null;
+  baseUrl;
+  model;
+  concurrency;
+  constructor(opts) {
+    this.model = opts.model;
+    this.baseUrl = opts.baseUrl ?? "http://localhost:11434";
+    this.concurrency = opts.concurrency ?? 4;
+    this.id = `ollama:${this.model}`;
+  }
+  async tryBatchEndpoint(texts) {
+    const res = await fetch(`${this.baseUrl}/api/embed`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: this.model, input: texts })
+    }).catch(() => null);
+    if (!res || !res.ok) return null;
+    const json = await res.json();
+    const embeddings = json.embeddings;
+    if (!embeddings) return null;
+    const out = embeddings.map((v) => Float32Array.from(v));
+    if (out.length > 0) this.dimension = out[0].length;
+    return out;
+  }
+  async embedOne(text) {
+    const res = await fetch(`${this.baseUrl}/api/embeddings`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: this.model, prompt: text })
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      throw new Error(`Ollama embeddings failed: ${res.status} ${res.statusText} ${errText}`);
+    }
+    const json = await res.json();
+    const emb = Float32Array.from(json.embedding);
+    this.dimension = emb.length;
+    return emb;
+  }
+  async embed(texts) {
+    const batch = await this.tryBatchEndpoint(texts);
+    if (batch) return batch;
+    const limit = pLimit2(this.concurrency);
+    const out = await Promise.all(texts.map((t) => limit(() => this.embedOne(t))));
+    return out;
+  }
+};
+
+// src/embeddings/openai.ts
+var OpenAIEmbeddingsProvider = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.id = `openai:${opts.model}`;
+  }
+  id;
+  dimension = null;
+  async embed(texts) {
+    const baseUrl = this.opts.baseUrl ?? "https://api.openai.com";
+    const res = await fetch(`${baseUrl}/v1/embeddings`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.opts.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.opts.model,
+        input: texts
+      })
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      throw new Error(`OpenAI embeddings failed: ${res.status} ${res.statusText} ${errText}`);
+    }
+    const json = await res.json();
+    const arr = json.data.map((d) => Float32Array.from(d.embedding));
+    if (arr.length > 0) this.dimension = arr[0].length;
+    return arr;
+  }
+};
+
+// src/embeddings/hash.ts
+import crypto3 from "crypto";
+var HashEmbeddingsProvider = class {
+  id;
+  dimension;
+  constructor(dimension = 384) {
+    this.dimension = dimension;
+    this.id = `hash:${dimension}`;
+  }
+  async embed(texts) {
+    return texts.map((t) => this.embedOne(t));
+  }
+  embedOne(text) {
+    const v = new Float32Array(this.dimension);
+    const tokens = text.split(/[^A-Za-z0-9_]+/).filter(Boolean).slice(0, 6e3);
+    for (const tok of tokens) {
+      const h = crypto3.createHash("sha256").update(tok).digest();
+      const idx = h.readUInt32LE(0) % this.dimension;
+      const sign = h[4] & 1 ? 1 : -1;
+      v[idx] += sign;
+    }
+    let sumSq = 0;
+    for (let i = 0; i < v.length; i++) sumSq += v[i] * v[i];
+    const norm = Math.sqrt(sumSq) || 1;
+    for (let i = 0; i < v.length; i++) v[i] /= norm;
+    return v;
+  }
+};
+
+// src/config.ts
+import fs14 from "fs";
+import path18 from "path";
+function loadConfigFile(filePath) {
+  const abs = path18.resolve(filePath);
+  const raw = fs14.readFileSync(abs, "utf8");
+  const json = JSON.parse(raw);
+  const cfg = { ...json };
+  if (json.redact?.patterns && Array.isArray(json.redact.patterns)) {
+    const pats = json.redact.patterns;
+    cfg.redact = cfg.redact ?? {};
+    cfg.redact.patterns = pats.map((p) => {
+      if (p.regex instanceof RegExp) {
+        return { name: p.name, regex: p.regex, replaceWith: p.replaceWith };
+      }
+      return {
+        name: p.name,
+        regex: new RegExp(p.regex, p.flags ?? "g"),
+        replaceWith: p.replaceWith
+      };
+    });
+  }
+  return cfg;
+}
+
+export {
+  IndexerProgressObservable,
+  asProgressSink,
+  languageFromPath,
+  chunkSource,
+  createVectorIndex,
+  stableSymbolId,
+  NoopAnnIndex,
+  createAnnIndex,
+  RepoIndexer,
+  DEFAULT_PROFILES,
+  deepMergeProfile,
+  discoverGitRepos,
+  pickRepoOverride,
+  mergeIndexerConfig,
+  WorkspaceStore,
+  Neo4jGraphStore,
+  createNeo4jGraphStore,
+  NestedRepoLinkStrategy,
+  NpmDependencyLinkStrategy,
+  GoModuleLinkStrategy,
+  VsCodeContributesLanguageLinkStrategy,
+  WorkspaceLinker,
+  linkWorkspaceRepos,
+  WorkspaceIndexer,
+  OllamaEmbeddingsProvider,
+  OpenAIEmbeddingsProvider,
+  HashEmbeddingsProvider,
+  loadConfigFile
+};