brainbank 0.7.0 → 0.8.0

package/dist/index.d.ts

@@ -1,48 +1,1063 @@
 import { EventEmitter } from 'node:events';
-import { a as ProgressCallback, B as BrainBankConfig, P as Plugin, C as Collection, S as StageProgressCallback, I as IndexResult, D as DocumentCollection, b as SearchResult, c as ContextOptions, d as CoEditSuggestion, e as IndexStats, R as ResolvedConfig, E as EmbeddingProvider, f as Reranker, V as VectorIndex, g as SearchHit, h as CodeChunk, i as Database, H as HNSWIndex, L as LearningPattern } from './base-3SNc_CeY.js';
-export { j as CodeResult, k as CodeResultMetadata, l as CollectionAddOptions, m as CollectionItem, n as CollectionPlugin, o as CollectionResult, p as CollectionSearchOptions, q as CommitResult, r as CommitResultMetadata, s as DistilledStrategy, t as DocChunk, u as DocumentResult, v as DocumentResultMetadata, G as GitCommitRecord, w as IndexablePlugin, x as PatternResult, y as PatternResultMetadata, z as PluginContext, A as SearchResultType, F as SearchablePlugin, W as WatchablePlugin, J as isCodeResult, K as isCollectionResult, M as isCommitResult, N as isDocumentResult, O as isPatternResult, Q as matchResult } from './base-3SNc_CeY.js';
-export { code } from './code.js';
-export { git } from './git.js';
-export { docs } from './docs.js';
-export { memory } from './memory.js';
-export { notes } from './notes.js';
-import 'better-sqlite3';
 
 /**
- * BrainBank — Watch Mode
+ * BrainBank — Database Adapter Interface
  *
- * Auto-indexes on file changes using fs.watch.
- * Works with built-in indexers (code, git, docs) and custom indexers.
+ * Abstract contract for database operations. All consumers depend on
+ * this interface — never on a concrete driver. The `SQLiteAdapter`
+ * is the built-in implementation; future adapters (LibSQL, Turso,
+ * PostgreSQL) implement the same contract.
  *
- * Built-in behavior:
- *   - Code files → re-indexes changed file
- *   - Doc files  → re-indexes changed collection
+ * Phase 1: sync-first API matching the existing `better-sqlite3` usage.
+ * Async variants will be added when needed by async-native adapters.
+ */
+/** Result from mutating queries (INSERT / UPDATE / DELETE). */
+interface ExecuteResult {
+    /** Row ID of the last inserted row. */
+    lastInsertRowid: number | bigint;
+    /** Number of rows changed by the statement. */
+    changes: number;
+}
+/** A prepared statement with typed query methods. */
+interface PreparedStatement<T = unknown> {
+    /** Execute a query and return the first matching row, or `undefined`. */
+    get(...params: unknown[]): T | undefined;
+    /** Execute a query and return all matching rows. */
+    all(...params: unknown[]): T[];
+    /** Execute a mutating statement and return the result. */
+    run(...params: unknown[]): ExecuteResult;
+    /** Iterate over matching rows without loading them all into memory. */
+    iterate(...params: unknown[]): IterableIterator<T>;
+}
+/** Adapter capability flags — describes what the underlying engine supports. */
+interface AdapterCapabilities {
+    /** Full-text search engine. */
+    fts: 'fts5' | 'tsvector' | 'none';
+    /** Upsert syntax dialect. */
+    upsert: 'or-replace' | 'on-conflict';
+    /** Native JSON column support. */
+    json: boolean;
+    /** Native vector column support (e.g. pgvector). */
+    vectors: boolean;
+}
+/**
+ * Database adapter interface.
+ *
+ * All BrainBank components depend on this contract instead of a
+ * concrete database driver. Keeps the door open for LibSQL, Turso,
+ * PostgreSQL, etc. without touching consumer code.
+ */
+interface DatabaseAdapter {
+    /** Prepare a reusable statement. */
+    prepare<T = unknown>(sql: string): PreparedStatement<T>;
+    /** Execute raw DDL / multi-statement SQL (no results). */
+    exec(sql: string): void;
+    /** Run `fn` inside a transaction. Auto-commits on success, auto-rollbacks on error. */
+    transaction<T>(fn: () => T): T;
+    /** Run a prepared statement on multiple rows inside a single transaction. */
+    batch<T extends unknown[]>(sql: string, rows: T[]): void;
+    /** Close the database and release resources. */
+    close(): void;
+    /** Engine capabilities (FTS, upsert dialect, etc.). */
+    readonly capabilities: AdapterCapabilities;
+    /**
+     * Escape hatch: access the underlying raw driver.
+     * Returns `undefined` for adapters that don't support raw access.
+     *
+     * @deprecated Use `DatabaseAdapter` methods instead. This exists
+     * only for gradual migration of plugins that depend on driver internals.
+     */
+    raw<T = unknown>(): T | undefined;
+}
+interface KvDataRow {
+    id: number;
+    collection: string;
+    content: string;
+    meta_json: string;
+    tags_json: string;
+    expires_at: number | null;
+    created_at: number;
+}
+interface KvVectorRow {
+    data_id: number;
+    embedding: Buffer;
+}
+interface EmbeddingMetaRow {
+    value: string;
+}
+interface VectorRow {
+    id: number;
+    embedding: Buffer;
+}
+interface CountRow {
+    c: number;
+}
+
+/**
+ * BrainBank — Plugin Migration System
  *
- * Custom indexers:
- *   - Implement `onFileChange(path, event)` to handle changes
- *   - Implement `watchPatterns()` to specify which files to watch
+ * Per-plugin versioned schema migrations.
+ * Each plugin declares a schemaVersion + ordered migrations array.
+ * Core stores applied versions in `plugin_versions` table.
  *
- * Usage:
- *   const watcher = brain.watch({ paths: ['.'] });
- *   watcher.close(); // stop watching
+ * Plugins call `runPluginMigrations()` at the top of their `initialize()`.
+ * Migrations use `IF NOT EXISTS` so first run on an existing DB is a no-op.
  */
 
