@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-KLK3PBTO.js

@@ -0,0 +1,1119 @@
+import {
+  bbProjectsDir
+} from "./chunk-2BSKD7O3.js";
+import {
+  brain_sql_exports
+} from "./chunk-ROMM6KMC.js";
+
+// src/storage/db.node.ts
+import Database from "better-sqlite3";
+function openDatabase(path2, options = {}) {
+  const db = new Database(path2, { readonly: options.readonly ?? false });
+  if (!options.readonly) {
+    db.pragma("journal_mode = WAL");
+    db.pragma("busy_timeout = 5000");
+    db.pragma("synchronous = NORMAL");
+    const tempStore = String(process.env.BB_SQLITE_TEMP_STORE ?? "").toUpperCase();
+    if (tempStore === "MEMORY" || tempStore === "FILE" || tempStore === "DEFAULT") db.pragma(`temp_store = ${tempStore}`);
+    else if (tempStore === "0" || tempStore === "1" || tempStore === "2") db.pragma(`temp_store = ${tempStore}`);
+    const cacheMb = Number(process.env.BB_SQLITE_CACHE_MB ?? 0);
+    if (Number.isInteger(cacheMb) && cacheMb >= 1 && cacheMb <= 4096) db.pragma(`cache_size = -${cacheMb * 1024}`);
+    db.pragma(process.env.BB_FK_ENFORCE === "0" ? "foreign_keys = OFF" : "foreign_keys = ON");
+  } else {
+    db.pragma(process.env.BB_FK_ENFORCE === "0" ? "foreign_keys = OFF" : "foreign_keys = ON");
+  }
+  return {
+    native: db,
+    prepare(sql) {
+      const stmt = db.prepare(sql);
+      return {
+        get: (...params) => stmt.get(...params),
+        all: (...params) => stmt.all(...params),
+        run: (...params) => {
+          const r = stmt.run(...params);
+          return { changes: Number(r.changes ?? 0), lastInsertRowid: Number(r.lastInsertRowid ?? 0) };
+        }
+      };
+    },
+    exec(sql) {
+      db.exec(sql);
+    },
+    close() {
+      db.close();
+    },
+    transaction(fn) {
+      const run = db.transaction(fn);
+      return (...args) => run(...args);
+    },
+    run(sql, ...params) {
+      const r = db.prepare(sql).run(...params);
+      return { changes: Number(r.changes ?? 0), lastInsertRowid: Number(r.lastInsertRowid ?? 0) };
+    },
+    readonly: options.readonly ?? false
+  };
+}
+
+// src/brain/database.ts
+import path from "path";
+import { mkdirSync, existsSync } from "fs";
+
+// src/brain/schema-ddl.ts
+var DDL = `
+CREATE TABLE IF NOT EXISTS brain_schema_version (version INTEGER PRIMARY KEY, applied_at INTEGER NOT NULL, migration_name TEXT NOT NULL);
+-- ================================================================
+      -- UNIVERSAL PROJECT BRAIN DATABASE FOUNDATION
+      -- Cross-language intelligence system  
+      -- ================================================================
+      
+      -- Core Files Table
+      CREATE TABLE IF NOT EXISTS brain_file (
+        id TEXT PRIMARY KEY NOT NULL,
+        project_id TEXT NOT NULL,
+        path TEXT NOT NULL,
+        relative_path TEXT NOT NULL, 
+        file_hash TEXT NOT NULL,
+        size_bytes INTEGER,
+        line_count INTEGER,
+        language TEXT,
+        last_modified REAL,
+        indexed_at TEXT,
+        layer TEXT,
+        is_test_file INTEGER,
+        is_config_file INTEGER,
+        is_documentation INTEGER,
+        has_syntax_errors INTEGER NOT NULL DEFAULT 0,
+        error_report TEXT,
+        framework_type TEXT,
+        -- The analyzer's FileMetadata as JSON: patterns, detectedFrameworks,
+        -- frameworkPatterns, architecturalInsights, complexity, cyclomaticComplexity,
+        -- codeQuality. The framework_type column above is the ONE field promoted
+        -- to its own column;
+        -- everything else the analyzer computed had nowhere to go, so a correct
+        -- analyzer's pattern evidence was discarded on the way into the index.
+        -- This is the same shape brain_relationship.metadata already uses.
+        metadata TEXT,
+        time_created INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+        time_updated INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+      );
+      
+      -- Universal Symbols Table
+
+      CREATE TABLE IF NOT EXISTS brain_symbol (
+        id TEXT PRIMARY KEY NOT NULL,
+        project_id TEXT NOT NULL,
+        file_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        qualified_name TEXT,
+        symbol_type TEXT NOT NULL,
+        line_start INTEGER,
+        line_end INTEGER,
+        byte_start INTEGER,
+        byte_end INTEGER, 
+        return_type TEXT,
+        parameters TEXT,
+        docstring TEXT,
+        -- The symbol's own source text, bounded. This is what makes a word
+        -- that appears ONLY inside a function reachable by a text query.
+        -- Measured on real corpora before it existed: content search selected
+        -- name/qualified_name/docstring and there was no body column at all, so
+        -- a body-only word was unreachable by BOTH retrieval paths \u2014 27% of
+        -- body-only words on rake, 38% on ripgrep. The body WAS indexed, but
+        -- only as a 50-dimensional hash, which cannot be queried by word.
+        -- Bounded because a symbol can be very large (a 25 599-character body
+        -- was measured on rake) and this table is scanned by content search.
+        source_text TEXT,
+        visibility TEXT,
+        is_async INTEGER,
+        is_static INTEGER,
+        is_abstract INTEGER,
+        is_override INTEGER,
+        is_getter INTEGER,
+        is_setter INTEGER,
+        complexity INTEGER,
+        owner_symbol_id TEXT,
+        scope_kind TEXT,
+        -- #612: 1 = the analyzer published this symbol as a DECLARATION
+        -- (a c prototype, a cpp in-class/field-declaration or header
+        -- prototype, a rust function_signature_item, a body-less zig
+        -- function declaration), NULL = a definition or a language that does
+        -- not distinguish. Name resolution reads this to prefer the
+        -- definition when a declaration and its definition share a name.
+        is_declaration INTEGER,
+        annotations TEXT,
+        generic_parameters TEXT,
+        qualified_calls TEXT,
+        -- M60/SDJ-8: the type hierarchy each symbol extends/implements, as a JSON
+        -- array of names (["Base","Mixin"]). Present because the overrides label
+        -- could not be resolved cross-file at all without it: brain_symbol held no
+        -- heritage data, so the post-index pass could only resolve targets BY NAME
+        -- which resolves the wrong parent perfectly happily. Measured on scala3:
+        -- 45.5% of low-confidence override rows pointed at a supertype that does
+        -- NOT declare the overridden method, and 0 of 677 were fixable from one
+        -- file. NULL = "this symbol declares no supertypes", which is also what
+        -- every pre-SDJ-8 row means, so an un-migrated database degrades to the
+        -- previous behaviour rather than mis-resolving.
+        super_types TEXT,
+        api_contract_path TEXT,
+        gravity_score REAL DEFAULT 0,
+        layer TEXT DEFAULT "core",
+        time_created INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+        time_updated INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+        FOREIGN KEY (file_id) REFERENCES brain_file(id) ON DELETE CASCADE
+      );
+      
+      -- Cross-Language Relationships Table  
+      CREATE TABLE IF NOT EXISTS brain_relationship (
+        id TEXT PRIMARY KEY NOT NULL,
+        project_id TEXT NOT NULL,
+        source_symbol_id TEXT,
+        target_symbol_id TEXT,
+        source_external TEXT,
+        target_external TEXT,
+        -- The RESOLUTION BASIS of the target \u2014 see ensureRelationshipTargetBasisColumn for why this is
+        -- a VIRTUAL GENERATED column rather than a writer-maintained one.
+        target_basis TEXT GENERATED ALWAYS AS (
+          CASE
+            WHEN target_symbol_id IS NOT NULL THEN 'symbol'
+            WHEN metadata IS NOT NULL AND json_extract(metadata, '$.isExternalTarget') = 1 THEN 'external'
+            WHEN target_external IS NOT NULL THEN 'unresolved'
+            ELSE 'unresolved'
+          END
+        ) VIRTUAL,
+        -- The EVIDENCE CLASS of the edge, extracted once (same generated-column
+        -- rule as target_basis): pattern rules read this per row for every
+        -- relationship in the project, and reading the wide metadata TEXT at
+        -- that rate made a 3.6 GB default scan 100+ s. A covering index over the
+        -- narrow computed column lets the scan run inside the index.
+        evidence_class TEXT GENERATED ALWAYS AS (json_extract(metadata, '$.evidenceClass')) VIRTUAL,
+        relationship_type TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        context TEXT,
+        line_number INTEGER,
+        is_cross_language INTEGER,
+        bridge_mechanism TEXT,
+        is_cross_file INTEGER NOT NULL DEFAULT 0,
+        metadata TEXT,
+        time_created INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+        time_updated INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+        FOREIGN KEY (source_symbol_id) REFERENCES brain_symbol(id) ON DELETE CASCADE,
+        FOREIGN KEY (target_symbol_id) REFERENCES brain_symbol(id) ON DELETE SET NULL
+      );
+      
+      -- Imports/Dependencies Table
+      CREATE TABLE IF NOT EXISTS brain_import (
+        id TEXT PRIMARY KEY NOT NULL,
+        project_id TEXT NOT NULL,
+        file_id TEXT NOT NULL,
+        imported_name TEXT NOT NULL,
+        imported_as TEXT,
+        import_path TEXT NOT NULL,
+        import_type TEXT NOT NULL,
+        is_external INTEGER,
+        package_name TEXT,
+        line_number INTEGER,
+        is_dynamic INTEGER,
+        resolved_symbol_id TEXT,
+        time_created INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+        time_updated INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+        FOREIGN KEY (file_id) REFERENCES brain_file(id) ON DELETE CASCADE
+      );
+      
+      -- Pattern Intelligence Table
+      
+      -- Query Cache Table
+      CREATE TABLE IF NOT EXISTS brain_query_cache (
+        id TEXT PRIMARY KEY NOT NULL,
+        project_id TEXT NOT NULL,
+        query_type TEXT NOT NULL,
+        query_hash TEXT NOT NULL,
+        query_params TEXT,
+        result_data TEXT,
+        confidence REAL NOT NULL,
+        computation_time_ms INTEGER,
+        cache_expires_at INTEGER,
+        hit_count INTEGER DEFAULT 0 NOT NULL,
+        time_created INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+        time_updated INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+      );
+      
+      -- Index Status Tracking
+      CREATE TABLE IF NOT EXISTS brain_index_status (
+        project_id TEXT PRIMARY KEY NOT NULL,
+        status TEXT,
+        last_full_index INTEGER,
+        last_incremental_index INTEGER,
+        total_files INTEGER DEFAULT 0 NOT NULL,
+        indexed_files INTEGER DEFAULT 0 NOT NULL,
+        total_symbols INTEGER DEFAULT 0 NOT NULL,
+        total_relationships INTEGER DEFAULT 0 NOT NULL,
+        indexing_version TEXT NOT NULL,
+        languages_detected TEXT,
+        frameworks_detected TEXT,
+        indexing_errors TEXT,
+        performance_stats TEXT,
+        time_created INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+        time_updated INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+      );
+      
+      -- ================================================================
+      -- PERFORMANCE INDEXES - Optimized for graph queries
+      -- ================================================================
+      
+      CREATE INDEX IF NOT EXISTS brain_file_project_idx ON brain_file(project_id);
+      CREATE INDEX IF NOT EXISTS brain_file_path_idx ON brain_file(path);
+      CREATE INDEX IF NOT EXISTS brain_file_language_idx ON brain_file(language);
+      CREATE INDEX IF NOT EXISTS brain_file_hash_idx ON brain_file(file_hash);
+      
+      CREATE INDEX IF NOT EXISTS brain_symbol_project_idx ON brain_symbol(project_id);
+      CREATE INDEX IF NOT EXISTS brain_symbol_file_idx ON brain_symbol(file_id);
+      CREATE INDEX IF NOT EXISTS brain_symbol_name_idx ON brain_symbol(name);
+      CREATE INDEX IF NOT EXISTS brain_symbol_type_idx ON brain_symbol(symbol_type);
+      CREATE INDEX IF NOT EXISTS brain_symbol_qualified_idx ON brain_symbol(qualified_name);
+      
+      CREATE INDEX IF NOT EXISTS brain_rel_project_idx ON brain_relationship(project_id);
+      CREATE INDEX IF NOT EXISTS brain_rel_source_idx ON brain_relationship(source_symbol_id);
+      CREATE INDEX IF NOT EXISTS brain_rel_target_idx ON brain_relationship(target_symbol_id);
+      CREATE INDEX IF NOT EXISTS brain_rel_type_idx ON brain_relationship(relationship_type);
+      CREATE INDEX IF NOT EXISTS brain_rel_source_type_idx ON brain_relationship(source_symbol_id, relationship_type);
+      CREATE INDEX IF NOT EXISTS brain_rel_proj_type_target_idx ON brain_relationship(project_id, relationship_type, target_symbol_id);
+      CREATE INDEX IF NOT EXISTS brain_rel_confidence_idx ON brain_relationship(confidence);
+      CREATE INDEX IF NOT EXISTS brain_rel_cross_file_idx ON brain_relationship(is_cross_file);
+      CREATE INDEX IF NOT EXISTS brain_rel_target_ext_idx ON brain_relationship(target_external);
+      
+      CREATE INDEX IF NOT EXISTS brain_import_project_idx ON brain_import(project_id);
+      CREATE INDEX IF NOT EXISTS brain_import_file_idx ON brain_import(file_id);
+      CREATE INDEX IF NOT EXISTS brain_import_path_idx ON brain_import(import_path);
+      
+      CREATE INDEX IF NOT EXISTS brain_symbol_owner_idx ON brain_symbol(owner_symbol_id);
+      -- Owner-cascade seeks carry the project filter, so the single-column owner index
+      -- cannot serve the range: (project_id, owner_symbol_id) lets the walk seek the
+      -- owner's members instead of scanning every symbol in the project per node.
+      CREATE INDEX IF NOT EXISTS brain_symbol_project_owner_idx ON brain_symbol(project_id, owner_symbol_id);
+
+      
+      -- Initialize project brain status
+      INSERT OR IGNORE INTO brain_index_status (
+        project_id, 
+        indexing_version, 
+        languages_detected, 
+        frameworks_detected,
+        indexing_errors,
+        performance_stats,
+        time_created,
+        time_updated
+      ) VALUES (
+        ?, 
+        'v1.0.0',
+        '[]',
+        '[]', 
+        '[]',
+        '{}',
+        strftime('%s','now') * 1000,
+        strftime('%s','now') * 1000
+      );
+CREATE TABLE IF NOT EXISTS brain_project_health (
+              project_id TEXT PRIMARY KEY NOT NULL,
+              complexity_score INTEGER NOT NULL DEFAULT 0,
+              maintainability_score INTEGER NOT NULL DEFAULT 0,
+              technical_debt_score INTEGER NOT NULL DEFAULT 0,
+              code_quality_score INTEGER NOT NULL DEFAULT 0,
+              language_distribution TEXT,
+              service_metrics TEXT,
+              dependency_metrics TEXT,
+              circular_dependencies TEXT,
+              contract_drift TEXT,
+              performance_bottlenecks TEXT,
+              time_created INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+              time_updated INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+            );
+
+CREATE TABLE IF NOT EXISTS brain_taint_flow (
+              id TEXT PRIMARY KEY NOT NULL,
+              project_id TEXT NOT NULL,
+              source_symbol_id TEXT,
+              sink_symbol_id TEXT,
+              source_type TEXT NOT NULL,
+              sink_type TEXT NOT NULL,
+              vulnerability_type TEXT NOT NULL,
+              severity TEXT NOT NULL,
+              is_mitigated INTEGER NOT NULL DEFAULT 0,
+              flow_path TEXT,
+              cross_language_boundaries INTEGER NOT NULL DEFAULT 0,
+              mitigation_steps TEXT,
+              time_created INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+              time_updated INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+            );
+CREATE INDEX IF NOT EXISTS brain_taint_project_idx ON brain_taint_flow(project_id);
+CREATE INDEX IF NOT EXISTS brain_taint_source_idx ON brain_taint_flow(source_symbol_id);
+CREATE INDEX IF NOT EXISTS brain_taint_sink_idx ON brain_taint_flow(sink_symbol_id);
+CREATE INDEX IF NOT EXISTS brain_taint_vuln_idx ON brain_taint_flow(vulnerability_type);
+CREATE INDEX IF NOT EXISTS brain_taint_severity_idx ON brain_taint_flow(severity);
+
+-- ================================================================
+-- COMPOUND & MISSING INDEXES - aligned with the drizzle schema
+-- ================================================================
+
+CREATE INDEX IF NOT EXISTS brain_file_proj_path_idx ON brain_file(project_id, path);
+CREATE INDEX IF NOT EXISTS brain_file_proj_hash_idx ON brain_file(project_id, file_hash);
+CREATE INDEX IF NOT EXISTS brain_file_syntax_errors_idx ON brain_file(has_syntax_errors);
+
+CREATE INDEX IF NOT EXISTS brain_sym_proj_file_idx ON brain_symbol(project_id, file_id);      CREATE INDEX IF NOT EXISTS brain_sym_proj_name_idx ON brain_symbol(project_id, name);
+      -- Case-insensitive name index: LOWER(name) = LOWER(?) wraps the column and
+      -- defeats the BINARY index (full scan on 1M symbols, M19.Q1 measured ~1.3s
+      -- with the join). SQLite's NOCASE collation folds ASCII exactly like its
+      -- LOWER(), so name = ? COLLATE NOCASE / name LIKE ? COLLATE NOCASE are
+      -- semantically identical to the old LOWER() forms but index-accelerated.
+      CREATE INDEX IF NOT EXISTS brain_sym_proj_name_nocase_idx ON brain_symbol(project_id, name COLLATE NOCASE);
+      CREATE INDEX IF NOT EXISTS brain_sym_proj_type_idx ON brain_symbol(project_id, symbol_type);
+CREATE INDEX IF NOT EXISTS brain_sym_proj_name_type_idx ON brain_symbol(project_id, name, symbol_type);
+
+-- MEASURED (bb_visualize on cargo: 2,071 files, 40,595 symbols, 164,767
+-- relationships): bb_visualize's project scope orders symbols by gravity_score to
+-- pick the project's busiest core, and SQLite had no index that could supply that
+-- order, so it materialised and sorted ALL 40,595 rows into a temp B-tree on every
+-- single call. Interleaved A/B, min of 6: 570.6 ms without this index, 2.8 ms with
+-- it -- 139x -- and the plan changes from
+--     SCAN f | SEARCH s ... | USE TEMP B-TREE FOR ORDER BY
+-- to
+--     SEARCH s USING INDEX brain_symbol_gravity_idx (project_id=?)
+-- which is a noise-free fact: the sort is gone, not merely faster.
+--
+-- line_start is the tie-breaker so the order is total and a render is reproducible.
+--
+-- Deliberately NOT added, having measured both:
+--   * brain_relationship(project_id, source_symbol_id, target_symbol_id) -- 4.4 s to
+--     build on cargo, and it made the joined edge fetch 38x SLOWER (18.8 ms ->
+--     714.4 ms), because the existing brain_rel_proj_source_idx already answers that
+--     query better. An index that costs four seconds of every index run to lose a
+--     benchmark is not an optimisation.
+CREATE INDEX IF NOT EXISTS brain_symbol_gravity_idx ON brain_symbol(project_id, gravity_score DESC, line_start);
+
+CREATE INDEX IF NOT EXISTS brain_rel_proj_target_idx ON brain_relationship(project_id, target_symbol_id);
+CREATE INDEX IF NOT EXISTS brain_rel_proj_source_idx ON brain_relationship(project_id, source_symbol_id);
+CREATE INDEX IF NOT EXISTS brain_rel_proj_type_idx ON brain_relationship(project_id, relationship_type);
+CREATE INDEX IF NOT EXISTS brain_rel_target_type_idx ON brain_relationship(target_symbol_id, relationship_type);
+CREATE INDEX IF NOT EXISTS brain_rel_cross_lang_idx ON brain_relationship(is_cross_language);
+-- M29.R3 (giant-repo, 59k files): hover's cross-language probes filter on
+-- is_cross_language = 1 AND target/source_symbol_id = ?. The single-column
+-- indexes leave SQLite scanning; the composite (symbol_id, is_cross_language)
+-- form answers both probes from the index (measured 477ms -> <1ms at scale).
+CREATE INDEX IF NOT EXISTS brain_rel_target_cross_idx ON brain_relationship(target_symbol_id, is_cross_language);
+CREATE INDEX IF NOT EXISTS brain_rel_source_cross_idx ON brain_relationship(source_symbol_id, is_cross_language);
+-- Pattern engines scan every relationship of a project, group by target, and
+-- compute a per-row evidence gate. This index carries all four columns those
+-- queries read (target/source ids, confidence, evidence class), so the scan never
+-- touches the 3.6 GB table heap or the wide metadata column.
+CREATE INDEX IF NOT EXISTS brain_rel_pattern_cover_idx ON brain_relationship(project_id, relationship_type, target_symbol_id, source_symbol_id, confidence, evidence_class, target_external);
+-- The reported-type scan reads symbol columns for every symbol of a set of types;
+-- (project_id, symbol_type) narrows it without a full symbol-table scan.
+CREATE INDEX IF NOT EXISTS brain_symbol_type_cover_idx ON brain_symbol(project_id, symbol_type);
+
+CREATE INDEX IF NOT EXISTS brain_import_name_idx ON brain_import(imported_name);
+CREATE INDEX IF NOT EXISTS brain_import_external_idx ON brain_import(is_external);
+
+
+CREATE INDEX IF NOT EXISTS brain_cache_project_idx ON brain_query_cache(project_id);
+CREATE INDEX IF NOT EXISTS brain_cache_query_type_idx ON brain_query_cache(query_type);
+CREATE INDEX IF NOT EXISTS brain_cache_hash_idx ON brain_query_cache(query_hash);
+
+CREATE TABLE IF NOT EXISTS brain_semantic_embedding (
+              id TEXT PRIMARY KEY NOT NULL,
+              project_id TEXT NOT NULL,
+              entity_id TEXT NOT NULL,
+              entity_type TEXT NOT NULL,
+              embedding_model TEXT NOT NULL,
+              -- DENSE vectors live in embedding_blob (little-endian float32); this
+              -- column holds an EMPTY STRING for those rows. It still carries the
+              -- JSON form for SPARSE token lists (tfidf-v1) and for LEGACY dense
+              -- rows written before the 2026-11-01 contract, whose blob is NULL.
+              -- Why: storing both duplicated 34% of an 84.5 MB index as JSON digits
+              -- (measured on apollo-server: 28.9 MB JSON beside 9.15 MB float32).
+              -- Read through readRowVector() (src/brain/semantic/vector-binary.ts).
+              embedding_vector TEXT NOT NULL,
+              embedding_blob BLOB,
+              vector_dimension INTEGER NOT NULL,
+              content_hash TEXT NOT NULL,
+              semantic_context TEXT,
+              similarity_threshold REAL DEFAULT 0.7,
+              last_updated INTEGER NOT NULL,
+              time_created INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+              time_updated INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+            );
+CREATE INDEX IF NOT EXISTS brain_embed_project_idx ON brain_semantic_embedding(project_id);
+CREATE INDEX IF NOT EXISTS brain_embed_entity_idx ON brain_semantic_embedding(entity_id);
+CREATE INDEX IF NOT EXISTS brain_embed_type_idx ON brain_semantic_embedding(entity_type);
+CREATE INDEX IF NOT EXISTS brain_embed_model_idx ON brain_semantic_embedding(embedding_model);
+CREATE INDEX IF NOT EXISTS brain_embed_hash_idx ON brain_semantic_embedding(content_hash);
+-- M52.P1 (#721): covering index for the bb_health aggregates (models/dims/
+-- entities). Without it SQLite reads full ~8KB vector BLOB rows to reach four
+-- metadata columns \u2014 measured 12.7s per bb_health call at 158k x 2048-dim.
+CREATE INDEX IF NOT EXISTS brain_embed_health_idx ON brain_semantic_embedding(project_id, embedding_model, entity_id, vector_dimension);
+
+      `;
+var SCHEMA_VERSION = 1;
+var SCHEMA_MIGRATION_NAME = "m13-universal-brain";
+var ANNOTATION_DDL = `
+    CREATE TABLE IF NOT EXISTS brain_annotation (
+      id TEXT PRIMARY KEY NOT NULL,
+      project_id TEXT NOT NULL,
+      symbol_name TEXT NOT NULL,
+      symbol_path TEXT,
+      author_class TEXT NOT NULL,
+      tool_identity TEXT NOT NULL,
+      body TEXT NOT NULL,
+      time_created INTEGER NOT NULL,
+      time_updated INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS brain_annotation_project_symbol_idx ON brain_annotation(project_id, symbol_name);
+    CREATE INDEX IF NOT EXISTS brain_annotation_project_idx ON brain_annotation(project_id);
+    -- Location identity in the schema, not in an encoded id string. COALESCE
+    -- is load-bearing: symbol_path is nullable and SQLite counts NULLs as
+    -- distinct in a UNIQUE index, so a path-less note must not escape the
+    -- constraint. See src/brain/annotation-store.ts for the measured defect
+    -- this replaces.
+    CREATE UNIQUE INDEX IF NOT EXISTS brain_annotation_location_idx
+      ON brain_annotation(project_id, symbol_name, author_class, COALESCE(symbol_path, ''));
+  `;
+var ANNOTATION_AUTHOR_CLASS_TRIGGER_DDL = `
+    CREATE TRIGGER IF NOT EXISTS brain_annotation_author_class_guard
+    BEFORE INSERT ON brain_annotation
+    WHEN NEW.author_class IS NULL OR NEW.author_class NOT IN ('agent', 'human')
+    BEGIN
+      SELECT RAISE(ABORT, 'brain_annotation.author_class must be ''agent'' or ''human''');
+    END;
+    CREATE TRIGGER IF NOT EXISTS brain_annotation_author_class_guard_update
+    BEFORE UPDATE OF author_class ON brain_annotation
+    WHEN NEW.author_class IS NULL OR NEW.author_class NOT IN ('agent', 'human')
+    BEGIN
+      SELECT RAISE(ABORT, 'brain_annotation.author_class must be ''agent'' or ''human''');
+    END;
+  `;
+function ensureAnnotationTable(raw) {
+  try {
+    raw.exec(ANNOTATION_DDL);
+  } catch {
+  }
+  const wantsGuard = ANNOTATION_AUTHOR_CLASS_TRIGGER_DDL;
+  const updateMarker = "CREATE TRIGGER IF NOT EXISTS brain_annotation_author_class_guard_update";
+  const updateIndex = wantsGuard.indexOf(updateMarker);
+  const wantedStatements = [
+    { name: "brain_annotation_author_class_guard", sql: wantsGuard.slice(0, updateIndex) },
+    { name: "brain_annotation_author_class_guard_update", sql: wantsGuard.slice(updateIndex) }
+  ];
+  const normalise = (sql) => {
+    const before = sql.indexOf("BEFORE");
+    if (before < 0) return "";
+    let body = sql.slice(before).replace(/\s+/g, " ").trim();
+    while (body.endsWith(";")) body = body.slice(0, -1).trimEnd();
+    return body;
+  };
+  let guardIsStale = false;
+  for (const wanted of wantedStatements) {
+    let installed = "";
+    try {
+      const row = raw.prepare("SELECT sql FROM sqlite_master WHERE type='trigger' AND name=?").get(wanted.name);
+      installed = String(row?.sql ?? "");
+    } catch {
+      installed = "";
+    }
+    if (installed === "" || normalise(installed) !== normalise(wanted.sql)) {
+      guardIsStale = true;
+      break;
+    }
+  }
+  if (guardIsStale) {
+    try {
+      raw.exec("DROP TRIGGER IF EXISTS brain_annotation_author_class_guard_update; DROP TRIGGER IF EXISTS brain_annotation_author_class_guard;");
+    } catch {
+    }
+  }
+  try {
+    raw.exec(ANNOTATION_AUTHOR_CLASS_TRIGGER_DDL);
+  } catch (error) {
+    try {
+      raw.prepare("SELECT count(*) FROM sqlite_master WHERE type='trigger'").all();
+    } catch (unreadable) {
+      throw new Error(
+        `annotation author-class guard failed AND the schema is unreadable after it: ${String(
+          unreadable?.message ?? unreadable
+        )}`
+      );
+    }
+  }
+}
+function ensureEmbeddingBlobColumn(raw) {
+  try {
+    const cols = raw.prepare("PRAGMA table_info(brain_semantic_embedding)").all().map((c) => c.name);
+    if (cols.length === 0) return;
+    if (cols.includes("embedding_blob")) return;
+    raw.exec("ALTER TABLE brain_semantic_embedding ADD COLUMN embedding_blob BLOB");
+  } catch {
+  }
+}
+function ensureQueryShapeIndexes(raw) {
+  try {
+    const names = raw.prepare("PRAGMA index_list(brain_symbol)").all().map((i) => i.name);
+    if (names.length === 0) return;
+    if (names.includes("brain_symbol_gravity_idx")) return;
+    raw.exec(
+      "CREATE INDEX IF NOT EXISTS brain_symbol_gravity_idx ON brain_symbol(project_id, gravity_score DESC, line_start)"
+    );
+  } catch {
+  }
+}
+function ensureSymbolDeclarationColumn(raw) {
+  try {
+    const cols = raw.prepare("PRAGMA table_info(brain_symbol)").all().map((c) => c.name);
+    if (cols.length === 0) return;
+    if (cols.includes("is_declaration")) return;
+    raw.exec("ALTER TABLE brain_symbol ADD COLUMN is_declaration INTEGER");
+  } catch {
+  }
+}
+function ensureSymbolSupertypesColumn(raw) {
+  try {
+    const cols = raw.prepare("PRAGMA table_info(brain_symbol)").all().map((c) => c.name);
+    if (cols.length === 0) return;
+    if (cols.includes("super_types")) return;
+    raw.exec("ALTER TABLE brain_symbol ADD COLUMN super_types TEXT");
+  } catch {
+  }
+}
+function ensureRelationshipTargetBasisColumn(raw) {
+  try {
+    const hidden = raw.prepare("PRAGMA table_xinfo(brain_relationship)").all();
+    if (hidden.length === 0) return;
+    if (hidden.some((c) => c.name === "target_basis")) return;
+    try {
+      raw.prepare("SELECT target_basis FROM brain_relationship LIMIT 1").get();
+      return;
+    } catch {
+    }
+    raw.exec(`ALTER TABLE brain_relationship ADD COLUMN target_basis TEXT GENERATED ALWAYS AS (
+      CASE
+        WHEN target_symbol_id IS NOT NULL THEN 'symbol'
+        WHEN metadata IS NOT NULL AND json_extract(metadata, '$.isExternalTarget') = 1 THEN 'external'
+        WHEN target_external IS NOT NULL THEN 'unresolved'
+        ELSE 'unresolved'
+      END
+    ) VIRTUAL`);
+  } catch {
+  }
+}
+function ensureRelationshipEvidenceClassColumn(raw) {
+  try {
+    const hidden = raw.prepare("PRAGMA table_xinfo(brain_relationship)").all();
+    if (hidden.length === 0) return;
+    if (!hidden.some((c) => c.name === "evidence_class")) {
+      try {
+        raw.prepare("SELECT evidence_class FROM brain_relationship LIMIT 1").get();
+      } catch {
+        raw.exec("ALTER TABLE brain_relationship ADD COLUMN evidence_class TEXT GENERATED ALWAYS AS (json_extract(metadata, '$.evidenceClass')) VIRTUAL");
+      }
+    }
+    const indexes = raw.prepare("PRAGMA index_list(brain_relationship)").all().map((i) => i.name);
+    if (indexes.includes("brain_rel_pattern_cover_idx")) {
+      const columns = raw.prepare("PRAGMA index_info(brain_rel_pattern_cover_idx)").all().map((c) => c.name);
+      if (!columns.includes("target_external")) {
+        raw.exec("DROP INDEX IF EXISTS brain_rel_pattern_cover_idx");
+      }
+    }
+    raw.exec("CREATE INDEX IF NOT EXISTS brain_rel_pattern_cover_idx ON brain_relationship(project_id, relationship_type, target_symbol_id, source_symbol_id, confidence, evidence_class, target_external)");
+    const symbolIndexes = raw.prepare("PRAGMA index_list(brain_symbol)").all().map((i) => i.name);
+    if (!symbolIndexes.includes("brain_symbol_type_cover_idx")) {
+      raw.exec("CREATE INDEX IF NOT EXISTS brain_symbol_type_cover_idx ON brain_symbol(project_id, symbol_type)");
+    }
+  } catch {
+  }
+}
+function ensureSymbolSourceTextColumn(raw) {
+  try {
+    const cols = raw.prepare("PRAGMA table_info(brain_symbol)").all().map((c) => c.name);
+    if (cols.length === 0) return;
+    if (cols.includes("source_text")) return;
+    raw.exec("ALTER TABLE brain_symbol ADD COLUMN source_text TEXT");
+  } catch {
+  }
+}
+function ensureFileMetadataColumn(raw) {
+  try {
+    const cols = raw.prepare("PRAGMA table_info(brain_file)").all().map((c) => c.name);
+    if (cols.length === 0) return;
+    if (cols.includes("metadata")) return;
+    raw.exec("ALTER TABLE brain_file ADD COLUMN metadata TEXT");
+  } catch {
+  }
+}
+function ensureHealthIndexes(raw) {
+  try {
+    raw.exec(`CREATE INDEX IF NOT EXISTS brain_embed_health_idx ON brain_semantic_embedding(project_id, embedding_model, entity_id, vector_dimension)`);
+  } catch {
+  }
+  const coreIdx = [
+    ["brain_symbol_owner_idx", "brain_symbol(owner_symbol_id)"],
+    ["brain_symbol_project_owner_idx", "brain_symbol(project_id, owner_symbol_id)"],
+    ["brain_symbol_project_idx", "brain_symbol(project_id)"],
+    ["brain_symbol_name_idx", "brain_symbol(name)"],
+    ["brain_rel_proj_type_target_idx", "brain_relationship(project_id, relationship_type, target_symbol_id)"],
+    ["brain_rel_source_idx", "brain_relationship(source_symbol_id)"],
+    ["brain_rel_target_idx", "brain_relationship(target_symbol_id)"],
+    ["brain_file_project_idx", "brain_file(project_id)"],
+    ["brain_file_path_idx", "brain_file(path)"]
+  ];
+  let recreated = 0;
+  for (const [name, cols] of coreIdx) {
+    try {
+      const before = raw.prepare("SELECT name FROM sqlite_master WHERE type='index' AND name=?").get(name);
+      raw.exec(`CREATE INDEX IF NOT EXISTS ${name} ON ${cols}`);
+      if (!before) recreated++;
+    } catch {
+    }
+  }
+  return { recreated };
+}
+function ensurePlannerStats(raw) {
+  try {
+    const hasStats = raw.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='sqlite_stat1'").get();
+    if (hasStats) return { analyzed: false };
+    if (process.env.BB_SKIP_ANALYZE === "1") return { analyzed: false };
+    raw.exec("ANALYZE");
+    return { analyzed: true };
+  } catch {
+    return { analyzed: false };
+  }
+}
+var fkHealedHandles = /* @__PURE__ */ new WeakSet();
+function cleanupOrphanedFkRows(raw) {
+  const handle = raw?.native ?? raw;
+  if (handle && typeof handle === "object" && fkHealedHandles.has(handle)) {
+    return { relationships: 0, imports: 0, symbols: 0 };
+  }
+  let relationships = 0;
+  let imports = 0;
+  let symbols = 0;
+  try {
+    const r = raw.prepare(`DELETE FROM brain_relationship WHERE source_symbol_id IN (
+      SELECT r.source_symbol_id FROM brain_relationship r
+      LEFT JOIN brain_symbol s ON s.id = r.source_symbol_id
+      WHERE s.id IS NULL
+    )`).run();
+    relationships = r?.changes ?? 0;
+  } catch {
+  }
+  try {
+    const i = raw.prepare(`DELETE FROM brain_import WHERE file_id IN (
+      SELECT i.file_id FROM brain_import i
+      LEFT JOIN brain_file f ON f.id = i.file_id
+      WHERE f.id IS NULL
+    )`).run();
+    imports = i?.changes ?? 0;
+  } catch {
+  }
+  try {
+    const s = raw.prepare(`DELETE FROM brain_symbol WHERE file_id IN (
+      SELECT sy.file_id FROM brain_symbol sy
+      LEFT JOIN brain_file f ON f.id = sy.file_id
+      WHERE f.id IS NULL
+    )`).run();
+    symbols = s?.changes ?? 0;
+  } catch {
+  }
+  if (handle && typeof handle === "object") fkHealedHandles.add(handle);
+  return { relationships, imports, symbols };
+}
+function migrateSchemaColumns(raw) {
+  try {
+    const cols = new Set(raw.prepare("PRAGMA table_info(brain_index_status)").all().map((c) => c.name));
+    const expected = [
+      ["status", "TEXT"],
+      ["last_full_index", "INTEGER"],
+      ["last_incremental_index", "INTEGER"],
+      ["total_files", "INTEGER NOT NULL DEFAULT 0"],
+      ["indexed_files", "INTEGER NOT NULL DEFAULT 0"],
+      ["total_symbols", "INTEGER NOT NULL DEFAULT 0"],
+      ["total_relationships", "INTEGER NOT NULL DEFAULT 0"],
+      ["time_created", "INTEGER"],
+      ["time_updated", "INTEGER"],
+      // M23.P3: codebase identity for index portability (adopt-on-move).
+      ["codebase_fingerprint", "TEXT"],
+      ["codebase_git", "TEXT"]
+    ];
+    for (const [name, ddl] of expected) {
+      if (!cols.has(name)) {
+        raw.exec(`ALTER TABLE brain_index_status ADD COLUMN ${name} ${ddl}`);
+        cols.add(name);
+      }
+    }
+  } catch {
+  }
+}
+function ensureSchema(raw) {
+  raw.exec(DDL);
+  ensureHealthIndexes(raw);
+  ensureEmbeddingBlobColumn(raw);
+  ensureSymbolDeclarationColumn(raw);
+  ensureSymbolSupertypesColumn(raw);
+  ensureSymbolSourceTextColumn(raw);
+  ensureRelationshipTargetBasisColumn(raw);
+  ensureRelationshipEvidenceClassColumn(raw);
+  try {
+    raw.prepare("INSERT OR IGNORE INTO brain_schema_version (version, applied_at, migration_name) VALUES (?, strftime('%s','now') * 1000, ?)").run(SCHEMA_VERSION, SCHEMA_MIGRATION_NAME);
+  } catch {
+  }
+  migrateSchemaColumns(raw);
+  ensureAnnotationTable(raw);
+  raw.exec(`
+    CREATE TABLE IF NOT EXISTS brain_analysis_run (
+      id TEXT PRIMARY KEY NOT NULL, project_id TEXT NOT NULL, kind TEXT NOT NULL,
+      status TEXT NOT NULL, engine_version TEXT NOT NULL, input_hash TEXT NOT NULL,
+      started_at INTEGER NOT NULL, completed_at INTEGER, finding_count INTEGER NOT NULL DEFAULT 0,
+      error TEXT, time_created INTEGER NOT NULL, time_updated INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS brain_analysis_finding (
+      id TEXT PRIMARY KEY NOT NULL, project_id TEXT NOT NULL, kind TEXT NOT NULL,
+      fingerprint TEXT NOT NULL, rule TEXT NOT NULL, title TEXT NOT NULL, severity TEXT NOT NULL,
+      state TEXT NOT NULL, confidence REAL, evidence TEXT, first_seen_at INTEGER NOT NULL,
+      last_seen_at INTEGER NOT NULL, resolved_at INTEGER, suppressed_at INTEGER, mitigated_at INTEGER,
+      occurrence_count INTEGER NOT NULL DEFAULT 0, time_created INTEGER NOT NULL, time_updated INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS brain_analysis_occurrence (
+      id TEXT PRIMARY KEY NOT NULL, finding_id TEXT NOT NULL, run_id TEXT NOT NULL, state TEXT NOT NULL,
+      location TEXT, evidence TEXT, observed_at INTEGER NOT NULL, time_created INTEGER NOT NULL, time_updated INTEGER NOT NULL
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS brain_analysis_finding_identity_idx ON brain_analysis_finding(project_id, kind, fingerprint);
+    CREATE INDEX IF NOT EXISTS brain_analysis_run_project_idx ON brain_analysis_run(project_id);
+    CREATE INDEX IF NOT EXISTS brain_analysis_run_kind_idx ON brain_analysis_run(kind);
+    CREATE INDEX IF NOT EXISTS brain_analysis_run_started_idx ON brain_analysis_run(started_at);
+    CREATE INDEX IF NOT EXISTS brain_analysis_finding_project_idx ON brain_analysis_finding(project_id);
+    CREATE INDEX IF NOT EXISTS brain_analysis_finding_state_idx ON brain_analysis_finding(project_id, state);
+    CREATE INDEX IF NOT EXISTS brain_analysis_occurrence_finding_idx ON brain_analysis_occurrence(finding_id);
+    CREATE INDEX IF NOT EXISTS brain_analysis_occurrence_run_idx ON brain_analysis_occurrence(run_id);
+  `);
+  try {
+    raw.prepare(`INSERT OR IGNORE INTO brain_index_status (project_id, indexing_version, languages_detected, frameworks_detected, indexing_errors, performance_stats, time_created, time_updated)
+      VALUES ('__schema__', 'v1.0.0', '[]', '[]', '[]', '{}', strftime('%s','now') * 1000, strftime('%s','now') * 1000)`).run();
+  } catch {
+  }
+}
+
+// src/brain/database.ts
+var rawInstances = /* @__PURE__ */ new Map();
+var drizzleInstances = /* @__PURE__ */ new Map();
+var pathOverrides = /* @__PURE__ */ new Map();
+function evictStaleRawHandle(cacheKey) {
+  if (rawInstances.has(cacheKey)) rawInstances.delete(cacheKey);
+}
+function resolveDbPath(projectId) {
+  return pathOverrides.get(projectId) ?? BrainDatabase.getDbPath(projectId);
+}
+function isBun() {
+  return typeof globalThis.Bun !== "undefined";
+}
+async function buildDrizzle(raw) {
+  if (isBun()) {
+    const { drizzle: drizzle2 } = await import("drizzle-orm/bun-sqlite");
+    return drizzle2({ client: raw.native }, { schema: brain_sql_exports });
+  }
+  const { drizzle } = await import("drizzle-orm/better-sqlite3");
+  return drizzle({ client: raw.native }, { schema: brain_sql_exports });
+}
+function ensureSchemaIfNew(raw) {
+  const hasFile = raw.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='brain_file'").get();
+  if (!hasFile) {
+    ensureSchema(raw);
+  } else {
+    migrateSchemaColumns(raw);
+    const idxHeal = ensureHealthIndexes(raw);
+    if (idxHeal.recreated > 0) {
+      try {
+        raw.exec("ANALYZE");
+      } catch {
+      }
+    }
+    ensurePlannerStats(raw);
+    cleanupOrphanedFkRows(raw);
+    ensureAnnotationTable(raw);
+    ensureEmbeddingBlobColumn(raw);
+    ensureSymbolDeclarationColumn(raw);
+    ensureSymbolSupertypesColumn(raw);
+    ensureFileMetadataColumn(raw);
+    ensureSymbolSourceTextColumn(raw);
+    ensureRelationshipTargetBasisColumn(raw);
+    ensureRelationshipEvidenceClassColumn(raw);
+    ensureQueryShapeIndexes(raw);
+  }
+}
+var BrainDatabase;
+((BrainDatabase2) => {
+  function registerPath(projectId, dbPath) {
+    pathOverrides.set(projectId, dbPath);
+  }
+  BrainDatabase2.registerPath = registerPath;
+  function clearPathOverrides() {
+    pathOverrides.clear();
+  }
+  BrainDatabase2.clearPathOverrides = clearPathOverrides;
+  function getDbPath(projectId) {
+    return path.join(bbProjectsDir(), projectId, "brain.db");
+  }
+  BrainDatabase2.getDbPath = getDbPath;
+  function getDbDirectory(projectId) {
+    return path.dirname(getDbPath(projectId));
+  }
+  BrainDatabase2.getDbDirectory = getDbDirectory;
+  function getPath(projectId) {
+    return getDbPath(projectId);
+  }
+  BrainDatabase2.getPath = getPath;
+  function getDirectory(projectId) {
+    return getDbDirectory(projectId);
+  }
+  BrainDatabase2.getDirectory = getDirectory;
+  function openByPath(dbPath, options = {}) {
+    const key = `${options.readonly ? "ro:" : "rw:"}${dbPath}`;
+    const cached = rawInstances.get(key);
+    if (cached && !existsSync(dbPath)) evictStaleRawHandle(key);
+    const fresh = rawInstances.get(key);
+    if (fresh) return fresh;
+    const db = openDatabase(dbPath, options);
+    if (!options.readonly) ensureSchemaIfNew(db);
+    rawInstances.set(key, db);
+    return db;
+  }
+  BrainDatabase2.openByPath = openByPath;
+  async function getInstance(projectId) {
+    const dbPath = resolveDbPath(projectId);
+    if (!existsSync(path.dirname(dbPath))) mkdirSync(path.dirname(dbPath), { recursive: true });
+    if (!existsSync(dbPath)) {
+      drizzleInstances.delete(projectId);
+      evictStaleRawHandle(dbPath);
+    }
+    if (drizzleInstances.has(projectId)) return drizzleInstances.get(projectId);
+    const cachedRaw = rawInstances.get(dbPath);
+    const raw = cachedRaw ?? openDatabase(dbPath);
+    ensureSchemaIfNew(raw);
+    if (!cachedRaw) cleanupOrphanedFkRows(raw);
+    rawInstances.set(dbPath, raw);
+    const drizzleDb = await buildDrizzle(raw);
+    drizzleInstances.set(projectId, drizzleDb);
+    return drizzleDb;
+  }
+  BrainDatabase2.getInstance = getInstance;
+  BrainDatabase2.initialize = getInstance;
+  async function getReadOnlyInstance(projectId) {
+    const key = `ro:${projectId}`;
+    const cached = drizzleInstances.get(key);
+    if (cached) return cached;
+    const raw = await getRawInstance(projectId, { readonly: true });
+    const drizzleDb = await buildDrizzle(raw);
+    drizzleInstances.set(key, drizzleDb);
+    return drizzleDb;
+  }
+  BrainDatabase2.getReadOnlyInstance = getReadOnlyInstance;
+  async function getRawInstance(projectId, options = {}) {
+    const dbPath = resolveDbPath(projectId);
+    if (options.readonly) {
+      const roKey = `ro:${dbPath}`;
+      if (!existsSync(dbPath)) evictStaleRawHandle(roKey);
+      const cachedRo = rawInstances.get(roKey);
+      if (cachedRo) return cachedRo;
+      if (!existsSync(dbPath)) {
+        throw new Error(`no index found for project ${projectId}: ${dbPath} \u2014 run: bb index <project>`);
+      }
+      const ro = openDatabase(dbPath, { readonly: true });
+      const hasFile = ro.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='brain_file'").get();
+      if (!hasFile) {
+        try {
+          ro.close();
+        } catch {
+        }
+        throw new Error(`index not initialised for project ${projectId}: ${dbPath} \u2014 run: bb index <project>`);
+      }
+      rawInstances.set(roKey, ro);
+      return ro;
+    }
+    if (!existsSync(path.dirname(dbPath))) mkdirSync(path.dirname(dbPath), { recursive: true });
+    if (!existsSync(dbPath)) evictStaleRawHandle(dbPath);
+    const raw = rawInstances.get(dbPath) ?? openDatabase(dbPath);
+    ensureSchemaIfNew(raw);
+    rawInstances.set(dbPath, raw);
+    return raw;
+  }
+  BrainDatabase2.getRawInstance = getRawInstance;
+  function getMemoryStats() {
+    const mem = process.memoryUsage();
+    return { rss: mem.rss, heapUsed: mem.heapUsed, heapTotal: mem.heapTotal };
+  }
+  BrainDatabase2.getMemoryStats = getMemoryStats;
+  function close(projectId) {
+    const dbPath = resolveDbPath(projectId);
+    drizzleInstances.delete(projectId);
+    const raw = rawInstances.get(dbPath);
+    if (raw) {
+      try {
+        raw.close();
+      } catch {
+      }
+      rawInstances.delete(dbPath);
+    }
+  }
+  BrainDatabase2.close = close;
+  function closeAll() {
+    for (const db of rawInstances.values()) {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+    rawInstances.clear();
+    drizzleInstances.clear();
+  }
+  BrainDatabase2.closeAll = closeAll;
+  function closeByPath(dbPath) {
+    const key = `ro:${dbPath}`;
+    const raw = rawInstances.get(key);
+    if (raw) {
+      try {
+        raw.close();
+      } catch {
+      }
+      rawInstances.delete(key);
+    }
+  }
+  BrainDatabase2.closeByPath = closeByPath;
+  async function getStats(projectId) {
+    const raw = await getRawInstance(projectId);
+    const files = raw.prepare("SELECT COUNT(*) as c FROM brain_file WHERE project_id = ?").get(projectId)?.c ?? 0;
+    const symbols = raw.prepare("SELECT COUNT(*) as c FROM brain_symbol WHERE project_id = ?").get(projectId)?.c ?? 0;
+    const relationships = raw.prepare("SELECT COUNT(*) as c FROM brain_relationship WHERE project_id = ?").get(projectId)?.c ?? 0;
+    const imports = raw.prepare("SELECT COUNT(*) as c FROM brain_import WHERE project_id = ?").get(projectId)?.c ?? 0;
+    return { files, symbols, relationships, imports };
+  }
+  BrainDatabase2.getStats = getStats;
+  const MAX_INDEXING_ERRORS = 1e3;
+  const MAX_PERF_RUNS = 10;
+  function parseJsonArray(value) {
+    if (Array.isArray(value)) return value;
+    if (typeof value !== "string") return [];
+    try {
+      const parsed = JSON.parse(value);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  async function updateIndexStatus(projectId, data) {
+    const raw = await getRawInstance(projectId);
+    const existing = raw.prepare("SELECT indexing_errors, performance_stats FROM brain_index_status WHERE project_id = ?").get(projectId);
+    let mergedErrors = parseJsonArray(existing?.indexing_errors);
+    if (data.errors && data.errors.length > 0) {
+      mergedErrors = [...mergedErrors, ...data.errors].slice(-MAX_INDEXING_ERRORS);
+    } else if (data.error) {
+      const legacy = {
+        phase: "index",
+        message: data.error,
+        timestamp: Date.now()
+      };
+      mergedErrors = [...mergedErrors, legacy].slice(-MAX_INDEXING_ERRORS);
+    }
+    const errorsJson = JSON.stringify(mergedErrors);
+    let perfJson = null;
+    if (data.performanceStats) {
+      let priorRuns = [];
+      if (existing?.performance_stats) {
+        try {
+          const prior = JSON.parse(existing.performance_stats);
+          if (Array.isArray(prior?.runs)) priorRuns = prior.runs;
+        } catch {
+        }
+      }
+      perfJson = JSON.stringify({
+        schemaVersion: 1,
+        runs: [...priorRuns, ...data.performanceStats.runs].slice(-MAX_PERF_RUNS)
+      });
+    } else if (existing?.performance_stats) {
+      perfJson = existing.performance_stats;
+    }
+    const filesTotal = data.filesIndexed ?? data.files ?? 0;
+    const symbolsTotal = data.symbolsIndexed ?? data.symbols ?? 0;
+    const filesParsed = data.filesParsed ?? filesTotal;
+    const relationshipsTotal = data.relationshipsIndexed ?? 0;
+    let fingerprint = null;
+    let gitIdentity = null;
+    if (data.codebaseFingerprintProjectPath) {
+      try {
+        const { computeCheckoutFingerprint } = await import("./fingerprint-XDXFRWO6.js");
+        const cf = await computeCheckoutFingerprint(data.codebaseFingerprintProjectPath);
+        fingerprint = cf.fingerprint;
+        gitIdentity = cf.git;
+      } catch {
+      }
+    }
+    raw.prepare(
+      `INSERT INTO brain_index_status (project_id, indexing_version, status, last_full_index, total_files, indexed_files, total_symbols, total_relationships, indexing_errors, performance_stats, codebase_fingerprint, codebase_git, time_created, time_updated)
+         VALUES (?, 'v1.0.0', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s','now') * 1000, strftime('%s','now') * 1000)
+         ON CONFLICT(project_id) DO UPDATE SET
+           status = COALESCE(excluded.status, status),
+           last_full_index = excluded.last_full_index,
+           total_files = COALESCE(excluded.total_files, total_files),
+           indexed_files = COALESCE(excluded.indexed_files, indexed_files),
+           total_symbols = COALESCE(excluded.total_symbols, total_symbols),
+           total_relationships = COALESCE(excluded.total_relationships, total_relationships),
+           indexing_errors = excluded.indexing_errors,
+           performance_stats = COALESCE(excluded.performance_stats, performance_stats),
+           codebase_fingerprint = COALESCE(excluded.codebase_fingerprint, codebase_fingerprint),
+           codebase_git = COALESCE(excluded.codebase_git, codebase_git),
+           time_updated = excluded.time_updated`
+    ).run(
+      projectId,
+      data.status ?? null,
+      data.lastIndexed ?? Date.now(),
+      filesTotal,
+      filesParsed,
+      symbolsTotal,
+      relationshipsTotal,
+      errorsJson,
+      perfJson,
+      fingerprint,
+      gitIdentity
+    );
+  }
+  BrainDatabase2.updateIndexStatus = updateIndexStatus;
+  async function getIndexStatus(projectId) {
+    const raw = await getRawInstance(projectId);
+    try {
+      const row = raw.prepare("SELECT status FROM brain_index_status WHERE project_id = ?").get(projectId);
+      return { status: row?.status ?? null };
+    } catch {
+      return { status: null };
+    }
+  }
+  BrainDatabase2.getIndexStatus = getIndexStatus;
+  async function getDurableIndexStatus(projectId) {
+    const raw = await getRawInstance(projectId);
+    try {
+      const row = raw.prepare("SELECT status, indexing_errors, performance_stats FROM brain_index_status WHERE project_id = ?").get(projectId);
+      let performanceStats = null;
+      if (row?.performance_stats) {
+        try {
+          const parsed = JSON.parse(row.performance_stats);
+          performanceStats = parsed && typeof parsed === "object" ? parsed : null;
+        } catch {
+          performanceStats = null;
+        }
+      }
+      return {
+        status: row?.status ?? null,
+        errors: parseJsonArray(row?.indexing_errors),
+        performanceStats
+      };
+    } catch {
+      return { status: null, errors: [], performanceStats: null };
+    }
+  }
+  BrainDatabase2.getDurableIndexStatus = getDurableIndexStatus;
+})(BrainDatabase || (BrainDatabase = {}));
+
+export {
+  BrainDatabase
+};