brainbank 0.1.0

package/dist/chunk-YGSEUWLV.js

@@ -0,0 +1,2053 @@
+import {
+  isIgnoredDir,
+  isIgnoredFile,
+  isSupported
+} from "./chunk-EDKSKLX4.js";
+import {
+  reciprocalRankFusion
+} from "./chunk-4ZKBQ33J.js";
+import {
+  cosineSimilarity
+} from "./chunk-2P3EGY6S.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/core/config.ts
+import * as path from "path";
+var DEFAULTS = {
+  repoPath: ".",
+  dbPath: ".brainbank/brainbank.db",
+  gitDepth: 500,
+  maxFileSize: 512e3,
+  // 500KB
+  maxDiffBytes: 8192,
+  hnswM: 16,
+  hnswEfConstruction: 200,
+  hnswEfSearch: 50,
+  embeddingDims: 384,
+  maxElements: 2e6
+};
+function resolveConfig(partial = {}) {
+  const repoPath = path.resolve(partial.repoPath ?? DEFAULTS.repoPath);
+  const rawDbPath = partial.dbPath ?? DEFAULTS.dbPath;
+  const dbPath = path.isAbsolute(rawDbPath) ? rawDbPath : path.join(repoPath, rawDbPath);
+  return {
+    repoPath,
+    dbPath,
+    gitDepth: partial.gitDepth ?? DEFAULTS.gitDepth,
+    maxFileSize: partial.maxFileSize ?? DEFAULTS.maxFileSize,
+    maxDiffBytes: partial.maxDiffBytes ?? DEFAULTS.maxDiffBytes,
+    hnswM: partial.hnswM ?? DEFAULTS.hnswM,
+    hnswEfConstruction: partial.hnswEfConstruction ?? DEFAULTS.hnswEfConstruction,
+    hnswEfSearch: partial.hnswEfSearch ?? DEFAULTS.hnswEfSearch,
+    embeddingDims: partial.embeddingDims ?? DEFAULTS.embeddingDims,
+    maxElements: partial.maxElements ?? DEFAULTS.maxElements,
+    embeddingProvider: partial.embeddingProvider,
+    reranker: partial.reranker
+  };
+}
+__name(resolveConfig, "resolveConfig");
+
+// src/vector/hnsw.ts
+var HNSWIndex = class {
+  constructor(_dims, _maxElements = 2e6, _M = 16, _efConstruction = 200, _efSearch = 50) {
+    this._dims = _dims;
+    this._maxElements = _maxElements;
+    this._M = _M;
+    this._efConstruction = _efConstruction;
+    this._efSearch = _efSearch;
+  }
+  static {
+    __name(this, "HNSWIndex");
+  }
+  _index = null;
+  _count = 0;
+  /**
+   * Initialize the HNSW index.
+   * Must be called before add/search.
+   */
+  async init() {
+    const HNSWLib = await import("hnswlib-node");
+    const HNSW = HNSWLib.default?.HierarchicalNSW ?? HNSWLib.HierarchicalNSW;
+    this._index = new HNSW("cosine", this._dims);
+    this._index.initIndex(this._maxElements, this._M, this._efConstruction);
+    this._index.setEf(this._efSearch);
+    return this;
+  }
+  /**
+   * Add a vector with an integer ID.
+   * The vector should be pre-normalized for cosine distance.
+   */
+  add(vector, id) {
+    if (!this._index) throw new Error("HNSW index not initialized \u2014 call init() first");
+    this._index.addPoint(Array.from(vector), id);
+    this._count++;
+  }
+  /**
+   * Search for the k nearest neighbors.
+   * Returns results sorted by score (highest first).
+   * Score is 1 - cosine_distance (1.0 = identical).
+   */
+  search(query, k) {
+    if (!this._index || this._count === 0) return [];
+    const actualK = Math.min(k, this._count);
+    const result = this._index.searchKnn(Array.from(query), actualK);
+    return result.neighbors.map((id, i) => ({
+      id,
+      score: 1 - result.distances[i]
+    }));
+  }
+  /** Number of vectors in the index. */
+  get size() {
+    return this._count;
+  }
+};
+
+// src/embeddings/local.ts
+var LocalEmbedding = class {
+  static {
+    __name(this, "LocalEmbedding");
+  }
+  dims = 384;
+  _pipeline = null;
+  _modelName;
+  _cacheDir;
+  constructor(options = {}) {
+    this._modelName = options.model ?? "Xenova/all-MiniLM-L6-v2";
+    this._cacheDir = options.cacheDir ?? ".model-cache";
+  }
+  /**
+   * Lazy-load the transformer pipeline.
+   * Singleton — created once and reused.
+   */
+  async _getPipeline() {
+    if (this._pipeline) return this._pipeline;
+    const { pipeline, env } = await import("@xenova/transformers");
+    env.cacheDir = this._cacheDir;
+    env.allowLocalModels = true;
+    this._pipeline = await pipeline("feature-extraction", this._modelName, {
+      quantized: true
+    });
+    return this._pipeline;
+  }
+  /**
+   * Embed a single text string.
+   * Returns a normalized Float32Array of length 384.
+   */
+  async embed(text) {
+    const pipe = await this._getPipeline();
+    const output = await pipe(text, { pooling: "mean", normalize: true });
+    return output.data;
+  }
+  /**
+   * Embed multiple texts.
+   * Processes sequentially to avoid OOM on large batches.
+   */
+  async embedBatch(texts) {
+    const results = [];
+    for (const text of texts) {
+      results.push(await this.embed(text));
+    }
+    return results;
+  }
+  async close() {
+    this._pipeline = null;
+  }
+};
+
+// src/vector/mmr.ts
+function searchMMR(index, query, vectorCache, k, lambda = 0.7) {
+  const candidates = index.search(query, k * 3);
+  if (candidates.length <= k) return candidates;
+  const selected = [];
+  const remaining = [...candidates];
+  while (selected.length < k && remaining.length > 0) {
+    let bestScore = -Infinity;
+    let bestIdx = 0;
+    for (let i = 0; i < remaining.length; i++) {
+      const relevance = remaining[i].score;
+      let maxSim = 0;
+      for (const sel of selected) {
+        const candidateVec = vectorCache.get(remaining[i].id);
+        const selectedVec = vectorCache.get(sel.id);
+        if (candidateVec && selectedVec) {
+          maxSim = Math.max(maxSim, cosineSimilarity(candidateVec, selectedVec));
+        }
+      }
+      const mmrScore = lambda * relevance - (1 - lambda) * maxSim;
+      if (mmrScore > bestScore) {
+        bestScore = mmrScore;
+        bestIdx = i;
+      }
+    }
+    selected.push(remaining[bestIdx]);
+    remaining.splice(bestIdx, 1);
+  }
+  return selected;
+}
+__name(searchMMR, "searchMMR");
+
+// src/query/search.ts
+var UnifiedSearch = class {
+  static {
+    __name(this, "UnifiedSearch");
+  }
+  _deps;
+  constructor(deps) {
+    this._deps = deps;
+  }
+  /**
+   * Search across all indices.
+   * Returns combined results sorted by score.
+   */
+  async search(query, options = {}) {
+    const {
+      codeK = 6,
+      gitK = 5,
+      memoryK = 4,
+      minScore = 0.25,
+      useMMR = true,
+      mmrLambda = 0.7
+    } = options;
+    const queryVec = await this._deps.embedding.embed(query);
+    const results = [];
+    if (this._deps.codeHnsw && this._deps.codeHnsw.size > 0) {
+      const hits = useMMR ? searchMMR(this._deps.codeHnsw, queryVec, this._deps.codeVecs, codeK, mmrLambda) : this._deps.codeHnsw.search(queryVec, codeK);
+      if (hits.length > 0) {
+        const ids = hits.map((h) => h.id);
+        const scoreMap = new Map(hits.map((h) => [h.id, h.score]));
+        const placeholders = ids.map(() => "?").join(",");
+        const rows = this._deps.db.prepare(
+          `SELECT * FROM code_chunks WHERE id IN (${placeholders})`
+        ).all(...ids);
+        for (const r of rows) {
+          const score = scoreMap.get(r.id) ?? 0;
+          if (score >= minScore) {
+            results.push({
+              type: "code",
+              score,
+              filePath: r.file_path,
+              content: r.content,
+              metadata: {
+                chunkType: r.chunk_type,
+                name: r.name,
+                startLine: r.start_line,
+                endLine: r.end_line,
+                language: r.language
+              }
+            });
+          }
+        }
+      }
+    }
+    if (this._deps.gitHnsw && this._deps.gitHnsw.size > 0) {
+      const hits = this._deps.gitHnsw.search(queryVec, gitK * 2);
+      if (hits.length > 0) {
+        const ids = hits.map((h) => h.id);
+        const scoreMap = new Map(hits.map((h) => [h.id, h.score]));
+        const placeholders = ids.map(() => "?").join(",");
+        const rows = this._deps.db.prepare(
+          `SELECT * FROM git_commits WHERE id IN (${placeholders}) AND is_merge = 0`
+        ).all(...ids);
+        for (const r of rows) {
+          const score = scoreMap.get(r.id) ?? 0;
+          if (score >= minScore) {
+            results.push({
+              type: "commit",
+              score,
+              content: r.message,
+              metadata: {
+                hash: r.hash,
+                shortHash: r.short_hash,
+                author: r.author,
+                date: r.date,
+                files: JSON.parse(r.files_json ?? "[]"),
+                additions: r.additions,
+                deletions: r.deletions,
+                diff: r.diff
+              }
+            });
+          }
+        }
+      }
+    }
+    if (this._deps.memHnsw && this._deps.memHnsw.size > 0) {
+      const hits = useMMR ? searchMMR(this._deps.memHnsw, queryVec, this._deps.memVecs, memoryK, mmrLambda) : this._deps.memHnsw.search(queryVec, memoryK);
+      if (hits.length > 0) {
+        const ids = hits.map((h) => h.id);
+        const scoreMap = new Map(hits.map((h) => [h.id, h.score]));
+        const placeholders = ids.map(() => "?").join(",");
+        const rows = this._deps.db.prepare(
+          `SELECT * FROM memory_patterns WHERE id IN (${placeholders}) AND success_rate >= 0.5`
+        ).all(...ids);
+        for (const r of rows) {
+          const score = scoreMap.get(r.id) ?? 0;
+          if (score >= minScore) {
+            results.push({
+              type: "pattern",
+              score,
+              content: r.approach,
+              metadata: {
+                taskType: r.task_type,
+                task: r.task,
+                outcome: r.outcome,
+                successRate: r.success_rate,
+                critique: r.critique
+              }
+            });
+          }
+        }
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    if (this._deps.reranker && results.length > 1) {
+      return this._rerank(query, results);
+    }
+    return results;
+  }
+  /**
+   * Re-rank results using position-aware blending.
+   * 
+   * Top 1-3:  75% retrieval / 25% reranker (preserves exact matches)
+   * Top 4-10: 60% retrieval / 40% reranker
+   * Top 11+:  40% retrieval / 60% reranker (trust reranker more)
+   */
+  async _rerank(query, results) {
+    const reranker = this._deps.reranker;
+    const documents = results.map((r) => r.content);
+    const scores = await reranker.rank(query, documents);
+    const blended = results.map((r, i) => {
+      const pos = i + 1;
+      const rrfWeight = pos <= 3 ? 0.75 : pos <= 10 ? 0.6 : 0.4;
+      return {
+        ...r,
+        score: rrfWeight * r.score + (1 - rrfWeight) * (scores[i] ?? 0)
+      };
+    });
+    return blended.sort((a, b) => b.score - a.score);
+  }
+};
+
+// src/query/fts-utils.ts
+function sanitizeFTS(query) {
+  const clean = query.replace(/[{}[\]()^~*:]/g, " ").replace(/\bAND\b|\bOR\b|\bNOT\b|\bNEAR\b/gi, "").trim();
+  const words = clean.split(/\s+/).filter((w) => w.length > 1);
+  if (words.length === 0) return "";
+  return words.map((w) => `"${w}"`).join(" ");
+}
+__name(sanitizeFTS, "sanitizeFTS");
+function normalizeBM25(rawScore) {
+  const abs = Math.abs(rawScore);
+  return 1 / (1 + Math.exp(-0.3 * (abs - 5)));
+}
+__name(normalizeBM25, "normalizeBM25");
+
+// src/query/bm25.ts
+var BM25Search = class {
+  constructor(_db) {
+    this._db = _db;
+  }
+  static {
+    __name(this, "BM25Search");
+  }
+  /**
+   * Full-text keyword search across all FTS5 indices.
+   * Uses BM25 scoring — lower scores = better matches.
+   * Query syntax: simple words, OR, NOT, "exact phrases", prefix*
+   */
+  search(query, options = {}) {
+    const { codeK = 8, gitK = 5, memoryK = 4 } = options;
+    const results = [];
+    const ftsQuery = sanitizeFTS(query);
+    if (!ftsQuery) return [];
+    if (codeK > 0) {
+      try {
+        const rows = this._db.prepare(`
+                    SELECT c.id, c.file_path, c.chunk_type, c.name, c.start_line, c.end_line,
+                           c.content, c.language, bm25(fts_code, 5.0, 3.0, 1.0) AS score
+                    FROM fts_code f
+                    JOIN code_chunks c ON c.id = f.rowid
+                    WHERE fts_code MATCH ?
+                    ORDER BY score ASC
+                    LIMIT ?
+                `).all(ftsQuery, codeK);
+        for (const r of rows) {
+          results.push({
+            type: "code",
+            score: normalizeBM25(r.score),
+            filePath: r.file_path,
+            content: r.content,
+            metadata: {
+              chunkType: r.chunk_type,
+              name: r.name,
+              startLine: r.start_line,
+              endLine: r.end_line,
+              language: r.language,
+              searchType: "bm25"
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    if (gitK > 0) {
+      try {
+        const rows = this._db.prepare(`
+                    SELECT c.id, c.hash, c.short_hash, c.message, c.author, c.date,
+                           c.files_json, c.diff, c.additions, c.deletions,
+                           bm25(fts_commits, 5.0, 2.0, 1.0) AS score
+                    FROM fts_commits f
+                    JOIN git_commits c ON c.id = f.rowid
+                    WHERE fts_commits MATCH ? AND c.is_merge = 0
+                    ORDER BY score ASC
+                    LIMIT ?
+                `).all(ftsQuery, gitK);
+        for (const r of rows) {
+          results.push({
+            type: "commit",
+            score: normalizeBM25(r.score),
+            content: r.message,
+            metadata: {
+              hash: r.hash,
+              shortHash: r.short_hash,
+              author: r.author,
+              date: r.date,
+              files: JSON.parse(r.files_json ?? "[]"),
+              additions: r.additions,
+              deletions: r.deletions,
+              diff: r.diff,
+              searchType: "bm25"
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    if (memoryK > 0) {
+      try {
+        const rows = this._db.prepare(`
+                    SELECT p.id, p.task_type, p.task, p.approach, p.outcome,
+                           p.success_rate, p.critique,
+                           bm25(fts_patterns, 3.0, 5.0, 5.0, 1.0) AS score
+                    FROM fts_patterns f
+                    JOIN memory_patterns p ON p.id = f.rowid
+                    WHERE fts_patterns MATCH ? AND p.success_rate >= 0.5
+                    ORDER BY score ASC
+                    LIMIT ?
+                `).all(ftsQuery, memoryK);
+        for (const r of rows) {
+          results.push({
+            type: "pattern",
+            score: normalizeBM25(r.score),
+            content: r.approach,
+            metadata: {
+              taskType: r.task_type,
+              task: r.task,
+              outcome: r.outcome,
+              successRate: r.success_rate,
+              critique: r.critique,
+              searchType: "bm25"
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    return results.sort((a, b) => b.score - a.score);
+  }
+  /**
+   * Rebuild the FTS index from scratch.
+   * Call this after bulk imports or if FTS gets out of sync.
+   */
+  rebuild() {
+    try {
+      this._db.prepare("INSERT INTO fts_code(fts_code) VALUES('rebuild')").run();
+      this._db.prepare("INSERT INTO fts_commits(fts_commits) VALUES('rebuild')").run();
+      this._db.prepare("INSERT INTO fts_patterns(fts_patterns) VALUES('rebuild')").run();
+    } catch {
+    }
+  }
+};
+
+// src/query/context-builder.ts
+var ContextBuilder = class {
+  constructor(_search, _coEdits) {
+    this._search = _search;
+    this._coEdits = _coEdits;
+  }
+  static {
+    __name(this, "ContextBuilder");
+  }
+  /**
+   * Build a full context block for a task.
+   * Returns clean markdown ready for system prompt injection.
+   */
+  async build(task, options = {}) {
+    const {
+      codeResults = 6,
+      gitResults = 5,
+      memoryResults = 4,
+      affectedFiles = [],
+      minScore = 0.25,
+      useMMR = true,
+      mmrLambda = 0.7
+    } = options;
+    const results = await this._search.search(task, {
+      codeK: codeResults,
+      gitK: gitResults,
+      memoryK: memoryResults,
+      minScore,
+      useMMR,
+      mmrLambda
+    });
+    const parts = [`# Context for: "${task}"
+`];
+    const codeHits = results.filter((r) => r.type === "code").slice(0, codeResults);
+    if (codeHits.length > 0) {
+      parts.push("## Relevant Code\n");
+      const byFile = /* @__PURE__ */ new Map();
+      for (const r of codeHits) {
+        const key = r.filePath ?? "unknown";
+        if (!byFile.has(key)) byFile.set(key, []);
+        byFile.get(key).push(r);
+      }
+      for (const [file, chunks] of byFile) {
+        parts.push(`### ${file}`);
+        for (const c of chunks) {
+          const m = c.metadata;
+          const label = m.name ? `${m.chunkType} \`${m.name}\` (L${m.startLine}-${m.endLine})` : `L${m.startLine}-${m.endLine}`;
+          parts.push(`**${label}** \u2014 ${Math.round(c.score * 100)}% match`);
+          parts.push("```" + (m.language || ""));
+          parts.push(c.content);
+          parts.push("```\n");
+        }
+      }
+    }
+    const gitHits = results.filter((r) => r.type === "commit").slice(0, gitResults);
+    if (gitHits.length > 0) {
+      parts.push("## Related Git History\n");
+      for (const c of gitHits) {
+        const m = c.metadata;
+        const score = Math.round(c.score * 100);
+        const files = (m.files ?? []).slice(0, 4).join(", ");
+        parts.push(`**[${m.shortHash}]** ${c.content} *(${m.author}, ${m.date?.slice(0, 10)}, ${score}%)*`);
+        if (files) parts.push(`  Files: ${files}`);
+        if (m.diff) {
+          const snippet = m.diff.split("\n").filter((l) => l.startsWith("+") || l.startsWith("-") || l.startsWith("@@")).slice(0, 10).join("\n");
+          if (snippet) {
+            parts.push("```diff");
+            parts.push(snippet);
+            parts.push("```");
+          }
+        }
+        parts.push("");
+      }
+    }
+    if (affectedFiles.length > 0) {
+      const coEditLines = [];
+      for (const file of affectedFiles.slice(0, 3)) {
+        const suggestions = this._coEdits.suggest(file, 4);
+        if (suggestions.length > 0) {
+          coEditLines.push(
+            `- **${file}** \u2192 also tends to change: ${suggestions.map((s) => `${s.file} (${s.count}x)`).join(", ")}`
+          );
+        }
+      }
+      if (coEditLines.length > 0) {
+        parts.push("## Co-Edit Patterns\n");
+        parts.push(...coEditLines);
+        parts.push("");
+      }
+    }
+    const memHits = results.filter((r) => r.type === "pattern").slice(0, memoryResults);
+    if (memHits.length > 0) {
+      parts.push("## Learned Patterns\n");
+      for (const p of memHits) {
+        const m = p.metadata;
+        const score = Math.round(p.score * 100);
+        const success = Math.round((m.successRate ?? 0) * 100);
+        parts.push(`**${m.taskType}** \u2014 ${success}% success, ${score}% match`);
+        parts.push(`Task: ${m.task}`);
+        parts.push(`Approach: ${p.content}`);
+        if (m.critique) parts.push(`Lesson: ${m.critique}`);
+        parts.push("");
+      }
+    }
+    return parts.join("\n");
+  }
+};
+
+// src/core/collection.ts
+var Collection = class {
+  constructor(_name, _db, _embedding, _hnsw, _vecs, _reranker) {
+    this._name = _name;
+    this._db = _db;
+    this._embedding = _embedding;
+    this._hnsw = _hnsw;
+    this._vecs = _vecs;
+    this._reranker = _reranker;
+  }
+  static {
+    __name(this, "Collection");
+  }
+  /** Collection name. */
+  get name() {
+    return this._name;
+  }
+  /** Add an item. Returns its ID. */
+  async add(content, options = {}) {
+    const opts = "tags" in options || "ttl" in options || "metadata" in options ? options : { metadata: options };
+    const metadata = opts.metadata ?? {};
+    const tags = opts.tags ?? [];
+    const expiresAt = opts.ttl ? Math.floor(Date.now() / 1e3) + parseDuration(opts.ttl) : null;
+    const result = this._db.prepare(
+      "INSERT INTO kv_data (collection, content, meta_json, tags_json, expires_at) VALUES (?, ?, ?, ?, ?)"
+    ).run(this._name, content, JSON.stringify(metadata), JSON.stringify(tags), expiresAt);
+    const id = Number(result.lastInsertRowid);
+    const vec = await this._embedding.embed(content);
+    this._db.prepare(
+      "INSERT INTO kv_vectors (data_id, embedding) VALUES (?, ?)"
+    ).run(id, Buffer.from(vec.buffer));
+    this._hnsw.add(vec, id);
+    this._vecs.set(id, vec);
+    return id;
+  }
+  /** Add multiple items. Returns their IDs. */
+  async addMany(items) {
+    const ids = [];
+    for (const item of items) {
+      ids.push(await this.add(item.content, {
+        metadata: item.metadata,
+        tags: item.tags,
+        ttl: item.ttl
+      }));
+    }
+    return ids;
+  }
+  /** Search this collection. */
+  async search(query, options = {}) {
+    const { k = 5, mode = "hybrid", minScore = 0.15, tags } = options;
+    this._pruneExpired();
+    if (mode === "keyword") return this._filterByTags(this._searchBM25(query, k, minScore), tags);
+    if (mode === "vector") return this._filterByTags(await this._searchVector(query, k, minScore), tags);
+    const [vectorHits, bm25Hits] = await Promise.all([
+      this._searchVector(query, k, 0),
+      Promise.resolve(this._searchBM25(query, k, 0))
+    ]);
+    const fused = reciprocalRankFusion([
+      vectorHits.map((h) => ({ type: "document", score: h.score ?? 0, content: h.content, metadata: { id: h.id } })),
+      bm25Hits.map((h) => ({ type: "document", score: h.score ?? 0, content: h.content, metadata: { id: h.id } }))
+    ]);
+    const allById = /* @__PURE__ */ new Map();
+    for (const h of [...vectorHits, ...bm25Hits]) allById.set(h.id, h);
+    const results = [];
+    for (const r of fused) {
+      const item = allById.get(r.metadata.id);
+      if (!item) continue;
+      const scored = { ...item, score: r.score };
+      if (scored.score >= minScore) results.push(scored);
+      if (results.length >= k) break;
+    }
+    if (this._reranker && results.length > 1) {
+      const documents = results.map((r) => r.content);
+      const scores = await this._reranker.rank(query, documents);
+      const blended = results.map((r, i) => ({
+        ...r,
+        score: 0.6 * (r.score ?? 0) + 0.4 * (scores[i] ?? 0)
+      }));
+      return this._filterByTags(
+        blended.sort((a, b) => (b.score ?? 0) - (a.score ?? 0)),
+        tags
+      );
+    }
+    return this._filterByTags(results, tags);
+  }
+  /** List items (newest first). */
+  list(options = {}) {
+    const { limit = 20, offset = 0, tags } = options;
+    this._pruneExpired();
+    const rows = this._db.prepare(
+      "SELECT * FROM kv_data WHERE collection = ? AND (expires_at IS NULL OR expires_at > ?) ORDER BY created_at DESC, id DESC LIMIT ? OFFSET ?"
+    ).all(this._name, Math.floor(Date.now() / 1e3), limit, offset);
+    return this._filterByTags(rows.map((r) => this._rowToItem(r)), tags);
+  }
+  /** Count items in this collection. */
+  count() {
+    return this._db.prepare(
+      "SELECT COUNT(*) as c FROM kv_data WHERE collection = ?"
+    ).get(this._name).c;
+  }
+  /** Keep only the N most recent items, remove the rest. */
+  async trim(options) {
+    const before = this.count();
+    if (before <= options.keep) return { removed: 0 };
+    const toRemove = this._db.prepare(`
+            SELECT id FROM kv_data 
+            WHERE collection = ? 
+            ORDER BY created_at DESC, id DESC 
+            LIMIT -1 OFFSET ?
+        `).all(this._name, options.keep);
+    for (const row of toRemove) {
+      this._removeById(row.id);
+    }
+    return { removed: toRemove.length };
+  }
+  /** Remove items older than a duration string (e.g. '30d', '12h'). */
+  async prune(options) {
+    const seconds = parseDuration(options.olderThan);
+    const cutoff = Math.floor(Date.now() / 1e3) - seconds;
+    const toRemove = this._db.prepare(
+      "SELECT id FROM kv_data WHERE collection = ? AND created_at < ?"
+    ).all(this._name, cutoff);
+    for (const row of toRemove) {
+      this._removeById(row.id);
+    }
+    return { removed: toRemove.length };
+  }
+  /** Remove a specific item by ID. */
+  remove(id) {
+    this._removeById(id);
+  }
+  /** Clear all items in this collection. */
+  clear() {
+    const rows = this._db.prepare(
+      "SELECT id FROM kv_data WHERE collection = ?"
+    ).all(this._name);
+    for (const row of rows) {
+      this._removeById(row.id);
+    }
+  }
+  // ── Private ──────────────────────────────────────
+  _removeById(id) {
+    this._vecs.delete(id);
+    this._db.prepare("DELETE FROM kv_data WHERE id = ?").run(id);
+  }
+  async _searchVector(query, k, minScore) {
+    if (this._hnsw.size === 0) return [];
+    const queryVec = await this._embedding.embed(query);
+    const hits = this._hnsw.search(queryVec, k * 3);
+    const ids = hits.map((h) => h.id);
+    if (ids.length === 0) return [];
+    const scoreMap = new Map(hits.map((h) => [h.id, h.score]));
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = this._db.prepare(
+      `SELECT * FROM kv_data WHERE id IN (${placeholders}) AND collection = ?`
+    ).all(...ids, this._name);
+    return rows.map((r) => ({ ...this._rowToItem(r), score: scoreMap.get(r.id) ?? 0 })).filter((r) => r.score >= minScore).sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, k);
+  }
+  _searchBM25(query, k, minScore) {
+    const ftsQuery = sanitizeFTS(query);
+    if (!ftsQuery) return [];
+    try {
+      const rows = this._db.prepare(`
+                SELECT d.*, bm25(fts_kv, 5.0, 1.0) AS score
+                FROM fts_kv f
+                JOIN kv_data d ON d.id = f.rowid
+                WHERE fts_kv MATCH ? AND d.collection = ?
+                ORDER BY score ASC
+                LIMIT ?
+            `).all(ftsQuery, this._name, k);
+      return rows.map((r) => ({
+        ...this._rowToItem(r),
+        score: normalizeBM25(r.score)
+      })).filter((r) => (r.score ?? 0) >= minScore);
+    } catch {
+      return [];
+    }
+  }
+  _rowToItem(r) {
+    return {
+      id: r.id,
+      collection: r.collection,
+      content: r.content,
+      metadata: JSON.parse(r.meta_json || "{}"),
+      tags: JSON.parse(r.tags_json || "[]"),
+      createdAt: r.created_at,
+      expiresAt: r.expires_at ?? void 0
+    };
+  }
+  /** Filter results by tags (item must have ALL specified tags). */
+  _filterByTags(items, tags) {
+    if (!tags || tags.length === 0) return items;
+    return items.filter(
+      (item) => tags.every((t) => item.tags.includes(t))
+    );
+  }
+  /** Remove expired items (TTL). Called automatically on search/list. */
+  _pruneExpired() {
+    const now = Math.floor(Date.now() / 1e3);
+    const expired = this._db.prepare(
+      "SELECT id FROM kv_data WHERE collection = ? AND expires_at IS NOT NULL AND expires_at <= ?"
+    ).all(this._name, now);
+    for (const row of expired) {
+      this._removeById(row.id);
+    }
+  }
+};
+function parseDuration(s) {
+  const match = s.match(/^(\d+)([dhms])$/);
+  if (!match) throw new Error(`Invalid duration: "${s}". Use format like '30d', '12h', '5m'.`);
+  const n = parseInt(match[1], 10);
+  switch (match[2]) {
+    case "d":
+      return n * 86400;
+    case "h":
+      return n * 3600;
+    case "m":
+      return n * 60;
+    case "s":
+      return n;
+    default:
+      return n;
+  }
+}
+__name(parseDuration, "parseDuration");
+
+// src/core/brainbank.ts
+import { EventEmitter } from "events";
+
+// src/storage/database.ts
+import BetterSqlite3 from "better-sqlite3";
+import * as fs from "fs";
+import * as path2 from "path";
+
+// src/core/schema.ts
+var SCHEMA_VERSION = 4;
+function createSchema(db) {
+  db.exec(`
+        -- \u2500\u2500 Schema versioning \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+        CREATE TABLE IF NOT EXISTS schema_version (
+            version     INTEGER PRIMARY KEY,
+            applied_at  INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+        INSERT OR IGNORE INTO schema_version (version) VALUES (${SCHEMA_VERSION});
+
+        -- \u2500\u2500 Code chunks \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+        CREATE TABLE IF NOT EXISTS code_chunks (
+            id          INTEGER PRIMARY KEY AUTOINCREMENT,
+            file_path   TEXT    NOT NULL,
+            chunk_type  TEXT    NOT NULL,
+            name        TEXT,
+            start_line  INTEGER NOT NULL,
+            end_line    INTEGER NOT NULL,
+            content     TEXT    NOT NULL,
+            language    TEXT    NOT NULL,
+            file_hash   TEXT,
+            indexed_at  INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS code_vectors (
+            chunk_id    INTEGER PRIMARY KEY REFERENCES code_chunks(id) ON DELETE CASCADE,
+            embedding   BLOB    NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS indexed_files (
+            file_path   TEXT PRIMARY KEY,
+            file_hash   TEXT    NOT NULL,
+            indexed_at  INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        -- \u2500\u2500 Git history \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+        CREATE TABLE IF NOT EXISTS git_commits (
+            id          INTEGER PRIMARY KEY AUTOINCREMENT,
+            hash        TEXT    UNIQUE NOT NULL,
+            short_hash  TEXT    NOT NULL,
+            message     TEXT    NOT NULL,
+            author      TEXT    NOT NULL,
+            date        TEXT    NOT NULL,
+            timestamp   INTEGER NOT NULL,
+            files_json  TEXT    NOT NULL,
+            diff        TEXT,
+            additions   INTEGER DEFAULT 0,
+            deletions   INTEGER DEFAULT 0,
+            is_merge    INTEGER DEFAULT 0
+        );
+
+        CREATE TABLE IF NOT EXISTS commit_files (
+            commit_id   INTEGER NOT NULL REFERENCES git_commits(id),
+            file_path   TEXT    NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS co_edits (
+            file_a      TEXT NOT NULL,
+            file_b      TEXT NOT NULL,
+            count       INTEGER NOT NULL DEFAULT 1,
+            PRIMARY KEY (file_a, file_b)
+        );
+
+        CREATE TABLE IF NOT EXISTS git_vectors (
+            commit_id   INTEGER PRIMARY KEY REFERENCES git_commits(id) ON DELETE CASCADE,
+            embedding   BLOB    NOT NULL
+        );
+
+        -- \u2500\u2500 Agent memory \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+        CREATE TABLE IF NOT EXISTS memory_patterns (
+            id           INTEGER PRIMARY KEY AUTOINCREMENT,
+            task_type    TEXT    NOT NULL,
+            task         TEXT    NOT NULL,
+            approach     TEXT    NOT NULL,
+            outcome      TEXT,
+            success_rate REAL    NOT NULL DEFAULT 0.5,
+            critique     TEXT,
+            tokens_used  INTEGER,
+            latency_ms   INTEGER,
+            created_at   INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS memory_vectors (
+            pattern_id  INTEGER PRIMARY KEY REFERENCES memory_patterns(id) ON DELETE CASCADE,
+            embedding   BLOB    NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS distilled_strategies (
+            task_type   TEXT PRIMARY KEY,
+            strategy    TEXT    NOT NULL,
+            confidence  REAL    NOT NULL DEFAULT 0.8,
+            updated_at  INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        -- \u2500\u2500 Indices \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+        CREATE INDEX IF NOT EXISTS idx_cc_file      ON code_chunks(file_path);
+        CREATE INDEX IF NOT EXISTS idx_cf_path      ON commit_files(file_path);
+        CREATE INDEX IF NOT EXISTS idx_gc_ts        ON git_commits(timestamp DESC);
+        CREATE INDEX IF NOT EXISTS idx_gc_hash      ON git_commits(hash);
+        CREATE INDEX IF NOT EXISTS idx_mp_type      ON memory_patterns(task_type);
+        CREATE INDEX IF NOT EXISTS idx_mp_success   ON memory_patterns(success_rate);
+        CREATE INDEX IF NOT EXISTS idx_mp_created   ON memory_patterns(created_at);
+
+        -- \u2500\u2500 FTS5 Full-Text Search \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+        -- Code chunks: search by file path, name, and content
+        CREATE VIRTUAL TABLE IF NOT EXISTS fts_code USING fts5(
+            file_path,
+            name,
+            content,
+            content='code_chunks',
+            content_rowid='id',
+            tokenize='porter unicode61'
+        );
+
+        -- Git commits: search by message, author, and diff
+        CREATE VIRTUAL TABLE IF NOT EXISTS fts_commits USING fts5(
+            message,
+            author,
+            diff,
+            content='git_commits',
+            content_rowid='id',
+            tokenize='porter unicode61'
+        );
+
+        -- Memory patterns: search by task type, task, approach, and critique
+        CREATE VIRTUAL TABLE IF NOT EXISTS fts_patterns USING fts5(
+            task_type,
+            task,
+            approach,
+            critique,
+            content='memory_patterns',
+            content_rowid='id',
+            tokenize='porter unicode61'
+        );
+
+        -- \u2500\u2500 FTS5 Sync Triggers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+        -- Auto-sync FTS indices on INSERT/UPDATE/DELETE
+
+        CREATE TRIGGER IF NOT EXISTS trg_fts_code_insert AFTER INSERT ON code_chunks BEGIN
+            INSERT INTO fts_code(rowid, file_path, name, content)
+            VALUES (new.id, new.file_path, COALESCE(new.name, ''), new.content);
+        END;
+        CREATE TRIGGER IF NOT EXISTS trg_fts_code_delete AFTER DELETE ON code_chunks BEGIN
+            INSERT INTO fts_code(fts_code, rowid, file_path, name, content)
+            VALUES ('delete', old.id, old.file_path, COALESCE(old.name, ''), old.content);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS trg_fts_commits_insert AFTER INSERT ON git_commits BEGIN
+            INSERT INTO fts_commits(rowid, message, author, diff)
+            VALUES (new.id, new.message, new.author, COALESCE(new.diff, ''));
+        END;
+        CREATE TRIGGER IF NOT EXISTS trg_fts_commits_delete AFTER DELETE ON git_commits BEGIN
+            INSERT INTO fts_commits(fts_commits, rowid, message, author, diff)
+            VALUES ('delete', old.id, old.message, old.author, COALESCE(old.diff, ''));
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS trg_fts_patterns_insert AFTER INSERT ON memory_patterns BEGIN
+            INSERT INTO fts_patterns(rowid, task_type, task, approach, critique)
+            VALUES (new.id, new.task_type, new.task, new.approach, COALESCE(new.critique, ''));
+        END;
+        CREATE TRIGGER IF NOT EXISTS trg_fts_patterns_delete AFTER DELETE ON memory_patterns BEGIN
+            INSERT INTO fts_patterns(fts_patterns, rowid, task_type, task, approach, critique)
+            VALUES ('delete', old.id, old.task_type, old.task, old.approach, COALESCE(old.critique, ''));
+        END;
+
+        -- \u2500\u2500 Note Memory \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+        CREATE TABLE IF NOT EXISTS note_memories (
+            id              INTEGER PRIMARY KEY AUTOINCREMENT,
+            title           TEXT    NOT NULL,
+            summary         TEXT    NOT NULL,
+            decisions_json  TEXT    NOT NULL DEFAULT '[]',
+            files_json      TEXT    NOT NULL DEFAULT '[]',
+            patterns_json   TEXT    NOT NULL DEFAULT '[]',
+            open_json       TEXT    NOT NULL DEFAULT '[]',
+            tags_json       TEXT    NOT NULL DEFAULT '[]',
+            tier            TEXT    NOT NULL DEFAULT 'short',
+            created_at      INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS note_vectors (
+            note_id     INTEGER PRIMARY KEY REFERENCES note_memories(id) ON DELETE CASCADE,
+            embedding   BLOB    NOT NULL
+        );
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS fts_notes USING fts5(
+            title,
+            summary,
+            decisions,
+            patterns,
+            tags,
+            content='note_memories',
+            content_rowid='id',
+            tokenize='porter unicode61'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS trg_fts_notes_insert AFTER INSERT ON note_memories BEGIN
+            INSERT INTO fts_notes(rowid, title, summary, decisions, patterns, tags)
+            VALUES (new.id, new.title, new.summary, new.decisions_json, new.patterns_json, new.tags_json);
+        END;
+        CREATE TRIGGER IF NOT EXISTS trg_fts_notes_delete AFTER DELETE ON note_memories BEGIN
+            INSERT INTO fts_notes(fts_notes, rowid, title, summary, decisions, patterns, tags)
+            VALUES ('delete', old.id, old.title, old.summary, old.decisions_json, old.patterns_json, old.tags_json);
+        END;
+
+        CREATE INDEX IF NOT EXISTS idx_nm_tier     ON note_memories(tier);
+        CREATE INDEX IF NOT EXISTS idx_nm_created  ON note_memories(created_at DESC);
+
+        -- \u2500\u2500 Document Collections \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+        CREATE TABLE IF NOT EXISTS collections (
+            name        TEXT PRIMARY KEY,
+            path        TEXT    NOT NULL,
+            pattern     TEXT    NOT NULL DEFAULT '**/*.md',
+            ignore_json TEXT    NOT NULL DEFAULT '[]',
+            context     TEXT,
+            created_at  INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS doc_chunks (
+            id           INTEGER PRIMARY KEY AUTOINCREMENT,
+            collection   TEXT    NOT NULL REFERENCES collections(name) ON DELETE CASCADE,
+            file_path    TEXT    NOT NULL,
+            title        TEXT    NOT NULL,
+            content      TEXT    NOT NULL,
+            seq          INTEGER NOT NULL DEFAULT 0,
+            pos          INTEGER NOT NULL DEFAULT 0,
+            content_hash TEXT    NOT NULL,
+            indexed_at   INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS doc_vectors (
+            chunk_id    INTEGER PRIMARY KEY REFERENCES doc_chunks(id) ON DELETE CASCADE,
+            embedding   BLOB    NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_dc_collection ON doc_chunks(collection);
+        CREATE INDEX IF NOT EXISTS idx_dc_file       ON doc_chunks(file_path);
+        CREATE INDEX IF NOT EXISTS idx_dc_hash       ON doc_chunks(content_hash);
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS fts_docs USING fts5(
+            title,
+            content,
+            file_path,
+            collection,
+            content='doc_chunks',
+            content_rowid='id',
+            tokenize='porter unicode61'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS trg_fts_docs_insert AFTER INSERT ON doc_chunks BEGIN
+            INSERT INTO fts_docs(rowid, title, content, file_path, collection)
+            VALUES (new.id, new.title, new.content, new.file_path, new.collection);
+        END;
+        CREATE TRIGGER IF NOT EXISTS trg_fts_docs_delete AFTER DELETE ON doc_chunks BEGIN
+            INSERT INTO fts_docs(fts_docs, rowid, title, content, file_path, collection)
+            VALUES ('delete', old.id, old.title, old.content, old.file_path, old.collection);
+        END;
+
+        -- \u2500\u2500 Path Contexts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+        CREATE TABLE IF NOT EXISTS path_contexts (
+            collection  TEXT    NOT NULL,
+            path        TEXT    NOT NULL,
+            context     TEXT    NOT NULL,
+            PRIMARY KEY (collection, path)
+        );
+
+        -- \u2500\u2500 Dynamic Collections (KV Store) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+        CREATE TABLE IF NOT EXISTS kv_data (
+            id          INTEGER PRIMARY KEY AUTOINCREMENT,
+            collection  TEXT    NOT NULL,
+            content     TEXT    NOT NULL,
+            meta_json   TEXT    NOT NULL DEFAULT '{}',
+            tags_json   TEXT    NOT NULL DEFAULT '[]',
+            expires_at  INTEGER,
+            created_at  INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE TABLE IF NOT EXISTS kv_vectors (
+            data_id   INTEGER PRIMARY KEY REFERENCES kv_data(id) ON DELETE CASCADE,
+            embedding BLOB    NOT NULL
+        );
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS fts_kv USING fts5(
+            content,
+            collection,
+            content='kv_data',
+            content_rowid='id',
+            tokenize='porter unicode61'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS trg_fts_kv_insert AFTER INSERT ON kv_data BEGIN
+            INSERT INTO fts_kv(rowid, content, collection)
+            VALUES (new.id, new.content, new.collection);
+        END;
+        CREATE TRIGGER IF NOT EXISTS trg_fts_kv_delete AFTER DELETE ON kv_data BEGIN
+            INSERT INTO fts_kv(fts_kv, rowid, content, collection)
+            VALUES ('delete', old.id, old.content, old.collection);
+        END;
+
+        CREATE INDEX IF NOT EXISTS idx_kv_collection ON kv_data(collection);
+        CREATE INDEX IF NOT EXISTS idx_kv_created    ON kv_data(created_at DESC);
+
+        -- \u2500\u2500 Embedding Metadata \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+        CREATE TABLE IF NOT EXISTS embedding_meta (
+            key     TEXT PRIMARY KEY,
+            value   TEXT NOT NULL
+        );
+    `);
+}
+__name(createSchema, "createSchema");
+
+// src/storage/database.ts
+var Database = class {
+  static {
+    __name(this, "Database");
+  }
+  db;
+  constructor(dbPath) {
+    const dir = path2.dirname(dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new BetterSqlite3(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("foreign_keys = ON");
+    createSchema(this.db);
+  }
+  /**
+   * Run a function inside a transaction.
+   * Auto-commits on success, auto-rollbacks on error.
+   */
+  transaction(fn) {
+    const tx = this.db.transaction(fn);
+    return tx();
+  }
+  /**
+   * Run a prepared statement on multiple rows.
+   * Wraps in a single transaction for performance.
+   */
+  batch(sql, rows) {
+    const stmt = this.db.prepare(sql);
+    const tx = this.db.transaction(() => {
+      for (const row of rows) {
+        stmt.run(...row);
+      }
+    });
+    tx();
+  }
+  /** Prepare a reusable statement. */
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
+  /** Execute raw SQL (no results). */
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  /** Close the database. */
+  close() {
+    this.db.close();
+  }
+};
+
+// src/core/reembed.ts
+var TABLES = [
+  {
+    name: "code",
+    textTable: "code_chunks",
+    vectorTable: "code_vectors",
+    idColumn: "id",
+    fkColumn: "chunk_id",
+    textBuilder: /* @__PURE__ */ __name((r) => [
+      `File: ${r.file_path}`,
+      r.name ? `${r.chunk_type}: ${r.name}` : r.chunk_type,
+      r.content
+    ].join("\n"), "textBuilder")
+  },
+  {
+    name: "git",
+    textTable: "git_commits",
+    vectorTable: "git_vectors",
+    idColumn: "id",
+    fkColumn: "commit_id",
+    textBuilder: /* @__PURE__ */ __name((r) => [
+      r.message,
+      r.diff ?? ""
+    ].filter(Boolean).join("\n"), "textBuilder")
+  },
+  {
+    name: "memory",
+    textTable: "memory_patterns",
+    vectorTable: "memory_vectors",
+    idColumn: "id",
+    fkColumn: "pattern_id",
+    textBuilder: /* @__PURE__ */ __name((r) => [
+      r.task_type,
+      r.task,
+      r.approach,
+      r.outcome ?? ""
+    ].filter(Boolean).join("\n"), "textBuilder")
+  },
+  {
+    name: "notes",
+    textTable: "note_memories",
+    vectorTable: "note_vectors",
+    idColumn: "id",
+    fkColumn: "note_id",
+    textBuilder: /* @__PURE__ */ __name((r) => [
+      r.title,
+      r.summary,
+      r.decisions_json !== "[]" ? `Decisions: ${r.decisions_json}` : "",
+      r.tags_json !== "[]" ? `Tags: ${r.tags_json}` : ""
+    ].filter(Boolean).join("\n"), "textBuilder")
+  },
+  {
+    name: "docs",
+    textTable: "doc_chunks",
+    vectorTable: "doc_vectors",
+    idColumn: "id",
+    fkColumn: "chunk_id",
+    textBuilder: /* @__PURE__ */ __name((r) => [
+      r.title ? `# ${r.title}` : "",
+      r.content
+    ].filter(Boolean).join("\n"), "textBuilder")
+  },
+  {
+    name: "kv",
+    textTable: "kv_data",
+    vectorTable: "kv_vectors",
+    idColumn: "id",
+    fkColumn: "data_id",
+    textBuilder: /* @__PURE__ */ __name((r) => r.content, "textBuilder")
+  }
+];
+async function reembedAll(db, embedding, hnswMap, options = {}) {
+  const { batchSize = 50, onProgress } = options;
+  const result = {};
+  let total = 0;
+  for (const table of TABLES) {
+    const count = await reembedTable(db, embedding, table, batchSize, onProgress);
+    result[table.name] = count;
+    total += count;
+    const entry = hnswMap.get(table.name);
+    if (entry && count > 0) {
+      await rebuildHnsw(db, table, entry.hnsw, entry.vecs);
+    }
+  }
+  const meta = {
+    provider: embedding.constructor?.name ?? "unknown",
+    dims: String(embedding.dims),
+    reembedded_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const upsert = db.prepare(
+    "INSERT OR REPLACE INTO embedding_meta (key, value) VALUES (?, ?)"
+  );
+  for (const [k, v] of Object.entries(meta)) {
+    upsert.run(k, v);
+  }
+  return {
+    code: result.code ?? 0,
+    git: result.git ?? 0,
+    memory: result.memory ?? 0,
+    notes: result.notes ?? 0,
+    docs: result.docs ?? 0,
+    kv: result.kv ?? 0,
+    total
+  };
+}
+__name(reembedAll, "reembedAll");
+async function reembedTable(db, embedding, table, batchSize, onProgress) {
+  const rows = db.prepare(
+    `SELECT * FROM ${table.textTable}`
+  ).all();
+  if (rows.length === 0) return 0;
+  db.prepare(`DELETE FROM ${table.vectorTable}`).run();
+  const insertVec = db.prepare(
+    `INSERT INTO ${table.vectorTable} (${table.fkColumn}, embedding) VALUES (?, ?)`
+  );
+  let processed = 0;
+  for (let i = 0; i < rows.length; i += batchSize) {
+    const batch = rows.slice(i, i + batchSize);
+    const texts = batch.map((r) => table.textBuilder(r));
+    const vectors = await embedding.embedBatch(texts);
+    db.transaction(() => {
+      for (let j = 0; j < batch.length; j++) {
+        const id = batch[j][table.idColumn];
+        const vec = vectors[j];
+        insertVec.run(id, Buffer.from(vec.buffer));
+      }
+    });
+    processed += batch.length;
+    onProgress?.(table.name, processed, rows.length);
+  }
+  return processed;
+}
+__name(reembedTable, "reembedTable");
+async function rebuildHnsw(db, table, hnsw, vecs) {
+  vecs.clear();
+  const rows = db.prepare(
+    `SELECT ${table.fkColumn} as id, embedding FROM ${table.vectorTable}`
+  ).all();
+  for (const row of rows) {
+    const vec = new Float32Array(new Uint8Array(row.embedding).buffer);
+    hnsw.add(vec, row.id);
+    vecs.set(row.id, vec);
+  }
+}
+__name(rebuildHnsw, "rebuildHnsw");
+function getEmbeddingMeta(db) {
+  try {
+    const provider = db.prepare(
+      "SELECT value FROM embedding_meta WHERE key = 'provider'"
+    ).get();
+    const dims = db.prepare(
+      "SELECT value FROM embedding_meta WHERE key = 'dims'"
+    ).get();
+    if (!provider || !dims) return null;
+    return { provider: provider.value, dims: Number(dims.value) };
+  } catch {
+    return null;
+  }
+}
+__name(getEmbeddingMeta, "getEmbeddingMeta");
+function setEmbeddingMeta(db, embedding) {
+  const upsert = db.prepare(
+    "INSERT OR REPLACE INTO embedding_meta (key, value) VALUES (?, ?)"
+  );
+  upsert.run("provider", embedding.constructor?.name ?? "unknown");
+  upsert.run("dims", String(embedding.dims));
+  upsert.run("indexed_at", (/* @__PURE__ */ new Date()).toISOString());
+}
+__name(setEmbeddingMeta, "setEmbeddingMeta");
+function detectProviderMismatch(db, embedding) {
+  const meta = getEmbeddingMeta(db);
+  if (!meta) return null;
+  const currentName = embedding.constructor?.name ?? "unknown";
+  const mismatch = meta.dims !== embedding.dims || meta.provider !== currentName;
+  return {
+    mismatch,
+    stored: `${meta.provider}/${meta.dims}`,
+    current: `${currentName}/${embedding.dims}`
+  };
+}
+__name(detectProviderMismatch, "detectProviderMismatch");
+
+// src/core/watch.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+function createWatcher(reindexFn, indexers, repoPath, options = {}) {
+  const {
+    paths = [repoPath],
+    debounceMs = 2e3,
+    onIndex,
+    onError
+  } = options;
+  let active = true;
+  const watchers = [];
+  const pending = /* @__PURE__ */ new Set();
+  let timer = null;
+  const customPatterns = [];
+  for (const indexer of indexers.values()) {
+    if (indexer.watchPatterns) {
+      customPatterns.push({ indexer, patterns: indexer.watchPatterns() });
+    }
+  }
+  function matchCustomIndexer(filePath) {
+    const rel = path3.relative(repoPath, filePath);
+    for (const { indexer, patterns } of customPatterns) {
+      for (const pattern of patterns) {
+        if (matchGlob(rel, pattern)) return indexer;
+      }
+    }
+    return null;
+  }
+  __name(matchCustomIndexer, "matchCustomIndexer");
+  function matchGlob(filePath, pattern) {
+    if (pattern.startsWith("**/")) {
+      const suffix = pattern.slice(3);
+      const ext = suffix.startsWith("*.") ? suffix.slice(1) : null;
+      if (ext) return filePath.endsWith(ext);
+      return path3.basename(filePath) === suffix;
+    }
+    if (pattern.startsWith("*.")) {
+      return filePath.endsWith(pattern.slice(1));
+    }
+    return filePath === pattern;
+  }
+  __name(matchGlob, "matchGlob");
+  async function flush() {
+    if (pending.size === 0) return;
+    const files = [...pending];
+    pending.clear();
+    let needsReindex = false;
+    for (const filePath of files) {
+      const absPath = path3.resolve(repoPath, filePath);
+      const customIndexer = matchCustomIndexer(absPath);
+      if (customIndexer?.onFileChange) {
+        try {
+          const handled = await customIndexer.onFileChange(absPath, detectEvent(absPath));
+          if (handled) {
+            onIndex?.(filePath, customIndexer.name);
+            continue;
+          }
+        } catch (err) {
+          onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+      if (isSupported(filePath)) {
+        needsReindex = true;
+        onIndex?.(filePath, "code");
+      }
+    }
+    if (needsReindex) {
+      try {
+        await reindexFn();
+      } catch (err) {
+        onError?.(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+  }
+  __name(flush, "flush");
+  function detectEvent(filePath) {
+    try {
+      fs2.accessSync(filePath);
+      return "update";
+    } catch {
+      return "delete";
+    }
+  }
+  __name(detectEvent, "detectEvent");
+  function shouldWatch(filename) {
+    if (!filename) return false;
+    const parts = filename.split(path3.sep);
+    for (const part of parts) {
+      if (isIgnoredDir(part)) return false;
+    }
+    if (isIgnoredFile(path3.basename(filename))) return false;
+    if (isSupported(filename)) return true;
+    if (matchCustomIndexer(path3.resolve(repoPath, filename))) return true;
+    return false;
+  }
+  __name(shouldWatch, "shouldWatch");
+  for (const watchPath of paths) {
+    const resolved = path3.resolve(watchPath);
+    try {
+      const watcher = fs2.watch(resolved, { recursive: true }, (_event, filename) => {
+        if (!active || !filename) return;
+        if (!shouldWatch(filename)) return;
+        pending.add(filename);
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(() => flush(), debounceMs);
+      });
+      watcher.on("error", (err) => {
+        onError?.(err instanceof Error ? err : new Error(String(err)));
+      });
+      watchers.push(watcher);
+    } catch (err) {
+      onError?.(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  return {
+    close() {
+      active = false;
+      if (timer) clearTimeout(timer);
+      for (const w of watchers) w.close();
+      watchers.length = 0;
+    },
+    get active() {
+      return active;
+    }
+  };
+}
+__name(createWatcher, "createWatcher");
+
+// src/core/brainbank.ts
+var BrainBank = class extends EventEmitter {
+  static {
+    __name(this, "BrainBank");
+  }
+  _config;
+  _db;
+  _embedding;
+  _modules = /* @__PURE__ */ new Map();
+  // Cross-module search (created if code/git/memory are present)
+  _search;
+  _bm25;
+  _contextBuilder;
+  _initialized = false;
+  _watcher;
+  // Collections
+  _collections = /* @__PURE__ */ new Map();
+  _kvHnsw;
+  _kvVecs = /* @__PURE__ */ new Map();
+  // Shared HNSW pool for multi-repo (code:frontend, code:backend share one HNSW)
+  _sharedHnsw = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    super();
+    this._config = resolveConfig(config);
+  }
+  // ── Indexer Registration ────────────────────────
+  /**
+   * Register an indexer. Chainable.
+   * 
+   *   brain.use(code({ repoPath: '.' })).use(docs());
+   */
+  use(indexer) {
+    if (this._initialized) {
+      throw new Error(
+        `BrainBank: Cannot add indexer '${indexer.name}' after initialization. Call .use() before any operations.`
+      );
+    }
+    this._modules.set(indexer.name, indexer);
+    return this;
+  }
+  /** Get the list of registered indexer names. */
+  get indexers() {
+    return [...this._modules.keys()];
+  }
+  /** @deprecated Use .indexers instead. */
+  get modules() {
+    return this.indexers;
+  }
+  /** Check if an indexer is loaded. Also matches type prefix (e.g. 'code' matches 'code:frontend'). */
+  has(name) {
+    if (this._modules.has(name)) return true;
+    for (const key of this._modules.keys()) {
+      if (key.startsWith(name + ":")) return true;
+    }
+    return false;
+  }
+  /** Get an indexer instance. Throws if not loaded. */
+  indexer(name) {
+    const mod = this._modules.get(name);
+    if (!mod) {
+      const first = this._findFirstByType(name);
+      if (first) return first;
+      throw new Error(
+        `BrainBank: Indexer '${name}' is not loaded. Add .use(${name}()) to your BrainBank instance.`
+      );
+    }
+    return mod;
+  }
+  /** @deprecated Use .indexer() instead. */
+  module(name) {
+    return this.indexer(name);
+  }
+  /** Find all indexers whose name equals or starts with the type prefix. */
+  _findAllByType(type) {
+    return [...this._modules.values()].filter(
+      (m) => m.name === type || m.name.startsWith(type + ":")
+    );
+  }
+  /** Find the first indexer that matches the type. */
+  _findFirstByType(type) {
+    for (const m of this._modules.values()) {
+      if (m.name === type || m.name.startsWith(type + ":")) return m;
+    }
+    return void 0;
+  }
+  // ── Initialization ──────────────────────────────
+  /**
+   * Initialize database, HNSW indices, and load existing vectors.
+   * Only initializes registered modules.
+   * Automatically called by index/search methods if not yet initialized.
+   */
+  async initialize() {
+    if (this._initialized) return;
+    const config = this._config;
+    this._db = new Database(config.dbPath);
+    this._embedding = config.embeddingProvider ?? new LocalEmbedding();
+    this._kvHnsw = new HNSWIndex(
+      config.embeddingDims,
+      config.maxElements ?? 5e5,
+      config.hnswM,
+      config.hnswEfConstruction,
+      config.hnswEfSearch
+    );
+    await this._kvHnsw.init();
+    this._loadVectors("kv_vectors", "data_id", this._kvHnsw, this._kvVecs);
+    const ctx = {
+      db: this._db,
+      embedding: this._embedding,
+      config,
+      createHnsw: /* @__PURE__ */ __name(async (maxElements) => {
+        return new HNSWIndex(
+          config.embeddingDims,
+          maxElements ?? config.maxElements,
+          config.hnswM,
+          config.hnswEfConstruction,
+          config.hnswEfSearch
+        ).init();
+      }, "createHnsw"),
+      loadVectors: /* @__PURE__ */ __name((table, idCol, hnsw, cache) => {
+        this._loadVectors(table, idCol, hnsw, cache);
+      }, "loadVectors"),
+      getOrCreateSharedHnsw: /* @__PURE__ */ __name(async (type, maxElements) => {
+        const existing = this._sharedHnsw.get(type);
+        if (existing) return { ...existing, isNew: false };
+        const hnsw = await new HNSWIndex(
+          config.embeddingDims,
+          maxElements ?? config.maxElements,
+          config.hnswM,
+          config.hnswEfConstruction,
+          config.hnswEfSearch
+        ).init();
+        const vecCache = /* @__PURE__ */ new Map();
+        this._sharedHnsw.set(type, { hnsw, vecCache });
+        return { hnsw, vecCache, isNew: true };
+      }, "getOrCreateSharedHnsw"),
+      collection: /* @__PURE__ */ __name((name) => this.collection(name), "collection")
+    };
+    for (const mod of this._modules.values()) {
+      await mod.initialize(ctx);
+    }
+    const codeShared = this._sharedHnsw.get("code");
+    const gitShared = this._sharedHnsw.get("git");
+    const memMod = this._modules.get("memory");
+    if (codeShared || gitShared || memMod) {
+      this._search = new UnifiedSearch({
+        db: this._db,
+        codeHnsw: codeShared?.hnsw,
+        gitHnsw: gitShared?.hnsw,
+        memHnsw: memMod?.hnsw,
+        codeVecs: codeShared?.vecCache ?? /* @__PURE__ */ new Map(),
+        gitVecs: gitShared?.vecCache ?? /* @__PURE__ */ new Map(),
+        memVecs: memMod?.vecCache ?? /* @__PURE__ */ new Map(),
+        embedding: this._embedding,
+        reranker: this._config.reranker
+      });
+      this._bm25 = new BM25Search(this._db);
+    }
+    if (this._search) {
+      const firstGit = this._findFirstByType("git");
+      this._contextBuilder = new ContextBuilder(this._search, firstGit?.coEdits);
+    }
+    setEmbeddingMeta(this._db, this._embedding);
+    const mismatch = detectProviderMismatch(this._db, this._embedding);
+    if (mismatch?.mismatch) {
+      this.emit("warning", {
+        type: "provider_mismatch",
+        message: `Embedding provider changed (${mismatch.stored} \u2192 ${mismatch.current}). Run brain.reembed() to regenerate vectors.`
+      });
+    }
+    this._initialized = true;
+    this.emit("initialized", { indexers: this.indexers });
+  }
+  // ── Collections ─────────────────────────────────
+  /**
+   * Get or create a dynamic collection.
+   * Collections are the universal data primitive — store anything, search semantically.
+   * 
+   *   const errors = brain.collection('debug_errors');
+   *   await errors.add('Fixed null check', { file: 'api.ts' });
+   *   const hits = await errors.search('null pointer');
+   */
+  collection(name) {
+    let coll = this._collections.get(name);
+    if (coll) return coll;
+    if (!this._initialized) {
+      throw new Error(
+        "BrainBank: Must call initialize() before using collections. Or use await brain.collection() after an async operation."
+      );
+    }
+    if (!this._kvHnsw) {
+      throw new Error("BrainBank: Collections HNSW not initialized. Call initialize() first.");
+    }
+    coll = new Collection(name, this._db, this._embedding, this._kvHnsw, this._kvVecs, this._config.reranker);
+    this._collections.set(name, coll);
+    return coll;
+  }
+  /** List all collection names that have data. */
+  listCollectionNames() {
+    const rows = this._db.prepare(
+      "SELECT DISTINCT collection FROM kv_data ORDER BY collection"
+    ).all();
+    return rows.map((r) => r.collection);
+  }
+  // ── Indexing ─────────────────────────────────────
+  /**
+   * Index code and git history in one call.
+   * Incremental — only processes changes since last run.
+   */
+  async index(options = {}) {
+    await this.initialize();
+    const result = {};
+    const codeMods = this._findAllByType("code");
+    for (const mod of codeMods) {
+      const label = mod.name === "code" ? "code" : mod.name;
+      options.onProgress?.(label, "Starting...");
+      const r = await mod.index({
+        forceReindex: options.forceReindex,
+        onProgress: /* @__PURE__ */ __name((f, i, t) => options.onProgress?.(label, `[${i}/${t}] ${f}`), "onProgress")
+      });
+      if (result.code) {
+        result.code.indexed += r.indexed;
+        result.code.skipped += r.skipped;
+        result.code.chunks = (result.code.chunks ?? 0) + (r.chunks ?? 0);
+      } else {
+        result.code = r;
+      }
+    }
+    const gitMods = this._findAllByType("git");
+    for (const mod of gitMods) {
+      const label = mod.name === "git" ? "git" : mod.name;
+      options.onProgress?.(label, "Starting...");
+      const r = await mod.index({
+        depth: options.gitDepth ?? this._config.gitDepth,
+        onProgress: /* @__PURE__ */ __name((f, i, t) => options.onProgress?.(label, `[${i}/${t}] ${f}`), "onProgress")
+      });
+      if (result.git) {
+        result.git.indexed += r.indexed;
+        result.git.skipped += r.skipped;
+      } else {
+        result.git = r;
+      }
+    }
+    this.emit("indexed", result);
+    return result;
+  }
+  /** Index only code files. */
+  async indexCode(options = {}) {
+    await this.initialize();
+    return this.module("code").index(options);
+  }
+  /** Index only git history. */
+  async indexGit(options = {}) {
+    await this.initialize();
+    return this.module("git").index(options);
+  }
+  // ── Document Collections ────────────────────────
+  /** Register a document collection. */
+  async addCollection(collection) {
+    await this.initialize();
+    this.module("docs").addCollection(collection);
+  }
+  /** Remove a collection and all its indexed data. */
+  async removeCollection(name) {
+    await this.initialize();
+    this.module("docs").removeCollection(name);
+  }
+  /** List all registered collections. */
+  listCollections() {
+    return this.module("docs").listCollections();
+  }
+  /** Index all (or specific) document collections. */
+  async indexDocs(options = {}) {
+    await this.initialize();
+    const results = await this.module("docs").indexCollections(options);
+    this.emit("docsIndexed", results);
+    return results;
+  }
+  /** Search documents only. */
+  async searchDocs(query, options) {
+    await this.initialize();
+    return this.module("docs").search(query, options);
+  }
+  // ── Context Metadata ────────────────────────────
+  /** Add context description for a collection path. */
+  addContext(collection, path4, context) {
+    this.module("docs").addContext(collection, path4, context);
+  }
+  /** Remove context for a collection path. */
+  removeContext(collection, path4) {
+    this.module("docs").removeContext(collection, path4);
+  }
+  /** List all context entries. */
+  listContexts() {
+    return this.module("docs").listContexts();
+  }
+  // ── Context ─────────────────────────────────────
+  /**
+   * Get formatted context for a task.
+   * Returns markdown ready for system prompt injection.
+   */
+  async getContext(task, options = {}) {
+    await this.initialize();
+    const sections = [];
+    if (this._contextBuilder) {
+      const coreContext = await this._contextBuilder.build(task, options);
+      if (coreContext) sections.push(coreContext);
+    }
+    if (this.has("docs")) {
+      const docResults = await this.searchDocs(task, { k: options.codeResults ?? 4 });
+      if (docResults.length > 0) {
+        const docSection = docResults.map((r) => {
+          const header = r.context ? `**[${r.metadata.collection}]** ${r.metadata.title} \u2014 _${r.context}_` : `**[${r.metadata.collection}]** ${r.metadata.title}`;
+          return `${header}
+
+${r.content}`;
+        }).join("\n\n---\n\n");
+        sections.push(`## Relevant Documents
+
+${docSection}`);
+      }
+    }
+    return sections.join("\n\n");
+  }
+  // ── Search ──────────────────────────────────────
+  /** Semantic search across all loaded modules. */
+  async search(query, options) {
+    await this.initialize();
+    if (!this._search) {
+      if (this.has("docs")) return this.searchDocs(query, { k: 8 });
+      return [];
+    }
+    return this._search.search(query, options);
+  }
+  /** Semantic search over code only. */
+  async searchCode(query, k = 8) {
+    this.module("code");
+    await this.initialize();
+    return this._search.search(query, { codeK: k, gitK: 0, memoryK: 0 });
+  }
+  /** Semantic search over commits only. */
+  async searchCommits(query, k = 8) {
+    this.module("git");
+    await this.initialize();
+    return this._search.search(query, { codeK: 0, gitK: k, memoryK: 0 });
+  }
+  // ── Hybrid Search ───────────────────────────────
+  /**
+   * Hybrid search: vector + BM25 fused with Reciprocal Rank Fusion.
+   * Best quality — catches both exact keyword matches and conceptual similarities.
+   */
+  async hybridSearch(query, options) {
+    await this.initialize();
+    const cols = options?.collections ?? {};
+    const codeK = cols.code ?? options?.codeK ?? 6;
+    const gitK = cols.git ?? options?.gitK ?? 5;
+    const docsK = cols.docs ?? 8;
+    const resultLists = [];
+    if (this._search) {
+      const searchOpts = { ...options, codeK, gitK };
+      const [vectorResults, bm25Results] = await Promise.all([
+        this._search.search(query, searchOpts),
+        Promise.resolve(this._bm25.search(query, searchOpts))
+      ]);
+      resultLists.push(vectorResults, bm25Results);
+    }
+    if (this.has("docs")) {
+      const docResults = await this.searchDocs(query, { k: docsK });
+      if (docResults.length > 0) resultLists.push(docResults);
+    }
+    const reserved = /* @__PURE__ */ new Set(["code", "git", "docs"]);
+    for (const [name, k] of Object.entries(cols)) {
+      if (reserved.has(name)) continue;
+      const col = this.collection(name);
+      const hits = await col.search(query, { k });
+      if (hits.length > 0) {
+        resultLists.push(hits.map((h) => ({
+          type: "collection",
+          score: h.score ?? 0,
+          content: h.content,
+          metadata: { collection: name, id: h.id, ...h.metadata }
+        })));
+      }
+    }
+    if (resultLists.length === 0) return [];
+    const fused = reciprocalRankFusion(resultLists);
+    if (this._config.reranker && fused.length > 1) {
+      const documents = fused.map((r) => r.content);
+      const scores = await this._config.reranker.rank(query, documents);
+      const blended = fused.map((r, i) => {
+        const pos = i + 1;
+        const rrfWeight = pos <= 3 ? 0.75 : pos <= 10 ? 0.6 : 0.4;
+        return {
+          ...r,
+          score: rrfWeight * r.score + (1 - rrfWeight) * (scores[i] ?? 0)
+        };
+      });
+      return blended.sort((a, b) => b.score - a.score);
+    }
+    return fused;
+  }
+  /** BM25 keyword search only (no embeddings needed). */
+  searchBM25(query, options) {
+    if (!this._bm25) return [];
+    return this._bm25.search(query, options);
+  }
+  /** Rebuild FTS5 indices. */
+  rebuildFTS() {
+    this._bm25?.rebuild();
+  }
+  // ── Query ───────────────────────────────────────
+  /** Get git history for a specific file. */
+  async fileHistory(filePath, limit = 20) {
+    this.module("git");
+    await this.initialize();
+    return this._db.prepare(`
+            SELECT c.short_hash, c.message, c.author, c.date, c.additions, c.deletions
+            FROM git_commits c
+            INNER JOIN commit_files cf ON c.id = cf.commit_id
+            WHERE cf.file_path LIKE ? AND c.is_merge = 0
+            ORDER BY c.timestamp DESC LIMIT ?
+        `).all(`%${filePath}%`, limit);
+  }
+  /** Get co-edit suggestions for a file. */
+  coEdits(filePath, limit = 5) {
+    const gitMod = this.module("git");
+    return gitMod.suggest(filePath, limit);
+  }
+  // ── Stats ───────────────────────────────────────
+  /** Get statistics for all loaded modules. */
+  stats() {
+    const result = {};
+    if (this.has("code")) {
+      const mod = this.indexer("code");
+      result.code = {
+        files: this._db.prepare("SELECT COUNT(DISTINCT file_path) as c FROM code_chunks").get().c,
+        chunks: this._db.prepare("SELECT COUNT(*) as c FROM code_chunks").get().c,
+        hnswSize: mod.hnsw?.size ?? 0
+      };
+    }
+    if (this.has("git")) {
+      const mod = this.indexer("git");
+      result.git = {
+        commits: this._db.prepare("SELECT COUNT(*) as c FROM git_commits").get().c,
+        filesTracked: this._db.prepare("SELECT COUNT(DISTINCT file_path) as c FROM commit_files").get().c,
+        coEdits: this._db.prepare("SELECT COUNT(*) as c FROM co_edits").get().c,
+        hnswSize: mod.hnsw?.size ?? 0
+      };
+    }
+    if (this.has("docs")) {
+      const mod = this.indexer("docs");
+      result.documents = mod.stats();
+    }
+    return result;
+  }
+  // ── Watch Mode ───────────────────────────────────
+  /**
+   * Start watching for file changes and auto-re-index.
+   * Works with built-in and custom indexers.
+   * 
+   *   const watcher = brain.watch({
+   *     onIndex: (file, indexer) => console.log(`${indexer}: ${file}`),
+   *   });
+   *   // later: watcher.close();
+   */
+  watch(options = {}) {
+    if (!this._initialized) {
+      throw new Error("BrainBank: Not initialized. Call initialize() before watch().");
+    }
+    this._watcher?.close();
+    this._watcher = createWatcher(
+      async () => {
+        await this.index();
+      },
+      this._modules,
+      this._config.repoPath,
+      options
+    );
+    return this._watcher;
+  }
+  // ── Re-embedding ────────────────────────────────
+  /**
+   * Re-embed all existing text with the current embedding provider.
+   * Use this when switching providers (e.g. Local → OpenAI).
+   * Does NOT re-parse files, git history, or documents — only regenerates vectors.
+   *
+   * @example
+   *   const brain = new BrainBank({ embeddingProvider: new OpenAIEmbedding() });
+   *   await brain.initialize();
+   *   const result = await brain.reembed();
+   *   // → { code: 1200, git: 500, docs: 80, kv: 45, notes: 12, total: 1837 }
+   */
+  async reembed(options = {}) {
+    if (!this._initialized) {
+      throw new Error("BrainBank: Not initialized. Call initialize() before reembed().");
+    }
+    const hnswMap = /* @__PURE__ */ new Map();
+    if (this._kvHnsw) {
+      hnswMap.set("kv", { hnsw: this._kvHnsw, vecs: this._kvVecs });
+    }
+    const codeMod = this._modules.get("code");
+    const gitMod = this._modules.get("git");
+    const memMod = this._modules.get("memory");
+    const docsMod = this._modules.get("docs");
+    const notesMod = this._modules.get("notes");
+    if (codeMod?.hnsw) hnswMap.set("code", { hnsw: codeMod.hnsw, vecs: codeMod.vecCache });
+    if (gitMod?.hnsw) hnswMap.set("git", { hnsw: gitMod.hnsw, vecs: gitMod.vecCache });
+    if (memMod?.hnsw) hnswMap.set("memory", { hnsw: memMod.hnsw, vecs: memMod.vecCache });
+    if (notesMod?.hnsw) hnswMap.set("notes", { hnsw: notesMod.hnsw, vecs: notesMod.vecCache });
+    if (docsMod?.hnsw) hnswMap.set("docs", { hnsw: docsMod.hnsw, vecs: docsMod.vecCache });
+    const result = await reembedAll(
+      this._db,
+      this._embedding,
+      hnswMap,
+      options
+    );
+    this.emit("reembedded", result);
+    return result;
+  }
+  // ── Lifecycle ────────────────────────────────────
+  /** Close database and release resources. */
+  close() {
+    this._watcher?.close();
+    for (const indexer of this._modules.values()) {
+      indexer.close?.();
+    }
+    if (this._db) this._db.close();
+    this._initialized = false;
+    this._collections.clear();
+  }
+  /** Whether the brainbank has been initialized. */
+  get isInitialized() {
+    return this._initialized;
+  }
+  /** The resolved configuration. */
+  get config() {
+    return this._config;
+  }
+  // ── Internals ───────────────────────────────────
+  /** Load vectors from SQLite into HNSW index. */
+  _loadVectors(table, idCol, hnsw, cache) {
+    const rows = this._db.prepare(`SELECT ${idCol}, embedding FROM ${table}`).all();
+    for (const row of rows) {
+      const vec = new Float32Array(row.embedding.buffer.slice(
+        row.embedding.byteOffset,
+        row.embedding.byteOffset + row.embedding.byteLength
+      ));
+      hnsw.add(vec, row[idCol]);
+      cache.set(row[idCol], vec);
+    }
+  }
+};
+
+export {
+  DEFAULTS,
+  resolveConfig,
+  HNSWIndex,
+  LocalEmbedding,
+  searchMMR,
+  UnifiedSearch,
+  BM25Search,
+  ContextBuilder,
+  Collection,
+  BrainBank
+};
+//# sourceMappingURL=chunk-YGSEUWLV.js.map