brainbank 0.1.3 → 0.2.1

package/dist/{chunk-TW5NTYYZ.js → chunk-6MFTQV3O.js}

@@ -2,18 +2,20 @@ import {
   isIgnoredDir,
   isIgnoredFile,
   isSupported
-} from "./chunk-RAEBYV75.js";
+} from "./chunk-WR4WXKJT.js";
 import {
-  reciprocalRankFusion
-} from "./chunk-4ZKBQ33J.js";
+  normalizeBM25,
+  reciprocalRankFusion,
+  sanitizeFTS
+} from "./chunk-V4UJKXPK.js";
 import {
   cosineSimilarity
-} from "./chunk-2P3EGY6S.js";
+} from "./chunk-QNHBCOKB.js";
 import {
   __name
 } from "./chunk-7QVYU63E.js";
 
-// src/core/config.ts
+// src/config/defaults.ts
 import * as path from "path";
 var DEFAULTS = {
   repoPath: ".",
@@ -49,7 +51,262 @@ function resolveConfig(partial = {}) {
 }
 __name(resolveConfig, "resolveConfig");
 
-// src/vector/hnsw.ts
+// src/app/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 vec = await this._embedding.embed(content);
+    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);
+    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) {
+    if (items.length === 0) return [];
+    const texts = items.map((i) => i.content);
+    const vecs = await this._embedding.embedBatch(texts);
+    const ids = [];
+    const insertData = this._db.prepare(
+      "INSERT INTO kv_data (collection, content, meta_json, tags_json, expires_at) VALUES (?, ?, ?, ?, ?)"
+    );
+    const insertVec = this._db.prepare(
+      "INSERT INTO kv_vectors (data_id, embedding) VALUES (?, ?)"
+    );
+    this._db.transaction(() => {
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const expiresAt = item.ttl ? Math.floor(Date.now() / 1e3) + parseDuration(item.ttl) : null;
+        const result = insertData.run(
+          this._name,
+          item.content,
+          JSON.stringify(item.metadata ?? {}),
+          JSON.stringify(item.tags ?? []),
+          expiresAt
+        );
+        const id = Number(result.lastInsertRowid);
+        insertVec.run(id, Buffer.from(vecs[i].buffer));
+        ids.push(id);
+      }
+    });
+    for (let i = 0; i < ids.length; i++) {
+      this._hnsw.add(vecs[i], ids[i]);
+      this._vecs.set(ids[i], vecs[i]);
+    }
+    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 = ? AND (expires_at IS NULL OR expires_at > ?)"
+    ).get(this._name, Math.floor(Date.now() / 1e3)).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._hnsw.remove(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 now = Math.floor(Date.now() / 1e3);
+    const collectionCount = this._db.prepare(
+      "SELECT COUNT(*) as c FROM kv_data WHERE collection = ? AND (expires_at IS NULL OR expires_at > ?)"
+    ).get(this._name, now)?.c ?? 0;
+    const ratio = collectionCount > 0 ? Math.max(3, Math.min(50, Math.ceil(this._hnsw.size / collectionCount))) : 3;
+    const searchK = Math.min(k * ratio, this._hnsw.size);
+    const hits = this._hnsw.search(queryVec, searchK);
+    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/providers/vector/hnsw.ts
 var HNSWIndex = class {
   constructor(_dims, _maxElements = 2e6, _M = 16, _efConstruction = 200, _efSearch = 50) {
     this._dims = _dims;
@@ -62,18 +319,36 @@ var HNSWIndex = class {
     __name(this, "HNSWIndex");
   }
   _index = null;
-  _count = 0;
+  _lib = null;
+  _ids = /* @__PURE__ */ new Set();
   /**
    * 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._lib = await import("hnswlib-node");
+    this._createIndex();
+    return this;
+  }
+  /**
+   * Reinitialize the index in-place, clearing all vectors.
+   * Required after reembed or full re-index to avoid duplicate IDs.
+   * init() must have been called first.
+   */
+  reinit() {
+    if (!this._lib) throw new Error("HNSW not initialized \u2014 call init() first");
+    this._createIndex();
+  }
+  _createIndex() {
+    const HNSW = this._lib.default?.HierarchicalNSW ?? this._lib.HierarchicalNSW;
     this._index = new HNSW("cosine", this._dims);
     this._index.initIndex(this._maxElements, this._M, this._efConstruction);
     this._index.setEf(this._efSearch);
-    return this;
+    this._ids = /* @__PURE__ */ new Set();
+  }
+  /** Maximum capacity of this index. */
+  get maxElements() {
+    return this._maxElements;
   }
   /**
    * Add a vector with an integer ID.
@@ -81,8 +356,28 @@ var HNSWIndex = class {
    */
   add(vector, id) {
     if (!this._index) throw new Error("HNSW index not initialized \u2014 call init() first");
+    if (this._ids.has(id)) return;
+    if (this._ids.size >= this._maxElements) {
+      throw new Error(
+        `HNSW index full (${this._maxElements} elements). Increase maxElements in config or prune old data.`
+      );
+    }
     this._index.addPoint(Array.from(vector), id);
-    this._count++;
+    this._ids.add(id);
+  }
+  /**
+   * Mark a vector as deleted so it no longer appears in searches.
+   * Uses hnswlib-node markDelete under the hood.
+   * Safe to call with an ID that doesn't exist.
+   */
+  remove(id) {
+    if (!this._index || this._ids.size === 0) return;
+    if (!this._ids.has(id)) return;
+    try {
+      this._index.markDelete(id);
+      this._ids.delete(id);
+    } catch {
+    }
   }
   /**
    * Search for the k nearest neighbors.
@@ -90,8 +385,8 @@ var HNSWIndex = class {
    * 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);
+    if (!this._index || this._ids.size === 0) return [];
+    const actualK = Math.min(k, this._ids.size);
     const result = this._index.searchKnn(Array.from(query), actualK);
     return result.neighbors.map((id, i) => ({
       id,
@@ -100,11 +395,11 @@ var HNSWIndex = class {
   }
   /** Number of vectors in the index. */
   get size() {
-    return this._count;
+    return this._ids.size;
   }
 };
 
-// src/embeddings/local.ts
+// src/providers/embeddings/local.ts
 var LocalEmbedding = class {
   static {
     __name(this, "LocalEmbedding");
@@ -117,19 +412,29 @@ var LocalEmbedding = class {
     this._modelName = options.model ?? "Xenova/all-MiniLM-L6-v2";
     this._cacheDir = options.cacheDir ?? ".model-cache";
   }
+  _pipelinePromise = null;
   /**
    * Lazy-load the transformer pipeline.
    * Singleton — created once and reused.
+   * Promise-deduped to prevent concurrent downloads.
    */
   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;
+    if (this._pipelinePromise) return this._pipelinePromise;
+    this._pipelinePromise = (async () => {
+      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;
+    })();
+    try {
+      return await this._pipelinePromise;
+    } finally {
+      this._pipelinePromise = null;
+    }
   }
   /**
    * Embed a single text string.
@@ -156,7 +461,7 @@ var LocalEmbedding = class {
   }
 };
 
-// src/vector/mmr.ts
+// src/search/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;
@@ -188,14 +493,14 @@ function searchMMR(index, query, vectorCache, k, lambda = 0.7) {
 }
 __name(searchMMR, "searchMMR");
 
-// src/query/search.ts
-var UnifiedSearch = class {
+// src/search/vector/multi-index.ts
+var MultiIndexSearch = class {
   static {
-    __name(this, "UnifiedSearch");
+    __name(this, "MultiIndexSearch");
   }
-  _deps;
-  constructor(deps) {
-    this._deps = deps;
+  _config;
+  constructor(config) {
+    this._config = config;
   }
   /**
    * Search across all indices.
@@ -205,20 +510,20 @@ var UnifiedSearch = class {
     const {
       codeK = 6,
       gitK = 5,
-      memoryK = 4,
+      patternK = 4,
       minScore = 0.25,
       useMMR = true,
       mmrLambda = 0.7
     } = options;
-    const queryVec = await this._deps.embedding.embed(query);
+    const queryVec = await this._config.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 (this._config.codeHnsw && this._config.codeHnsw.size > 0) {
+      const hits = useMMR ? searchMMR(this._config.codeHnsw, queryVec, this._config.codeVecs, codeK, mmrLambda) : this._config.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(
+        const rows = this._config.db.prepare(
           `SELECT * FROM code_chunks WHERE id IN (${placeholders})`
         ).all(...ids);
         for (const r of rows) {
@@ -241,13 +546,13 @@ var UnifiedSearch = class {
         }
       }
     }
-    if (this._deps.gitHnsw && this._deps.gitHnsw.size > 0) {
-      const hits = this._deps.gitHnsw.search(queryVec, gitK * 2);
+    if (this._config.gitHnsw && this._config.gitHnsw.size > 0) {
+      const hits = this._config.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(
+        const rows = this._config.db.prepare(
           `SELECT * FROM git_commits WHERE id IN (${placeholders}) AND is_merge = 0`
         ).all(...ids);
         for (const r of rows) {
@@ -272,13 +577,13 @@ var UnifiedSearch = class {
         }
       }
     }
-    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 (this._config.patternHnsw && this._config.patternHnsw.size > 0) {
+      const hits = useMMR ? searchMMR(this._config.patternHnsw, queryVec, this._config.patternVecs, patternK, mmrLambda) : this._config.patternHnsw.search(queryVec, patternK);
       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(
+        const rows = this._config.db.prepare(
           `SELECT * FROM memory_patterns WHERE id IN (${placeholders}) AND success_rate >= 0.5`
         ).all(...ids);
         for (const r of rows) {
@@ -301,7 +606,7 @@ var UnifiedSearch = class {
       }
     }
     results.sort((a, b) => b.score - a.score);
-    if (this._deps.reranker && results.length > 1) {
+    if (this._config.reranker && results.length > 1) {
       return this._rerank(query, results);
     }
     return results;
@@ -314,7 +619,7 @@ var UnifiedSearch = class {
    * Top 11+:  40% retrieval / 60% reranker (trust reranker more)
    */
   async _rerank(query, results) {
-    const reranker = this._deps.reranker;
+    const reranker = this._config.reranker;
     const documents = results.map((r) => r.content);
     const scores = await reranker.rank(query, documents);
     const blended = results.map((r, i) => {
@@ -329,21 +634,7 @@ var UnifiedSearch = class {
   }
 };
 
-// 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
+// src/search/keyword/bm25.ts
 var BM25Search = class {
   constructor(_db) {
     this._db = _db;
@@ -357,7 +648,7 @@ var BM25Search = class {
    * Query syntax: simple words, OR, NOT, "exact phrases", prefix*
    */
   search(query, options = {}) {
-    const { codeK = 8, gitK = 5, memoryK = 4 } = options;
+    const { codeK = 8, gitK = 5, patternK = 4 } = options;
     const results = [];
     const ftsQuery = sanitizeFTS(query);
     if (!ftsQuery) return [];
@@ -424,7 +715,7 @@ var BM25Search = class {
       } catch {
       }
     }
-    if (memoryK > 0) {
+    if (patternK > 0) {
       try {
         const rows = this._db.prepare(`
                     SELECT p.id, p.task_type, p.task, p.approach, p.outcome,
@@ -435,7 +726,7 @@ var BM25Search = class {
                     WHERE fts_patterns MATCH ? AND p.success_rate >= 0.5
                     ORDER BY score ASC
                     LIMIT ?
-                `).all(ftsQuery, memoryK);
+                `).all(ftsQuery, patternK);
         for (const r of rows) {
           results.push({
             type: "pattern",
@@ -470,7 +761,7 @@ var BM25Search = class {
   }
 };
 
-// src/query/context-builder.ts
+// src/app/context-builder.ts
 var ContextBuilder = class {
   constructor(_search, _coEdits) {
     this._search = _search;
@@ -487,7 +778,7 @@ var ContextBuilder = class {
     const {
       codeResults = 6,
       gitResults = 5,
-      memoryResults = 4,
+      patternResults = 4,
       affectedFiles = [],
       minScore = 0.25,
       useMMR = true,
@@ -496,7 +787,7 @@ var ContextBuilder = class {
     const results = await this._search.search(task, {
       codeK: codeResults,
       gitK: gitResults,
-      memoryK: memoryResults,
+      patternK: patternResults,
       minScore,
       useMMR,
       mmrLambda
@@ -544,7 +835,7 @@ var ContextBuilder = class {
         parts.push("");
       }
     }
-    if (affectedFiles.length > 0) {
+    if (affectedFiles.length > 0 && this._coEdits) {
       const coEditLines = [];
       for (const file of affectedFiles.slice(0, 3)) {
         const suggestions = this._coEdits.suggest(file, 4);
@@ -560,7 +851,7 @@ var ContextBuilder = class {
         parts.push("");
       }
     }
-    const memHits = results.filter((r) => r.type === "pattern").slice(0, memoryResults);
+    const memHits = results.filter((r) => r.type === "pattern").slice(0, patternResults);
     if (memHits.length > 0) {
       parts.push("## Learned Patterns\n");
       for (const p of memHits) {
@@ -578,241 +869,97 @@ var ContextBuilder = class {
   }
 };
 
-// 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;
-  }
+// src/app/brainbank.ts
+import { EventEmitter } from "events";
+
+// src/app/registry.ts
+var ALIASES = {};
+var IndexerRegistry = class {
   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);
+    __name(this, "IndexerRegistry");
   }
-  /** Count items in this collection. */
-  count() {
-    return this._db.prepare(
-      "SELECT COUNT(*) as c FROM kv_data WHERE collection = ?"
-    ).get(this._name).c;
+  _map = /* @__PURE__ */ new Map();
+  // ── Registration ────────────────────────────────
+  /** Store an indexer. Duplicate names silently overwrite. */
+  register(indexer) {
+    this._map.set(indexer.name, indexer);
   }
-  /** 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);
+  // ── Lookup ──────────────────────────────────────
+  /**
+   * Check whether an indexer is registered.
+   * Supports type-prefix matching: `has('code')` returns true if
+   * 'code', 'code:frontend', or 'code:backend' is registered.
+   */
+  has(name) {
+    if (this._map.has(name)) return true;
+    for (const key of this._map.keys()) {
+      if (key.startsWith(name + ":")) return true;
     }
-    return { removed: toRemove.length };
+    return false;
   }
-  /** 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 };
+  /**
+   * Get an indexer by name.  Throws a descriptive error if not found.
+   *
+   * Resolution order:
+   *   1. Alias map   (currently empty)
+   *   2. Exact match
+   *   3. First type-prefix match  ('code' → 'code:frontend')
+   */
+  get(name) {
+    const resolved = ALIASES[name] ?? name;
+    const exact = this._map.get(resolved);
+    if (exact) return exact;
+    const prefixed = this.firstByType(name);
+    if (prefixed) return prefixed;
+    throw new Error(
+      `BrainBank: Indexer '${name}' is not loaded. Add .use(${name}()) to your BrainBank instance.`
+    );
   }
-  /** Remove a specific item by ID. */
-  remove(id) {
-    this._removeById(id);
+  /**
+   * Return every indexer whose name equals `type` or starts with `type + ':'`.
+   * Example: allByType('code') → [code, code:frontend, code:backend]
+   */
+  allByType(type) {
+    return [...this._map.values()].filter(
+      (m) => m.name === type || m.name.startsWith(type + ":")
+    );
   }
-  /** 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);
+  /** Return the first indexer that matches the type prefix, or undefined. */
+  firstByType(type) {
+    for (const m of this._map.values()) {
+      if (m.name === type || m.name.startsWith(type + ":")) return m;
     }
+    return void 0;
   }
-  // ── Private ──────────────────────────────────────
-  _removeById(id) {
-    this._vecs.delete(id);
-    this._db.prepare("DELETE FROM kv_data WHERE id = ?").run(id);
+  // ── Accessors ───────────────────────────────────
+  /** All registered indexer names (insertion order). */
+  get names() {
+    return [...this._map.keys()];
   }
-  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);
+  /** All registered indexer instances (insertion order). */
+  get all() {
+    return [...this._map.values()];
   }
-  _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))
-    );
+  /**
+   * Underlying Map.
+   * Prefer `all`, `allByType`, or `firstByType` everywhere else.
+   */
+  get raw() {
+    return this._map;
   }
-  /** 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);
-    }
+  // ── Lifecycle ───────────────────────────────────
+  /** Remove all registered indexers. Called by BrainBank.close(). */
+  clear() {
+    this._map.clear();
   }
 };
-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
+// src/db/database.ts
 import BetterSqlite3 from "better-sqlite3";
 import * as fs from "fs";
 import * as path2 from "path";
 
-// src/core/schema.ts
+// src/db/schema.ts
 var SCHEMA_VERSION = 4;
 function createSchema(db) {
   db.exec(`
@@ -1123,7 +1270,7 @@ function createSchema(db) {
 }
 __name(createSchema, "createSchema");
 
-// src/storage/database.ts
+// src/db/database.ts
 var Database = class {
   static {
     __name(this, "Database");
@@ -1175,7 +1322,7 @@ var Database = class {
   }
 };
 
-// src/core/reembed.ts
+// src/services/reembed.ts
 var TABLES = [
   {
     name: "code",
@@ -1195,9 +1342,14 @@ var TABLES = [
     vectorTable: "git_vectors",
     idColumn: "id",
     fkColumn: "commit_id",
+    // Must match git-engine.ts:119-125 exactly
     textBuilder: /* @__PURE__ */ __name((r) => [
-      r.message,
-      r.diff ?? ""
+      `Commit: ${r.message}`,
+      `Author: ${r.author}`,
+      `Date: ${r.date}`,
+      r.files_json && r.files_json !== "[]" ? `Files: ${JSON.parse(r.files_json).join(", ")}` : "",
+      r.diff ? `Changes:
+${r.diff.slice(0, 2e3)}` : ""
     ].filter(Boolean).join("\n"), "textBuilder")
   },
   {
@@ -1206,12 +1358,8 @@ var TABLES = [
     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")
+    // Must match memory/pattern-store.ts:49 exactly
+    textBuilder: /* @__PURE__ */ __name((r) => `${r.task_type} ${r.task} ${r.approach}`, "textBuilder")
   },
   {
     name: "notes",
@@ -1219,12 +1367,15 @@ var TABLES = [
     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")
+    // Must match notes/engine.ts:90 exactly
+    textBuilder: /* @__PURE__ */ __name((r) => {
+      const decisions = JSON.parse(r.decisions_json || "[]").join(". ");
+      const patterns = JSON.parse(r.patterns_json || "[]").join(". ");
+      return `${r.title}
+${r.summary}
+${decisions}
+${patterns}`;
+    }, "textBuilder")
   },
   {
     name: "docs",
@@ -1232,10 +1383,8 @@ var TABLES = [
     vectorTable: "doc_vectors",
     idColumn: "id",
     fkColumn: "chunk_id",
-    textBuilder: /* @__PURE__ */ __name((r) => [
-      r.title ? `# ${r.title}` : "",
-      r.content
-    ].filter(Boolean).join("\n"), "textBuilder")
+    // Must match docs-engine.ts:160 exactly
+    textBuilder: /* @__PURE__ */ __name((r) => `title: ${r.title ?? ""} | text: ${r.content}`, "textBuilder")
   },
   {
     name: "kv",
@@ -1282,39 +1431,45 @@ async function reembedAll(db, embedding, hnswMap, options = {}) {
 }
 __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 (?, ?)`
-  );
+  const totalCount = db.prepare(
+    `SELECT COUNT(*) as c FROM ${table.textTable}`
+  ).get().c;
+  if (totalCount === 0) return 0;
+  const allNewVectors = [];
   let processed = 0;
-  for (let i = 0; i < rows.length; i += batchSize) {
-    const batch = rows.slice(i, i + batchSize);
+  for (let offset = 0; offset < totalCount; offset += batchSize) {
+    const batch = db.prepare(
+      `SELECT * FROM ${table.textTable} LIMIT ? OFFSET ?`
+    ).all(batchSize, offset);
     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));
-      }
-    });
+    for (let j = 0; j < batch.length; j++) {
+      allNewVectors.push({ id: batch[j][table.idColumn], vec: vectors[j] });
+    }
     processed += batch.length;
-    onProgress?.(table.name, processed, rows.length);
+    onProgress?.(table.name, processed, totalCount);
   }
+  const insertVec = db.prepare(
+    `INSERT INTO ${table.vectorTable} (${table.fkColumn}, embedding) VALUES (?, ?)`
+  );
+  db.transaction(() => {
+    db.prepare(`DELETE FROM ${table.vectorTable}`).run();
+    for (const { id, vec } of allNewVectors) {
+      insertVec.run(id, Buffer.from(vec.buffer));
+    }
+  });
   return processed;
 }
 __name(reembedTable, "reembedTable");
 async function rebuildHnsw(db, table, hnsw, vecs) {
   vecs.clear();
+  hnsw.reinit();
   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);
+    const buf = Buffer.from(row.embedding);
+    const vec = new Float32Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength));
     hnsw.add(vec, row.id);
     vecs.set(row.id, vec);
   }
@@ -1357,7 +1512,296 @@ function detectProviderMismatch(db, embedding) {
 }
 __name(detectProviderMismatch, "detectProviderMismatch");
 
-// src/core/watch.ts
+// src/app/initializer.ts
+async function earlyInit(config, emit) {
+  const db = new Database(config.dbPath);
+  const embedding = config.embeddingProvider ?? new LocalEmbedding();
+  const mismatch = detectProviderMismatch(db, embedding);
+  const skipVectorLoad = !!mismatch?.mismatch;
+  if (skipVectorLoad) {
+    emit("warning", {
+      type: "provider_mismatch",
+      previous: mismatch.stored,
+      current: mismatch.current,
+      message: "Embedding provider changed \u2014 vectors not loaded. Run brain.reembed() to regenerate."
+    });
+  }
+  setEmbeddingMeta(db, embedding);
+  const kvHnsw = new HNSWIndex(
+    config.embeddingDims,
+    config.maxElements ?? 5e5,
+    config.hnswM,
+    config.hnswEfConstruction,
+    config.hnswEfSearch
+  );
+  await kvHnsw.init();
+  return { db, embedding, kvHnsw, skipVectorLoad };
+}
+__name(earlyInit, "earlyInit");
+async function lateInit(early, config, registry, sharedHnsw, kvVecs, getCollection) {
+  const { db, embedding, kvHnsw, skipVectorLoad } = early;
+  if (!skipVectorLoad) {
+    loadVectors(db, "kv_vectors", "data_id", kvHnsw, kvVecs);
+  }
+  const ctx = {
+    db,
+    embedding,
+    config,
+    createHnsw: /* @__PURE__ */ __name((maxElements) => new HNSWIndex(
+      config.embeddingDims,
+      maxElements ?? config.maxElements,
+      config.hnswM,
+      config.hnswEfConstruction,
+      config.hnswEfSearch
+    ).init(), "createHnsw"),
+    loadVectors: /* @__PURE__ */ __name((table, idCol, hnsw, cache) => {
+      if (skipVectorLoad) return;
+      loadVectors(db, table, idCol, hnsw, cache);
+    }, "loadVectors"),
+    getOrCreateSharedHnsw: /* @__PURE__ */ __name(async (type, maxElements) => {
+      const existing = 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();
+      sharedHnsw.set(type, { hnsw, vecCache });
+      return { hnsw, vecCache, isNew: true };
+    }, "getOrCreateSharedHnsw"),
+    collection: getCollection
+  };
+  for (const mod of registry.all) {
+    await mod.initialize(ctx);
+  }
+  const codeMod = sharedHnsw.get("code");
+  const gitMod = sharedHnsw.get("git");
+  const memMod = registry.firstByType("memory");
+  let search;
+  let bm25;
+  let contextBuilder;
+  if (codeMod || gitMod || memMod) {
+    search = new MultiIndexSearch({
+      db,
+      codeHnsw: codeMod?.hnsw,
+      gitHnsw: gitMod?.hnsw,
+      patternHnsw: memMod?.hnsw,
+      codeVecs: codeMod?.vecCache ?? /* @__PURE__ */ new Map(),
+      gitVecs: gitMod?.vecCache ?? /* @__PURE__ */ new Map(),
+      patternVecs: memMod?.vecCache ?? /* @__PURE__ */ new Map(),
+      embedding,
+      reranker: config.reranker
+    });
+    bm25 = new BM25Search(db);
+  }
+  if (search) {
+    const firstGit = registry.firstByType("git");
+    contextBuilder = new ContextBuilder(search, firstGit?.coEdits);
+  }
+  return { search, bm25, contextBuilder };
+}
+__name(lateInit, "lateInit");
+function loadVectors(db, table, idCol, hnsw, cache) {
+  const rows = 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);
+  }
+}
+__name(loadVectors, "loadVectors");
+
+// src/app/search-api.ts
+var SearchAPI = class {
+  constructor(_d) {
+    this._d = _d;
+  }
+  static {
+    __name(this, "SearchAPI");
+  }
+  // ── Vector ──────────────────────────────────────
+  async search(query, options) {
+    if (!this._d.search) {
+      return this._d.registry.has("docs") ? this._d.searchDocs(query, { k: 8 }) : [];
+    }
+    return this._d.search.search(query, options);
+  }
+  async searchCode(query, k = 8) {
+    if (!this._d.registry.firstByType("code"))
+      throw new Error("BrainBank: Indexer 'code' is not loaded. Add .use(code()) to your BrainBank instance.");
+    if (!this._d.search)
+      throw new Error("BrainBank: MultiIndexSearch not available. Ensure code indexer is loaded.");
+    return this._d.search.search(query, { codeK: k, gitK: 0, patternK: 0 });
+  }
+  async searchCommits(query, k = 8) {
+    if (!this._d.registry.firstByType("git"))
+      throw new Error("BrainBank: Indexer 'git' is not loaded. Add .use(git()) to your BrainBank instance.");
+    if (!this._d.search)
+      throw new Error("BrainBank: MultiIndexSearch not available. Ensure git indexer is loaded.");
+    return this._d.search.search(query, { codeK: 0, gitK: k, patternK: 0 });
+  }
+  // ── Hybrid ──────────────────────────────────────
+  async hybridSearch(query, options) {
+    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._d.search) {
+      const [vec, kw] = await Promise.all([
+        this._d.search.search(query, { ...options, codeK, gitK }),
+        Promise.resolve(this._d.bm25.search(query, { codeK, gitK }))
+      ]);
+      resultLists.push(vec, kw);
+    }
+    if (this._d.registry.has("docs")) {
+      const docs = await this._d.searchDocs(query, { k: docsK });
+      if (docs.length > 0) resultLists.push(docs);
+    }
+    const reserved = /* @__PURE__ */ new Set(["code", "git", "docs"]);
+    for (const [name, k] of Object.entries(cols)) {
+      if (reserved.has(name)) continue;
+      const hits = await this._d.collection(name).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._d.config.reranker && fused.length > 1) {
+      const scores = await this._d.config.reranker.rank(query, fused.map((r) => r.content));
+      return fused.map((r, i) => {
+        const w = i < 3 ? 0.75 : i < 10 ? 0.6 : 0.4;
+        return { ...r, score: w * r.score + (1 - w) * (scores[i] ?? 0) };
+      }).sort((a, b) => b.score - a.score);
+    }
+    return fused;
+  }
+  // ── Keyword ─────────────────────────────────────
+  searchBM25(query, options) {
+    return this._d.bm25?.search(query, options) ?? [];
+  }
+  rebuildFTS() {
+    this._d.bm25?.rebuild();
+  }
+  // ── Context ─────────────────────────────────────
+  async getContext(task, options = {}) {
+    const sections = [];
+    if (this._d.contextBuilder) {
+      const core = await this._d.contextBuilder.build(task, options);
+      if (core) sections.push(core);
+    }
+    if (this._d.registry.has("docs")) {
+      const docs = await this._d.searchDocs(task, { k: options.codeResults ?? 4 });
+      if (docs.length > 0) {
+        const body = docs.map((r) => {
+          const m = r.metadata;
+          const h = r.context ? `**[${m.collection}]** ${m.title} \u2014 _${r.context}_` : `**[${m.collection}]** ${m.title}`;
+          return `${h}
+
+${r.content}`;
+        }).join("\n\n---\n\n");
+        sections.push(`## Relevant Documents
+
+${body}`);
+      }
+    }
+    return sections.join("\n\n");
+  }
+};
+
+// src/app/index-api.ts
+var IndexAPI = class {
+  constructor(_d) {
+    this._d = _d;
+  }
+  static {
+    __name(this, "IndexAPI");
+  }
+  async index(options = {}) {
+    const want = new Set(options.modules ?? ["code", "git", "docs"]);
+    const result = {};
+    if (want.has("code")) {
+      for (const mod of this._d.registry.allByType("code")) {
+        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;
+        }
+      }
+    }
+    if (want.has("git")) {
+      for (const mod of this._d.registry.allByType("git")) {
+        const label = mod.name === "git" ? "git" : mod.name;
+        options.onProgress?.(label, "Starting...");
+        const r = await mod.index({
+          depth: options.gitDepth ?? this._d.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;
+        }
+      }
+    }
+    if (want.has("docs") && this._d.registry.has("docs")) {
+      options.onProgress?.("docs", "Starting...");
+      result.docs = await this._d.registry.get("docs").indexCollections({
+        onProgress: /* @__PURE__ */ __name((coll, file, cur, total) => options.onProgress?.("docs", `[${coll}] ${cur}/${total}: ${file}`), "onProgress")
+      });
+    }
+    this._d.emit("indexed", result);
+    return result;
+  }
+  async indexCode(options = {}) {
+    const mods = this._d.registry.allByType("code");
+    if (!mods.length) throw new Error("BrainBank: Indexer 'code' is not loaded. Add .use(code()) to your BrainBank instance.");
+    const acc = { indexed: 0, skipped: 0, chunks: 0 };
+    for (const mod of mods) {
+      const r = await mod.index(options);
+      acc.indexed += r.indexed;
+      acc.skipped += r.skipped;
+      acc.chunks = (acc.chunks ?? 0) + (r.chunks ?? 0);
+    }
+    return acc;
+  }
+  async indexGit(options = {}) {
+    const mods = this._d.registry.allByType("git");
+    if (!mods.length) throw new Error("BrainBank: Indexer 'git' is not loaded. Add .use(git()) to your BrainBank instance.");
+    const acc = { indexed: 0, skipped: 0 };
+    for (const mod of mods) {
+      const r = await mod.index(options);
+      acc.indexed += r.indexed;
+      acc.skipped += r.skipped;
+    }
+    return acc;
+  }
+};
+
+// src/services/watch.ts
 import * as fs2 from "fs";
 import * as path3 from "path";
 function createWatcher(reindexFn, indexers, repoPath, options = {}) {
@@ -1457,7 +1901,8 @@ function createWatcher(reindexFn, indexers, repoPath, options = {}) {
   for (const watchPath of paths) {
     const resolved = path3.resolve(watchPath);
     try {
-      const watcher = fs2.watch(resolved, { recursive: true }, (_event, filename) => {
+      const supportsRecursive = process.platform === "darwin" || process.platform === "win32";
+      const watcher = fs2.watch(resolved, { recursive: supportsRecursive }, (_event, filename) => {
         if (!active || !filename) return;
         if (!shouldWatch(filename)) return;
         pending.add(filename);
@@ -1486,92 +1931,56 @@ function createWatcher(reindexFn, indexers, repoPath, options = {}) {
 }
 __name(createWatcher, "createWatcher");
 
-// src/core/brainbank.ts
+// src/app/brainbank.ts
 var BrainBank = class extends EventEmitter {
   static {
     __name(this, "BrainBank");
   }
+  // ── State ───────────────────────────────────────
   _config;
   _db;
   _embedding;
-  _modules = /* @__PURE__ */ new Map();
-  // Cross-module search (created if code/git/memory are present)
-  _search;
-  _bm25;
-  _contextBuilder;
+  _registry = new IndexerRegistry();
+  _searchAPI;
+  _indexAPI;
   _initialized = false;
+  _initPromise = null;
   _watcher;
-  // Collections
+  // Collections (KV store)
   _collections = /* @__PURE__ */ new Map();
   _kvHnsw;
   _kvVecs = /* @__PURE__ */ new Map();
-  // Shared HNSW pool for multi-repo (code:frontend, code:backend share one HNSW)
+  // Shared HNSW pool — code:frontend + code:backend share one index
   _sharedHnsw = /* @__PURE__ */ new Map();
   constructor(config = {}) {
     super();
     this._config = resolveConfig(config);
   }
-  // ── Indexer Registration ────────────────────────
+  // ── 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);
+    if (this._initialized)
+      throw new Error(`BrainBank: Cannot add indexer '${indexer.name}' after initialization. Call .use() before any operations.`);
+    this._registry.register(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;
+    return this._registry.names;
   }
   /** 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;
+    return this._registry.has(name);
   }
   /** 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;
+  indexer(n) {
+    return this._registry.get(n);
   }
-  // ── Initialization ──────────────────────────────
+  // ── Initialization ───────────────────────────────
   /**
    * Initialize database, HNSW indices, and load existing vectors.
    * Only initializes registered modules.
@@ -1579,339 +1988,184 @@ var BrainBank = class extends EventEmitter {
    */
   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
+    if (this._initPromise) return this._initPromise;
+    this._initPromise = this._runInitialize().catch((err) => {
+      for (const { hnsw } of this._sharedHnsw.values()) try {
+        hnsw.reinit();
+      } catch {
+      }
+      this._kvVecs.clear();
+      if (this._kvHnsw) try {
+        this._kvHnsw.reinit();
+      } catch {
+      }
+      try {
+        this._db?.close();
+      } catch {
+      }
+      this._db = void 0;
+      this._kvHnsw = void 0;
+      this._searchAPI = void 0;
+      this._indexAPI = void 0;
+      throw err;
+    }).finally(() => {
+      this._initPromise = null;
+    });
+    return this._initPromise;
+  }
+  async _runInitialize() {
+    if (this._initialized) return;
+    const early = await earlyInit(this._config, (e, d) => this.emit(e, d));
+    this._db = early.db;
+    this._embedding = early.embedding;
+    this._kvHnsw = early.kvHnsw;
+    const late = await lateInit(
+      early,
+      this._config,
+      this._registry,
+      this._sharedHnsw,
+      this._kvVecs,
+      (name) => this.collection(name)
     );
-    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._searchAPI = new SearchAPI({
+      ...late,
+      registry: this._registry,
+      config: this._config,
+      searchDocs: /* @__PURE__ */ __name((q, o) => this.searchDocs(q, o), "searchDocs"),
+      collection: /* @__PURE__ */ __name((n) => this.collection(n), "collection")
+    });
+    this._indexAPI = new IndexAPI({
+      registry: this._registry,
+      gitDepth: this._config.gitDepth,
+      emit: /* @__PURE__ */ __name((e, d) => this.emit(e, d), "emit")
+    });
     this._initialized = true;
     this.emit("initialized", { indexers: this.indexers });
   }
-  // ── Collections ─────────────────────────────────
+  // ── Collections (KV) ────────────────────────────
   /**
    * 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);
+    if (this._collections.has(name)) return this._collections.get(name);
+    if (!this._kvHnsw)
+      throw new Error("BrainBank: Collections not ready. Call await brain.initialize() first.");
+    const 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);
+    this._requireInit("listCollectionNames");
+    return this._db.prepare("SELECT DISTINCT collection FROM kv_data ORDER BY collection").all().map((r) => r.collection);
   }
-  // ── Indexing ─────────────────────────────────────
-  /**
-   * Index code, git, and/or docs in one call.
-   * Incremental — only processes changes since last run.
-   * @param modules - Which modules to index. Default: all available (['code', 'git', 'docs'])
-   */
+  // ── Indexing (delegated to IndexAPI) ─────────────
   async index(options = {}) {
     await this.initialize();
-    const want = new Set(options.modules ?? ["code", "git", "docs"]);
-    const result = {};
-    if (want.has("code")) {
-      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;
-        }
-      }
-    }
-    if (want.has("git")) {
-      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;
-        }
-      }
-    }
-    if (want.has("docs") && this._modules.has("docs")) {
-      options.onProgress?.("docs", "Starting...");
-      const docsResults = await this.module("docs").indexCollections({
-        onProgress: /* @__PURE__ */ __name((coll, file, cur, total) => options.onProgress?.("docs", `[${coll}] ${cur}/${total}: ${file}`), "onProgress")
-      });
-      result.docs = docsResults;
-    }
-    this.emit("indexed", result);
-    return result;
+    return this._indexAPI.index(options);
   }
-  /** Index only code files. */
+  /** Index only code files (all repos in multi-repo mode). */
   async indexCode(options = {}) {
     await this.initialize();
-    return this.module("code").index(options);
+    return this._indexAPI.indexCode(options);
   }
-  /** Index only git history. */
+  /** Index only git history (all repos in multi-repo mode). */
   async indexGit(options = {}) {
     await this.initialize();
-    return this.module("git").index(options);
+    return this._indexAPI.indexGit(options);
   }
-  // ── Document Collections ────────────────────────
+  // ── Document collections ─────────────────────────
   /** Register a document collection. */
   async addCollection(collection) {
     await this.initialize();
-    this.module("docs").addCollection(collection);
+    this.indexer("docs").addCollection(collection);
   }
   /** Remove a collection and all its indexed data. */
   async removeCollection(name) {
     await this.initialize();
-    this.module("docs").removeCollection(name);
+    this.indexer("docs").removeCollection(name);
   }
   /** List all registered collections. */
   listCollections() {
-    return this.module("docs").listCollections();
+    this._requireInit("listCollections");
+    return this.indexer("docs").listCollections();
   }
   /** Index all (or specific) document collections. */
   async indexDocs(options = {}) {
     await this.initialize();
-    const results = await this.module("docs").indexCollections(options);
+    const results = await this.indexer("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);
+    return this.indexer("docs").search(query, options);
   }
-  // ── Context Metadata ────────────────────────────
+  // ── Context metadata ─────────────────────────────
   /** Add context description for a collection path. */
   addContext(collection, path4, context) {
-    this.module("docs").addContext(collection, path4, context);
+    this.indexer("docs").addContext(collection, path4, context);
   }
   /** Remove context for a collection path. */
   removeContext(collection, path4) {
-    this.module("docs").removeContext(collection, path4);
+    this.indexer("docs").removeContext(collection, path4);
   }
   /** List all context entries. */
   listContexts() {
-    return this.module("docs").listContexts();
+    return this.indexer("docs").listContexts();
   }
-  // ── Context ─────────────────────────────────────
+  // ── Search (delegated to SearchAPI) ─────────────
   /**
    * 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");
+    return this._searchAPI.getContext(task, options);
   }
-  // ── 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);
+    return this._searchAPI.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 });
+    return this._searchAPI.searchCode(query, k);
   }
   /** 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 });
+    return this._searchAPI.searchCommits(query, k);
   }
-  // ── 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;
+    return this._searchAPI.hybridSearch(query, options);
   }
   /** BM25 keyword search only (no embeddings needed). */
   searchBM25(query, options) {
-    if (!this._bm25) return [];
-    return this._bm25.search(query, options);
+    this._requireInit("searchBM25");
+    return this._searchAPI.searchBM25(query, options);
   }
   /** Rebuild FTS5 indices. */
   rebuildFTS() {
-    this._bm25?.rebuild();
+    this._requireInit("rebuildFTS");
+    this._searchAPI.rebuildFTS();
   }
-  // ── Query ───────────────────────────────────────
+  // ── Queries ──────────────────────────────────────
   /** Get git history for a specific file. */
   async fileHistory(filePath, limit = 20) {
-    this.module("git");
+    this.indexer("git");
     await this.initialize();
     return this._db.prepare(`
             SELECT c.short_hash, c.message, c.author, c.date, c.additions, c.deletions
@@ -1923,97 +2177,71 @@ ${docSection}`);
   }
   /** Get co-edit suggestions for a file. */
   coEdits(filePath, limit = 5) {
-    const gitMod = this.module("git");
-    return gitMod.suggest(filePath, limit);
+    this._requireInit("coEdits");
+    return this.indexer("git").suggestCoEdits(filePath, limit);
   }
-  // ── Stats ───────────────────────────────────────
+  // ── Stats ────────────────────────────────────────
   /** Get statistics for all loaded modules. */
   stats() {
+    this._requireInit("stats");
     const result = {};
     if (this.has("code")) {
-      const mod = this.indexer("code");
+      const sh = this._sharedHnsw.get("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
+        hnswSize: sh?.hnsw.size ?? 0
       };
     }
     if (this.has("git")) {
-      const mod = this.indexer("git");
+      const sh = this._sharedHnsw.get("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
+        hnswSize: sh?.hnsw.size ?? 0
       };
     }
     if (this.has("docs")) {
-      const mod = this.indexer("docs");
-      result.documents = mod.stats();
+      result.documents = this.indexer("docs").stats();
     }
     return result;
   }
-  // ── Watch Mode ───────────────────────────────────
+  // ── Watch ────────────────────────────────────────
   /**
    * 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._requireInit("watch");
     this._watcher?.close();
     this._watcher = createWatcher(
       async () => {
         await this.index();
       },
-      this._modules,
+      this._registry.raw,
       this._config.repoPath,
       options
     );
     return this._watcher;
   }
-  // ── Re-embedding ────────────────────────────────
+  // ── Re-embed ─────────────────────────────────────
   /**
    * 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().");
-    }
+    this._requireInit("reembed");
     const hnswMap = /* @__PURE__ */ new Map();
-    if (this._kvHnsw) {
-      hnswMap.set("kv", { hnsw: this._kvHnsw, vecs: this._kvVecs });
+    if (this._kvHnsw) hnswMap.set("kv", { hnsw: this._kvHnsw, vecs: this._kvVecs });
+    for (const [type, shared] of this._sharedHnsw) {
+      hnswMap.set(type, { hnsw: shared.hnsw, vecs: shared.vecCache });
     }
-    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
-    );
+    for (const type of ["memory", "notes", "docs"]) {
+      const mod = this._registry.firstByType(type);
+      if (mod?.hnsw) hnswMap.set(type, { hnsw: mod.hnsw, vecs: mod.vecCache });
+    }
+    const result = await reembedAll(this._db, this._embedding, hnswMap, options);
     this.emit("reembedded", result);
     return result;
   }
@@ -2021,12 +2249,16 @@ ${docSection}`);
   /** Close database and release resources. */
   close() {
     this._watcher?.close();
-    for (const indexer of this._modules.values()) {
-      indexer.close?.();
-    }
-    if (this._db) this._db.close();
+    for (const indexer of this._registry.all) indexer.close?.();
+    this._db?.close();
     this._initialized = false;
     this._collections.clear();
+    this._sharedHnsw.clear();
+    this._kvVecs.clear();
+    this._kvHnsw = void 0;
+    this._searchAPI = void 0;
+    this._indexAPI = void 0;
+    this._registry.clear();
   }
   /** Whether the brainbank has been initialized. */
   get isInitialized() {
@@ -2036,31 +2268,23 @@ ${docSection}`);
   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);
-    }
+  // ── Internal guard ───────────────────────────────
+  _requireInit(method) {
+    if (!this._initialized)
+      throw new Error(`BrainBank: Not initialized. Call await brain.initialize() before ${method}().`);
   }
 };
 
 export {
   DEFAULTS,
   resolveConfig,
+  Collection,
   HNSWIndex,
   LocalEmbedding,
   searchMMR,
-  UnifiedSearch,
+  MultiIndexSearch,
   BM25Search,
   ContextBuilder,
-  Collection,
   BrainBank
 };
-//# sourceMappingURL=chunk-TW5NTYYZ.js.map
+//# sourceMappingURL=chunk-6MFTQV3O.js.map