-interface WatchOptions {
-    /** Paths to watch. Default: [config.repoPath] */
-    paths?: string[];
-    /** Debounce interval in ms. Default: 2000 */
+/** A single migration step. */
+interface Migration {
+    /** Version this migration brings the schema to. */
+    version: number;
+    /** Apply the migration. Must be idempotent (use IF NOT EXISTS). */
+    up(adapter: DatabaseAdapter): void;
+}
+/**
+ * Run pending migrations for a plugin.
+ * Skips migrations whose version <= stored version.
+ * Each migration runs in its own transaction.
+ */
+declare function runPluginMigrations(adapter: DatabaseAdapter, pluginName: string, schemaVersion: number, migrations: Migration[]): void;
+
+/**
+ * BrainBank — Incremental Tracker
+ *
+ * Standardized helper for plugins to detect add/update/delete during indexing.
+ * Uses a shared `plugin_tracking` table with per-plugin namespacing.
+ *
+ * Usage in a plugin:
+ *   const tracker = ctx.createTracker();  // uses plugin name
+ *   for (const file of files) {
+ *       const hash = sha256(content);
+ *       if (tracker.isUnchanged(file, hash)) { skipped++; continue; }
+ *       indexFile(file, content);
+ *       tracker.markIndexed(file, hash);
+ *   }
+ *   const orphans = tracker.findOrphans(new Set(files));
+ *   for (const key of orphans) { removeData(key); tracker.remove(key); }
+ */
+
+/** Incremental index tracker — detects add/update/delete for plugin files. */
+interface IncrementalTracker {
+    /** Check if a key's content is unchanged. Returns true if the hash matches (skip indexing). */
+    isUnchanged(key: string, contentHash: string): boolean;
+    /** Mark a key as successfully indexed with the given hash. Call after indexing completes. */
+    markIndexed(key: string, contentHash: string): void;
+    /** Find tracked keys that are NOT in the current set. Returns keys to delete. */
+    findOrphans(currentKeys: Set<string>): string[];
+    /** Remove tracking for a key. Call after cleaning up the key's data. */
+    remove(key: string): void;
+    /** Remove all tracking entries for this plugin. */
+    clear(): void;
+}
+/** Create an IncrementalTracker scoped to a plugin name. */
+declare function createTracker(db: DatabaseAdapter, pluginName: string): IncrementalTracker;
+
+/**
+ * BrainBank — Collection
+ *
+ * Universal key-value store with vector + BM25 hybrid search.
+ * The foundation primitive — store anything, search semantically.
+ *
+ *   const errors = brain.collection('debug_errors');
+ *   await errors.add('Fixed null check in api handler', { file: 'api.ts' });
+ *   const hits = await errors.search('null pointer');
+ */
+
+interface CollectionItem {
+    id: number;
+    collection: string;
+    content: string;
+    metadata: Record<string, unknown>;
+    tags: string[];
+    createdAt: number;
+    expiresAt?: number;
+    score?: number;
+}
+interface CollectionSearchOptions {
+    /** Max results. Default: 5 */
+    k?: number;
+    /** Search mode. Default: 'hybrid' */
+    mode?: 'hybrid' | 'vector' | 'keyword';
+    /** Minimum score threshold. Default: 0.15 */
+    minScore?: number;
+    /** Filter by tags (item must have ALL specified tags). */
+    tags?: string[];
+}
+interface CollectionAddOptions {
+    /** Metadata key-value pairs. */
+    metadata?: Record<string, unknown>;
+    /** Tags for filtering. */
+    tags?: string[];
+    /** Time-to-live duration string (e.g. '7d', '24h', '30m'). */
+    ttl?: string;
+}
+declare class Collection {
+    private _name;
+    private _db;
+    private _embedding;
+    private _hnsw;
+    private _vecs;
+    private _reranker?;
+    constructor(_name: string, _db: DatabaseAdapter, _embedding: EmbeddingProvider, _hnsw: HNSWIndex, _vecs: Map<number, Float32Array>, _reranker?: Reranker | undefined);
+    /** Collection name. */
+    get name(): string;
+    /** Add an item. Returns its ID. */
+    add(content: string, options?: CollectionAddOptions | Record<string, unknown>): Promise<number>;
+    /** Update an item's content (re-embeds). Returns the new ID. */
+    update(id: number, content: string, options?: CollectionAddOptions): Promise<number>;
+    /** Add multiple items. Returns their IDs. */
+    addMany(items: {
+        content: string;
+        metadata?: Record<string, unknown>;
+        tags?: string[];
+        ttl?: string;
+    }[]): Promise<number[]>;
+    /** Search this collection. */
+    search(query: string, options?: CollectionSearchOptions): Promise<CollectionItem[]>;
+    /** Search and return results as SearchResult[] for use in hybrid search pipelines. */
+    searchAsResults(query: string, k: number): Promise<SearchResult[]>;
+    /** List items (newest first). */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+        tags?: string[];
+    }): CollectionItem[];
+    /** Count items in this collection. */
+    count(): number;
+    /** Keep only the N most recent items, remove the rest. */
+    trim(options: {
+        keep: number;
+    }): Promise<{
+        removed: number;
+    }>;
+    /** Remove items older than a duration string (e.g. '30d', '12h'). */
+    prune(options: {
+        olderThan: string;
+    }): Promise<{
+        removed: number;
+    }>;
+    /** Remove a specific item by ID. */
+    remove(id: number): void;
+    /** Clear all items in this collection. */
+    clear(): void;
+    private _removeById;
+    private _searchVector;
+    /** Compute adaptive over-fetch multiplier based on collection density in shared HNSW. */
+    private _adaptiveSearchK;
+    private _searchBM25;
+    private _rowToItem;
+    /** Filter results by tags (item must have ALL specified tags). */
+    private _filterByTags;
+    /** Remove expired items (TTL). Called automatically on search/list. */
+    private _pruneExpired;
+}
+
+/**
+ * BrainBank — Type Definitions
+ *
+ * All interfaces and types for the semantic knowledge bank.
+ */
+
+/** Public contract for a KV collection. Plugins depend on this interface, not the concrete class. */
+interface ICollection {
+    /** Collection name. */
+    readonly name: string;
+    /** Add an item. Returns its ID. */
+    add(content: string, options?: CollectionAddOptions | Record<string, unknown>): Promise<number>;
+    /** Update an item's content (re-embeds). Returns the new ID. */
+    update(id: number, content: string, options?: CollectionAddOptions): Promise<number>;
+    /** Add multiple items. Returns their IDs. */
+    addMany(items: {
+        content: string;
+        metadata?: Record<string, unknown>;
+        tags?: string[];
+        ttl?: string;
+    }[]): Promise<number[]>;
+    /** Search this collection. */
+    search(query: string, options?: CollectionSearchOptions): Promise<CollectionItem[]>;
+    /** List items (newest first). */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+        tags?: string[];
+    }): CollectionItem[];
+    /** Count items in this collection. */
+    count(): number;
+    /** Keep only the N most recent items. */
+    trim(options: {
+        keep: number;
+    }): Promise<{
+        removed: number;
+    }>;
+    /** Remove items older than a duration string. */
+    prune(options: {
+        olderThan: string;
+    }): Promise<{
+        removed: number;
+    }>;
+    /** Remove a specific item by ID. */
+    remove(id: number): void;
+    /** Clear all items in this collection. */
+    clear(): void;
+}
+interface BrainBankConfig {
+    /** Root path of the repository to index. Default: '.' */
+    repoPath?: string;
+    /** SQLite database path. Default: '.brainbank/data/brainbank.db' */
+    dbPath?: string;
+    /** Max git commits to index. Default: 500 */
+    gitDepth?: number;
+    /** Max file size in bytes to index. Default: 512_000 (500KB) */
+    maxFileSize?: number;
+    /** Max diff bytes per commit. Default: 8192 */
+    maxDiffBytes?: number;
+    /** HNSW M parameter (connections per node). Default: 16 */
+    hnswM?: number;
+    /** HNSW efConstruction (build-time candidates). Default: 200 */
+    hnswEfConstruction?: number;
+    /** HNSW efSearch (query-time candidates). Default: 50 */
+    hnswEfSearch?: number;
+    /** Embedding dimensions. Default: 384 */
+    embeddingDims?: number;
+    /** Max HNSW elements. Default: 2_000_000 */
+    maxElements?: number;
+    /** Custom embedding provider (default: local WASM model) */
+    embeddingProvider?: EmbeddingProvider;
+    /** Optional reranker for improved search quality */
+    reranker?: Reranker;
+    /** Optional LLM noise filter — drops irrelevant results before formatting */
+    pruner?: Pruner;
+    /** Optional LLM context expander — discovers additional relevant chunks after pruning */
+    expander?: Expander;
+    /** Port for optional webhook server (enables push-based watch plugins). */
+    webhookPort?: number;
+    /** Context field defaults from config.json "context" section. */
+    contextFields?: Record<string, unknown>;
+}
+interface ResolvedConfig {
+    repoPath: string;
+    dbPath: string;
+    gitDepth: number;
+    maxFileSize: number;
+    maxDiffBytes: number;
+    hnswM: number;
+    hnswEfConstruction: number;
+    hnswEfSearch: number;
+    embeddingDims: number;
+    maxElements: number;
+    embeddingProvider?: EmbeddingProvider;
+    reranker?: Reranker;
+    pruner?: Pruner;
+    expander?: Expander;
+    webhookPort?: number;
+    /** Context field defaults from config.json "context" section. */
+    contextFields?: Record<string, unknown>;
+}
+interface EmbeddingProvider {
+    /** Vector dimensions produced by this provider. */
+    readonly dims: number;
+    /** Embed a single text string. */
+    embed(text: string): Promise<Float32Array>;
+    /** Embed multiple texts (batch). */
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    /** Release resources. */
+    close(): Promise<void>;
+}
+interface Reranker {
+    /**
+     * Score each document's relevance to the query.
+     * @param query - The search query
+     * @param documents - Document contents to rank
+     * @returns Relevance scores (0.0 - 1.0) in same order as documents
+     */
+    rank(query: string, documents: string[]): Promise<number[]>;
+    /** Release resources (e.g. unload model). */
+    close?(): Promise<void>;
+}
+/** Item passed to the pruner for noise classification. */
+interface PrunerItem {
+    /** Positional index (used to map back to SearchResult[]) */
+    id: number;
+    /** File path — primary signal for relevance */
+    filePath: string;
+    /** Trimmed content preview */
+    preview: string;
+    /** Chunk metadata (type, name, language, lines, etc.) */
+    metadata: Record<string, unknown>;
+}
+interface Pruner {
+    /**
+     * Filter noise from search results and order by semantic relevance.
+     * @param query - The search query
+     * @param items - Items to evaluate (filePath + metadata + trimmed preview)
+     * @returns Array of item IDs to KEEP, ordered by relevance to the query
+     *          (most relevant first). Everything else is dropped.
+     */
+    prune(query: string, items: PrunerItem[]): Promise<number[]>;
+    /** Release resources. */
+    close?(): Promise<void>;
+}
+/** Lightweight chunk descriptor for the expander manifest. */
+interface ExpanderManifestItem {
+    /** Chunk ID (code_chunks.id) */
+    id: number;
+    /** File path */
+    filePath: string;
+    /** Chunk name (e.g. function/class name) */
+    name: string;
+    /** Chunk type (function, class, method, etc.) */
+    chunkType: string;
+    /** Line range (e.g. "L45-L89") */
+    lines: string;
+}
+/** Result from the expander: chunk IDs to add + optional free-text note. */
+interface ExpanderResult {
+    /** Additional chunk IDs to splice into results. */
+    ids: number[];
+    /** Brief observation for the agent (e.g. "file X not found", "module Y is deprecated"). */
+    note?: string;
+}
+interface Expander {
+    /**
+     * Given a task and a manifest of available chunks,
+     * return additional chunk IDs + an optional contextual note.
+     * Runs after pruning. Fail-open: errors return empty result.
+     *
+     * @param query - The search query / task description
+     * @param currentIds - IDs of chunks already in results (from search + prune)
+     * @param manifest - All available chunks (lightweight descriptors)
+     * @returns Chunk IDs to add + optional note
+     */
+    expand(query: string, currentIds: number[], manifest: ExpanderManifestItem[]): Promise<ExpanderResult>;
+    /** Release resources. */
+    close?(): Promise<void>;
+}
+interface SearchHit {
+    id: number;
+    score: number;
+}
+interface VectorIndex {
+    /** Initialize the index. Must be called before add/search. */
+    init(): Promise<this>;
+    /** Add a vector with an integer ID. Idempotent: duplicate IDs are skipped. */
+    add(vector: Float32Array, id: number): void;
+    /** Mark a vector as deleted so it no longer appears in searches. */
+    remove(id: number): void;
+    /** Search for k nearest neighbors. */
+    search(query: Float32Array, k: number): SearchHit[];
+    /** Clear all vectors and reset to empty state. */
+    reinit(): void;
+    /** Number of vectors in the index. */
+    readonly size: number;
+}
+interface CodeChunk {
+    /** Auto-incremented DB id (set after insert) */
+    id?: number;
+    /** Relative file path from repo root */
+    filePath: string;
+    /** Chunk type: 'file' | 'function' | 'class' | 'block' */
+    chunkType: string;
+    /** Function/class name (if detected) */
+    name?: string;
+    /** Start line (1-indexed) */
+    startLine: number;
+    /** End line (1-indexed, inclusive) */
+    endLine: number;
+    /** Raw content of the chunk */
+    content: string;
+    /** Language identifier */
+    language: string;
+}
+interface GitCommitRecord {
+    id?: number;
+    hash: string;
+    shortHash: string;
+    message: string;
+    author: string;
+    date: string;
+    timestamp: number;
+    filesChanged: string[];
+    diff?: string;
+    additions: number;
+    deletions: number;
+    isMerge: boolean;
+}
+type SearchResultType = 'code' | 'commit' | 'document' | 'collection';
+interface CodeResultMetadata {
+    /** Database chunk ID (used by call graph annotations). */
+    id?: number;
+    /** File path (may duplicate CodeResult.filePath for metadata-only access). */
+    filePath?: string;
+    /** Adjacent chunk IDs from the same file (used by context expansion). */
+    chunkIds?: number[];
+    chunkType: string;
+    name?: string;
+    startLine: number;
+    endLine: number;
+    language: string;
+    searchType?: string;
+    rrfScore?: number;
+}
+interface CommitResultMetadata {
+    hash: string;
+    shortHash: string;
+    author: string;
+    date: string;
+    files: string[];
+    additions?: number;
+    deletions?: number;
+    diff?: string;
+    searchType?: string;
+    rrfScore?: number;
+}
+interface DocumentResultMetadata {
+    collection?: string;
+    title?: string;
+    seq?: number;
+    path?: string;
+    searchType?: string;
+    /** Internal chunk ID used by hybrid search to map fused results. */
+    chunkId?: number;
+    rrfScore?: number;
+}
+interface CodeResult {
+    type: 'code';
+    score: number;
+    filePath: string;
+    content: string;
+    context?: string;
+    metadata: CodeResultMetadata;
+}
+interface CommitResult {
+    type: 'commit';
+    score: number;
+    filePath?: string;
+    content: string;
+    context?: string;
+    metadata: CommitResultMetadata;
+}
+interface DocumentResult {
+    type: 'document';
+    score: number;
+    filePath: string;
+    content: string;
+    context?: string;
+    metadata: DocumentResultMetadata;
+}
+interface CollectionResultMetadata {
+    id?: number;
+    collection?: string;
+    rrfScore?: number;
+    [key: string]: unknown;
+}
+interface CollectionResult {
+    type: 'collection';
+    score: number;
+    filePath?: string;
+    content: string;
+    context?: string;
+    metadata: CollectionResultMetadata;
+}
+type SearchResult = CodeResult | CommitResult | DocumentResult | CollectionResult;
+/** Narrow a SearchResult to CodeResult. */
+declare function isCodeResult(r: SearchResult): r is CodeResult;
+/** Narrow a SearchResult to CommitResult. */
+declare function isCommitResult(r: SearchResult): r is CommitResult;
+/** Narrow a SearchResult to DocumentResult. */
+declare function isDocumentResult(r: SearchResult): r is DocumentResult;
+/** Narrow a SearchResult to CollectionResult. */
+declare function isCollectionResult(r: SearchResult): r is CollectionResult;
+type MatchHandlers<T> = {
+    code?: (r: CodeResult) => T;
+    commit?: (r: CommitResult) => T;
+    document?: (r: DocumentResult) => T;
+    collection?: (r: CollectionResult) => T;
+    _?: (r: SearchResult) => T;
+};
+/**
+ * Pattern-match on SearchResult type. Calls the matching handler
+ * or the `_` fallback. Returns undefined if no handler matches.
+ */
+declare function matchResult<T>(result: SearchResult, handlers: MatchHandlers<T>): T | undefined;
+interface ContextOptions {
+    /** Per-source result limits. Built-in: 'code', 'git'. Default: { code: 6, git: 5 } */
+    sources?: Record<string, number>;
+    /** Files the agent is about to modify (improves co-edit suggestions) */
+    affectedFiles?: string[];
+    /** Minimum similarity score threshold. Default: 0.25 */
+    minScore?: number;
+    /** Use MMR for diversity. Default: true */
+    useMMR?: boolean;
+    /** MMR lambda (0 = diversity, 1 = relevance). Default: 0.7 */
+    mmrLambda?: number;
+    /** Filter results to files under this path prefix (e.g. 'src/services/'). */
+    pathPrefix?: string;
+    /** File paths to exclude from results (e.g. files already returned in a previous query). */
+    excludeFiles?: Set<string>;
+    /** Optional per-request pruner override (e.g. HaikuPruner for LLM noise filtering). */
+    pruner?: Pruner;
+    /** Caller origin for debug logging. */
+    source?: 'cli' | 'mcp' | 'daemon' | 'api';
+    /**
+     * Context field overrides. Merged on top of config.json "context" defaults.
+     * Plugin-defined fields like `lines`, `callTree`, `symbols`, `compact`, `imports`.
+     * Example: `{ lines: true, callTree: { depth: 3 }, symbols: true }`
+     */
+    fields?: Record<string, unknown>;
+}
+interface DocumentCollection {
+    /** Collection name (e.g. 'notes', 'docs') */
+    name: string;
+    /** Directory path to index */
+    path: string;
+    /** Glob pattern for files (default: all markdown) */
+    pattern?: string;
+    /** Glob patterns to ignore */
+    ignore?: string[];
+    /** Context description for this collection */
+    context?: string;
+}
+interface DocChunk {
+    id?: number;
+    /** Collection name */
+    collection: string;
+    /** Relative file path within the collection */
+    filePath: string;
+    /** Document title (first heading or filename) */
+    title: string;
+    /** Chunk content */
+    content: string;
+    /** Chunk sequence within the document (0, 1, 2...) */
+    seq: number;
+    /** Character position in original document */
+    pos: number;
+    /** Content hash for incremental updates */
+    contentHash: string;
+}
+/** File-level progress (used by indexers). */
+type ProgressCallback = (file: string, current: number, total: number) => void;
+/** Stage-level progress (used by BrainBank.index() orchestrator). */
+type StageProgressCallback = (stage: string, message: string) => void;
+interface IndexResult {
+    indexed: number;
+    skipped: number;
+    chunks?: number;
+    removed?: number;
+}
+interface CoEditSuggestion {
+    file: string;
+    count: number;
+}
+/** Generalized watch event — works for files, APIs, webhooks. */
+interface WatchEvent {
+    /** Event type. 'sync' is for batch/poll sources that don't distinguish CRUD. */
+    type: 'create' | 'update' | 'delete' | 'sync';
+    /** Unique ID of the changed item (file path, PR#123, PROJ-456, etc.). */
+    sourceId: string;
+    /** Source descriptor (e.g. 'file', 'github:pr', 'jira:card'). */
+    sourceName: string;
+    /** Optional raw payload to avoid re-fetching. */
+    payload?: unknown;
+}
+/** Callback that plugins invoke when they detect a change. */
+type WatchEventHandler = (event: WatchEvent) => void;
+/** Lifecycle handle returned by WatchablePlugin.watch(). */
+interface WatchHandle {
+    /** Stop watching and release resources. */
+    stop(): Promise<void>;
+    /** Whether the watcher is still active. */
+    readonly active: boolean;
+}
+/** Optional hints from plugin to core — debounce, batching, priority. */
+interface WatchConfig {
+    /** Debounce interval in ms. 0 = process immediately. Default: inherited from WatchOptions. */
     debounceMs?: number;
-    /** Called when a file is re-indexed. */
-    onIndex?: (filePath: string, indexer: string) => void;
-    /** Called on errors. */
-    onError?: (error: Error) => void;
+    /** Max events to batch before triggering re-index. Default: unlimited. */
+    batchSize?: number;
+    /** Processing priority. Default: 'realtime'. */
+    priority?: 'realtime' | 'background';
 }
