brainbank 0.7.0 → 0.8.0

package/dist/chunk-JRVYSTMP.js

@@ -0,0 +1,3256 @@
+import {
+  isBM25SearchPlugin,
+  isContextFieldPlugin,
+  isContextFormatterPlugin,
+  isDocsPlugin,
+  isExpandablePlugin,
+  isFileResolvable,
+  isIndexable,
+  isReembeddable,
+  isSearchable,
+  isVectorSearchPlugin,
+  isWatchable
+} from "./chunk-E3J37GDA.js";
+import {
+  providerKey,
+  resolveEmbedding
+} from "./chunk-7T2ZCZQA.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/config.ts
+import * as path from "path";
+var DEFAULTS = {
+  repoPath: ".",
+  dbPath: ".brainbank/data/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,
+    pruner: partial.pruner,
+    expander: partial.expander,
+    webhookPort: partial.webhookPort,
+    contextFields: partial.contextFields
+  };
+}
+__name(resolveConfig, "resolveConfig");
+
+// src/constants.ts
+var HNSW = {
+  KV: "kv"
+};
+
+// src/db/sqlite-adapter.ts
+import BetterSqlite3 from "better-sqlite3";
+import * as fs from "fs";
+import * as path2 from "path";
+var SCHEMA_VERSION = 9;
+function createSchema(adapter) {
+  adapter.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 Plugin Versions (migration tracking) \u2500\u2500\u2500\u2500\u2500\u2500
+        CREATE TABLE IF NOT EXISTS plugin_versions (
+            plugin_name TEXT    PRIMARY KEY,
+            version     INTEGER NOT NULL,
+            applied_at  INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        -- \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
+        );
+
+        -- \u2500\u2500 Index State (cross-process coordination) \u2500
+        CREATE TABLE IF NOT EXISTS index_state (
+            name       TEXT    PRIMARY KEY,
+            version    INTEGER NOT NULL DEFAULT 0,
+            writer_pid INTEGER NOT NULL DEFAULT 0,
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        -- \u2500\u2500 Plugin Tracking (incremental indexing) \u2500\u2500\u2500\u2500
+        CREATE TABLE IF NOT EXISTS plugin_tracking (
+            plugin       TEXT NOT NULL,
+            key          TEXT NOT NULL,
+            content_hash TEXT NOT NULL,
+            indexed_at   INTEGER NOT NULL DEFAULT (unixepoch()),
+            PRIMARY KEY (plugin, key)
+        );
+    `);
+}
+__name(createSchema, "createSchema");
+function wrapStatement(stmt) {
+  return {
+    get(...params) {
+      return stmt.get(...params);
+    },
+    all(...params) {
+      return stmt.all(...params);
+    },
+    run(...params) {
+      const info = stmt.run(...params);
+      return {
+        lastInsertRowid: info.lastInsertRowid,
+        changes: info.changes
+      };
+    },
+    iterate(...params) {
+      return stmt.iterate(...params);
+    }
+  };
+}
+__name(wrapStatement, "wrapStatement");
+var SQLiteAdapter = class {
+  static {
+    __name(this, "SQLiteAdapter");
+  }
+  _db;
+  capabilities = {
+    fts: "fts5",
+    upsert: "or-replace",
+    json: true,
+    vectors: false
+  };
+  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("busy_timeout = 5000");
+    this._db.pragma("synchronous = NORMAL");
+    this._db.pragma("foreign_keys = ON");
+    createSchema(this);
+  }
+  /** Prepare a reusable statement. */
+  prepare(sql) {
+    return wrapStatement(this._db.prepare(sql));
+  }
+  /** Execute raw SQL (no results). */
+  exec(sql) {
+    this._db.exec(sql);
+  }
+  /** 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. */
+  batch(sql, rows) {
+    const stmt = this._db.prepare(sql);
+    const tx = this._db.transaction(() => {
+      for (const row of rows) {
+        stmt.run(...row);
+      }
+    });
+    tx();
+  }
+  /** Close the database. */
+  close() {
+    this._db.close();
+  }
+  /**
+   * Access the underlying `better-sqlite3` Database instance.
+   *
+   * @deprecated Use `DatabaseAdapter` methods instead. This exists
+   * only for gradual migration of plugins that depend on driver internals.
+   */
+  raw() {
+    return this._db;
+  }
+};
+
+// src/db/tracker.ts
+function createTracker(db, pluginName) {
+  return {
+    isUnchanged(key, contentHash) {
+      const row = db.prepare(
+        "SELECT content_hash FROM plugin_tracking WHERE plugin = ? AND key = ?"
+      ).get(pluginName, key);
+      return row?.content_hash === contentHash;
+    },
+    markIndexed(key, contentHash) {
+      db.prepare(`
+                INSERT INTO plugin_tracking (plugin, key, content_hash)
+                VALUES (?, ?, ?)
+                ON CONFLICT(plugin, key) DO UPDATE SET
+                    content_hash = excluded.content_hash,
+                    indexed_at = unixepoch()
+            `).run(pluginName, key, contentHash);
+    },
+    findOrphans(currentKeys) {
+      const rows = db.prepare(
+        "SELECT key FROM plugin_tracking WHERE plugin = ?"
+      ).all(pluginName);
+      return rows.filter((r) => !currentKeys.has(r.key)).map((r) => r.key);
+    },
+    remove(key) {
+      db.prepare(
+        "DELETE FROM plugin_tracking WHERE plugin = ? AND key = ?"
+      ).run(pluginName, key);
+    },
+    clear() {
+      db.prepare(
+        "DELETE FROM plugin_tracking WHERE plugin = ?"
+      ).run(pluginName);
+    }
+  };
+}
+__name(createTracker, "createTracker");
+
+// src/db/metadata.ts
+function bumpVersion(db, name) {
+  const row = db.prepare(`
+        INSERT INTO index_state (name, version, writer_pid, updated_at)
+        VALUES (?, 1, ?, unixepoch())
+        ON CONFLICT(name) DO UPDATE SET
+            version    = version + 1,
+            writer_pid = excluded.writer_pid,
+            updated_at = excluded.updated_at
+        RETURNING version
+    `).get(name, process.pid);
+  return row.version;
+}
+__name(bumpVersion, "bumpVersion");
+function getVersions(db) {
+  const rows = db.prepare("SELECT name, version FROM index_state").all();
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    map.set(row.name, row.version);
+  }
+  return map;
+}
+__name(getVersions, "getVersions");
+function getVersion(db, name) {
+  const row = db.prepare("SELECT version FROM index_state WHERE name = ?").get(name);
+  return row?.version ?? 0;
+}
+__name(getVersion, "getVersion");
+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();
+    const key = db.prepare(
+      "SELECT value FROM embedding_meta WHERE key = 'provider_key'"
+    ).get();
+    if (!provider || !dims) return null;
+    return {
+      provider: provider.value,
+      dims: Number(dims.value),
+      providerKey: key?.value ?? "local"
+    };
+  } 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("provider_key", providerKey(embedding));
+  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/lib/write-lock.ts
+import { openSync, closeSync, unlinkSync, readFileSync, writeFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, constants } from "fs";
+import { join as join2 } from "path";
+var MAX_WAIT_MS = 3e4;
+var INITIAL_DELAY_MS = 50;
+function isProcessAlive(pid) {
+  if (isNaN(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isProcessAlive, "isProcessAlive");
+function lockPath(lockDir2, name) {
+  return join2(lockDir2, `${name}.lock`);
+}
+__name(lockPath, "lockPath");
+function tryCreateLock(filePath) {
+  try {
+    const fd = openSync(filePath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
+    writeFileSync(fd, String(process.pid));
+    closeSync(fd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(tryCreateLock, "tryCreateLock");
+async function acquireLock(lockDir2, name) {
+  if (!existsSync2(lockDir2)) {
+    mkdirSync2(lockDir2, { recursive: true });
+  }
+  const fp = lockPath(lockDir2, name);
+  let delay = INITIAL_DELAY_MS;
+  let elapsed = 0;
+  while (true) {
+    if (tryCreateLock(fp)) return;
+    try {
+      const content = readFileSync(fp, "utf-8").trim();
+      const pid = parseInt(content, 10);
+      if (isNaN(pid) || !isProcessAlive(pid)) {
+        try {
+          unlinkSync(fp);
+        } catch {
+        }
+        if (tryCreateLock(fp)) return;
+      }
+    } catch {
+      if (tryCreateLock(fp)) return;
+    }
+    if (elapsed >= MAX_WAIT_MS) {
+      throw new Error(`BrainBank: Could not acquire write lock '${name}' after ${MAX_WAIT_MS}ms. Another process may be indexing.`);
+    }
+    await new Promise((r) => setTimeout(r, delay));
+    elapsed += delay;
+    delay = Math.min(delay * 2, 2e3);
+  }
+}
+__name(acquireLock, "acquireLock");
+function releaseLock(lockDir2, name) {
+  try {
+    unlinkSync(lockPath(lockDir2, name));
+  } catch {
+  }
+}
+__name(releaseLock, "releaseLock");
+async function withLock(lockDir2, name, fn) {
+  await acquireLock(lockDir2, name);
+  try {
+    return await fn();
+  } finally {
+    releaseLock(lockDir2, name);
+  }
+}
+__name(withLock, "withLock");
+
+// src/lib/math.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+  }
+  if (a.length === 0) return 0;
+  let dot = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+__name(cosineSimilarity, "cosineSimilarity");
+function normalize(vec) {
+  let norm = 0;
+  for (let i = 0; i < vec.length; i++) {
+    norm += vec[i] * vec[i];
+  }
+  norm = Math.sqrt(norm);
+  if (norm === 0) return new Float32Array(vec.length);
+  const result = new Float32Array(vec.length);
+  for (let i = 0; i < vec.length; i++) {
+    result[i] = vec[i] / norm;
+  }
+  return result;
+}
+__name(normalize, "normalize");
+function vecToBuffer(vec) {
+  return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+__name(vecToBuffer, "vecToBuffer");
+
+// src/lib/rerank.ts
+async function rerank(query, results, 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);
+}
+__name(rerank, "rerank");
+
+// src/lib/rrf.ts
+function reciprocalRankFusion(resultSets, k = 60, maxResults = 15) {
+  const fused = /* @__PURE__ */ new Map();
+  for (const results of resultSets) {
+    for (let rank = 0; rank < results.length; rank++) {
+      const r = results[rank];
+      const key = resultKey(r);
+      const rrfContribution = 1 / (k + rank + 1);
+      const existing = fused.get(key);
+      if (existing) {
+        existing.rrfScore += rrfContribution;
+        if (r.score > existing.result.score) {
+          existing.result = { ...r };
+        }
+      } else {
+        fused.set(key, {
+          result: { ...r },
+          rrfScore: rrfContribution
+        });
+      }
+    }
+  }
+  const sorted = Array.from(fused.values()).sort((a, b) => b.rrfScore - a.rrfScore).slice(0, maxResults);
+  const maxRRF = sorted[0]?.rrfScore ?? 1;
+  return sorted.map((entry) => ({
+    ...entry.result,
+    score: entry.rrfScore / maxRRF,
+    metadata: {
+      ...entry.result.metadata,
+      rrfScore: entry.rrfScore
+    }
+  }));
+}
+__name(reciprocalRankFusion, "reciprocalRankFusion");
+function resultKey(r) {
+  switch (r.type) {
+    case "code":
+      return `code:${r.filePath}:${r.metadata.startLine}-${r.metadata.endLine}`;
+    case "commit":
+      return `commit:${r.metadata.hash || r.metadata.shortHash}`;
+    case "document":
+      return `document:${r.filePath ?? ""}:${r.metadata.collection ?? ""}:${r.metadata.seq ?? ""}:${r.content?.slice(0, 80)}`;
+    case "collection":
+      return `collection:${r.metadata.id ?? r.content?.slice(0, 80)}`;
+  }
+}
+__name(resultKey, "resultKey");
+function fuseRankedLists(lists, keyFn, scoreFn, k = 60, maxResults = 15) {
+  const fused = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    for (let rank = 0; rank < list.length; rank++) {
+      const item = list[rank];
+      const key = keyFn(item);
+      const contribution = 1 / (k + rank + 1);
+      const score = scoreFn(item);
+      const existing = fused.get(key);
+      if (existing) {
+        existing.rrfScore += contribution;
+        if (score > existing.bestScore) {
+          existing.item = item;
+          existing.bestScore = score;
+        }
+      } else {
+        fused.set(key, { item, rrfScore: contribution, bestScore: score });
+      }
+    }
+  }
+  const sorted = [...fused.values()].sort((a, b) => b.rrfScore - a.rrfScore).slice(0, maxResults);
+  const maxRRF = sorted[0]?.rrfScore ?? 1;
+  return sorted.map((e) => ({ item: e.item, score: e.rrfScore / maxRRF }));
+}
+__name(fuseRankedLists, "fuseRankedLists");
+
+// src/lib/prune.ts
+var MAX_PREVIEW_CHARS = 8e3;
+async function pruneResults(query, results, pruner) {
+  if (results.length <= 1) return results;
+  const items = results.map((r, i) => ({
+    id: i,
+    filePath: r.filePath ?? "unknown",
+    preview: _buildPreview(r.content),
+    metadata: r.metadata
+  }));
+  const keepIds = await pruner.prune(query, items);
+  const validIds = new Set(Array.from({ length: results.length }, (_, i) => i));
+  return keepIds.filter((id) => validIds.has(id)).map((id) => results[id]);
+}
+__name(pruneResults, "pruneResults");
+function _buildPreview(content) {
+  if (content.length <= MAX_PREVIEW_CHARS) return content;
+  const lines = content.split("\n");
+  const totalLines = lines.length;
+  const topCount = Math.floor(totalLines * 0.6);
+  const bottomCount = Math.floor(totalLines * 0.25);
+  const omitted = totalLines - topCount - bottomCount;
+  const topPart = lines.slice(0, topCount).join("\n");
+  const bottomPart = lines.slice(totalLines - bottomCount).join("\n");
+  return `${topPart}
+
+// [... ${omitted} lines omitted ...]
+
+${bottomPart}`;
+}
+__name(_buildPreview, "_buildPreview");
+
+// src/search/bm25-boost.ts
+function filterByPath(results, prefix) {
+  if (!prefix) return results;
+  return results.filter((r) => r.filePath?.startsWith(prefix));
+}
+__name(filterByPath, "filterByPath");
+
+// src/lib/logger.ts
+import * as fs2 from "fs";
+var LOG_PATH = "/tmp/brainbank.log";
+var MAX_BYTES = 10 * 1024 * 1024;
+function logQuery(entry) {
+  try {
+    _truncateIfNeeded();
+    fs2.appendFileSync(LOG_PATH, _formatEntry(entry));
+  } catch {
+  }
+}
+__name(logQuery, "logQuery");
+function _formatEntry(e) {
+  const divider = "\u2550".repeat(70);
+  const lines = [
+    "",
+    divider,
+    `[${(/* @__PURE__ */ new Date()).toISOString()}] ${e.source.toUpperCase()} \xB7 ${e.method}`,
+    `Query: "${e.query}"`,
+    `Embedding: ${e.embedding} | Pruner: ${e.pruner ?? "none"} | Reranker: ${e.reranker ?? "none"}`
+  ];
+  const opts = Object.entries(e.options).filter(([, v]) => v !== void 0);
+  if (opts.length > 0) {
+    const parts = opts.map(
+      ([k, v]) => `${k}: ${typeof v === "object" ? JSON.stringify(v) : String(v)}`
+    );
+    lines.push(parts.join(" | "));
+  }
+  lines.push(`Duration: ${e.durationMs}ms`);
+  lines.push("");
+  const resultCount = e.results.length;
+  const prunedCount = e.pruned?.length ?? 0;
+  const header = prunedCount > 0 ? `Results (${resultCount + prunedCount} \u2192 ${resultCount} after pruning):` : `Results (${resultCount}):`;
+  lines.push(header);
+  for (let i = 0; i < e.results.length; i++) {
+    const r = e.results[i];
+    const pct = Math.round(r.score * 100);
+    const name = r.name ? `[${r.name}]` : "";
+    lines.push(`  #${String(i + 1).padStart(2)}  ${String(pct).padStart(3)}% ${r.filePath.padEnd(45)} ${name}`);
+  }
+  if (e.pruned && e.pruned.length > 0) {
+    lines.push("");
+    lines.push(`Pruned (${e.pruned.length} removed):`);
+    for (const r of e.pruned) {
+      const name = r.name ? `[${r.name}]` : "";
+      lines.push(`  \u2717 ${r.filePath.padEnd(45)} ${name}`);
+    }
+  }
+  lines.push(divider);
+  lines.push("");
+  return lines.join("\n");
+}
+__name(_formatEntry, "_formatEntry");
+function _truncateIfNeeded() {
+  try {
+    const stat = fs2.statSync(LOG_PATH);
+    if (stat.size < MAX_BYTES) return;
+    const content = fs2.readFileSync(LOG_PATH, "utf-8");
+    const half = Math.floor(content.length / 2);
+    const nextEntry = content.indexOf("\n\u2550", half);
+    if (nextEntry > 0) {
+      fs2.writeFileSync(LOG_PATH, "[truncated]\n" + content.slice(nextEntry + 1));
+    }
+  } catch {
+  }
+}
+__name(_truncateIfNeeded, "_truncateIfNeeded");
+
+// src/search/context-builder.ts
+var ContextBuilder = class {
+  constructor(_search, _registry, _pruner, _embedding, _rerankerName, _configFields = {}, _expander) {
+    this._search = _search;
+    this._registry = _registry;
+    this._pruner = _pruner;
+    this._embedding = _embedding;
+    this._rerankerName = _rerankerName;
+    this._configFields = _configFields;
+    this._expander = _expander;
+  }
+  static {
+    __name(this, "ContextBuilder");
+  }
+  /** Set config-level context field defaults (from config.json "context" section). */
+  set configFields(fields) {
+    this._configFields = fields;
+  }
+  /** Set the expander instance. */
+  set expander(expander) {
+    this._expander = expander;
+  }
+  /** Build a full context block for a task. Returns markdown for system prompt. */
+  async build(task, options = {}) {
+    const t0 = Date.now();
+    const src = options.sources ?? {};
+    const { minScore = 0.25, useMMR = true, mmrLambda = 0.7 } = options;
+    let results = this._search ? await this._search.search(task, {
+      sources: src,
+      minScore,
+      useMMR,
+      mmrLambda
+    }) : [];
+    results = filterByPath(results, options.pathPrefix);
+    const pruner = options.pruner ?? this._pruner;
+    const beforePrune = results;
+    if (pruner && results.length > 1) {
+      results = await pruneResults(task, results, pruner);
+    }
+    if (options.excludeFiles && options.excludeFiles.size > 0) {
+      results = results.filter((r) => !r.filePath || !options.excludeFiles.has(r.filePath));
+    }
+    const resolvedFields = this._resolveFields(options);
+    let expanderNote;
+    if (resolvedFields.expander === true && this._expander && results.length > 0) {
+      const expansion = await this._expand(task, results);
+      if (expansion.results.length > 0) {
+        results = [...results, ...expansion.results];
+      }
+      expanderNote = expansion.note;
+    }
+    const parts = [`# Context for: "${task}"
+`];
+    this._appendFormatterResults(results, parts, options, resolvedFields);
+    await this._appendSearchableResults(task, src, minScore, parts);
+    if (expanderNote) {
+      parts.push(`
+## Expansion Notes
+
+${expanderNote}
+`);
+    }
+    const prunedResults = pruner ? beforePrune.filter((r) => !results.includes(r)) : [];
+    logQuery({
+      source: options.source ?? "api",
+      method: "getContext",
+      query: task,
+      embedding: this._embedding ? providerKey(this._embedding) : "unknown",
+      pruner: pruner ? _prunerName(pruner) : null,
+      reranker: this._rerankerName ?? null,
+      options: {
+        sources: src,
+        pathPrefix: options.pathPrefix,
+        minScore,
+        affectedFiles: options.affectedFiles
+      },
+      results: results.map(_toLogResult),
+      pruned: prunedResults.length > 0 ? prunedResults.map(_toLogResult) : void 0,
+      durationMs: Date.now() - t0
+    });
+    return parts.join("\n");
+  }
+  /** Invoke ContextFormatterPlugins. Multi-repo: each plugin formats its own results. */
+  _appendFormatterResults(results, parts, options, resolvedFields) {
+    const fields = resolvedFields ?? this._resolveFields(options);
+    const seenFormatters = /* @__PURE__ */ new Set();
+    for (const mod of this._registry.all) {
+      if (!isContextFormatterPlugin(mod)) continue;
+      const baseType = mod.name.split(":")[0];
+      const colonIdx = mod.name.indexOf(":");
+      if (colonIdx > 0) {
+        const repoPrefix = mod.name.slice(colonIdx + 1);
+        const scoped = results.filter(
+          (r) => r.filePath?.startsWith(repoPrefix + "/")
+        );
+        if (scoped.length > 0) {
+          mod.formatContext(scoped, parts, fields);
+        }
+        continue;
+      }
+      if (seenFormatters.has(baseType)) continue;
+      seenFormatters.add(baseType);
+      mod.formatContext(results, parts, fields);
+    }
+  }
+  /**
+   * Resolve context fields: plugin defaults ← config.json ← per-query.
+   * Returns a flat Record with the final value for each field.
+   */
+  _resolveFields(options) {
+    const defaults = {};
+    for (const mod of this._registry.all) {
+      if (isContextFieldPlugin(mod)) {
+        for (const field of mod.contextFields()) {
+          defaults[field.name] = field.default;
+        }
+      }
+    }
+    return { ...defaults, ...this._configFields, ...options.fields ?? {} };
+  }
+  /**
+   * Run LLM expansion: build manifest of candidate chunks from files
+   * NOT already in search results, call expander, resolve selected IDs.
+   */
+  async _expand(task, results) {
+    if (!this._expander) return { results: [] };
+    const repoPrefix = this._detectRepoPrefix(results);
+    const excludeFilePaths = [...new Set(
+      results.filter((r) => r.filePath).map((r) => {
+        const fp = r.filePath;
+        return repoPrefix && fp.startsWith(repoPrefix + "/") ? fp.slice(repoPrefix.length + 1) : fp;
+      })
+    )];
+    const excludeIds = [];
+    for (const r of results) {
+      const meta = r.metadata;
+      const id = meta?.id;
+      if (id !== void 0) excludeIds.push(id);
+    }
+    const manifest = [];
+    let resolver;
+    for (const mod of this._registry.all) {
+      if (!isExpandablePlugin(mod)) continue;
+      const colonIdx = mod.name.indexOf(":");
+      const pluginRepo = colonIdx > 0 ? mod.name.slice(colonIdx + 1) : void 0;
+      if (repoPrefix && pluginRepo && pluginRepo !== repoPrefix) continue;
+      manifest.push(...mod.buildManifest(excludeFilePaths, excludeIds));
+      if (!resolver) {
+        const prefix = pluginRepo;
+        resolver = /* @__PURE__ */ __name((ids) => {
+          const chunks = mod.resolveChunks(ids);
+          if (prefix) {
+            for (const chunk of chunks) {
+              if (chunk.filePath) chunk.filePath = `${prefix}/${chunk.filePath}`;
+              const meta = chunk.metadata;
+              if (typeof meta.filePath === "string") {
+                meta.filePath = `${prefix}/${meta.filePath}`;
+              }
+            }
+          }
+          return chunks;
+        }, "resolver");
+      }
+    }
+    if (manifest.length === 0 || !resolver) return { results: [] };
+    try {
+      const expandResult = await this._expander.expand(task, excludeIds, manifest);
+      if (expandResult.ids.length === 0) return { results: [], note: expandResult.note };
+      return { results: resolver(expandResult.ids), note: expandResult.note };
+    } catch {
+      return { results: [] };
+    }
+  }
+  /** Detect the multi-repo prefix from existing results (e.g. 'servicehub-frontend'). */
+  _detectRepoPrefix(results) {
+    for (const r of results) {
+      if (!r.filePath) continue;
+      const srcIdx = r.filePath.indexOf("/src/");
+      if (srcIdx > 0) return r.filePath.slice(0, srcIdx);
+    }
+    return void 0;
+  }
+  /** Collect results from SearchablePlugins that don't have their own formatter. */
+  async _appendSearchableResults(task, sources, minScore, parts) {
+    for (const mod of this._registry.all) {
+      if (isContextFormatterPlugin(mod)) continue;
+      if (!isSearchable(mod)) continue;
+      const hits = await mod.search(task, { k: sources[mod.name.split(":")[0]] ?? 6, minScore });
+      if (hits.length > 0) {
+        parts.push(`## ${mod.name}
+`);
+        for (const r of hits) {
+          parts.push(`- [${Math.round(r.score * 100)}%] ${r.content.slice(0, 200)}`);
+        }
+        parts.push("");
+      }
+    }
+  }
+};
+function _toLogResult(r) {
+  const meta = r.metadata;
+  return {
+    filePath: r.filePath ?? "unknown",
+    score: r.score,
+    type: r.type,
+    name: meta?.name ?? void 0
+  };
+}
+__name(_toLogResult, "_toLogResult");
+function _prunerName(pruner) {
+  return pruner.constructor?.name ?? "custom";
+}
+__name(_prunerName, "_prunerName");
+
+// src/search/keyword/composite-bm25-search.ts
+var DEFAULT_K = 8;
+var CompositeBM25Search = class {
+  constructor(_registry) {
+    this._registry = _registry;
+  }
+  static {
+    __name(this, "CompositeBM25Search");
+  }
+  /**
+   * Run BM25 keyword search across all plugins that implement BM25SearchPlugin.
+   * Each plugin searches its own FTS5 tables.
+   */
+  async search(query, options = {}) {
+    const src = options.sources ?? {};
+    const results = [];
+    for (const plugin of this._registry.all) {
+      if (!isBM25SearchPlugin(plugin)) continue;
+      const baseType = plugin.name.split(":")[0];
+      const k = src[baseType] ?? DEFAULT_K;
+      if (k <= 0) continue;
+      const hits = plugin.searchBM25(query, k);
+      const colonIdx = plugin.name.indexOf(":");
+      if (colonIdx > 0) {
+        const subRepo = plugin.name.slice(colonIdx + 1);
+        for (const hit of hits) {
+          if (hit.filePath) hit.filePath = `${subRepo}/${hit.filePath}`;
+          const meta = hit.metadata;
+          if (typeof meta.filePath === "string") {
+            meta.filePath = `${subRepo}/${meta.filePath}`;
+          }
+        }
+      }
+      results.push(...hits);
+    }
+    return results.sort((a, b) => b.score - a.score);
+  }
+  /** Rebuild FTS5 indices across all BM25 plugins. */
+  rebuild() {
+    for (const plugin of this._registry.all) {
+      if (!isBM25SearchPlugin(plugin)) continue;
+      plugin.rebuildFTS?.();
+    }
+  }
+};
+
+// src/search/vector/composite-vector-search.ts
+var CompositeVectorSearch = class _CompositeVectorSearch {
+  constructor(_c) {
+    this._c = _c;
+  }
+  static {
+    __name(this, "CompositeVectorSearch");
+  }
+  /** Default K when no source override is provided. */
+  static DEFAULT_K = 6;
+  /** Search across all registered domain strategies with score-based merge. */
+  async search(query, options = {}) {
+    const src = options.sources ?? {};
+    const { minScore = 0.25, useMMR = true, mmrLambda = 0.7 } = options;
+    const queryVec = await this._c.embedding.embed(query);
+    const allResults = [];
+    let requestedK = 0;
+    for (const [name, strategy] of this._c.strategies) {
+      const baseName = name.split(":")[0];
+      const k = src[name] ?? src[baseName] ?? this._c.defaults?.[name] ?? _CompositeVectorSearch.DEFAULT_K;
+      if (k <= 0) continue;
+      requestedK = Math.max(requestedK, k);
+      const hits = strategy.search(queryVec, k, minScore, useMMR, mmrLambda, query);
+      const colonIdx = name.indexOf(":");
+      if (colonIdx > 0) {
+        const subRepo = name.slice(colonIdx + 1);
+        for (const hit of hits) {
+          if (hit.filePath) hit.filePath = `${subRepo}/${hit.filePath}`;
+          const meta = hit.metadata;
+          if (typeof meta.filePath === "string") {
+            meta.filePath = `${subRepo}/${meta.filePath}`;
+          }
+        }
+      }
+      allResults.push(...hits);
+    }
+    if (allResults.length === 0) return [];
+    allResults.sort((a, b) => b.score - a.score);
+    const capped = allResults.slice(0, requestedK);
+    const maxScore = capped[0].score;
+    if (maxScore > 0) {
+      for (const r of capped) r.score = r.score / maxScore;
+    }
+    return capped;
+  }
+};
+
+// src/providers/vector/hnsw-index.ts
+import { existsSync as existsSync3 } from "fs";
+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;
+  _lib = null;
+  _ids = /* @__PURE__ */ new Set();
+  /**
+   * Initialize the HNSW index.
+   * Must be called before add/search.
+   */
+  async init() {
+    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() {
+    if (!this._lib) throw new Error("HNSW lib not loaded");
+    const HNSW2 = this._lib.default?.HierarchicalNSW ?? this._lib.HierarchicalNSW;
+    if (!HNSW2) throw new Error("HierarchicalNSW not found in hnswlib-node module");
+    this._index = new HNSW2("cosine", this._dims);
+    this._index.initIndex(this._maxElements, this._M, this._efConstruction);
+    this._index.setEf(this._efSearch);
+    this._ids = /* @__PURE__ */ new Set();
+  }
+  /** Maximum capacity of this index. */
+  get maxElements() {
+    return this._maxElements;
+  }
+  /**
+   * 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");
+    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._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.
+   * Returns results sorted by score (highest first).
+   * Score is 1 - cosine_distance (1.0 = identical).
+   */
+  search(query, k) {
+    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,
+      score: 1 - result.distances[i]
+    }));
+  }
+  /** Number of vectors in the index. */
+  get size() {
+    return this._ids.size;
+  }
+  /**
+   * Save the HNSW graph to disk.
+   * The file can be loaded later with tryLoad() to skip vector-by-vector insertion.
+   */
+  save(path9) {
+    if (!this._index || this._ids.size === 0) return;
+    this._index.writeIndexSync(path9);
+  }
+  /**
+   * Try to load a previously saved HNSW index from disk.
+   * Returns true if loaded successfully, false if stale or missing.
+   * @param path File path to the saved index
+   * @param expectedCount Expected number of vectors (from SQLite) — used to detect staleness
+   */
+  tryLoad(path9, expectedCount) {
+    if (!this._index || !existsSync3(path9)) return false;
+    try {
+      this._index.readIndexSync(path9);
+      const loadedCount = this._index.getCurrentCount();
+      if (loadedCount !== expectedCount) {
+        this.reinit();
+        return false;
+      }
+      const ids = this._index.getIdsList();
+      this._ids = new Set(ids);
+      this._index.setEf(this._efSearch);
+      return true;
+    } catch {
+      this.reinit();
+      return false;
+    }
+  }
+};
+
+// src/lib/fts.ts
+function splitCompound(word) {
+  return word.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[_\-./\\]/g, " ").trim();
+}
+__name(splitCompound, "splitCompound");
+function sanitizeFTS(query) {
+  const clean = query.replace(/[{}[\]()^~*:]/g, " ").replace(/\bAND\b|\bOR\b|\bNOT\b|\bNEAR\b/gi, "").trim();
+  const expanded = clean.split(/\s+/).map((w) => splitCompound(w)).join(" ");
+  const words = expanded.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");
+function escapeLike(s) {
+  return s.replace(/[%_\\]/g, "\\$&");
+}
+__name(escapeLike, "escapeLike");
+
+// src/services/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, vecToBuffer(vec));
+    this._hnsw.add(vec, id);
+    this._vecs.set(id, vec);
+    return id;
+  }
+  /** Update an item's content (re-embeds). Returns the new ID. */
+  async update(id, content, options) {
+    const row = this._db.prepare(
+      "SELECT * FROM kv_data WHERE id = ? AND collection = ?"
+    ).get(id, this._name);
+    if (!row) throw new Error(`BrainBank: Item ${id} not found in collection '${this._name}'.`);
+    const metadata = options?.metadata ?? JSON.parse(row.meta_json || "{}");
+    const tags = options?.tags ?? JSON.parse(row.tags_json || "[]");
+    const ttl = options?.ttl;
+    this._removeById(id);
+    return this.add(content, { metadata, tags, ...ttl ? { ttl } : {} });
+  }
+  /** 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, vecToBuffer(vecs[i]));
+        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 = fuseRankedLists(
+      [vectorHits, bm25Hits],
+      (h) => String(h.id),
+      (h) => h.score ?? 0
+    );
+    const results = fused.map(({ item, score }) => ({ ...item, score })).filter((r) => r.score >= minScore).slice(0, k);
+    if (this._reranker && results.length > 1) {
+      const asSearchResults = results.map((r) => ({
+        type: "collection",
+        score: r.score ?? 0,
+        content: r.content,
+        metadata: { id: r.id }
+      }));
+      const reranked = await rerank(query, asSearchResults, this._reranker);
+      const rerankedById = new Map(
+        reranked.map((r) => [r.type === "collection" ? r.metadata.id : void 0, r.score])
+      );
+      const blended = results.map((r) => ({ ...r, score: rerankedById.get(r.id) ?? r.score ?? 0 }));
+      return this._filterByTags(
+        blended.sort((a, b) => (b.score ?? 0) - (a.score ?? 0)),
+        tags
+      );
+    }
+    return this._filterByTags(results, tags);
+  }
+  /** Search and return results as SearchResult[] for use in hybrid search pipelines. */
+  async searchAsResults(query, k) {
+    const hits = await this.search(query, { k });
+    return hits.map((h) => ({
+      type: "collection",
+      score: h.score ?? 0,
+      content: h.content,
+      metadata: { ...h.metadata, id: h.id, collection: this._name }
+    }));
+  }
+  /** 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);
+    }
+  }
+  _removeById(id) {
+    this._db.prepare("DELETE FROM kv_data WHERE id = ?").run(id);
+    this._hnsw.remove(id);
+    this._vecs.delete(id);
+  }
+  async _searchVector(query, k, minScore) {
+    if (this._hnsw.size === 0) return [];
+    const queryVec = await this._embedding.embed(query);
+    const searchK = this._adaptiveSearchK(k);
+    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);
+  }
+  /** Compute adaptive over-fetch multiplier based on collection density in shared HNSW. */
+  _adaptiveSearchK(k) {
+    const totalSize = this._hnsw.size;
+    if (totalSize === 0) return 0;
+    const collectionCount = this.count();
+    if (collectionCount === 0) return Math.min(k * 3, totalSize);
+    const ratio = Math.ceil(totalSize / collectionCount);
+    const multiplier = Math.max(3, Math.min(ratio, 50));
+    return Math.min(k * multiplier, totalSize);
+  }
+  _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/services/kv-service.ts
+var KVService = class {
+  constructor(_db, _embedding, _hnsw, _vecs, _reranker) {
+    this._db = _db;
+    this._embedding = _embedding;
+    this._hnsw = _hnsw;
+    this._vecs = _vecs;
+    this._reranker = _reranker;
+  }
+  static {
+    __name(this, "KVService");
+  }
+  _collections = /* @__PURE__ */ new Map();
+  /** Get or create a named collection. */
+  collection(name) {
+    if (this._collections.has(name)) return this._collections.get(name);
+    const coll = new Collection(name, this._db, this._embedding, this._hnsw, this._vecs, this._reranker);
+    this._collections.set(name, coll);
+    return coll;
+  }
+  /** List all collection names that have data. */
+  listNames() {
+    return this._db.prepare("SELECT DISTINCT collection FROM kv_data ORDER BY collection").all().map((r) => r.collection);
+  }
+  /** Delete a collection's data and evict from cache. Removes vectors from HNSW to prevent ghost entries. */
+  delete(name) {
+    const ids = this._db.prepare(
+      "SELECT id FROM kv_data WHERE collection = ?"
+    ).all(name);
+    for (const { id } of ids) {
+      this._hnsw.remove(id);
+      this._vecs.delete(id);
+    }
+    this._db.prepare("DELETE FROM kv_data WHERE collection = ?").run(name);
+    this._collections.delete(name);
+  }
+  /** Access the shared HNSW index (used by reembed). */
+  get hnsw() {
+    return this._hnsw;
+  }
+  /** Access the shared vector cache. @internal */
+  get vecs() {
+    return this._vecs;
+  }
+  /** Clear all cached collections and vectors. */
+  clear() {
+    this._collections.clear();
+    this._vecs.clear();
+  }
+};
+
+// src/lib/languages.ts
+import path3 from "path";
+var SUPPORTED_EXTENSIONS = {
+  // TypeScript / JavaScript
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  // Systems
+  ".go": "go",
+  ".rs": "rust",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".c": "c",
+  ".h": "c",
+  ".hpp": "cpp",
+  // JVM
+  ".java": "java",
+  ".kt": "kotlin",
+  ".scala": "scala",
+  // Scripting
+  ".py": "python",
+  ".rb": "ruby",
+  ".php": "php",
+  ".lua": "lua",
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "bash",
+  // Web
+  ".html": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".less": "less",
+  ".svelte": "svelte",
+  ".vue": "vue",
+  // Data / Config (JSON + YAML excluded — config/CI files cause search noise)
+  ".toml": "toml",
+  ".xml": "xml",
+  ".graphql": "graphql",
+  ".gql": "graphql",
+  // Database
+  ".sql": "sql",
+  ".prisma": "prisma",
+  // Other
+  ".swift": "swift",
+  ".dart": "dart",
+  ".r": "r",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".zig": "zig"
+};
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  // Package managers
+  "node_modules",
+  "bower_components",
+  ".pnpm",
+  // Build output
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".svelte-kit",
+  // Auto-generated code
+  "generated",
+  "sdk",
+  "openapi",
+  // Version control
+  ".git",
+  ".hg",
+  ".svn",
+  // IDE / Editor
+  ".idea",
+  ".vscode",
+  // Runtime / Cache
+  "__pycache__",
+  ".pytest_cache",
+  "venv",
+  ".venv",
+  ".env",
+  ".tox",
+  // Coverage / Test artifacts
+  "coverage",
+  ".nyc_output",
+  "htmlcov",
+  // Compiled
+  "target",
+  // Rust, Java
+  ".cargo",
+  "vendor",
+  // Go, PHP
+  // Database (auto-generated migrations, dumps, seeds)
+  "migrations",
+  "db_dumps",
+  "seeds",
+  // AI / Model cache
+  ".model-cache",
+  ".brainbank",
+  // OS
+  ".DS_Store"
+]);
+var IGNORE_FILES = /* @__PURE__ */ new Set([
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lockb",
+  "Cargo.lock",
+  "Gemfile.lock",
+  "poetry.lock",
+  "composer.lock",
+  "go.sum"
+]);
+function isSupported(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  return ext in SUPPORTED_EXTENSIONS;
+}
+__name(isSupported, "isSupported");
+function getLanguage(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  return SUPPORTED_EXTENSIONS[ext];
+}
+__name(getLanguage, "getLanguage");
+function isIgnoredDir(dirName) {
+  return IGNORE_DIRS.has(dirName);
+}
+__name(isIgnoredDir, "isIgnoredDir");
+function isIgnoredFile(fileName) {
+  return IGNORE_FILES.has(fileName);
+}
+__name(isIgnoredFile, "isIgnoredFile");
+function matchesGlob(relPath, patterns) {
+  for (const pattern of patterns) {
+    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\x00/g, ".*");
+    if (new RegExp(`^${regex}$`).test(relPath)) return true;
+  }
+  return false;
+}
+__name(matchesGlob, "matchesGlob");
+
+// src/services/watch.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+var DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".txt", ".rst"]);
+var Watcher = class {
+  static {
+    __name(this, "Watcher");
+  }
+  _active = true;
+  _batches = /* @__PURE__ */ new Map();
+  _reindexFn;
+  _options;
+  _keepalive = null;
+  constructor(reindexFn, plugins, options = {}, repoPath) {
+    this._reindexFn = reindexFn;
+    this._options = options;
+    this._startWatching(plugins, repoPath);
+  }
+  /** Whether the watcher is active. */
+  get active() {
+    return this._active;
+  }
+  /** Stop all plugin watchers. */
+  async close() {
+    this._active = false;
+    if (this._keepalive) {
+      clearInterval(this._keepalive);
+      this._keepalive = null;
+    }
+    for (const batch of this._batches.values()) {
+      if (batch.timer) clearTimeout(batch.timer);
+      try {
+        await batch.handle.stop();
+      } catch (err) {
+        this._options.onError?.(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    this._batches.clear();
+  }
+  /** Start watching for each WatchablePlugin, with shared fs.watch fallback. */
+  _startWatching(plugins, repoPath) {
+    let hasAnyWatcher = false;
+    const fallbackPlugins = [];
+    for (const plugin of plugins) {
+      if (isWatchable(plugin)) {
+        try {
+          const handle = plugin.watch((event) => this._onEvent(plugin, event));
+          this._batches.set(plugin.name, {
+            plugin,
+            handle,
+            events: [],
+            timer: null,
+            flushing: false
+          });
+          hasAnyWatcher = true;
+        } catch (err) {
+          this._options.onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+      } else if (isIndexable(plugin) && repoPath) {
+        fallbackPlugins.push(plugin);
+      }
+    }
+    if (fallbackPlugins.length > 0 && repoPath) {
+      const sharedHandle = this._startSharedFsWatch(fallbackPlugins, repoPath);
+      if (sharedHandle) {
+        for (const plugin of fallbackPlugins) {
+          this._batches.set(plugin.name, {
+            plugin,
+            handle: sharedHandle,
+            events: [],
+            timer: null,
+            flushing: false
+          });
+        }
+        hasAnyWatcher = true;
+      }
+    }
+    if (hasAnyWatcher) {
+      this._keepalive = setInterval(() => {
+      }, 6e4);
+      this._keepalive.unref?.();
+    }
+  }
+  /**
+   * Single shared recursive fs.watch that fans out events to multiple plugins.
+   * Each event is routed based on: sub-repo prefix (code:backend → servicehub-backend/),
+   * file extension (docs → .md only), and code support (code → isSupported).
+   */
+  _startSharedFsWatch(plugins, repoPath) {
+    const watchers = [];
+    const ignorePatterns = this._options.ignore ?? [];
+    const recentEvents = /* @__PURE__ */ new Map();
+    const DEDUP_MS = 100;
+    const routes = plugins.map((plugin) => {
+      const baseName = plugin.name.split(":")[0];
+      const subRepo = plugin.name.includes(":") ? plugin.name.split(":").slice(1).join(":") : null;
+      return { plugin, baseName, subRepo };
+    });
+    const watchDir = /* @__PURE__ */ __name((dir) => {
+      try {
+        const watcher = fs3.watch(dir, { persistent: true }, (_eventType, filename) => {
+          if (!filename || !this._active) return;
+          const fullPath = path4.join(dir, filename);
+          const relPath = path4.relative(repoPath, fullPath);
+          const ext = path4.extname(fullPath).toLowerCase();
+          if (ignorePatterns.length > 0 && matchesGlob(relPath, ignorePatterns)) return;
+          const now = Date.now();
+          const lastSeen = recentEvents.get(relPath);
+          if (lastSeen && now - lastSeen < DEDUP_MS) return;
+          recentEvents.set(relPath, now);
+          const event = {
+            type: "update",
+            sourceId: relPath,
+            sourceName: "file"
+          };
+          for (const { plugin, baseName, subRepo } of routes) {
+            if (subRepo && !relPath.startsWith(subRepo + "/")) continue;
+            if (baseName === "docs") {
+              if (!DOC_EXTENSIONS.has(ext)) continue;
+            } else {
+              if (!isSupported(fullPath)) continue;
+            }
+            this._onEvent(plugin, event);
+          }
+        });
+        watcher.on("error", (err) => {
+          this._options.onError?.(err instanceof Error ? err : new Error(String(err)));
+        });
+        watchers.push(watcher);
+      } catch {
+      }
+      try {
+        for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+          if (!entry.isDirectory()) continue;
+          if (isIgnoredDir(entry.name)) continue;
+          if (entry.name.startsWith(".")) continue;
+          const dirRel = path4.relative(repoPath, path4.join(dir, entry.name));
+          if (ignorePatterns.length > 0 && matchesGlob(dirRel + "/", ignorePatterns)) continue;
+          watchDir(path4.join(dir, entry.name));
+        }
+      } catch {
+      }
+    }, "watchDir");
+    watchDir(repoPath);
+    if (watchers.length === 0) return null;
+    const cleanupInterval = setInterval(() => {
+      const cutoff = Date.now() - 1e4;
+      for (const [key, ts] of recentEvents) {
+        if (ts < cutoff) recentEvents.delete(key);
+      }
+    }, 3e4);
+    cleanupInterval.unref?.();
+    let stopped = false;
+    return {
+      get active() {
+        return !stopped;
+      },
+      async stop() {
+        if (stopped) return;
+        stopped = true;
+        clearInterval(cleanupInterval);
+        for (const w of watchers) {
+          try {
+            w.close();
+          } catch {
+          }
+        }
+        watchers.length = 0;
+      }
+    };
+  }
+  /** Handle an incoming event from a plugin. */
+  _onEvent(plugin, event) {
+    if (!this._active) return;
+    const batch = this._batches.get(plugin.name);
+    if (!batch) return;
+    batch.events.push(event);
+    const pluginDebounce = isWatchable(plugin) ? plugin.watchConfig?.()?.debounceMs : void 0;
+    const debounceMs = pluginDebounce ?? this._options.debounceMs ?? 2e3;
+    const batchSize = isWatchable(plugin) ? plugin.watchConfig?.()?.batchSize : void 0;
+    const shouldFlushNow = debounceMs === 0 || batchSize !== void 0 && batch.events.length >= batchSize;
+    if (shouldFlushNow) {
+      if (batch.timer) clearTimeout(batch.timer);
+      batch.timer = null;
+      void this._flush(batch);
+      return;
+    }
+    if (batch.timer) clearTimeout(batch.timer);
+    batch.timer = setTimeout(() => void this._flush(batch), debounceMs);
+  }
+  /** Flush pending events for a plugin — trigger re-indexing. */
+  async _flush(batch) {
+    if (batch.flushing || batch.events.length === 0) return;
+    batch.flushing = true;
+    const { onIndex, onError } = this._options;
+    try {
+      const events = [...batch.events];
+      batch.events.length = 0;
+      const ids = events.map((e) => e.sourceId);
+      if (isIndexable(batch.plugin) && batch.plugin.indexItems) {
+        await batch.plugin.indexItems(ids);
+        for (const id of ids) {
+          onIndex?.(id, batch.plugin.name);
+        }
+      } else if (isIndexable(batch.plugin)) {
+        await batch.plugin.index();
+        for (const id of ids) {
+          onIndex?.(id, batch.plugin.name);
+        }
+      } else {
+        await this._reindexFn();
+        for (const id of ids) {
+          onIndex?.(id, batch.plugin.name);
+        }
+      }
+    } catch (err) {
+      onError?.(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      batch.flushing = false;
+      if (batch.events.length > 0 && this._active) {
+        const debounceMs = this._options.debounceMs ?? 2e3;
+        batch.timer = setTimeout(() => void this._flush(batch), debounceMs);
+      }
+    }
+  }
+};
+
+// src/services/webhook-server.ts
+import * as http from "http";
+var WebhookServer = class {
+  static {
+    __name(this, "WebhookServer");
+  }
+  _server = null;
+  _routes = [];
+  _listening = false;
+  /** Start listening on the specified port. */
+  listen(port) {
+    if (this._listening) return;
+    this._server = http.createServer((req, res) => {
+      this._handleRequest(req, res);
+    });
+    this._server.listen(port);
+    this._listening = true;
+  }
+  /** Register a webhook route for a plugin. */
+  register(pluginName, path9, handler) {
+    const normalizedPath = path9.startsWith("/") ? path9 : `/${path9}`;
+    this._routes.push({ pluginName, path: normalizedPath, handler });
+  }
+  /** Remove all routes for a plugin. */
+  unregister(pluginName) {
+    this._routes = this._routes.filter((r) => r.pluginName !== pluginName);
+  }
+  /** Stop the server and clear all routes. */
+  close() {
+    this._server?.close();
+    this._server = null;
+    this._routes = [];
+    this._listening = false;
+  }
+  /** Whether the server is currently listening. */
+  get active() {
+    return this._listening;
+  }
+  /** Route incoming POST requests to the matching handler. */
+  _handleRequest(req, res) {
+    if (req.method !== "POST") {
+      res.writeHead(405, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Method not allowed" }));
+      return;
+    }
+    const route = this._routes.find((r) => req.url === r.path);
+    if (!route) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
+      return;
+    }
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      try {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        const body = raw ? JSON.parse(raw) : {};
+        route.handler(body);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true }));
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid JSON" }));
+      }
+    });
+  }
+};
+
+// src/brainbank.ts
+import { EventEmitter } from "events";
+import * as path5 from "path";
+
+// src/providers/vector/hnsw-loader.ts
+import { dirname as dirname2, join as join4 } from "path";
+function hnswPath(dbPath, name) {
+  return join4(dirname2(dbPath), `hnsw-${name}.index`);
+}
+__name(hnswPath, "hnswPath");
+function lockDir(dbPath) {
+  return dirname2(dbPath);
+}
+__name(lockDir, "lockDir");
+function countRows(db, table) {
+  const row = db.prepare(`SELECT COUNT(*) as c FROM ${table}`).get();
+  return row?.c ?? 0;
+}
+__name(countRows, "countRows");
+async function saveAllHnsw(dbPath, kvHnsw, sharedHnsw, privateHnsw) {
+  try {
+    await withLock(lockDir(dbPath), "hnsw", () => {
+      kvHnsw.save(hnswPath(dbPath, "kv"));
+      for (const [name, { hnsw }] of sharedHnsw) {
+        hnsw.save(hnswPath(dbPath, name));
+      }
+      for (const [name, hnsw] of privateHnsw) {
+        hnsw.save(hnswPath(dbPath, name));
+      }
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(saveAllHnsw, "saveAllHnsw");
+function loadVectors(db, table, idCol, hnsw, cache) {
+  const iter = db.prepare(`SELECT ${idCol}, embedding FROM ${table}`).iterate();
+  for (const row of iter) {
+    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");
+function loadVecCache(db, table, idCol, cache) {
+  const iter = db.prepare(`SELECT ${idCol}, embedding FROM ${table}`).iterate();
+  for (const row of iter) {
+    const vec = new Float32Array(
+      row.embedding.buffer.slice(
+        row.embedding.byteOffset,
+        row.embedding.byteOffset + row.embedding.byteLength
+      )
+    );
+    cache.set(row[idCol], vec);
+  }
+}
+__name(loadVecCache, "loadVecCache");
+function reloadHnsw(deps) {
+  const { dbPath, db, name, hnsw, vecCache, vectorTable, idCol } = deps;
+  const indexPath = hnswPath(dbPath, name);
+  const rowCount = countRows(db, vectorTable);
+  hnsw.reinit();
+  vecCache.clear();
+  if (hnsw.tryLoad(indexPath, rowCount)) {
+    loadVecCache(db, vectorTable, idCol, vecCache);
+  } else {
+    loadVectors(db, vectorTable, idCol, hnsw, vecCache);
+  }
+}
+__name(reloadHnsw, "reloadHnsw");
+
+// src/engine/index-api.ts
+function mergeResult(acc, r) {
+  if (!acc) return { ...r };
+  return {
+    indexed: acc.indexed + r.indexed,
+    skipped: acc.skipped + r.skipped,
+    chunks: (acc.chunks ?? 0) + (r.chunks ?? 0)
+  };
+}
+__name(mergeResult, "mergeResult");
+async function runIndex(deps, options = {}) {
+  const want = options.modules ? new Set(options.modules) : null;
+  const results = {};
+  for (const mod of deps.registry.all) {
+    const baseType = mod.name.split(":")[0];
+    if (want && !want.has(baseType)) continue;
+    if (!isIndexable(mod)) continue;
+    const label = mod.name;
+    options.onProgress?.(label, "Starting...");
+    const r = await mod.index({
+      forceReindex: options.forceReindex,
+      onProgress: /* @__PURE__ */ __name((msg, cur, total) => options.onProgress?.(label, `[${cur}/${total}] ${msg}`), "onProgress"),
+      ...options.pluginOptions
+    });
+    results[baseType] = mergeResult(results[baseType], r);
+    bumpVersion(deps.db, mod.name);
+  }
+  await saveAllHnsw(
+    deps.dbPath,
+    deps.kvHnsw,
+    deps.sharedHnsw,
+    /* @__PURE__ */ new Map()
+  );
+  deps.emit("indexed", results);
+  return results;
+}
+__name(runIndex, "runIndex");
+
+// src/engine/reembed.ts
+var CORE_TABLES = [
+  {
+    name: "kv",
+    textTable: "kv_data",
+    vectorTable: "kv_vectors",
+    idColumn: "id",
+    fkColumn: "data_id",
+    textBuilder: /* @__PURE__ */ __name((r) => String(r.content), "textBuilder")
+  }
+];
+function collectTables(plugins) {
+  const byVectorTable = /* @__PURE__ */ new Map();
+  for (const p of plugins) {
+    if (isReembeddable(p)) {
+      const config = p.reembedConfig();
+      byVectorTable.set(config.vectorTable, config);
+    }
+  }
+  for (const t of CORE_TABLES) {
+    byVectorTable.set(t.vectorTable, t);
+  }
+  return [...byVectorTable.values()];
+}
+__name(collectTables, "collectTables");
+async function reembedAll(db, embedding, hnswMap, plugins, options = {}, persist) {
+  const { batchSize = 50, onProgress } = options;
+  const tables = collectTables(plugins);
+  const counts = {};
+  let total = 0;
+  for (const table of tables) {
+    try {
+      const textExists = db.prepare(
+        `SELECT COUNT(*) as c FROM sqlite_master WHERE type='table' AND name=?`
+      ).get(table.textTable).c;
+      const vecExists = db.prepare(
+        `SELECT COUNT(*) as c FROM sqlite_master WHERE type='table' AND name=?`
+      ).get(table.vectorTable).c;
+      if (!textExists || !vecExists) continue;
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("no such table")) continue;
+      throw e;
+    }
+    const count = await reembedTable(db, embedding, table, batchSize, onProgress);
+    counts[table.name] = count;
+    total += count;
+    const entry = hnswMap.get(table.name);
+    if (entry && count > 0) {
+      await rebuildHnsw(db, table, entry.hnsw, entry.vecs);
+    }
+  }
+  setEmbeddingMeta(db, embedding);
+  if (persist) {
+    saveAllHnsw(persist.dbPath, persist.kvHnsw, persist.sharedHnsw, /* @__PURE__ */ new Map());
+  }
+  return {
+    counts,
+    total
+  };
+}
+__name(reembedAll, "reembedAll");
+async function reembedTable(db, embedding, table, batchSize, onProgress) {
+  const totalCount = db.prepare(
+    `SELECT COUNT(*) as c FROM ${table.textTable}`
+  ).get().c;
+  if (totalCount === 0) return 0;
+  const tempTable = `_reembed_${table.vectorTable}`;
+  db.exec(`DROP TABLE IF EXISTS ${tempTable}`);
+  db.exec(`CREATE TABLE ${tempTable} AS SELECT * FROM ${table.vectorTable} WHERE 0`);
+  const insertTemp = db.prepare(
+    `INSERT INTO ${tempTable} (${table.fkColumn}, embedding) VALUES (?, ?)`
+  );
+  let processed = 0;
+  try {
+    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++) {
+          insertTemp.run(batch[j][table.idColumn], vecToBuffer(vectors[j]));
+        }
+      });
+      processed += batch.length;
+      onProgress?.(table.name, processed, totalCount);
+    }
+    db.transaction(() => {
+      db.exec(`DELETE FROM ${table.vectorTable}`);
+      db.exec(`INSERT INTO ${table.vectorTable} SELECT * FROM ${tempTable}`);
+    });
+  } finally {
+    db.exec(`DROP TABLE IF EXISTS ${tempTable}`);
+  }
+  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 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);
+  }
+}
+__name(rebuildHnsw, "rebuildHnsw");
+
+// src/engine/search-api.ts
+function createSearchAPI(_db, embedding, config, registry, kvService, sharedHnsw) {
+  const strategies = /* @__PURE__ */ new Map();
+  for (const mod of registry.all) {
+    if (isVectorSearchPlugin(mod)) {
+      const vs = mod.createVectorSearch();
+      if (vs) {
+        strategies.set(mod.name, vs);
+      }
+    }
+  }
+  const search = strategies.size > 0 ? new CompositeVectorSearch({
+    strategies,
+    embedding
+  }) : void 0;
+  const bm25 = new CompositeBM25Search(registry);
+  const rerankerName = config.reranker ? config.reranker.constructor?.name ?? "custom" : void 0;
+  const contextBuilder = new ContextBuilder(search, registry, config.pruner, embedding, rerankerName, config.contextFields ?? {}, config.expander);
+  return new SearchAPI({
+    search,
+    bm25,
+    registry,
+    config,
+    kvService,
+    contextBuilder,
+    embedding
+  });
+}
+__name(createSearchAPI, "createSearchAPI");
+var SearchAPI = class {
+  constructor(_d) {
+    this._d = _d;
+  }
+  static {
+    __name(this, "SearchAPI");
+  }
+  /** Build formatted context block for LLM injection. */
+  async getContext(task, options = {}) {
+    if (!this._d.contextBuilder) return "";
+    return this._d.contextBuilder.build(task, options);
+  }
+  /** Semantic search across all loaded modules. */
+  async search(query, options) {
+    const t0 = Date.now();
+    const lists = [];
+    if (this._d.search) {
+      lists.push(await this._d.search.search(query, options));
+    }
+    lists.push(...await this._collectSearchablePlugins(query, options));
+    let results;
+    if (lists.length === 0) results = [];
+    else if (lists.length === 1) results = lists[0];
+    else results = reciprocalRankFusion(lists);
+    this._logSearch("search", query, options, results, Date.now() - t0);
+    return results;
+  }
+  /** Hybrid search: vector + BM25 → RRF. */
+  async hybridSearch(query, options) {
+    const t0 = Date.now();
+    const src = options?.sources ?? {};
+    const lists = [];
+    if (this._d.search) {
+      const [vec, kw] = await Promise.all([
+        this._d.search.search(query, options),
+        Promise.resolve(this._d.bm25?.search(query, options) ?? [])
+      ]);
+      lists.push(vec, kw);
+    }
+    lists.push(...await this._collectSearchablePlugins(query, options));
+    lists.push(...await this._collectKvCollections(query, src));
+    let results;
+    if (lists.length === 0) results = [];
+    else {
+      const fused = reciprocalRankFusion(lists);
+      if (this._d.config.reranker && fused.length > 1) {
+        results = await rerank(query, fused, this._d.config.reranker);
+      } else {
+        results = fused;
+      }
+    }
+    this._logSearch("hybridSearch", query, options, results, Date.now() - t0);
+    return results;
+  }
+  /** BM25 keyword search only. */
+  async searchBM25(query, options) {
+    const t0 = Date.now();
+    const results = await this._d.bm25?.search(query, options) ?? [];
+    this._logSearch("searchBM25", query, options, results, Date.now() - t0);
+    return results;
+  }
+  /** Rebuild FTS5 indices. */
+  rebuildFTS() {
+    this._d.bm25?.rebuild?.();
+  }
+  /** Collect results from all SearchablePlugins (docs, custom). */
+  async _collectSearchablePlugins(query, options) {
+    const lists = [];
+    for (const mod of this._d.registry.all) {
+      if (!isSearchable(mod)) continue;
+      if (isVectorSearchPlugin(mod)) continue;
+      const hits = await mod.search(query, options ? { ...options } : void 0);
+      if (hits.length > 0) lists.push(hits);
+    }
+    return lists;
+  }
+  /** Collect results from KV collections named in sources. */
+  async _collectKvCollections(query, sources) {
+    const pluginNames = new Set(this._d.registry.names.map((n) => n.split(":")[0]));
+    const lists = [];
+    for (const [name, k] of Object.entries(sources)) {
+      if (pluginNames.has(name)) continue;
+      const hits = await this._d.kvService.collection(name).searchAsResults(query, k);
+      if (hits.length > 0) lists.push(hits);
+    }
+    return lists;
+  }
+  /** Log a search/hybridSearch/searchBM25 call. */
+  _logSearch(method, query, options, results, durationMs) {
+    logQuery({
+      source: options?.source ?? "api",
+      method,
+      query,
+      embedding: providerKey(this._d.embedding),
+      pruner: null,
+      reranker: this._d.config.reranker ? this._d.config.reranker.constructor?.name ?? "custom" : null,
+      options: {
+        sources: options?.sources,
+        minScore: options?.minScore
+      },
+      results: results.map(_toLogResult2),
+      durationMs
+    });
+  }
+};
+function _toLogResult2(r) {
+  const meta = r.metadata;
+  return {
+    filePath: r.filePath ?? "unknown",
+    score: r.score,
+    type: r.type,
+    name: meta?.name ?? void 0
+  };
+}
+__name(_toLogResult2, "_toLogResult");
+
+// src/services/plugin-registry.ts
+var ALIASES = {};
+var PluginRegistry = class {
+  static {
+    __name(this, "PluginRegistry");
+  }
+  _map = /* @__PURE__ */ new Map();
+  /** Store a plugin. Duplicate names silently overwrite. */
+  register(plugin) {
+    this._map.set(plugin.name, plugin);
+  }
+  /**
+   * Check whether a plugin 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 false;
+  }
+  /**
+   * Get a plugin 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: Plugin '${name}' is not loaded. Add .use(${name}()) to your BrainBank instance.`
+    );
+  }
+  /**
+   * Return every plugin 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 + ":")
+    );
+  }
+  /** Return the first plugin 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;
+  }
+  /** All registered plugin names (insertion order). */
+  get names() {
+    return [...this._map.keys()];
+  }
+  /** All registered plugin instances (insertion order). */
+  get all() {
+    return [...this._map.values()];
+  }
+  /**
+   * Underlying Map.
+   * Prefer `all`, `allByType`, or `firstByType` everywhere else.
+   */
+  get raw() {
+    return this._map;
+  }
+  /** Remove all registered plugins. Called by BrainBank.close(). */
+  clear() {
+    this._map.clear();
+  }
+};
+
+// src/brainbank.ts
+var BrainBank = class extends EventEmitter {
+  static {
+    __name(this, "BrainBank");
+  }
+  _config;
+  _db;
+  _embedding;
+  _registry = new PluginRegistry();
+  _searchAPI;
+  _indexDeps;
+  _kvService;
+  _initialized = false;
+  _initPromise = null;
+  _watcher;
+  _webhookServer;
+  _sharedHnsw = /* @__PURE__ */ new Map();
+  _repoDBs = /* @__PURE__ */ new Map();
+  _loadedVersions = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    super();
+    this._config = resolveConfig(config);
+  }
+  /** Whether the brainbank has been initialized. */
+  get isInitialized() {
+    return this._initialized;
+  }
+  /** The resolved configuration. */
+  get config() {
+    return this._config;
+  }
+  /** All registered plugin names (insertion order). */
+  get plugins() {
+    return this._registry.names;
+  }
+  /**
+   * Register a plugin. Chainable.
+   *
+   * @example
+   * brain.use(code({ repoPath: '.' })).use(docs());
+   *
+   * @throws If called after `initialize()`.
+   */
+  use(plugin) {
+    if (this._initialized) {
+      throw new Error(
+        `BrainBank: Cannot add plugin '${plugin.name}' after initialization. Call .use() before any operations.`
+      );
+    }
+    this._registry.register(plugin);
+    return this;
+  }
+  /**
+   * Check if a plugin is loaded.
+   * Also matches type prefix (e.g. `'code'` matches `'code:frontend'`).
+   */
+  has(name) {
+    return this._registry.has(name);
+  }
+  /** Get a plugin instance by name. Returns `undefined` if not loaded. */
+  plugin(name) {
+    return this._registry.has(name) ? this._registry.get(name) : void 0;
+  }
+  /**
+   * Initialize database, HNSW indices, and load existing vectors.
+   * Automatically called by `index` / `search` methods if not yet initialized.
+   * Concurrent calls are deduped via `_initPromise`.
+   *
+   * @param options.force - If `true`, skip vector load on dimension mismatch.
+   */
+  async initialize(options = {}) {
+    if (this._initialized) return;
+    if (this._initPromise) return this._initPromise;
+    this._initPromise = this._runInitialize(options).then(() => {
+      this._initPromise = null;
+    }).catch((err) => {
+      this._cleanupAfterFailedInit();
+      throw err;
+    });
+    return this._initPromise;
+  }
+  /**
+   * Estimated memory footprint of loaded HNSW indices (bytes).
+   * Counts only vector data: `vectorCount × dims × 4`.
+   * Returns 0 if not initialized.
+   */
+  memoryHint() {
+    if (!this._initialized) return 0;
+    const dims = this._config.embeddingDims;
+    const bytesPerVector = dims * 4;
+    let total = 0;
+    if (this._kvService) total += this._kvService.hnsw.size * bytesPerVector;
+    for (const { hnsw } of this._sharedHnsw.values()) {
+      total += hnsw.size * bytesPerVector;
+    }
+    return total;
+  }
+  /** Close database and release all resources. Synchronous. */
+  close() {
+    void this._watcher?.close();
+    this._webhookServer?.close();
+    for (const plugin of this._registry.all) plugin.close?.();
+    const reranker = this._config.reranker;
+    reranker?.close?.();
+    const pruner = this._config.pruner;
+    pruner?.close?.();
+    this._embedding?.close().catch(() => {
+    });
+    for (const db of this._repoDBs.values()) db.close();
+    this._repoDBs.clear();
+    this._db?.close();
+    this._initialized = false;
+    this._kvService?.clear();
+    this._sharedHnsw.clear();
+    this._loadedVersions.clear();
+    this._kvService = void 0;
+    this._searchAPI = void 0;
+    this._indexDeps = void 0;
+    this._webhookServer = void 0;
+    this._registry.clear();
+  }
+  /**
+   * Get or create a dynamic collection (universal KV primitive).
+   *
+   * @example
+   * const errors = brain.collection('debug_errors');
+   * await errors.add('Fixed null check', { file: 'api.ts' });
+   * const hits = await errors.search('null pointer');
+   *
+   * @throws If not initialized.
+   */
+  collection(name) {
+    if (!this._kvService) {
+      throw new Error("BrainBank: Collections not ready. Call await brain.initialize() first.");
+    }
+    return this._kvService.collection(name);
+  }
+  /** List all collection names that have data. */
+  listCollectionNames() {
+    this._requireInit("listCollectionNames");
+    return this._kvService.listNames();
+  }
+  /** Delete a collection's data and evict from cache. */
+  deleteCollection(name) {
+    this._requireInit("deleteCollection");
+    this._kvService.delete(name);
+  }
+  /** Run indexing across selected modules. Auto-initializes. */
+  async index(options = {}) {
+    await this.initialize();
+    return runIndex(this._indexDeps, options);
+  }
+  /**
+   * Detect stale HNSW indices and hot-reload from disk.
+   * Called implicitly before every search operation.
+   * Cost: one SQLite SELECT (~5μs on WAL mode).
+   */
+  async ensureFresh() {
+    if (!this._initialized) return;
+    const dbVersions = getVersions(this._db);
+    for (const [name, dbVersion] of dbVersions) {
+      const loaded = this._loadedVersions.get(name) ?? 0;
+      if (dbVersion <= loaded) continue;
+      this.emit("progress", `Hot-reload: ${name} version ${loaded} \u2192 ${dbVersion}`);
+      this._reloadIndex(name);
+      this._loadedVersions.set(name, dbVersion);
+    }
+  }
+  /**
+   * Semantic search across all loaded modules.
+   * Scope via `sources: { code: 10, git: 0 }`.
+   */
+  async search(query, options) {
+    await this.initialize();
+    await this.ensureFresh();
+    return this._searchAPI?.search(query, options) ?? [];
+  }
+  /**
+   * Hybrid search: vector + BM25 fused with Reciprocal Rank Fusion.
+   * Scope via `sources: { code: 10, git: 5, docs: 3, myNotes: 5 }`.
+   */
+  async hybridSearch(query, options) {
+    await this.initialize();
+    await this.ensureFresh();
+    return this._searchAPI?.hybridSearch(query, options) ?? [];
+  }
+  /** BM25 keyword search only (no embeddings needed). */
+  async searchBM25(query, options) {
+    await this.initialize();
+    await this.ensureFresh();
+    return this._searchAPI?.searchBM25(query, options) ?? [];
+  }
+  /** Build formatted context block for LLM system prompt injection. Auto-initializes. */
+  async getContext(task, options = {}) {
+    await this.initialize();
+    await this.ensureFresh();
+    return this._searchAPI?.getContext(task, options) ?? "";
+  }
+  /**
+   * Resolve file paths, directories, and glob patterns to full SearchResults.
+   * Bypasses search entirely — reads directly from plugin indexes.
+   *
+   * @example
+   * const files = brain.resolveFiles(['src/auth/login.ts', 'src/graph/']);
+   */
+  resolveFiles(patterns) {
+    this._requireInit("resolveFiles");
+    const results = [];
+    for (const mod of this._registry.all) {
+      if (!isFileResolvable(mod)) continue;
+      results.push(...mod.resolveFiles(patterns));
+    }
+    return results;
+  }
+  /** Rebuild FTS5 indices. */
+  rebuildFTS() {
+    this._requireInit("rebuildFTS");
+    this._searchAPI?.rebuildFTS();
+  }
+  /** Get statistics for all loaded plugins. */
+  stats() {
+    this._requireInit("stats");
+    const result = {};
+    for (const mod of this._registry.all) {
+      if (mod.stats) {
+        const baseType = mod.name.split(":")[0];
+        result[baseType] = mod.stats();
+      }
+    }
+    return result;
+  }
+  /** Start watching for changes and auto-re-index. */
+  watch(options = {}) {
+    this._requireInit("watch");
+    void this._watcher?.close();
+    this._watcher = new Watcher(
+      async () => {
+        await this.index();
+      },
+      this._registry.all,
+      options,
+      this._config.repoPath
+    );
+    return this._watcher;
+  }
+  /**
+   * Re-embed all existing text with the current embedding provider.
+   * Use after switching providers (e.g. Local → OpenAI).
+   */
+  async reembed(options = {}) {
+    await this.initialize();
+    const hnswMap = /* @__PURE__ */ new Map();
+    if (this._kvService) {
+      hnswMap.set(HNSW.KV, { hnsw: this._kvService.hnsw, vecs: this._kvService.vecs });
+    }
+    for (const [type, shared] of this._sharedHnsw) {
+      hnswMap.set(type, { hnsw: shared.hnsw, vecs: shared.vecCache });
+    }
+    const result = await reembedAll(this._db, this._embedding, hnswMap, this._registry.all, options, {
+      dbPath: this._config.dbPath,
+      kvHnsw: this._kvService.hnsw,
+      sharedHnsw: this._sharedHnsw
+    });
+    this.emit("reembedded", result);
+    return result;
+  }
+  /**
+   * Linear 8-step initialization:
+   * 1. Open database
+   * 2. Resolve embedding provider
+   * 3. Check dimension mismatch
+   * 4. Create KV HNSW + KVService
+   * 5. Load KV vectors
+   * 6. Initialize plugins
+   * 7. Persist HNSW indices
+   * 8. Build SearchAPI + index deps
+   */
+  async _runInitialize(options = {}) {
+    if (this._initialized) return;
+    this._db = new SQLiteAdapter(this._config.dbPath);
+    this._embedding = await this._resolveEmbedding();
+    const mismatch = detectProviderMismatch(this._db, this._embedding);
+    if (mismatch?.mismatch && !options.force) {
+      this._db.close();
+      throw new Error(
+        `BrainBank: Embedding dimension mismatch (stored: ${mismatch.stored}, current: ${mismatch.current}). Run brain.reembed() to re-index with the new provider, or switch back to the original provider.`
+      );
+    }
+    setEmbeddingMeta(this._db, this._embedding);
+    const skipVectorLoad = !!(options.force && mismatch?.mismatch);
+    const dims = this._embedding.dims ?? this._config.embeddingDims;
+    const kvHnsw = new HNSWIndex(
+      dims,
+      this._config.maxElements ?? 5e5,
+      this._config.hnswM,
+      this._config.hnswEfConstruction,
+      this._config.hnswEfSearch
+    );
+    await kvHnsw.init();
+    this._kvService = new KVService(this._db, this._embedding, kvHnsw, /* @__PURE__ */ new Map(), this._config.reranker);
+    if (!skipVectorLoad) {
+      const kvIndexPath = hnswPath(this._config.dbPath, "kv");
+      const kvCount = countRows(this._db, "kv_vectors");
+      if (kvHnsw.tryLoad(kvIndexPath, kvCount)) {
+        loadVecCache(this._db, "kv_vectors", "data_id", this._kvService.vecs);
+      } else {
+        loadVectors(this._db, "kv_vectors", "data_id", kvHnsw, this._kvService.vecs);
+      }
+    }
+    const privateHnsw = /* @__PURE__ */ new Map();
+    for (const mod of this._registry.all) {
+      const pluginDb = this._getOrCreatePluginDb(mod.name);
+      if (pluginDb !== this._db) {
+        setEmbeddingMeta(pluginDb, this._embedding);
+      }
+      const ctx = this._buildPluginContext(skipVectorLoad, privateHnsw, pluginDb, mod.name);
+      await mod.initialize(ctx);
+    }
+    if (this._config.webhookPort) {
+      this._webhookServer = new WebhookServer();
+      this._webhookServer.listen(this._config.webhookPort);
+    }
+    await saveAllHnsw(this._config.dbPath, kvHnsw, this._sharedHnsw, privateHnsw);
+    this._searchAPI = createSearchAPI(
+      this._db,
+      this._embedding,
+      this._config,
+      this._registry,
+      this._kvService,
+      this._sharedHnsw
+    );
+    this._indexDeps = {
+      db: this._db,
+      dbPath: this._config.dbPath,
+      sharedHnsw: this._sharedHnsw,
+      kvHnsw,
+      registry: this._registry,
+      emit: /* @__PURE__ */ __name((e, d) => this.emit(e, d), "emit")
+    };
+    this._loadedVersions = getVersions(this._db);
+    this._initialized = true;
+    this.emit("initialized", { plugins: this.plugins });
+  }
+  /** Reset shared state after a failed `_runInitialize`. */
+  _cleanupAfterFailedInit() {
+    for (const { hnsw } of this._sharedHnsw.values()) {
+      try {
+        hnsw.reinit();
+      } catch (e) {
+        this.emit("warn", `HNSW reinit failed during cleanup: ${e}`);
+      }
+    }
+    this._kvService?.clear();
+    if (this._kvService) {
+      try {
+        this._kvService.hnsw.reinit();
+      } catch (e) {
+        this.emit("warn", `KV HNSW reinit failed during cleanup: ${e}`);
+      }
+    }
+    try {
+      this._db?.close();
+    } catch {
+    }
+    this._db = void 0;
+    this._kvService = void 0;
+    this._searchAPI = void 0;
+    this._indexDeps = void 0;
+    this._initPromise = null;
+  }
+  /** Resolve embedding: explicit config > stored DB key > local default. */
+  async _resolveEmbedding() {
+    if (this._config.embeddingProvider) return this._config.embeddingProvider;
+    const meta = getEmbeddingMeta(this._db);
+    if (meta?.providerKey && meta.providerKey !== "local") {
+      this.emit("progress", `Embedding: auto-resolved '${meta.providerKey}' from DB`);
+      return resolveEmbedding(meta.providerKey);
+    }
+    return resolveEmbedding("local");
+  }
+  /**
+   * Get or create a per-repo SQLiteAdapter for namespaced plugins.
+   * Non-namespaced plugins use the root DB.
+   * DB path: `.brainbank/<repoName>.db` (e.g., `servicehub-backend.db`).
+   */
+  _getOrCreatePluginDb(pluginName) {
+    if (!pluginName.includes(":")) return this._db;
+    const repoName = pluginName.split(":").slice(1).join(":");
+    const existing = this._repoDBs.get(repoName);
+    if (existing) return existing;
+    const dir = path5.dirname(this._config.dbPath);
+    const repoDbPath = path5.join(dir, `${repoName}.db`);
+    const db = new SQLiteAdapter(repoDbPath);
+    this._repoDBs.set(repoName, db);
+    return db;
+  }
+  /** Build a per-plugin `PluginContext` with appropriate DB and HNSW scoping. */
+  _buildPluginContext(skipVectorLoad, privateHnsw, pluginDb, pluginName) {
+    let autoId = 0;
+    const dbPath = this._config.dbPath;
+    return {
+      db: pluginDb,
+      embedding: this._embedding,
+      config: this._config,
+      createHnsw: /* @__PURE__ */ __name(async (maxElements, dims, name) => {
+        const hnsw = await new HNSWIndex(
+          dims ?? this._config.embeddingDims,
+          maxElements ?? this._config.maxElements,
+          this._config.hnswM,
+          this._config.hnswEfConstruction,
+          this._config.hnswEfSearch
+        ).init();
+        privateHnsw.set(name ?? `private-${autoId++}`, hnsw);
+        return hnsw;
+      }, "createHnsw"),
+      loadVectors: /* @__PURE__ */ __name((table, idCol, hnsw, cache) => {
+        if (skipVectorLoad) return;
+        const indexName = table.replace("_vectors", "").replace("_chunks", "");
+        const indexPath = hnswPath(dbPath, `${indexName}-${pluginDb === this._db ? "root" : "repo"}`);
+        const rowCount = countRows(pluginDb, table);
+        if (hnsw.tryLoad(indexPath, rowCount)) {
+          loadVecCache(pluginDb, table, idCol, cache);
+        } else {
+          loadVectors(pluginDb, table, idCol, hnsw, cache);
+        }
+      }, "loadVectors"),
+      getOrCreateSharedHnsw: /* @__PURE__ */ __name(async (type, maxElements, dims) => {
+        const existing = this._sharedHnsw.get(type);
+        if (existing) return { ...existing, isNew: false };
+        const hnsw = await new HNSWIndex(
+          dims ?? this._config.embeddingDims,
+          maxElements ?? this._config.maxElements,
+          this._config.hnswM,
+          this._config.hnswEfConstruction,
+          this._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._kvService.collection(name), "collection"),
+      createTracker: /* @__PURE__ */ __name(() => createTracker(pluginDb, pluginName), "createTracker"),
+      webhookServer: this._webhookServer
+    };
+  }
+  /**
+   * Reload a single HNSW index by name.
+   * Discovers the vector table via ReembeddablePlugin capability.
+   * KV is handled directly since it's core-owned.
+   *
+   * The `name` comes from `index_state` and equals the plugin's `mod.name`
+   * (e.g. `code:backend`, `git`, `docs`). This matches the key used in
+   * `getOrCreateSharedHnsw()` during initialization.
+   */
+  _reloadIndex(name) {
+    if (name === HNSW.KV && this._kvService) {
+      reloadHnsw({
+        dbPath: this._config.dbPath,
+        db: this._db,
+        name,
+        hnsw: this._kvService.hnsw,
+        vecCache: this._kvService.vecs,
+        vectorTable: "kv_vectors",
+        idCol: "data_id"
+      });
+      return;
+    }
+    const shared = this._sharedHnsw.get(name);
+    if (!shared) return;
+    for (const mod of this._registry.all) {
+      if (!isReembeddable(mod)) continue;
+      if (mod.name !== name) continue;
+      const cfg = mod.reembedConfig();
+      reloadHnsw({
+        dbPath: this._config.dbPath,
+        db: this._db,
+        name,
+        hnsw: shared.hnsw,
+        vecCache: shared.vecCache,
+        vectorTable: cfg.vectorTable,
+        idCol: cfg.fkColumn
+      });
+      return;
+    }
+  }
+  /** Guard: throw descriptive error if not initialized. */
+  _requireInit(method) {
+    if (!this._initialized) {
+      throw new Error(`BrainBank: Not initialized. Call await brain.initialize() before ${method}().`);
+    }
+  }
+};
+
+// src/cli/utils.ts
+var c = {
+  green: /* @__PURE__ */ __name((s) => `\x1B[32m${s}\x1B[0m`, "green"),
+  red: /* @__PURE__ */ __name((s) => `\x1B[31m${s}\x1B[0m`, "red"),
+  yellow: /* @__PURE__ */ __name((s) => `\x1B[33m${s}\x1B[0m`, "yellow"),
+  cyan: /* @__PURE__ */ __name((s) => `\x1B[36m${s}\x1B[0m`, "cyan"),
+  dim: /* @__PURE__ */ __name((s) => `\x1B[2m${s}\x1B[0m`, "dim"),
+  bold: /* @__PURE__ */ __name((s) => `\x1B[1m${s}\x1B[0m`, "bold"),
+  magenta: /* @__PURE__ */ __name((s) => `\x1B[35m${s}\x1B[0m`, "magenta")
+};
+var args = process.argv.slice(2);
+function getFlag(name) {
+  const idx = args.indexOf(`--${name}`);
+  return idx >= 0 ? args[idx + 1] : void 0;
+}
+__name(getFlag, "getFlag");
+function hasFlag(name) {
+  return args.includes(`--${name}`);
+}
+__name(hasFlag, "hasFlag");
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "repo",
+  "depth",
+  "collection",
+  "pattern",
+  "context",
+  "name",
+  "keep",
+  "reranker",
+  "pruner",
+  "only",
+  "docs",
+  "path",
+  "ignore",
+  "meta",
+  "k",
+  "mode",
+  "limit"
+]);
+function stripFlags(argv) {
+  const result = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith("--")) {
+      const name = argv[i].slice(2);
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) {
+        if (VALUE_FLAGS.has(name) || /^\d+$/.test(next)) {
+          i++;
+        }
+      }
+      continue;
+    }
+    result.push(argv[i]);
+  }
+  return result;
+}
+__name(stripFlags, "stripFlags");
+function printResults(results, minScore = 0.7) {
+  const filtered = results.filter((r) => r.score >= minScore).slice(0, 20);
+  if (filtered.length === 0) {
+    console.log(c.yellow(`  No results above ${Math.round(minScore * 100)}% score.`));
+    return;
+  }
+  for (const r of filtered) {
+    const score = Math.round(r.score * 100);
+    if (r.type === "code") {
+      const m = r.metadata;
+      console.log(
+        `${c.green(`[CODE ${score}%]`)} ${c.bold(r.filePath)} \u2014 ${m.name || m.chunkType} ${c.dim(`L${m.startLine}-${m.endLine}`)}`
+      );
+      console.log(c.dim(r.content.split("\n").slice(0, 5).join("\n")));
+      console.log("");
+    } else if (r.type === "commit") {
+      const m = r.metadata;
+      console.log(
+        `${c.cyan(`[COMMIT ${score}%]`)} ${c.bold(m.shortHash)} ${r.content} ${c.dim(`(${m.author})`)}`
+      );
+      if (m.files?.length) console.log(c.dim(`  Files: ${m.files.slice(0, 4).join(", ")}`));
+      console.log("");
+    } else if (r.type === "document") {
+      const ctx = r.context ? ` \u2014 ${c.dim(r.context)}` : "";
+      console.log(
+        `${c.magenta(`[DOC ${score}%]`)} ${c.bold(r.filePath)} [${r.metadata.collection}]${ctx}`
+      );
+      console.log(c.dim(r.content.split("\n").slice(0, 4).join("\n")));
+      console.log("");
+    }
+  }
+}
+__name(printResults, "printResults");
+function findDocsPlugin(brain) {
+  for (const name of brain.plugins) {
+    const p = brain.plugin(name);
+    if (p && isDocsPlugin(p)) return p;
+  }
+  return void 0;
+}
+__name(findDocsPlugin, "findDocsPlugin");
+
+// src/cli/factory/brain-context.ts
+function contextFromCLI(repoPath) {
+  return {
+    repoPath: repoPath ?? getFlag("repo") ?? ".",
+    env: process.env,
+    flags: {
+      ignore: getFlag("ignore"),
+      reranker: getFlag("reranker"),
+      pruner: getFlag("pruner"),
+      embedding: getFlag("embedding")
+    }
+  };
+}
+__name(contextFromCLI, "contextFromCLI");
+function ctxFlag(ctx, name) {
+  return ctx.flags?.[name];
+}
+__name(ctxFlag, "ctxFlag");
+
+// src/cli/factory/builtin-registration.ts
+import * as fs5 from "fs";
+import * as path7 from "path";
+
+// src/cli/factory/plugin-loader.ts
+import * as fs4 from "fs";
+import * as path6 from "path";
+var PLUGIN_LOADERS = /* @__PURE__ */ new Map([
+  ["code", async () => {
+    try {
+      return (await import("@brainbank/code")).code;
+    } catch {
+      return null;
+    }
+  }],
+  ["git", async () => {
+    try {
+      return (await import("@brainbank/git")).git;
+    } catch {
+      return null;
+    }
+  }],
+  ["docs", async () => {
+    try {
+      return (await import("@brainbank/docs")).docs;
+    } catch {
+      return null;
+    }
+  }]
+]);
+var MULTI_REPO_PLUGINS = /* @__PURE__ */ new Set(["code", "git"]);
+async function loadPlugin(name) {
+  const loader = PLUGIN_LOADERS.get(name);
+  if (!loader) return null;
+  return loader();
+}
+__name(loadPlugin, "loadPlugin");
+function isMultiRepoCapable(name) {
+  return MULTI_REPO_PLUGINS.has(name);
+}
+__name(isMultiRepoCapable, "isMultiRepoCapable");
+var INDEXER_EXTENSIONS = [".ts", ".js", ".mjs"];
+var NOT_LOADED = /* @__PURE__ */ Symbol("not-loaded");
+var _folderPluginsCache = NOT_LOADED;
+async function discoverFolderPlugins(repoPath) {
+  if (_folderPluginsCache !== NOT_LOADED) return _folderPluginsCache;
+  const pluginsDir = path6.resolve(repoPath, ".brainbank", "plugins");
+  if (!fs4.existsSync(pluginsDir)) {
+    _folderPluginsCache = [];
+    return [];
+  }
+  const files = fs4.readdirSync(pluginsDir).filter((f) => INDEXER_EXTENSIONS.some((ext) => f.endsWith(ext))).sort();
+  const plugins = [];
+  for (const file of files) {
+    const filePath = path6.join(pluginsDir, file);
+    try {
+      const mod = await import(filePath);
+      const plugin = mod.default ?? mod;
+      if (plugin && typeof plugin === "object" && plugin.name) {
+        plugins.push(plugin);
+      } else {
+        console.error(c.yellow(`\u26A0 ${file}: must export a default Plugin with a 'name' property, skipping`));
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(c.red(`Error loading plugin ${file}: ${message}`));
+    }
+  }
+  _folderPluginsCache = plugins;
+  return plugins;
+}
+__name(discoverFolderPlugins, "discoverFolderPlugins");
+function resetPluginCache() {
+  _folderPluginsCache = NOT_LOADED;
+}
+__name(resetPluginCache, "resetPluginCache");
+async function resolveEmbeddingKey(key) {
+  const { resolveEmbedding: resolveEmbedding2 } = await import("./resolve-Q5D6HECY.js");
+  return resolveEmbedding2(key);
+}
+__name(resolveEmbeddingKey, "resolveEmbeddingKey");
+async function setupProviders(brainOpts, config, flags, env) {
+  const rerankerFlag = flags?.reranker ?? config?.reranker;
+  if (rerankerFlag === "qwen3") {
+    const { Qwen3Reranker } = await import("./qwen3-reranker-HVIQOLKS.js");
+    brainOpts.reranker = new Qwen3Reranker();
+  }
+  const prunerFlag = flags?.pruner ?? config?.pruner;
+  if (prunerFlag === "haiku") {
+    const { HaikuPruner } = await import("./haiku-pruner-DB77ZQLJ.js");
+    brainOpts.pruner = new HaikuPruner();
+  }
+  const expanderFlag = flags?.expander ?? config?.expander;
+  if (expanderFlag === "haiku") {
+    try {
+      const { HaikuExpander } = await import("./haiku-expander-WOVJIVXD.js");
+      brainOpts.expander = new HaikuExpander();
+    } catch {
+    }
+  }
+  const embFlag = flags?.embedding ?? config?.embedding ?? env?.BRAINBANK_EMBEDDING ?? process.env.BRAINBANK_EMBEDDING;
+  if (embFlag) {
+    const provider = await resolveEmbeddingKey(embFlag);
+    brainOpts.embeddingProvider = provider;
+    brainOpts.embeddingDims = provider.dims;
+  }
+  if (config?.context) {
+    brainOpts.contextFields = config.context;
+  }
+}
+__name(setupProviders, "setupProviders");
+
+// src/cli/factory/builtin-registration.ts
+function pluginCfg(config, pluginName) {
+  const section = config?.[pluginName];
+  if (section && typeof section === "object" && !Array.isArray(section)) {
+    return section;
+  }
+  return {};
+}
+__name(pluginCfg, "pluginCfg");
+function detectGitSubdirs(parentPath, repos) {
+  try {
+    const entries = fs5.readdirSync(parentPath, { withFileTypes: true });
+    let subdirs = entries.filter((e) => {
+      if (e.name.startsWith(".") || e.name.startsWith("node_modules")) return false;
+      const isDir = e.isDirectory() || e.isSymbolicLink() && fs5.statSync(path7.join(parentPath, e.name)).isDirectory();
+      return isDir && fs5.existsSync(path7.join(parentPath, e.name, ".git"));
+    }).map((e) => ({ name: e.name, path: path7.join(parentPath, e.name) }));
+    if (repos && repos.length > 0) {
+      const allowed = new Set(repos);
+      subdirs = subdirs.filter((s) => allowed.has(s.name));
+    }
+    return subdirs;
+  } catch {
+    return [];
+  }
+}
+__name(detectGitSubdirs, "detectGitSubdirs");
+async function registerBuiltins(brain, rp, pluginNames, config, ignorePatterns = []) {
+  const resolvedRp = path7.resolve(rp);
+  const hasRootGit = fs5.existsSync(path7.join(resolvedRp, ".git"));
+  const configRepos = config?.repos;
+  const gitSubdirs = !hasRootGit ? detectGitSubdirs(resolvedRp, configRepos) : [];
+  for (const name of pluginNames) {
+    const factory = await loadPlugin(name);
+    if (!factory) {
+      console.error(c.yellow(`  \u26A0 @brainbank/${name} not installed \u2014 skipping ${name} indexing`));
+      console.error(c.dim(`    Install: npm i -g @brainbank/${name}`));
+      continue;
+    }
+    const cfg = pluginCfg(config, name);
+    const embKey = cfg.embedding;
+    const embeddingProvider = embKey ? await resolveEmbeddingKey(embKey) : void 0;
+    if (gitSubdirs.length > 0 && isMultiRepoCapable(name)) {
+      console.error(c.cyan(`  Multi-repo: found ${gitSubdirs.length} git repos: ${gitSubdirs.map((d) => d.name).join(", ")}`));
+      for (const sub of gitSubdirs) {
+        const mergedIgnore = [...cfg.ignore ?? [], ...ignorePatterns];
+        brain.use(factory({
+          ...cfg,
+          repoPath: sub.path,
+          name: `${name}:${sub.name}`,
+          embeddingProvider,
+          ignore: mergedIgnore.length > 0 ? mergedIgnore : void 0
+        }));
+      }
+    } else {
+      const configIgnore = cfg.ignore ?? [];
+      const mergedIgnore = [...configIgnore, ...ignorePatterns];
+      brain.use(factory({
+        ...cfg,
+        repoPath: rp,
+        embeddingProvider,
+        ignore: mergedIgnore.length > 0 ? mergedIgnore : void 0
+      }));
+    }
+  }
+}
+__name(registerBuiltins, "registerBuiltins");
+async function registerConfigCollections(brain, rp, config) {
+  const docsCfg = pluginCfg(config, "docs");
+  const collections = docsCfg.collections;
+  if (!collections?.length) return;
+  const { isDocsPlugin: isDocsPlugin2 } = await import("./plugin-FF4Q34TI.js");
+  const rawPlugin = brain.plugin("docs");
+  if (!rawPlugin || !isDocsPlugin2(rawPlugin)) return;
+  const repoPath = path7.resolve(rp);
+  for (const coll of collections) {
+    const absPath = path7.resolve(repoPath, coll.path);
+    try {
+      await rawPlugin.addCollection({
+        name: coll.name,
+        path: absPath,
+        pattern: coll.pattern ?? "**/*.md",
+        ignore: coll.ignore,
+        context: coll.context
+      });
+    } catch (e) {
+      if (!(e instanceof Error && e.message.includes("already"))) throw e;
+    }
+  }
+}
+__name(registerConfigCollections, "registerConfigCollections");
+
+// src/cli/factory/config-loader.ts
+import * as fs6 from "fs";
+import * as path8 from "path";
+var CONFIG_NAMES = ["config.json", "config.ts", "config.js", "config.mjs"];
+var NOT_LOADED2 = /* @__PURE__ */ Symbol("not-loaded");
+var _configCache = NOT_LOADED2;
+async function loadConfig(repoPath) {
+  if (_configCache !== NOT_LOADED2) return _configCache;
+  const brainbankDir = path8.resolve(repoPath, ".brainbank");
+  for (const name of CONFIG_NAMES) {
+    const configPath = path8.join(brainbankDir, name);
+    if (!fs6.existsSync(configPath)) continue;
+    try {
+      if (name === "config.json") {
+        const raw = fs6.readFileSync(configPath, "utf-8");
+        _configCache = JSON.parse(raw);
+      } else {
+        const mod = await import(configPath);
+        _configCache = mod.default ?? mod;
+      }
+      return _configCache;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(c.red(`Error loading .brainbank/${name}: ${message}`));
+      process.exit(1);
+    }
+  }
+  _configCache = null;
+  return null;
+}
+__name(loadConfig, "loadConfig");
+async function getConfig(repoPath) {
+  return loadConfig(repoPath ?? ".");
+}
+__name(getConfig, "getConfig");
+function resetConfigCache() {
+  _configCache = NOT_LOADED2;
+}
+__name(resetConfigCache, "resetConfigCache");
+
+// src/cli/factory/index.ts
+function resetFactoryCache() {
+  resetConfigCache();
+  resetPluginCache();
+}
+__name(resetFactoryCache, "resetFactoryCache");
+async function createBrain(contextOrRepo) {
+  const ctx = typeof contextOrRepo === "string" ? contextFromCLI(contextOrRepo) : contextOrRepo ?? contextFromCLI();
+  const rp = ctx.repoPath;
+  const config = await loadConfig(rp);
+  const folderPlugins = await discoverFolderPlugins(rp);
+  const brainOpts = { repoPath: rp, ...config?.brainbank ?? {} };
+  if (config?.maxFileSize) brainOpts.maxFileSize = config.maxFileSize;
+  await setupProviders(brainOpts, config, ctx.flags, ctx.env);
+  const brain = new BrainBank(brainOpts);
+  const builtins = config?.plugins ?? ["code", "git", "docs"];
+  const ignoreFlag = ctxFlag(ctx, "ignore");
+  const ignorePatterns = ignoreFlag ? ignoreFlag.split(",").map((s) => s.trim()) : [];
+  await registerBuiltins(brain, rp, builtins, config, ignorePatterns);
+  for (const plugin of folderPlugins) brain.use(plugin);
+  if (config?.indexers) {
+    for (const plugin of config.indexers) brain.use(plugin);
+  }
+  return brain;
+}
+__name(createBrain, "createBrain");
+
+export {
+  DEFAULTS,
+  resolveConfig,
+  HNSW,
+  SQLiteAdapter,
+  createTracker,
+  bumpVersion,
+  getVersions,
+  getVersion,
+  acquireLock,
+  releaseLock,
+  withLock,
+  cosineSimilarity,
+  normalize,
+  vecToBuffer,
+  rerank,
+  reciprocalRankFusion,
+  pruneResults,
+  ContextBuilder,
+  CompositeBM25Search,
+  CompositeVectorSearch,
+  HNSWIndex,
+  sanitizeFTS,
+  normalizeBM25,
+  escapeLike,
+  Collection,
+  KVService,
+  SUPPORTED_EXTENSIONS,
+  IGNORE_DIRS,
+  isSupported,
+  getLanguage,
+  isIgnoredDir,
+  isIgnoredFile,
+  Watcher,
+  WebhookServer,
+  BrainBank,
+  c,
+  args,
+  getFlag,
+  hasFlag,
+  stripFlags,
+  printResults,
+  findDocsPlugin,
+  contextFromCLI,
+  registerConfigCollections,
+  loadConfig,
+  getConfig,
+  resetFactoryCache,
+  createBrain
+};
+//# sourceMappingURL=chunk-JRVYSTMP.js.map