-interface Watcher {
-    /** Stop watching. */
+
+/**
+ * BrainBank — HNSW Vector Index
+ *
+ * Wraps hnswlib-node for O(log n) approximate nearest neighbor search.
+ * M=16 connections, ef=200 construction, ef=50 search by default.
+ * 150x faster than brute force at 1M vectors.
+ *
+ * Supports disk persistence: save(path) / tryLoad(path, count)
+ * to skip costly vector-by-vector rebuild on startup.
+ */
+
+declare class HNSWIndex implements VectorIndex {
+    private _dims;
+    private _maxElements;
+    private _M;
+    private _efConstruction;
+    private _efSearch;
+    private _index;
+    private _lib;
+    private _ids;
+    constructor(_dims: number, _maxElements?: number, _M?: number, _efConstruction?: number, _efSearch?: number);
+    /**
+     * Initialize the HNSW index.
+     * Must be called before add/search.
+     */
+    init(): Promise<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(): void;
+    private _createIndex;
+    /** Maximum capacity of this index. */
+    get maxElements(): number;
+    /**
+     * Add a vector with an integer ID.
+     * The vector should be pre-normalized for cosine distance.
+     */
+    add(vector: Float32Array, id: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * Search for the k nearest neighbors.
+     * Returns results sorted by score (highest first).
+     * Score is 1 - cosine_distance (1.0 = identical).
+     */
+    search(query: Float32Array, k: number): SearchHit[];
+    /** Number of vectors in the index. */
+    get size(): number;
+    /**
+     * Save the HNSW graph to disk.
+     * The file can be loaded later with tryLoad() to skip vector-by-vector insertion.
+     */
+    save(path: string): void;
+    /**
+     * 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(path: string, expectedCount: number): boolean;
+}
+
+/**
+ * BrainBank — Search Types
+ *
+ * Shared interface for all search strategies.
+ * Implement SearchStrategy to add a new search backend.
+ */
+
+/** Any search implementation follows this shape. */
+interface SearchStrategy {
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    /** Rebuild internal indices (e.g. FTS5). Optional. */
+    rebuild?(): void;
+}
+/** Pre-embedded vector search for a single domain (code, git, etc.). */
+interface DomainVectorSearch {
+    /** Search using a pre-computed query vector. Optional queryText enables BM25 fusion. */
+    search(queryVec: Float32Array, k: number, minScore: number, useMMR?: boolean, mmrLambda?: number, queryText?: string): SearchResult[];
+}
+interface SearchOptions {
+    /** Per-source result limits. Built-in: 'code', 'git', 'memory'. Any other key = custom plugin or KV collection. */
+    sources?: Record<string, number>;
+    /** Minimum similarity score. Default: 0.25 */
+    minScore?: number;
+    /** Use MMR for diversity. Default: true */
+    useMMR?: boolean;
+    /** MMR lambda. Default: 0.7 */
+    mmrLambda?: number;
+    /** Caller origin for debug logging. */
+    source?: 'cli' | 'mcp' | 'daemon' | 'api';
+}
+
+/**
+ * BrainBank — Webhook Server
+ *
+ * Optional shared HTTP server for push-based watch plugins (e.g. Jira, GitHub).
+ * Opt-in: only created when `new BrainBank({ webhookPort: 4242 })` is configured.
+ *
+ * Plugins register routes during `watch()`:
+ *   ctx.webhookServer?.register('jira', '/jira/webhook', handler);
+ *
+ * Each plugin gets its own path namespace. Unregistering cleans up the route.
+ */
+/** Handler for incoming webhook payloads. */
+type WebhookHandler = (body: unknown) => void;
+/** Shared HTTP server for push-based watch plugins. */
+declare class WebhookServer {
+    private _server;
+    private _routes;
+    private _listening;
+    /** Start listening on the specified port. */
+    listen(port: number): void;
+    /** Register a webhook route for a plugin. */
+    register(pluginName: string, path: string, handler: WebhookHandler): void;
+    /** Remove all routes for a plugin. */
+    unregister(pluginName: string): void;
+    /** Stop the server and clear all routes. */
     close(): void;
-    /** Whether the watcher is active. */
-    readonly active: boolean;
+    /** Whether the server is currently listening. */
+    get active(): boolean;
+    /** Route incoming POST requests to the matching handler. */
+    private _handleRequest;
+}
+
+/**
+ * BrainBank — Plugin System
+ *
+ * Plugins are pluggable strategies that scan external data sources
+ * and push content into BrainBank. Built-in plugins handle code,
+ * git, and docs. Third-party frameworks (LangChain, etc.)
+ * can implement custom plugins.
+ *
+ *   import { BrainBank } from 'brainbank';
+ *   import { code } from 'brainbank/indexers/code';
+ *
+ *   const brain = new BrainBank()
+ *     .use(code({ repoPath: '.' }));
+ */
+
+interface PluginContext {
+    /** Database adapter (shared across all plugins). */
+    db: DatabaseAdapter;
+    /** Embedding provider (shared). */
+    embedding: EmbeddingProvider;
+    /** Resolved BrainBank config. */
+    config: ResolvedConfig;
+    /**
+     * Create and initialize an HNSW index.
+     * Pass `name` to enable disk persistence (recommended).
+     *
+     * **Private vs shared:** Use `getOrCreateSharedHnsw()` for indexes that should be
+     * part of the composite search (code, git) and persisted across restarts.
+     * Use `createHnsw()` for plugin-local indexes that don't participate in the
+     * main search pipeline (e.g. internal similarity lookups).
+     */
+    createHnsw(maxElements?: number, dims?: number, name?: string): Promise<HNSWIndex>;
+    /** Load existing vectors from a SQLite vectors table into an HNSW index + cache. */
+    loadVectors(table: string, idCol: string, hnsw: HNSWIndex, cache: Map<number, Float32Array>): void;
+    /**
+     * Get or create a shared HNSW index by key.
+     *
+     * **HNSW sharing strategies:**
+     * The `type` key determines sharing behavior. Two plugins that pass the
+     * same key share one HNSW index; different keys get separate indexes.
+     *
+     * | Plugin type | Key passed        | Sharing behavior                          |
+     * |------------|------------------|------------------------------------------|
+     * | git        | `'git'`           | All `git:*` repos share one HNSW          |
+     * | docs       | `'docs'`          | All docs share one HNSW                   |
+     * | code       | `this.name`       | Each `code:*` repo gets its own HNSW      |
+     *
+     * **Rule of thumb:**
+     * - Same key = shared index (saves memory, single search covers all)
+     * - Plugin name as key = per-repo index (avoids cross-repo noise)
+     *
+     * The key is also used for hot-reload (`ensureFresh`) and disk persistence
+     * (`hnsw-<key>.index`), so it must match the key used in `bumpVersion()`.
+     */
+    getOrCreateSharedHnsw(type: string, maxElements?: number, dims?: number): Promise<{
+        hnsw: HNSWIndex;
+        vecCache: Map<number, Float32Array>;
+        isNew: boolean;
+    }>;
+    /** Get or create a dynamic collection. */
+    collection(name: string): ICollection;
+    /**
+     * Create an incremental tracker scoped to this plugin.
+     * Provides `isUnchanged`, `markIndexed`, `findOrphans`, `remove`, `clear`
+     * for standardized add/update/delete detection during indexing.
+     */
+    createTracker(): IncrementalTracker;
+    /** Optional webhook server for push-based watch plugins. undefined if not configured. */
+    webhookServer?: WebhookServer;
+}
+interface Plugin {
+    /** Unique plugin name (e.g. 'code', 'git', 'docs'). */
+    readonly name: string;
+    /** Initialize the plugin (create HNSW, load vectors, etc.). */
+    initialize(ctx: PluginContext): Promise<void>;
+    /** Return stats for this plugin. */
+    stats?(): Record<string, number | string>;
+    /** Clean up resources. */
+    close?(): void;
+}
+/** Options accepted by IndexablePlugin.index(). */
+interface IndexOptions {
+    forceReindex?: boolean;
+    depth?: number;
+    onProgress?: ProgressCallback;
+}
+/** Plugins that can scan and index content (code, git). */
+interface IndexablePlugin extends Plugin {
+    index(options?: IndexOptions): Promise<IndexResult>;
+    /** Incremental: re-index only specific items by ID. Falls back to index() if not implemented. */
+    indexItems?(ids: string[]): Promise<IndexResult>;
+}
+/** Plugins that can search indexed content (docs). */
+interface SearchablePlugin extends Plugin {
+    search(query: string, options?: Record<string, unknown>): Promise<SearchResult[]>;
+}
+/** Plugins that can watch their own data source for changes. */
+interface WatchablePlugin extends Plugin {
+    /** Start watching. Plugin controls how (fs.watch, polling, webhook, etc.). */
+    watch(onEvent: WatchEventHandler): WatchHandle;
+    /** Optional hints for the core (debounce, batching, priority). */
+    watchConfig?(): WatchConfig;
+}
+/** Check if a plugin can scan/index content. */
+declare function isIndexable(i: Plugin): i is IndexablePlugin;
+/** Check if a plugin can search content. */
+declare function isSearchable(i: Plugin): i is SearchablePlugin;
+/** Check if a plugin can watch its own data source. */
+declare function isWatchable(i: Plugin): i is WatchablePlugin;
+/** Path-specific context metadata for document collections. */
+interface PathContext {
+    collection: string;
+    path: string;
+    context: string;
+}
+/** Plugins that manage document collections (docs). */
+interface DocsPlugin extends SearchablePlugin {
+    addCollection(collection: DocumentCollection): void;
+    removeCollection(name: string): void;
+    listCollections(): DocumentCollection[];
+    indexDocs(options?: {
+        onProgress?: (collection: string, file: string, current: number, total: number) => void;
+    }): Promise<Record<string, {
+        indexed: number;
+        skipped: number;
+        removed: number;
+        chunks: number;
+    }>>;
+    addContext(collection: string, path: string, context: string): void;
+    listContexts(): PathContext[];
+}
+/** Check if a plugin manages document collections. */
+declare function isDocsPlugin(i: Plugin): i is DocsPlugin;
+/** Plugin that provides co-edit suggestions (e.g. git). */
+interface CoEditPlugin extends Plugin {
+    coEdits: {
+        suggest(filePath: string, limit: number): {
+            file: string;
+            count: number;
+        }[];
+    };
 }
+/** Check if a plugin provides co-edit suggestions. */
+declare function isCoEditPlugin(p: Plugin): p is CoEditPlugin;
+/** Table descriptor for re-embedding — maps text rows to vector BLOBs. */
+interface ReembedTable {
+    /** Human-readable name (for progress). */
+    name: string;
+    /** Table with text content. */
+    textTable: string;
+    /** Table with vector BLOBs. */
+    vectorTable: string;
+    /** PK column in text table. */
+    idColumn: string;
+    /** FK column in vector table. */
+    fkColumn: string;
+    /** Build the embedding text from a DB row. */
+    textBuilder: (row: Record<string, unknown>) => string;
+}
+/** Plugins that own vector tables and can rebuild embedding text from DB rows. */
+interface ReembeddablePlugin extends Plugin {
+    /** Table descriptor for re-embedding. */
+    reembedConfig(): ReembedTable;
+}
+/** Check if a plugin supports re-embedding. */
+declare function isReembeddable(p: Plugin): p is ReembeddablePlugin;
+/** Plugin that provides a domain-specific vector search strategy. */
+interface VectorSearchPlugin extends Plugin {
+    /** Create the domain vector search (called during SearchAPI wiring). */
+    createVectorSearch(): DomainVectorSearch | undefined;
+}
+/** Check if a plugin provides a domain vector search. */
+declare function isVectorSearchPlugin(p: Plugin): p is VectorSearchPlugin;
+/** Describes a configurable context field that a plugin supports. */
+interface ContextFieldDef {
+    /** Field name (e.g. 'lines', 'callTree', 'symbols'). Must be unique per plugin. */
+    name: string;
+    /** Accepted value type. 'object' allows nested config like `{ depth: 3 }`. */
+    type: 'boolean' | 'number' | 'object';
+    /** Default value (used when not specified in config or query). */
+    default: unknown;
+    /** Human-readable description for CLI --help and MCP tool descriptions. */
+    description: string;
+}
+/** Plugin that declares configurable context fields. */
+interface ContextFieldPlugin extends Plugin {
+    /** Declare available context fields. Called once during setup. */
+    contextFields(): ContextFieldDef[];
+}
+/** Check if a plugin declares context fields. */
+declare function isContextFieldPlugin(p: Plugin): p is ContextFieldPlugin;
+/** Plugin that contributes sections to the context builder output. */
+interface ContextFormatterPlugin extends Plugin {
+    /**
+     * Append formatted markdown sections to `parts`.
+     * `fields` contains resolved context fields (plugin defaults ← config ← per-query).
+     */
+    formatContext(results: SearchResult[], parts: string[], fields: Record<string, unknown>): void;
+}
+/** Check if a plugin provides context formatting. */
+declare function isContextFormatterPlugin(p: Plugin): p is ContextFormatterPlugin;
+/** Plugin that owns database tables and supports versioned migrations. */
+interface MigratablePlugin extends Plugin {
+    /** Current schema version for this plugin. */
+    readonly schemaVersion: number;
+    /** Ordered list of migrations (version 1, 2, 3, …). */
+    readonly migrations: Migration[];
+}
+/** Check if a plugin supports schema migrations. */
+declare function isMigratable(p: Plugin): p is MigratablePlugin;
+/** Plugin that can do FTS5 keyword search on its own tables. */
+interface BM25SearchPlugin extends Plugin {
+    /** Run BM25 keyword search. Returns scored results. */
+    searchBM25(query: string, k: number, minScore?: number): SearchResult[];
+    /** Rebuild the FTS5 index from the content table. */
+    rebuildFTS?(): void;
+}
+/** Check if a plugin provides BM25 keyword search. */
+declare function isBM25SearchPlugin(p: Plugin): p is BM25SearchPlugin;
+/** Plugin that supports context expansion (provides manifest + resolves chunk IDs). */
+interface ExpandablePlugin extends Plugin {
+    /**
+     * Build a manifest of candidate chunks for LLM expansion.
+     * Returns chunks from files NOT already in search results.
+     *
+     * @param excludeFilePaths File paths already present in search results — excluded from manifest.
+     * @param excludeIds       Chunk IDs already in search results — excluded from manifest.
+     */
+    buildManifest(excludeFilePaths: string[], excludeIds: number[]): ExpanderManifestItem[];
+    /**
+     * Resolve chunk IDs back into SearchResults.
+     * Called after the expander selects additional IDs.
+     */
+    resolveChunks(ids: number[]): SearchResult[];
+}
+/** Check if a plugin supports context expansion. */
+declare function isExpandablePlugin(p: Plugin): p is ExpandablePlugin;
+/** Plugin that can resolve file paths/patterns directly to SearchResults (no search). */
+interface FileResolvablePlugin extends Plugin {
+    /**
+     * Resolve file paths, directories, and glob patterns to SearchResults.
+     * Each entry is resolved: exact → directory → glob → fuzzy basename fallback.
+     *
+     * @param patterns - File paths, directory prefixes (trailing `/`), or glob patterns (`*`).
+     */
+    resolveFiles(patterns: string[]): SearchResult[];
+}
+/** Check if a plugin can resolve files directly. */
+declare function isFileResolvable(p: Plugin): p is FileResolvablePlugin;
 
 /**
  * BrainBank — Re-embedding Engine
@@ -53,16 +1068,12 @@ interface Watcher {
  *
  * Usage:
  *   const result = await brain.reembed({ onProgress });
- *   // → { code: 1200, git: 500, docs: 80, kv: 45, notes: 12, total: 1837 }
+ *   // → { code: 1200, git: 500, docs: 80, kv: 45, total: 1837 }
  */
 
 interface ReembedResult {
-    code: number;
-    git: number;
-    memory: number;
-    notes: number;
-    docs: number;
-    kv: number;
+    /** Per-table vector counts. Keys are table names (e.g. 'code', 'git', 'docs', 'kv'). */
+    counts: Record<string, number>;
     total: number;
 }
 interface ReembedOptions {
@@ -72,17 +1083,79 @@ interface ReembedOptions {
     batchSize?: number;
 }
 
+/**
+ * BrainBank — Watcher
+ *
+ * Thin coordinator for plugin-driven watching. Each plugin CAN drive its own
+ * watching via WatchablePlugin.watch(). For IndexablePlugins that don't
+ * implement WatchablePlugin, the Watcher provides a single shared fs.watch
+ * tree with fan-out routing so each plugin only receives relevant events.
+ *
+ * Responsibilities:
+ *   1. Call `plugin.watch(onEvent)` for each WatchablePlugin
+ *   2. For IndexablePlugins without watch(), share one recursive fs.watch tree
+ *   3. Route events to the correct plugin based on sub-repo scope
+ *   4. Dedup macOS double-fire events (change+rename per save)
+ *   5. Apply per-plugin debounce from `plugin.watchConfig()`
+ *   6. On event: call `plugin.indexItems([id])` or `plugin.index()` for re-indexing
+ *   7. Call `handle.stop()` on `close()`
+ *
+ *   const watcher = brain.watch({ debounceMs: 2000 });
+ *   watcher.close(); // stop watching
+ */
+
+interface WatchOptions {
+    /** Default debounce for plugins that don't specify watchConfig. Default: 2000 */
+    debounceMs?: number;
+    /** Glob patterns to ignore (from config.json code.ignore). */
+    ignore?: string[];
+    /** Called when a source triggers re-indexing. */
+    onIndex?: (sourceId: string, pluginName: string) => void;
+    /** Called on errors. */
+    onError?: (error: Error) => void;
+}
+/** Plugin-driven watcher that coordinates re-indexing across all WatchablePlugins. */
+declare class Watcher {
+    private _active;
+    private _batches;
+    private _reindexFn;
+    private _options;
+    private _keepalive;
+    constructor(reindexFn: () => Promise<void>, plugins: Plugin[], options?: WatchOptions, repoPath?: string);
+    /** Whether the watcher is active. */
+    get active(): boolean;
+    /** Stop all plugin watchers. */
+    close(): Promise<void>;
+    /** Start watching for each WatchablePlugin, with shared fs.watch fallback. */
+    private _startWatching;
+    /**
+     * 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).
+     */
+    private _startSharedFsWatch;
+    /** Handle an incoming event from a plugin. */
+    private _onEvent;
+    /** Flush pending events for a plugin — trigger re-indexing. */
+    private _flush;
+}
+
 /**
  * BrainBank — Main Orchestrator
  *
- * Thin facade that composes four services:
- *   PluginRegistry   — registration + lookup
- *   Initializer      — two-phase startup (earlyInit / lateInit)
- *   SearchAPI        — all search + context logic
- *   IndexAPI         — code / git / docs indexing orchestration
+ * Thin facade that composes services:
+ *   - **PluginRegistry** — registration + lookup
+ *   - **SearchAPI** — all search + context logic
+ *   - **runIndex** — code / git / docs indexing orchestration
  *
+ * Initialization is inline — no indirection layers.
  * All heavy logic lives in those modules; BrainBank owns state,
- * guards (requireInit / initialize()), and public API shape.
+ * guards (`_requireInit` / `initialize`), and public API shape.
+ *
+ * Multi-process coordination:
+ *   - `ensureFresh()` detects stale HNSW indices via `index_state` table
+ *   - Hot-reloads from disk when another process updated the index
+ *   - Called implicitly before every search operation
  */
 
 declare class BrainBank extends EventEmitter {
@@ -91,168 +1164,167 @@ declare class BrainBank extends EventEmitter {
     private _embedding;
     private _registry;
     private _searchAPI?;
-    private _indexAPI?;
+    private _indexDeps?;
+    private _kvService?;
     private _initialized;
     private _initPromise;
     private _watcher?;
-    private _collections;
-    private _kvHnsw?;
-    private _kvVecs;
+    private _webhookServer?;
     private _sharedHnsw;
+    private _repoDBs;
+    private _loadedVersions;
     constructor(config?: BrainBankConfig);
+    /** Whether the brainbank has been initialized. */
+    get isInitialized(): boolean;
+    /** The resolved configuration. */
+    get config(): Readonly<ResolvedConfig>;
+    /** All registered plugin names (insertion order). */
+    get plugins(): string[];
     /**
      * Register a plugin. Chainable.
      *
-     *   brain.use(code({ repoPath: '.' })).use(docs());
+     * @example
+     * brain.use(code({ repoPath: '.' })).use(docs());
+     *
+     * @throws If called after `initialize()`.
      */
     use(plugin: Plugin): this;
-    /** Get the list of registered plugin names. */
-    get plugins(): string[];
-    /** Check if a plugin is loaded. Also matches type prefix (e.g. 'code' matches 'code:frontend'). */
+    /**
+     * Check if a plugin is loaded.
+     * Also matches type prefix (e.g. `'code'` matches `'code:frontend'`).
+     */
     has(name: string): boolean;
-    /** Get a plugin instance. Throws if not loaded. */
-    plugin<T extends Plugin = Plugin>(n: string): T;
+    /** Get a plugin instance by name. Returns `undefined` if not loaded. */
+    plugin<T extends Plugin = Plugin>(name: string): T | undefined;
     /**
      * Initialize database, HNSW indices, and load existing vectors.
-     * Only initializes registered modules.
-     * Automatically called by index/search methods if not yet initialized.
+     * 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.
      */
     initialize(options?: {
         force?: boolean;
     }): Promise<void>;
-    private _runInitialize;
     /**
-     * Get or create a dynamic collection.
-     * Collections are the universal data primitive — store anything, search semantically.
+     * Estimated memory footprint of loaded HNSW indices (bytes).
+     * Counts only vector data: `vectorCount × dims × 4`.
+     * Returns 0 if not initialized.
+     */
+    memoryHint(): number;
+    /** Close database and release all resources. Synchronous. */
+    close(): void;
+    /**
+     * Get or create a dynamic collection (universal KV primitive).
      *
-     *   const errors = brain.collection('debug_errors');
-     *   await errors.add('Fixed null check', { file: 'api.ts' });
-     *   const hits = await errors.search('null pointer');
+     * @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: string): Collection;
+    collection(name: string): ICollection;
     /** List all collection names that have data. */
     listCollectionNames(): string[];
     /** Delete a collection's data and evict from cache. */
     deleteCollection(name: string): void;
+    /** Run indexing across selected modules. Auto-initializes. */
     index(options?: {
-        modules?: ('code' | 'git' | 'docs')[];
-        gitDepth?: number;
+        modules?: string[];
         forceReindex?: boolean;
         onProgress?: StageProgressCallback;
-    }): Promise<{
-        code?: IndexResult;
-        git?: IndexResult;
-        docs?: Record<string, {
-            indexed: number;
-            skipped: number;
-            chunks: number;
-        }>;
-    }>;
-    /** Index only code files (all repos in multi-repo mode). */
-    indexCode(options?: {
-        forceReindex?: boolean;
-        onProgress?: ProgressCallback;
-    }): Promise<IndexResult>;
-    /** Index only git history (all repos in multi-repo mode). */
-    indexGit(options?: {
-        depth?: number;
-        onProgress?: ProgressCallback;
-    }): Promise<IndexResult>;
-    /** Register a document collection. */
-    addCollection(collection: DocumentCollection): Promise<void>;
-    /** Remove a collection and all its indexed data. */
-    removeCollection(name: string): Promise<void>;
-    /** List all registered collections. */
-    listCollections(): DocumentCollection[];
-    /** Index all (or specific) document collections. */
-    indexDocs(options?: {
-        collections?: string[];
-        onProgress?: (collection: string, file: string, current: number, total: number) => void;
-    }): Promise<Record<string, {
-        indexed: number;
-        skipped: number;
-        chunks: number;
-    }>>;
-    /** Search documents only. */
-    searchDocs(query: string, options?: {
-        collection?: string;
-        k?: number;
-        minScore?: number;
-    }): Promise<SearchResult[]>;
-    /** Add context description for a collection path. */
-    addContext(collection: string, path: string, context: string): void;
-    /** Remove context for a collection path. */
-    removeContext(collection: string, path: string): void;
-    /** List all context entries. */
-    listContexts(): {
-        collection: string;
-        path: string;
-        context: string;
-    }[];
+        pluginOptions?: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
     /**
-     * Get formatted context for a task.
-     * Returns markdown ready for system prompt injection.
+     * Detect stale HNSW indices and hot-reload from disk.
+     * Called implicitly before every search operation.
+     * Cost: one SQLite SELECT (~5μs on WAL mode).
      */
-    getContext(task: string, options?: ContextOptions): Promise<string>;
-    /** Semantic search across all loaded modules. */
-    search(query: string, options?: {
-        codeK?: number;
-        gitK?: number;
-        patternK?: number;
-        minScore?: number;
-        useMMR?: boolean;
-    }): Promise<SearchResult[]>;
-    /** Semantic search over code only. */
-    searchCode(query: string, k?: number): Promise<SearchResult[]>;
-    /** Semantic search over commits only. */
-    searchCommits(query: string, k?: number): Promise<SearchResult[]>;
+    ensureFresh(): Promise<void>;
+    /**
+     * Semantic search across all loaded modules.
+     * Scope via `sources: { code: 10, git: 0 }`.
+     */
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
     /**
      * Hybrid search: vector + BM25 fused with Reciprocal Rank Fusion.
-     * Best quality — catches both exact keyword matches and conceptual similarities.
+     * Scope via `sources: { code: 10, git: 5, docs: 3, myNotes: 5 }`.
      */
-    hybridSearch(query: string, options?: {
-        codeK?: number;
-        gitK?: number;
-        patternK?: number;
-        minScore?: number;
-        useMMR?: boolean;
-        collections?: Record<string, number>;
-    }): Promise<SearchResult[]>;
+    hybridSearch(query: string, options?: SearchOptions): Promise<SearchResult[]>;
     /** BM25 keyword search only (no embeddings needed). */
-    searchBM25(query: string, options?: {
-        codeK?: number;
-        gitK?: number;
-        patternK?: number;
-    }): Promise<SearchResult[]>;
-    /** Rebuild FTS5 indices. */
-    rebuildFTS(): void;
-    /** Get git history for a specific file. */
-    fileHistory(filePath: string, limit?: number): Promise<Record<string, unknown>[]>;
-    /** Get co-edit suggestions for a file. */
-    coEdits(filePath: string, limit?: number): CoEditSuggestion[];
-    /** Get statistics for all loaded modules. */
-    stats(): IndexStats;
+    searchBM25(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    /** Build formatted context block for LLM system prompt injection. Auto-initializes. */
+    getContext(task: string, options?: ContextOptions): Promise<string>;
     /**
-     * Start watching for file changes and auto-re-index.
-     * Works with built-in and custom indexers.
+     * 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: string[]): SearchResult[];
+    /** Rebuild FTS5 indices. */
+    rebuildFTS(): void;
+    /** Get statistics for all loaded plugins. */
+    stats(): Record<string, Record<string, number | string> | undefined>;
+    /** Start watching for changes and auto-re-index. */
     watch(options?: WatchOptions): Watcher;
     /**
      * Re-embed all existing text with the current embedding provider.
-     * Use this when switching providers (e.g. Local → OpenAI).
+     * Use after switching providers (e.g. Local → OpenAI).
      */
     reembed(options?: ReembedOptions): Promise<ReembedResult>;
-    /** Close database and release resources. */
-    close(): void;
-    /** Whether the brainbank has been initialized. */
-    get isInitialized(): boolean;
-    /** The resolved configuration. */
-    get config(): Readonly<ResolvedConfig>;
+    /**
+     * 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
+     */
+    private _runInitialize;
+    /** Reset shared state after a failed `_runInitialize`. */
+    private _cleanupAfterFailedInit;
+    /** Resolve embedding: explicit config > stored DB key > local default. */
+    private _resolveEmbedding;
+    /**
+     * 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`).
+     */
+    private _getOrCreatePluginDb;
+    /** Build a per-plugin `PluginContext` with appropriate DB and HNSW scoping. */
+    private _buildPluginContext;
+    /**
+     * 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.
+     */
+    private _reloadIndex;
+    /** Guard: throw descriptive error if not initialized. */
     private _requireInit;
-    /** Get the docs indexer as CollectionPlugin with init + type check. */
-    private _docsPlugin;
 }
 
+/**
+ * BrainBank — Constants
+ *
+ * Core-only constants. Plugin names are NOT defined here — they belong
+ * to their respective packages. Only keys owned by the core live here.
+ */
+/** HNSW index key for KV collections (core-owned). */
+declare const HNSW: {
+    readonly KV: "kv";
+};
+type HnswKey = typeof HNSW[keyof typeof HNSW];
+
 /**
  * BrainBank — Local Embedding Provider
  *
@@ -425,22 +1497,116 @@ declare class PerplexityContextEmbedding implements EmbeddingProvider {
 }
 
 /**
- * BrainBank — Math Utilities
+ * BrainBank — Embedding Worker Proxy
  *
- * Pure vector math functions for similarity calculations.
- * No dependencies — works on Float32Array directly.
+ * Drop-in replacement for any EmbeddingProvider that offloads
+ * embedding computation to a dedicated worker thread.
+ * The main thread's event loop stays free for serving searches.
+ *
+ * Usage:
+ *   const proxy = new EmbeddingWorkerProxy('local', { model: '...' });
+ *   await proxy.ready();
+ *   const vec = await proxy.embed('hello');
  */
+
+declare class EmbeddingWorkerProxy implements EmbeddingProvider {
+    private _worker;
+    private _nextId;
+    private _pending;
+    private _ready;
+    private _dims;
+    /** Embedding dimensions (available after `ready()` resolves). */
+    get dims(): number;
+    constructor(providerType: string, providerOptions?: Record<string, unknown>);
+    /** Wait for the worker to be ready (provider loaded). */
+    ready(): Promise<void>;
+    /** Send a request to the worker and wait for the response. */
+    private _send;
+    /** Embed a single text string. */
+    embed(text: string): Promise<Float32Array>;
+    /** Embed multiple texts in a batch. */
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    /** Terminate the worker. */
+    close(): Promise<void>;
+}
+
 /**
- * Cosine similarity between two vectors.
- * Assumes vectors are already normalized (unit length).
- * Returns value between -1.0 and 1.0.
+ * HttpServer — Lightweight JSON API for BrainBank.
+ *
+ * Exposes BrainBank operations over HTTP so CLI commands can delegate
+ * to a running server instead of cold-loading models each time.
+ *
+ * Routes:
+ *   POST /context  → brain.getContext()
+ *   POST /index    → brain.index()
+ *   GET  /health   → { ok, pid, uptime, port }
+ *
+ * Multi-repo: a single server handles all repos via WorkspacePool.
+ * Each request includes a `repo` field to select the workspace.
  */
-declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+
+interface HttpServerOptions {
+    port?: number;
+    /** Factory to create a BrainBank instance for a given repo path. */
+    factory: (repoPath: string) => Promise<BrainBank>;
+    /** Default repo path when request doesn't specify one. */
+    defaultRepo?: string;
+    /** Called when an error occurs during pool operations. */
+    onError?: (repo: string, err: unknown) => void;
+    /** Called on server lifecycle events. */
+    onLog?: (msg: string) => void;
+}
+declare class HttpServer {
+    private _server;
+    private _pool;
+    private _port;
+    private _defaultRepo;
+    private _startTime;
+    private _log;
+    constructor(options: HttpServerOptions);
+    /** Start listening. Writes PID file for daemon detection. */
+    start(): Promise<void>;
+    /** Stop the server and clean up. */
+    close(): void;
+    get port(): number;
+    private _handleRequest;
+    private _handleHealth;
+    private _handleContext;
+    private _handleIndex;
+    private _readBody;
+}
+
 /**
- * L2-normalize a vector to unit length.
- * Returns a new Float32Array.
+ * Daemon — PID file management for the BrainBank HTTP server.
+ *
+ * PID file: ~/.cache/brainbank/server.pid
+ * Format: JSON { pid: number, port: number }
+ *
+ * Used by:
+ *   - `brainbank daemon` to write PID on start
+ *   - `brainbank daemon stop` to find and kill the daemon
+ *   - `brainbank status` to report server state
+ *   - CLI commands to detect running server for delegation
  */
-declare function normalize(vec: Float32Array): Float32Array;
+declare const DEFAULT_PORT = 8181;
+interface PidInfo {
+    pid: number;
+    port: number;
+}
+/** Write the PID file after server starts. */
+declare function writePid(pid: number, port: number): void;
+/** Read PID info from file. Returns null if missing or malformed. */
+declare function readPid(): PidInfo | null;
+/** Remove the PID file. */
+declare function removePid(): void;
+/**
+ * Check if the server process is still alive.
+ * Uses `kill(pid, 0)` which doesn't actually send a signal —
+ * it just checks whether the process exists.
+ */
+declare function isServerRunning(): PidInfo | null;
+/** Get the server URL if running, or null. */
+declare function getServerUrl(): string | null;
 
 /**
  * BrainBank — Qwen3 Local Reranker
@@ -463,30 +1629,120 @@ interface Qwen3RerankerOptions {
     /** Context size for ranking. Default: 2048 */
     contextSize?: number;
 }
-declare class Qwen3Reranker implements Reranker {
-    private readonly _modelUri;
-    private readonly _cacheDir;
-    private readonly _contextSize;
-    private _model;
-    private _context;
-    private _loadPromise;
-    constructor(options?: Qwen3RerankerOptions);
-    /**
-     * Lazy-load the reranker model and create a ranking context.
-     * Model is auto-downloaded from HuggingFace on first use.
-     */
-    private _ensureLoaded;
-    /**
-     * Score each document's relevance to the query.
-     * Returns scores (0.0 - 1.0) in same order as input documents.
-     *
-     * Deduplicates identical documents to avoid redundant computation.
-     */
-    rank(query: string, documents: string[]): Promise<number[]>;
-    /** Release model resources. */
+declare class Qwen3Reranker implements Reranker {
+    private readonly _modelUri;
+    private readonly _cacheDir;
+    private readonly _contextSize;
+    private _model;
+    private _context;
+    private _loadPromise;
+    constructor(options?: Qwen3RerankerOptions);
+    /**
+     * Lazy-load the reranker model and create a ranking context.
+     * Model is auto-downloaded from HuggingFace on first use.
+     */
+    private _ensureLoaded;
+    /**
+     * Score each document's relevance to the query.
+     * Returns scores (0.0 - 1.0) in same order as input documents.
+     *
+     * Deduplicates identical documents to avoid redundant computation.
+     */
+    rank(query: string, documents: string[]): Promise<number[]>;
+    /** Release model resources. */
+    close(): Promise<void>;
+}
+
+/**
+ * BrainBank — Haiku Pruner
+ *
+ * LLM-based noise filter using Anthropic's Haiku 4.5 model.
+ * Binary classification: for each search result, Haiku decides
+ * "relevant" or "noise" based on filePath, metadata, and full
+ * file content (capped at ~8K chars per item by prune.ts).
+ *
+ * Latency: ~300-600ms.
+ */
+
+interface HaikuPrunerOptions {
+    /** Anthropic API key. Falls back to ANTHROPIC_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: claude-haiku-4-5-20251001 */
+    model?: string;
+}
+declare class HaikuPruner implements Pruner {
+    private readonly _apiKey;
+    private readonly _model;
+    constructor(options?: HaikuPrunerOptions);
+    prune(query: string, items: PrunerItem[]): Promise<number[]>;
+    close(): Promise<void>;
+}
+
+/**
+ * BrainBank — Prune Utility
+ *
+ * Bridges SearchResult[] → Pruner.prune() → filtered SearchResult[].
+ * Converts results to lightweight PrunerItems with full content previews,
+ * calls the pruner, and filters out dropped results.
+ *
+ * Content strategy: send the FULL chunk content to the pruner so it can
+ * make informed decisions. A per-item character cap prevents cost blowups
+ * on monster files — when truncated, the middle is kept (imports + core
+ * logic) rather than just the top.
+ */
+
+/** Run the pruner on search results. Returns results in the order the pruner chose. */
+declare function pruneResults(query: string, results: SearchResult[], pruner: Pruner): Promise<SearchResult[]>;
+
+/**
+ * BrainBank — Haiku Expander
+ *
+ * LLM-powered context expansion using Anthropic's Haiku 4.5 model.
+ * After search + pruning, reviews a manifest of available chunks
+ * and requests additional IDs to include.
+ *
+ * Flow:
+ *   1. Receives lightweight manifest (~20 chars per chunk)
+ *   2. Haiku selects additional chunk IDs (just numbers, fast)
+ *   3. Caller fetches those chunks from DB and splices into results
+ *
+ * Designed for minimal token usage:
+ *   - Input: ~2,000-3,000 tokens (manifest)
+ *   - Output: ~50-100 tokens (ID array)
+ *   - Cost: ~$0.001 per call
+ *   - Latency: ~300-600ms
+ *
+ * Fail-open: any error returns empty array (no expansion).
+ */
+
+interface HaikuExpanderOptions {
+    /** Anthropic API key. Falls back to ANTHROPIC_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: claude-haiku-4-5-20251001 */
+    model?: string;
+}
+declare class HaikuExpander implements Expander {
+    private readonly _apiKey;
+    private readonly _model;
+    constructor(options?: HaikuExpanderOptions);
+    expand(query: string, currentIds: number[], manifest: ExpanderManifestItem[]): Promise<ExpanderResult>;
+    /** Parse Haiku response — handles both `{ ids, note }` and bare `[...]` formats. */
+    private _parseResponse;
     close(): Promise<void>;
 }
 
+/**
+ * BrainBank — Provider Key
+ *
+ * Infers a stable key from an existing EmbeddingProvider instance.
+ * Lives in lib/ (Layer 0) to avoid db/ → providers/ dependency.
+ */
+
+/** Known embedding provider keys. */
+type EmbeddingKey = 'local' | 'openai' | 'perplexity' | 'perplexity-context';
+/** Infer a stable key from an existing provider instance. */
+declare function providerKey(p: EmbeddingProvider): EmbeddingKey;
+
 /**
  * BrainBank — Embedding Provider Resolver
  *
@@ -494,12 +1750,8 @@ declare class Qwen3Reranker implements Reranker {
  * Used by the Initializer to auto-resolve from DB config.
  */
 
-/** Known embedding provider keys. */
-type EmbeddingKey = 'local' | 'openai' | 'perplexity' | 'perplexity-context';
 /** Resolve an EmbeddingProvider from a key string. Lazy-loads the provider module. */
 declare function resolveEmbedding(key: string): Promise<EmbeddingProvider>;
-/** Infer a stable key from an existing provider instance. */
-declare function providerKey(p: EmbeddingProvider): EmbeddingKey;
 
 declare const DEFAULTS: ResolvedConfig;
 /**
@@ -526,196 +1778,6 @@ declare function resolveConfig(partial?: BrainBankConfig): ResolvedConfig;
  */
 declare function searchMMR(index: VectorIndex, query: Float32Array, vectorCache: Map<number, Float32Array>, k: number, lambda?: number): SearchHit[];
 
-/**
- * BrainBank — Tree-Sitter Code Chunker
- *
- * AST-aware code splitting using native tree-sitter bindings.
- * Extracts semantic blocks (functions, classes, methods, interfaces)
- * from the AST. Falls back to sliding window for unsupported languages.
- */
-
-interface ChunkerConfig {
-    /** Max lines per chunk. Default: 80 */
-    maxLines?: number;
-    /** Min lines for a detected block to be a chunk. Default: 3 */
-    minLines?: number;
-    /** Overlap between adjacent generic chunks. Default: 5 */
-    overlap?: number;
-}
-declare class CodeChunker {
-    private MAX;
-    private MIN;
-    private OVERLAP;
-    private _parser;
-    private _langCache;
-    constructor(config?: ChunkerConfig);
-    /** Lazy-init tree-sitter parser. */
-    private _ensureParser;
-    /** Load a language grammar (cached). Throws if grammar package is not installed. */
-    private _loadGrammar;
-    /**
-     * Split file content into semantic chunks using tree-sitter AST.
-     * Throws if the language has a grammar but the package isn't installed.
-     * Falls back to sliding window only for truly unsupported languages.
-     */
-    chunk(filePath: string, content: string, language: string): Promise<CodeChunk[]>;
-    /** Walk AST and extract top-level semantic blocks. */
-    private _extractChunks;
-    /** Classify and process a single AST node. */
-    private _processNode;
-    /** Check which category a node type belongs to. */
-    private _categorize;
-    /** Process a matched declaration: class → split by methods, else → chunk directly. */
-    private _processDeclaration;
-    /** Split a large class into individual method chunks. */
-    private _splitClassIntoMethods;
-    /** Find the class body node. */
-    private _findClassBody;
-    /** Extract name from an AST node. */
-    private _extractName;
-    /** Map category to chunk type. */
-    private _toChunkType;
-    /** Add a node as a chunk, avoiding duplicates. */
-    private _addChunk;
-    private _chunkGeneric;
-    /** Split a large block into overlapping sub-chunks. */
-    private _splitLargeBlock;
-}
-
-/**
- * BrainBank — Code Indexer
- *
- * Walks a repository, chunks source files semantically,
- * embeds each chunk, and stores in SQLite + HNSW.
- * Incremental: only re-indexes files that changed (by content hash).
- */
-
-interface CodeWalkerDeps {
-    db: Database;
-    hnsw: HNSWIndex;
-    vectorCache: Map<number, Float32Array>;
-    embedding: EmbeddingProvider;
-}
-interface CodeIndexOptions {
-    forceReindex?: boolean;
-    onProgress?: ProgressCallback;
-}
-declare class CodeWalker {
-    private _chunker;
-    private _deps;
-    private _repoPath;
-    private _maxFileSize;
-    constructor(repoPath: string, deps: CodeWalkerDeps, maxFileSize?: number);
-    /** Index all supported files. Skips unchanged files (same content hash). */
-    index(options?: CodeIndexOptions): Promise<IndexResult>;
-    /** Remove old chunks and their HNSW vectors for a file. */
-    private _removeOldChunks;
-    /** Chunk, embed, and store a single file. Returns chunk count. */
-    private _indexFile;
-    private _walkRepo;
-    private _hash;
-}
-
-/**
- * BrainBank — Git Indexer
- *
- * Reads git history, embeds commit messages + diffs,
- * and computes file co-edit relationships.
- * Incremental: only processes new commits.
- */
-
-interface GitIndexerDeps {
-    db: Database;
-    hnsw: HNSWIndex;
-    vectorCache: Map<number, Float32Array>;
-    embedding: EmbeddingProvider;
-}
-interface GitIndexOptions {
-    depth?: number;
-    onProgress?: ProgressCallback;
-}
-declare class GitIndexer {
-    private _deps;
-    private _repoPath;
-    private _maxDiffBytes;
-    constructor(repoPath: string, deps: GitIndexerDeps, maxDiffBytes?: number);
-    /**
-     * Index git history.
-     * Only processes commits not already in the database.
-     */
-    index(options?: GitIndexOptions): Promise<IndexResult>;
-    /** Initialize simple-git. Returns null if git is unavailable. */
-    private _initGit;
-    /** Prepare all SQL statements (hoisted outside loops). */
-    private _prepareStatements;
-    /** Phase 1: Collect commit data from git (async git calls). */
-    private _collectCommits;
-    /** Extract diff, stat, and text from a single commit. */
-    private _parseCommit;
-    /** Phase 3: Insert commits + vectors in a single transaction. */
-    private _insertCommits;
-    /** Phase 4: Update HNSW index and compute co-edits. */
-    private _updateHnsw;
-    /** Compute which files tend to be edited together. */
-    private _computeCoEdits;
-    /** Query commit_files in chunks to stay under SQLite's 999-variable limit. */
-    private _queryCommitFiles;
-    /** Group file paths by commit ID. */
-    private _groupFilesByCommit;
-}
-
-/**
- * BrainBank — Document Indexer
- *
- * Indexes generic document collections (markdown, text, etc.)
- * with heading-aware smart chunking, inspired by qmd.
- *
- *   const indexer = new DocsIndexer(db, embedding, hnsw, vecCache);
- *   await indexer.indexCollection('notes', '/path/to/notes', '**\/*.md');
- */
-
-declare class DocsIndexer {
-    private _db;
-    private _embedding;
-    private _hnsw;
-    private _vecCache;
-    constructor(_db: Database, _embedding: EmbeddingProvider, _hnsw: HNSWIndex, _vecCache: Map<number, Float32Array>);
-    /**
-     * Index all documents in a collection.
-     * Incremental — skips unchanged files (by content hash).
-     */
-    indexCollection(collection: string, dirPath: string, pattern?: string, options?: {
-        ignore?: string[];
-        onProgress?: (file: string, current: number, total: number) => void;
-    }): Promise<{
-        indexed: number;
-        skipped: number;
-        chunks: number;
-    }>;
-    /** Walk directory tree and collect matching files. */
-    private _walkFiles;
-    /** Check if a file matches any ignore patterns. */
-    private _isIgnoredFile;
-    /** Check if all chunks for a file match the current hash and have vectors. */
-    private _isUnchanged;
-    /** Remove old chunks and their HNSW vectors for a file. */
-    private _removeOldChunks;
-    /** Index a single file: chunk, embed, store in DB + HNSW. */
-    private _indexFile;
-    /** Remove all indexed data for a collection. */
-    removeCollection(collection: string): void;
-    /** Split document into chunks at natural markdown boundaries. */
-    private _smartChunk;
-    /** Handle the last chunk: merge if too small, otherwise push. */
-    private _flushRemainder;
-    /** Find the best break position within the target window. */
-    private _findBestBreak;
-    /** Find all potential break points in the document with scores. */
-    private _findBreakPoints;
-    /** Extract document title from first heading or filename. */
-    private _extractTitle;
-}
-
 /**
  * BrainBank — Language Registry
  *
@@ -728,281 +1790,206 @@ declare const IGNORE_DIRS: Set<string>;
 declare function isSupported(filePath: string): boolean;
 /** Get the language name for a file. Returns undefined if not supported. */
 declare function getLanguage(filePath: string): string | undefined;
+/** Check if a directory name should be ignored. */
+declare function isIgnoredDir(dirName: string): boolean;
+/** Check if a filename should be ignored. */
+declare function isIgnoredFile(fileName: string): boolean;
 
 /**
- * BrainBank — Pattern Store (Agent Memory)
+ * BrainBank — Math Utilities
  *
- * Stores what the agent learned from past tasks.
- * Each pattern records task, approach, and success rate.
- * Searchable by semantic similarity via HNSW.
+ * Pure vector math functions for similarity calculations.
+ * No dependencies — works on Float32Array directly.
  */
-
-interface PatternStoreDeps {
-    db: Database;
-    hnsw: HNSWIndex;
-    vectorCache: Map<number, Float32Array>;
-    embedding: EmbeddingProvider;
-}
-declare class PatternStore {
-    private _deps;
-    constructor(deps: PatternStoreDeps);
-    /**
-     * Store a learned pattern.
-     * Returns the pattern ID.
-     */
-    learn(pattern: LearningPattern): Promise<number>;
-    /**
-     * Search for similar successful patterns.
-     * Filters by minimum success rate.
-     */
-    search(query: string, k?: number, minSuccess?: number): Promise<(LearningPattern & {
-        score: number;
-    })[]>;
-    /**
-     * Get all patterns for a specific task type.
-     */
-    getByTaskType(taskType: string, limit?: number): LearningPattern[];
-    /** Total number of stored patterns. */
-    get count(): number;
-}
+/**
+ * Cosine similarity between two vectors.
+ * Assumes vectors are already normalized (unit length).
+ * Returns value between -1.0 and 1.0.
+ */
+declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+/**
+ * L2-normalize a vector to unit length.
+ * Returns a new Float32Array.
+ */
+declare function normalize(vec: Float32Array): Float32Array;
+/**
+ * Convert a Float32Array to a Buffer for SQLite storage.
+ * Handles views with non-zero byteOffset (e.g. from batched embedding output).
+ * Using Buffer.from(vec.buffer) directly is WRONG for views — it copies the entire parent buffer.
+ */
+declare function vecToBuffer(vec: Float32Array): Buffer;
 
 /**
- * BrainBank — Consolidator
+ * BrainBank — KV Service
  *
- * Maintenance operations for the agent memory:
- *   - prune: remove old failed patterns
- *   - dedup: merge near-duplicate patterns (cosine > 0.95)
- *   - consolidate: run both
+ * Owns the shared HNSW index and vector cache for KV collections.
+ * Provides collection creation, listing, and deletion.
+ * Extracted from BrainBank to separate infrastructure from facade.
  */
 
-declare class Consolidator {
+declare class KVService {
     private _db;
-    private _vectorCache;
-    constructor(_db: Database, _vectorCache: Map<number, Float32Array>);
-    /**
-     * Remove old failed patterns.
-     * Criteria: success_rate < 0.3 AND created > 90 days ago.
-     */
-    prune(maxAgeDays?: number, minSuccess?: number): number;
-    /**
-     * Merge near-duplicate patterns.
-     * Keeps the one with higher success_rate.
-     * Threshold: cosine similarity > 0.95.
-     */
-    dedup(threshold?: number): number;
-    /**
-     * Run full consolidation: prune + dedup.
-     */
-    consolidate(): {
-        pruned: number;
-        deduped: number;
-    };
+    private _embedding;
+    private _hnsw;
+    private _vecs;
+    private _reranker?;
+    private _collections;
+    constructor(_db: DatabaseAdapter, _embedding: EmbeddingProvider, _hnsw: HNSWIndex, _vecs: Map<number, Float32Array>, _reranker?: Reranker | undefined);
+    /** Get or create a named collection. */
+    collection(name: string): Collection;
+    /** List all collection names that have data. */
+    listNames(): string[];
+    /** Delete a collection's data and evict from cache. Removes vectors from HNSW to prevent ghost entries. */
+    delete(name: string): void;
+    /** Access the shared HNSW index (used by reembed). */
+    get hnsw(): HNSWIndex;
+    /** Access the shared vector cache. @internal */
+    get vecs(): Map<number, Float32Array>;
+    /** Clear all cached collections and vectors. */
+    clear(): void;
 }
 
 /**
- * BrainBank — Note Memory Store
+ * BrainBank — Plugin Registry
  *
- * Stores structured note digests for long-term agent memory.
- * Each digest captures decisions, files changed, patterns, and open questions.
- * Supports vector + BM25 hybrid retrieval via HNSW + FTS5.
+ * Manages registration and lookup of plugins.
+ * Extracted from BrainBank so the facade stays focused on orchestration.
  *
- * Memory tiers:
- *   - "short" (default): Full digest, last ~20 notes
- *   - "long":  Compressed to patterns + decisions only
+ * Responsibilities:
+ *   - Store plugins by name
+ *   - Type-prefix matching  ('code' finds 'code:frontend', 'code:backend')
+ *   - Alias resolution      (currently none; add here if needed)
+ *   - Consistent error messages on missing plugins
  */
 
-interface NoteDigest {
-    title: string;
-    summary: string;
-    decisions?: string[];
-    filesChanged?: string[];
-    patterns?: string[];
-    openQuestions?: string[];
-    tags?: string[];
-}
-interface StoredNote extends NoteDigest {
-    id: number;
-    tier: 'short' | 'long';
-    createdAt: number;
-    score?: number;
-}
-interface RecallOptions {
-    /** Max results. Default: 5 */
-    k?: number;
-    /** Search mode. Default: 'hybrid' */
-    mode?: 'hybrid' | 'vector' | 'keyword';
-    /** Minimum score threshold. Default: 0.15 */
-    minScore?: number;
-    /** Filter by tier. Default: all */
-    tier?: 'short' | 'long';
-}
-declare class NoteStore {
-    private _db;
-    private _embedding;
-    private _hnsw;
-    private _vecs;
-    constructor(db: Database, embedding: EmbeddingProvider, hnsw: HNSWIndex, vecs: Map<number, Float32Array>);
-    /**
-     * Store a note digest.
-     * Embeds title + summary for vector search, auto-indexed in FTS5.
-     */
-    remember(digest: NoteDigest): Promise<number>;
-    /**
-     * Recall relevant notes.
-     * Supports vector, keyword, or hybrid (default) retrieval.
-     */
-    recall(query: string, options?: RecallOptions): Promise<StoredNote[]>;
+declare class PluginRegistry {
+    private _map;
+    /** Store a plugin. Duplicate names silently overwrite. */
+    register(plugin: Plugin): void;
     /**
-     * List recent notes.
+     * Check whether a plugin is registered.
+     * Supports type-prefix matching: `has('code')` returns true if
+     * 'code', 'code:frontend', or 'code:backend' is registered.
      */
-    list(limit?: number, tier?: 'short' | 'long'): StoredNote[];
+    has(name: string): boolean;
     /**
-     * Get total count of notes.
+     * 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')
      */
-    count(): {
-        total: number;
-        short: number;
-        long: number;
-    };
+    get<T extends Plugin = Plugin>(name: string): T;
     /**
-     * Consolidate old short-term notes into long-term.
-     * Keeps the most recent `keepRecent` as short-term, compresses the rest.
+     * Return every plugin whose name equals `type` or starts with `type + ':'`.
+     * Example: allByType('code') → [code, code:frontend, code:backend]
      */
-    consolidate(keepRecent?: number): {
-        promoted: number;
-    };
-    private _searchVector;
-    private _searchBM25;
-    private _rowToNote;
-}
-
-/**
- * BrainBank — Search Types
- *
- * Shared interface for all search strategies.
- * Implement SearchStrategy to add a new search backend.
- */
-
-/** Any search implementation follows this shape. */
-interface SearchStrategy {
-    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
-    /** Rebuild internal indices (e.g. FTS5). Optional. */
-    rebuild?(): void;
-}
-interface SearchOptions {
-    /** Max code results. Default: 6 */
-    codeK?: number;
-    /** Max git results. Default: 5 */
-    gitK?: number;
-    /** Max pattern results. Default: 4 */
-    patternK?: number;
-    /** Minimum similarity score. Default: 0.25 */
-    minScore?: number;
-    /** Use MMR for diversity. Default: true */
-    useMMR?: boolean;
-    /** MMR lambda. Default: 0.7 */
-    mmrLambda?: number;
-}
-
-/**
- * BrainBank — Co-Edit Analyzer
- *
- * Suggests files that historically change together.
- * Based on git commit co-occurrence analysis.
- */
-
-declare class CoEditAnalyzer {
-    private _db;
-    constructor(_db: Database);
+    allByType(type: string): Plugin[];
+    /** Return the first plugin that matches the type prefix, or undefined. */
+    firstByType(type: string): Plugin | undefined;
+    /** All registered plugin names (insertion order). */
+    get names(): string[];
+    /** All registered plugin instances (insertion order). */
+    get all(): Plugin[];
     /**
-     * Get files that frequently change alongside the given file.
-     * Returns sorted by co-edit count (highest first).
+     * Underlying Map.
+     * Prefer `all`, `allByType`, or `firstByType` everywhere else.
      */
-    suggest(filePath: string, limit?: number): CoEditSuggestion[];
+    get raw(): Map<string, Plugin>;
+    /** Remove all registered plugins. Called by BrainBank.close(). */
+    clear(): void;
 }
 
 /**
  * BrainBank — Context Builder
  *
- * Builds a formatted markdown context block from search results.
- * Ready for injection into an LLM system prompt.
- * Groups code by file, includes git history and learned patterns.
+ * Orchestrates the context-building pipeline:
+ *   1. Vector search (primary)
+ *   2. Path scoping (filter)
+ *   3. LLM noise pruning (optional)
+ *   4. Session dedup (filter)
+ *   5. LLM context expansion (optional — expander field)
+ *   6. Plugin formatters (output)
+ *
+ * All search post-processing lives in `bm25-boost.ts`.
+ * Plugin-agnostic — discovers formatters from ContextFormatterPlugin.
  */
 
 declare class ContextBuilder {
     private _search;
-    private _coEdits?;
-    constructor(_search: SearchStrategy, _coEdits?: CoEditAnalyzer | undefined);
+    private _registry;
+    private _pruner?;
+    private _embedding?;
+    private _rerankerName?;
+    private _configFields;
+    private _expander?;
+    constructor(_search: SearchStrategy | undefined, _registry: PluginRegistry, _pruner?: Pruner | undefined, _embedding?: EmbeddingProvider | undefined, _rerankerName?: string | undefined, _configFields?: Record<string, unknown>, _expander?: Expander | undefined);
+    /** Set config-level context field defaults (from config.json "context" section). */
+    set configFields(fields: Record<string, unknown>);
+    /** Set the expander instance. */
+    set expander(expander: Expander | undefined);
     /** Build a full context block for a task. Returns markdown for system prompt. */
     build(task: string, options?: ContextOptions): Promise<string>;
-    /** Format code search results grouped by file. */
-    private _formatCodeResults;
-    /** Format git commit results with diff snippets. */
-    private _formatGitResults;
-    /** Format co-edit suggestions for affected files. */
-    private _formatCoEdits;
-    /** Format memory pattern results. */
-    private _formatPatternResults;
+    /** Invoke ContextFormatterPlugins. Multi-repo: each plugin formats its own results. */
+    private _appendFormatterResults;
+    /**
+     * Resolve context fields: plugin defaults ← config.json ← per-query.
+     * Returns a flat Record with the final value for each field.
+     */
+    private _resolveFields;
+    /**
+     * Run LLM expansion: build manifest of candidate chunks from files
+     * NOT already in search results, call expander, resolve selected IDs.
+     */
+    private _expand;
+    /** Detect the multi-repo prefix from existing results (e.g. 'servicehub-frontend'). */
+    private _detectRepoPrefix;
+    /** Collect results from SearchablePlugins that don't have their own formatter. */
+    private _appendSearchableResults;
 }
 
 /**
- * BrainBank — Vector Search Strategy
+ * BrainBank — Composite Vector Search
  *
- * Searches across code, git, and memory pattern HNSW indices.
- * Returns typed results sorted by relevance.
+ * Generic orchestrator for domain-specific vector searches.
+ * Embeds the query once, delegates to registered DomainVectorSearch strategies.
+ * Uses round-robin interleaving when multiple strategies exist to ensure
+ * balanced representation across repos/domains.
+ * Plugin-agnostic — strategies are discovered at wiring time.
  */
 
-interface VectorSearchConfig {
-    db: Database;
-    codeHnsw?: HNSWIndex;
-    gitHnsw?: HNSWIndex;
-    patternHnsw?: HNSWIndex;
-    codeVecs: Map<number, Float32Array>;
-    gitVecs: Map<number, Float32Array>;
-    patternVecs: Map<number, Float32Array>;
+interface CompositeVectorConfig {
+    strategies: Map<string, DomainVectorSearch>;
     embedding: EmbeddingProvider;
-    reranker?: Reranker;
+    /** Default K values per strategy name. Strategies not listed default to 0. */
+    defaults?: Record<string, number>;
 }
-declare class VectorSearch implements SearchStrategy {
-    private _config;
-    constructor(config: VectorSearchConfig);
-    /** Search across all indices. Returns combined results sorted by score. */
+declare class CompositeVectorSearch implements SearchStrategy {
+    private _c;
+    /** Default K when no source override is provided. */
+    private static readonly DEFAULT_K;
+    constructor(_c: CompositeVectorConfig);
+    /** Search across all registered domain strategies with score-based merge. */
     search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
-    /** Vector search across code chunks. */
-    private _searchCode;
-    /** Vector search across git commits. */
-    private _searchGit;
-    /** Vector search across memory patterns. */
-    private _searchPatterns;
 }
 
 /**
- * BrainBank — Keyword Search Strategy
+ * BrainBank — Composite BM25 Search Strategy
  *
- * Keyword search via SQLite FTS5 with BM25 ranking.
- * Searches across code chunks, git commits, and memory patterns.
- * Uses Porter stemming + unicode61 tokenizer.
+ * Generic BM25 coordinator that discovers BM25SearchPlugin instances
+ * from the registry and delegates per-source keyword search.
  */
 
-declare class KeywordSearch implements SearchStrategy {
-    private _db;
-    constructor(_db: Database);
+declare class CompositeBM25Search implements SearchStrategy {
+    private _registry;
+    constructor(_registry: PluginRegistry);
     /**
-     * Full-text keyword search across all FTS5 indices.
-     * Uses BM25 scoring — lower scores = better matches.
+     * Run BM25 keyword search across all plugins that implement BM25SearchPlugin.
+     * Each plugin searches its own FTS5 tables.
      */
     search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
-    /** FTS5 search across code chunks + file-path fallback. */
-    private _searchCode;
-    /** File-path fallback: match filenames via LIKE. */
-    private _searchCodeByPath;
-    /** FTS5 search across git commits. */
-    private _searchGit;
-    /** FTS5 search across memory patterns. */
-    private _searchPatterns;
-    /** Map a code_chunks row to a CodeResult. */
-    private _toCodeResult;
-    /** Rebuild the FTS index from scratch. */
+    /** Rebuild FTS5 indices across all BM25 plugins. */
     rebuild(): void;
 }
 
@@ -1028,4 +2015,180 @@ declare class KeywordSearch implements SearchStrategy {
  */
 declare function reciprocalRankFusion(resultSets: SearchResult[][], k?: number, maxResults?: number): SearchResult[];
 
-export { KeywordSearch as BM25Search, BrainBank, BrainBankConfig, CoEditAnalyzer, CoEditSuggestion, CodeChunk, CodeChunker, CodeWalker, Collection, Consolidator, ContextBuilder, ContextOptions, DEFAULTS, DocsIndexer, DocumentCollection, type EmbeddingKey, EmbeddingProvider, GitIndexer, HNSWIndex, IGNORE_DIRS, IndexResult, IndexStats, KeywordSearch, LearningPattern, LocalEmbedding, VectorSearch as MultiIndexSearch, type NoteDigest, NoteStore, OpenAIEmbedding, type OpenAIEmbeddingOptions, PatternStore, PerplexityContextEmbedding, type PerplexityContextEmbeddingOptions, PerplexityEmbedding, type PerplexityEmbeddingOptions, Plugin, ProgressCallback, Qwen3Reranker, type Qwen3RerankerOptions, type RecallOptions, type ReembedOptions, type ReembedResult, Reranker, ResolvedConfig, SUPPORTED_EXTENSIONS, SearchHit, type SearchOptions, SearchResult, type SearchStrategy, StageProgressCallback, type StoredNote, VectorIndex, VectorSearch, type WatchOptions, type Watcher, cosineSimilarity, getLanguage, isSupported, normalize, providerKey, reciprocalRankFusion, resolveConfig, resolveEmbedding, searchMMR };
+/**
+ * BrainBank — FTS Utilities
+ *
+ * Shared helpers for SQLite FTS5 query sanitization.
+ */
+/**
+ * Sanitize a user query for FTS5 syntax.
+ * Strips operators that would cause parse errors, splits compound words,
+ * and converts words to implicit AND with exact-match quoting.
+ */
+declare function sanitizeFTS(query: string): string;
+/**
+ * Normalize BM25 score from SQLite (negative, lower = better)
+ * to 0.0–1.0 (higher = better) for consistency with vector search.
+ */
+declare function normalizeBM25(rawScore: number): number;
+/**
+ * Escape SQL LIKE wildcard characters (`%`, `_`, `\`).
+ * Use with `LIKE ? ESCAPE '\'` in queries.
+ */
+declare function escapeLike(s: string): string;
+
+/**
+ * BrainBank — Rerank
+ *
+ * Position-aware score blending between retrieval and reranker.
+ * Pure function — no state.
+ *
+ * Top 1-3:  75% retrieval / 25% reranker (preserves exact matches)
+ * Top 4-10: 60% retrieval / 40% reranker
+ * Top 11+:  40% retrieval / 60% reranker (trust reranker more)
+ */
+
+/** Re-rank results using position-aware blending. */
+declare function rerank(query: string, results: SearchResult[], reranker: Reranker): Promise<SearchResult[]>;
+
+/**
+ * BrainBank — Database Metadata
+ *
+ * Helpers for reading/writing metadata stored in core SQLite tables:
+ *
+ * - **Index State** — cross-process HNSW version tracking.
+ *   Processes compare in-memory versions with DB to detect staleness
+ *   and trigger hot-reload via `ensureFresh()`.
+ *
+ * - **Embedding Meta** — tracks which embedding provider is stored in
+ *   the database. Detects dimension mismatches at startup and updates
+ *   metadata after `reembed()`.
+ */
+
+/**
+ * Increment the version for a given index name.
+ * Sets writer_pid to current process PID.
+ * Uses UPSERT so the row is created on first call.
+ */
+declare function bumpVersion(db: DatabaseAdapter, name: string): number;
+/**
+ * Get all index versions as a Map.
+ * Used by `ensureFresh()` to compare against in-memory versions.
+ */
+declare function getVersions(db: DatabaseAdapter): Map<string, number>;
+/** Get the version of a single index. Returns 0 if not found. */
+declare function getVersion(db: DatabaseAdapter, name: string): number;
+
+/**
+ * BrainBank — Write Lock
+ *
+ * Advisory file lock for cross-process HNSW write exclusion.
+ * Uses `O_CREAT | O_EXCL` for atomic lock creation — works on all OS.
+ * Stale locks (dead PID) are detected and stolen automatically.
+ */
+/**
+ * Acquire an advisory lock. Blocks with exponential backoff if another
+ * process holds the lock. Steals stale locks from dead processes.
+ *
+ * @throws After MAX_WAIT_MS if the lock cannot be acquired.
+ */
+declare function acquireLock(lockDir: string, name: string): Promise<void>;
+/** Release an advisory lock. Safe to call even if not held. */
+declare function releaseLock(lockDir: string, name: string): void;
+/**
+ * Execute a function while holding an advisory lock.
+ * Lock is always released, even on error.
+ */
+declare function withLock<T>(lockDir: string, name: string, fn: () => T | Promise<T>): Promise<T>;
+
+/**
+ * BrainBank — SQLite Adapter
+ *
+ * Implements `DatabaseAdapter` using `better-sqlite3`.
+ * Drop-in replacement for the old `Database` class.
+ * Handles WAL mode, directory creation, schema init, and transactions.
+ */
+
+declare class SQLiteAdapter implements DatabaseAdapter {
+    private _db;
+    readonly capabilities: AdapterCapabilities;
+    constructor(dbPath: string);
+    /** Prepare a reusable statement. */
+    prepare<T = unknown>(sql: string): PreparedStatement<T>;
+    /** Execute raw SQL (no results). */
+    exec(sql: string): void;
+    /** Run a function inside a transaction. Auto-commits on success, auto-rollbacks on error. */
+    transaction<T>(fn: () => T): T;
+    /** Run a prepared statement on multiple rows. Wraps in a single transaction. */
+    batch<T extends unknown[]>(sql: string, rows: T[]): void;
+    /** Close the database. */
+    close(): void;
+    /**
+     * 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<T = unknown>(): T;
+}
+
+/**
+ * BrainBank — Brain Context
+ *
+ * Portable input for `createBrain()`. Decouples the factory from
+ * `process.argv` / `process.env` so it can be called from the CLI,
+ * MCP server, tests, or any programmatic consumer.
+ */
+/** Everything the factory needs to build a BrainBank instance. */
+interface BrainContext {
+    /** Repository root path. */
+    repoPath: string;
+    /** Environment variable overrides. Falls back to `process.env`. */
+    env?: Record<string, string | undefined>;
+    /** CLI flag overrides (e.g. `{ ignore: 'dist,vendor' }`). */
+    flags?: Record<string, string | undefined>;
+}
+/** Build a `BrainContext` from CLI argv + process.env. */
+declare function contextFromCLI(repoPath?: string): BrainContext;
+
+/**
+ * BrainBank CLI — Config Loader
+ *
+ * Loads .brainbank/config.json (or .ts/.js/.mjs fallback).
+ * Config priority: CLI flags > config file > defaults.
+ */
+
+/** Full .brainbank/config.json schema. */
+interface ProjectConfig {
+    plugins?: string[];
+    embedding?: string;
+    reranker?: string;
+    pruner?: string;
+    maxFileSize?: number;
+    indexers?: Plugin[];
+    brainbank?: Partial<BrainBankConfig>;
+    /** Context field defaults (e.g. { lines: true, callTree: true, symbols: false }). */
+    context?: Record<string, unknown>;
+    /** Per-plugin config sections (e.g. code, git, docs). */
+    [pluginName: string]: unknown;
+}
+
+/**
+ * BrainBank CLI — Brain Factory
+ *
+ * Creates a configured BrainBank instance with dynamically loaded plugins,
+ * auto-discovered indexers, and config file support.
+ * Delegates to focused modules in factory/.
+ */
+
+/** Reset factory caches. Useful for tests. */
+declare function resetFactoryCache(): void;
+/**
+ * Create a BrainBank with built-in + discovered + config plugins.
+ *
+ * Accepts either a `BrainContext` (for programmatic use) or an optional
+ * `repoPath` string (for CLI backward compat — builds context from argv).
+ */
+declare function createBrain(contextOrRepo?: BrainContext | string): Promise<BrainBank>;
+
+export { type AdapterCapabilities, type BM25SearchPlugin, BrainBank, type BrainBankConfig, type BrainContext, type CoEditPlugin, type CoEditSuggestion, type CodeChunk, type CodeResult, type CodeResultMetadata, Collection, type CollectionAddOptions, type CollectionItem, type CollectionResult, type CollectionSearchOptions, type CommitResult, type CommitResultMetadata, CompositeBM25Search, CompositeVectorSearch, ContextBuilder, type ContextFieldDef, type ContextFieldPlugin, type ContextFormatterPlugin, type ContextOptions, type CountRow, DEFAULTS, DEFAULT_PORT, type DatabaseAdapter, type DocChunk, type DocsPlugin, type DocumentCollection, type DocumentResult, type DocumentResultMetadata, type DomainVectorSearch, type EmbeddingKey, type EmbeddingMetaRow, type EmbeddingProvider, EmbeddingWorkerProxy, type ExecuteResult, type ExpandablePlugin, type Expander, type ExpanderManifestItem, type ExpanderResult, type FileResolvablePlugin, type GitCommitRecord, HNSW, HNSWIndex, HaikuExpander, type HaikuExpanderOptions, HaikuPruner, type HaikuPrunerOptions, type HnswKey, HttpServer, type HttpServerOptions, IGNORE_DIRS, type IncrementalTracker, type IndexResult, type IndexablePlugin, KVService, type KvDataRow, type KvVectorRow, LocalEmbedding, type MigratablePlugin, type Migration, OpenAIEmbedding, type OpenAIEmbeddingOptions, PerplexityContextEmbedding, type PerplexityContextEmbeddingOptions, PerplexityEmbedding, type PerplexityEmbeddingOptions, type Plugin, type PluginContext, type PreparedStatement, type ProgressCallback, type ProjectConfig, type Pruner, type PrunerItem, Qwen3Reranker, type Qwen3RerankerOptions, type ReembedOptions, type ReembedResult, type ReembedTable, type ReembeddablePlugin, type Reranker, type ResolvedConfig, SQLiteAdapter, SUPPORTED_EXTENSIONS, type SearchHit, type SearchOptions, type SearchResult, type SearchResultType, type SearchStrategy, type SearchablePlugin, type StageProgressCallback, type VectorIndex, type VectorRow, type VectorSearchPlugin, type WatchConfig, type WatchEvent, type WatchEventHandler, type WatchHandle, type WatchOptions, type WatchablePlugin, Watcher, type WebhookHandler, WebhookServer, acquireLock, bumpVersion, contextFromCLI, cosineSimilarity, createBrain, createTracker, escapeLike, getLanguage, getServerUrl, getVersion, getVersions, isBM25SearchPlugin, isCoEditPlugin, isCodeResult, isCollectionResult, isCommitResult, isContextFieldPlugin, isContextFormatterPlugin, isDocsPlugin, isDocumentResult, isExpandablePlugin, isFileResolvable, isIgnoredDir, isIgnoredFile, isIndexable, isMigratable, isReembeddable, isSearchable, isServerRunning, isSupported, isVectorSearchPlugin, isWatchable, matchResult, normalize, normalizeBM25, providerKey, pruneResults, readPid, reciprocalRankFusion, releaseLock, removePid, rerank, resetFactoryCache, resolveConfig, resolveEmbedding, runPluginMigrations, sanitizeFTS, searchMMR, vecToBuffer, withLock, writePid };