ultracode 5.3.0 → 5.5.0

package/dist/chunks/chunk-XFGXM4CR.js

@@ -0,0 +1,4403 @@
+import { ProllyNodeStore, CommitManager, BranchDiffCache } from './chunk-HNDYLCWI.js';
+import { ProllyTree, serializeEntity } from './chunk-AIZUHUK6.js';
+import { detectBaseBranch } from './chunk-L2X4HRXI.js';
+import { init_storage_paths, getCurrentGitBranchOrDefault, normalizeBranchName, getProjectHash, getGlobalDbPaths } from './chunk-ZD54CMKT.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import { DatabaseCorruptionError, DEFAULT_CONFIG, CACHE_CONFIG, normalizeToSupportedDimension, getEmbeddingColumn, isCorruptionError } from './chunk-UN27MREV.js';
+import { existsSync, mkdirSync, unlinkSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+import { nanoid } from 'nanoid';
+import xxhash from 'xxhash-wasm';
+import * as cbor from 'cbor-x';
+import { LRUCache } from 'lru-cache';
+import { AsyncLocalStorage } from 'async_hooks';
+
+// src/storage/graph-storage-factory.ts
+init_logging();
+init_storage_paths();
+
+// src/storage/graph-storage-libsql.ts
+init_logging();
+init_storage_paths();
+var ID_LENGTH = 12;
+var DEFAULT_QUERY_LIMIT = 100;
+var MAX_QUERY_LIMIT = 5e4;
+var MAX_SUBGRAPH_DEPTH = 5;
+function createProjectContext(projectPath, branchName) {
+  const resolvedBranch = branchName ?? getCurrentGitBranchOrDefault(projectPath);
+  const normalizedBranch = normalizeBranchName(resolvedBranch);
+  const baseBranch = detectBaseBranch(projectPath);
+  return {
+    projectHash: getProjectHash(projectPath),
+    branchName: normalizedBranch,
+    // Set baseBranch for layered reads if current branch is different from base
+    baseBranch: baseBranch && baseBranch !== normalizedBranch ? baseBranch : void 0
+  };
+}
+var GraphStorageLibSQL = class {
+  adapter;
+  xxhashInstance = null;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  // ===========================================================================
+  // INITIALIZATION
+  // ===========================================================================
+  async initialize() {
+    const startTime = Date.now();
+    log.t("STORAGE", `[GraphStorageLibSQL] \u25B6 initialize() START`);
+    this.xxhashInstance = await xxhash();
+    log.t("STORAGE", `[GraphStorageLibSQL] \u25C0 initialize() END (${Date.now() - startTime}ms)`);
+    log.i("GRAPHSTORAGE", "init_xxhash");
+  }
+  // ===========================================================================
+  // PROJECT CONTEXT
+  // ===========================================================================
+  setProjectContext(context) {
+    this.adapter.setProjectContext(context);
+  }
+  setProject(projectPath, branchName) {
+    const ctx = createProjectContext(projectPath, branchName);
+    log.w("STORAGE", "setProject", {
+      path: projectPath,
+      hash: ctx.projectHash,
+      branch: ctx.branchName,
+      base: ctx.baseBranch || "none"
+    });
+    this.adapter.setProjectContext(ctx);
+    this.adapter.loadGenerationCache().catch((err) => {
+      log.w("STORAGE", "gen_cache_load_fail", { error: err.message });
+    });
+  }
+  getProjectContext() {
+    return this.adapter.getProjectContext();
+  }
+  // ===========================================================================
+  // ENTITY OPERATIONS
+  // ===========================================================================
+  async insertEntity(entity) {
+    const id = this.stableEntityId(entity);
+    const now = Date.now();
+    const entityWithId = {
+      ...entity,
+      id,
+      complexityScore: entity.complexityScore ?? this.calculateComplexity(entity),
+      language: entity.language ?? this.detectLanguage(entity.filePath),
+      sizeBytes: entity.sizeBytes ?? 0,
+      createdAt: entity.createdAt || now,
+      updatedAt: entity.updatedAt || now
+    };
+    await this.adapter.insertEntity(entityWithId);
+  }
+  async insertEntities(entities) {
+    const startTime = Date.now();
+    log.t("STORAGE", `[GraphStorageLibSQL] \u25B6 insertEntities (${entities.length} entities)`);
+    const now = Date.now();
+    const seen = /* @__PURE__ */ new Set();
+    const unique = [];
+    for (const e of entities) {
+      const key = this.entityKey(e);
+      if (!seen.has(key)) {
+        seen.add(key);
+        unique.push(e);
+      }
+    }
+    const entitiesWithIds = unique.map((entity) => ({
+      ...entity,
+      id: this.stableEntityId(entity),
+      complexityScore: entity.complexityScore ?? this.calculateComplexity(entity),
+      language: entity.language ?? this.detectLanguage(entity.filePath),
+      sizeBytes: entity.sizeBytes ?? 0,
+      createdAt: entity.createdAt || now,
+      updatedAt: entity.updatedAt || now
+    }));
+    const result = await this.adapter.insertEntities(entitiesWithIds);
+    log.t("STORAGE", `insertEntities`, { count: unique.length, ms: Date.now() - startTime });
+    return result;
+  }
+  async updateEntity(id, updates) {
+    const existing = await this.adapter.getEntity(id);
+    if (!existing) {
+      throw new Error(`Entity ${id} not found`);
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      updatedAt: Date.now(),
+      complexityScore: updates.complexityScore ?? this.calculateComplexity({ ...existing, ...updates }),
+      language: updates.language ?? this.detectLanguage(updates.filePath || existing.filePath)
+    };
+    await this.adapter.insertEntity(updated);
+  }
+  async deleteEntity(id) {
+    await this.adapter.deleteEntity(id);
+  }
+  async getEntity(id) {
+    return await this.adapter.getEntity(id);
+  }
+  async getEntitiesBatch(ids) {
+    return await this.adapter.getEntitiesBatch(ids);
+  }
+  async getEntityFromBranch(id, targetBranch) {
+    const currentContext = this.adapter.getProjectContext();
+    this.adapter.setProjectContext({
+      projectHash: currentContext.projectHash,
+      branchName: normalizeBranchName(targetBranch)
+    });
+    try {
+      return await this.adapter.getEntity(id);
+    } finally {
+      this.adapter.setProjectContext(currentContext);
+    }
+  }
+  async findEntities(query) {
+    return await this.adapter.findEntities({
+      filters: query.filters,
+      limit: Math.min(query.limit || DEFAULT_QUERY_LIMIT, MAX_QUERY_LIMIT),
+      offset: query.offset || 0
+    });
+  }
+  /**
+   * Count entities by language (efficient SQL aggregation for TechnologyDetector).
+   * Excludes external placeholder entities.
+   */
+  async countByLanguage() {
+    return await this.adapter.countByLanguage();
+  }
+  async findEntitiesInBranch(query, targetBranch) {
+    const currentContext = this.adapter.getProjectContext();
+    this.adapter.setProjectContext({
+      projectHash: currentContext.projectHash,
+      branchName: normalizeBranchName(targetBranch)
+    });
+    try {
+      return await this.adapter.findEntities({
+        filters: query.filters,
+        limit: Math.min(query.limit || DEFAULT_QUERY_LIMIT, MAX_QUERY_LIMIT),
+        offset: query.offset || 0
+      });
+    } finally {
+      this.adapter.setProjectContext(currentContext);
+    }
+  }
+  async compareEntitiesBetweenBranches(namePattern, branch1, branch2) {
+    const query = {
+      type: "entity",
+      filters: { name: new RegExp(namePattern) },
+      limit: MAX_QUERY_LIMIT
+    };
+    const [entities1, entities2] = await Promise.all([
+      this.findEntitiesInBranch(query, branch1),
+      this.findEntitiesInBranch(query, branch2)
+    ]);
+    const map1 = new Map(entities1.map((e) => [this.entityKey(e), e]));
+    const matched = [];
+    for (const e2 of entities2) {
+      const key = this.entityKey(e2);
+      const e1 = map1.get(key);
+      if (e1) {
+        matched.push([e1, e2]);
+      }
+    }
+    return { branch1Entities: entities1, branch2Entities: entities2, matched };
+  }
+  async getAllEntities() {
+    return await this.adapter.getAllEntities();
+  }
+  async searchEntities(options) {
+    return await this.adapter.searchEntities(options);
+  }
+  /**
+   * Search entities by directory path (LIKE pattern)
+   */
+  async searchEntitiesInDirectory(directoryPath) {
+    return await this.adapter.searchEntitiesInDirectory(directoryPath);
+  }
+  // ===========================================================================
+  // RELATIONSHIP OPERATIONS
+  // ===========================================================================
+  async insertRelationship(relationship) {
+    const id = this.stableRelationshipId(relationship);
+    const now = Date.now();
+    const relWithId = {
+      ...relationship,
+      id,
+      createdAt: relationship.createdAt ?? now
+    };
+    await this.adapter.insertRelationship(relWithId);
+    const reverseRels = this.generateReverseRelationships([relationship]);
+    for (const rev of reverseRels) {
+      const revWithId = {
+        ...rev,
+        id: this.stableRelationshipId(rev),
+        createdAt: now
+      };
+      await this.adapter.insertRelationship(revWithId);
+    }
+  }
+  async insertRelationships(relationships) {
+    const startTime = Date.now();
+    log.t("STORAGE", `[GraphStorageLibSQL] \u25B6 insertRelationships (${relationships.length} relationships)`);
+    const now = Date.now();
+    const seen = /* @__PURE__ */ new Set();
+    const unique = [];
+    for (const r of relationships) {
+      const key = this.relationshipKey(r);
+      if (!seen.has(key)) {
+        seen.add(key);
+        unique.push(r);
+      }
+    }
+    const reverseRelationships = this.generateReverseRelationships(unique);
+    for (const r of reverseRelationships) {
+      const key = this.relationshipKey(r);
+      if (!seen.has(key)) {
+        seen.add(key);
+        unique.push(r);
+      }
+    }
+    const relsWithIds = unique.map((r) => ({
+      ...r,
+      id: this.stableRelationshipId(r),
+      createdAt: r.createdAt ?? now
+    }));
+    const result = await this.adapter.insertRelationships(relsWithIds);
+    log.t("STORAGE", `insertRelationships`, { count: unique.length, ms: Date.now() - startTime });
+    return result;
+  }
+  /**
+   * Generate reverse relationships for bidirectional graph traversal
+   * For each A → calls → B, creates B → called_by → A
+   */
+  generateReverseRelationships(relationships) {
+    const reverseMap = {
+      ["calls" /* CALLS */]: "called_by" /* CALLED_BY */,
+      ["imports" /* IMPORTS */]: "imported_by" /* IMPORTED_BY */,
+      ["references" /* REFERENCES */]: "referenced_by" /* REFERENCED_BY */,
+      ["extends" /* EXTENDS */]: "extended_by" /* EXTENDED_BY */,
+      ["implements" /* IMPLEMENTS */]: "implemented_by" /* IMPLEMENTED_BY */,
+      // No reverse for these (already bidirectional or self-referential)
+      ["called_by" /* CALLED_BY */]: null,
+      ["imported_by" /* IMPORTED_BY */]: null,
+      ["referenced_by" /* REFERENCED_BY */]: null,
+      ["extended_by" /* EXTENDED_BY */]: null,
+      ["implemented_by" /* IMPLEMENTED_BY */]: null,
+      ["exports" /* EXPORTS */]: null,
+      ["contains" /* CONTAINS */]: null,
+      ["depends_on" /* DEPENDS_ON */]: null,
+      ["member_of" /* MEMBER_OF */]: null,
+      ["documents" /* DOCUMENTS */]: null,
+      ["dispatches_action" /* DISPATCHES_ACTION */]: null,
+      ["listens_to_action" /* LISTENS_TO_ACTION */]: null,
+      ["handles_action" /* HANDLES_ACTION */]: null,
+      ["selects_state" /* SELECTS_STATE */]: null,
+      ["modifies_state" /* MODIFIES_STATE */]: null,
+      ["produces_api" /* PRODUCES_API */]: null,
+      ["consumes_api" /* CONSUMES_API */]: null,
+      ["generated_from" /* GENERATED_FROM */]: null
+    };
+    const reverse = [];
+    for (const r of relationships) {
+      const reverseType = reverseMap[r.type];
+      if (reverseType) {
+        reverse.push({
+          id: "",
+          // Will be assigned by stableRelationshipId
+          fromId: r.toId,
+          toId: r.fromId,
+          type: reverseType,
+          metadata: {
+            ...r.metadata,
+            isReverse: true,
+            originalType: r.type
+          }
+        });
+      }
+    }
+    return reverse;
+  }
+  async deleteRelationship(id) {
+    await this.adapter.deleteRelationship(id);
+  }
+  async getRelationshipsForEntity(entityId, type) {
+    return await this.adapter.getRelationshipsForEntity(entityId, type);
+  }
+  async findRelationships(query) {
+    return await this.adapter.findRelationships({
+      filters: query.filters,
+      limit: Math.min(query.limit || DEFAULT_QUERY_LIMIT, MAX_QUERY_LIMIT),
+      offset: query.offset || 0
+    });
+  }
+  async getAllRelationships() {
+    return await this.adapter.getAllRelationships();
+  }
+  async getRelationships(sourceId, type) {
+    return this.getRelationshipsForEntity(sourceId, type);
+  }
+  async getRelationshipsFromBranch(entityId, targetBranch, type) {
+    const currentContext = this.adapter.getProjectContext();
+    this.adapter.setProjectContext({
+      projectHash: currentContext.projectHash,
+      branchName: normalizeBranchName(targetBranch)
+    });
+    try {
+      return await this.adapter.getRelationshipsForEntity(entityId, type);
+    } finally {
+      this.adapter.setProjectContext(currentContext);
+    }
+  }
+  async findIncomingRelationshipsByName(entityName, types) {
+    const entities = await this.adapter.searchEntities({ namePattern: entityName });
+    const results = [];
+    for (const entity of entities) {
+      const rels = await this.adapter.getRelationshipsForEntity(entity.id);
+      const incoming = rels.filter((r) => r.toId === entity.id);
+      if (types && types.length > 0) {
+        results.push(...incoming.filter((r) => types.includes(r.type)));
+      } else {
+        results.push(...incoming);
+      }
+    }
+    return results;
+  }
+  // ===========================================================================
+  // FILE OPERATIONS
+  // ===========================================================================
+  async updateFileInfo(info) {
+    await this.adapter.updateFileInfo(info);
+  }
+  async batchUpdateFileInfo(infos) {
+    await this.adapter.batchUpdateFileInfo(infos);
+  }
+  async getFileInfo(path) {
+    return await this.adapter.getFileInfo(path);
+  }
+  async getOutdatedFiles(since) {
+    return await this.adapter.getOutdatedFiles(since);
+  }
+  async getAllIndexedFiles() {
+    return await this.adapter.getAllIndexedFiles();
+  }
+  async deleteFileInfo(path) {
+    await this.adapter.deleteFileInfo(path);
+  }
+  // ===========================================================================
+  // ENTITY OPERATIONS BY FILE PATH (for incremental indexing)
+  // ===========================================================================
+  async getEntityIdsByFilePath(filePath) {
+    return await this.adapter.getEntityIdsByFilePath(filePath);
+  }
+  async deleteEntitiesByFilePath(filePath) {
+    return await this.adapter.deleteEntitiesByFilePath(filePath);
+  }
+  /**
+   * Invalidate file generation (for deleted files).
+   * Marks all entities for this file as stale without blocking DELETE.
+   */
+  async invalidateFileGeneration(filePath) {
+    await this.adapter.getGenerationManager().invalidateFileGeneration(filePath);
+  }
+  /**
+   * Run generation-based GC: clean stale entities and orphan name_tokens.
+   * Call after incremental reindex completes.
+   */
+  async runGenerationGC() {
+    return await this.adapter.getGenerationManager().runFullGC();
+  }
+  // ===========================================================================
+  // QUERY OPERATIONS
+  // ===========================================================================
+  async executeQuery(query) {
+    const start = Date.now();
+    const [entities, relationships] = await Promise.all([this.findEntities(query), this.findRelationships(query)]);
+    const stats = await this.adapter.getStats();
+    return {
+      entities,
+      relationships,
+      stats: {
+        totalEntities: stats.totalEntities,
+        totalRelationships: stats.totalRelationships,
+        queryTimeMs: Date.now() - start
+      }
+    };
+  }
+  async getSubgraph(entityId, depth) {
+    const start = Date.now();
+    const maxDepth = Math.min(depth, MAX_SUBGRAPH_DEPTH);
+    const entities = /* @__PURE__ */ new Map();
+    const relationships = /* @__PURE__ */ new Map();
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [{ id: entityId, level: 0 }];
+    while (queue.length > 0) {
+      const { id, level } = queue.shift();
+      if (visited.has(id) || level > maxDepth) continue;
+      visited.add(id);
+      const entity = await this.adapter.getEntity(id);
+      if (entity) {
+        entities.set(id, entity);
+        const rels = await this.adapter.getRelationshipsForEntity(id);
+        for (const rel of rels) {
+          relationships.set(rel.id, rel);
+          if (level < maxDepth) {
+            const nextId = rel.fromId === id ? rel.toId : rel.fromId;
+            if (!visited.has(nextId)) {
+              queue.push({ id: nextId, level: level + 1 });
+            }
+          }
+        }
+      }
+    }
+    return {
+      entities: Array.from(entities.values()),
+      relationships: Array.from(relationships.values()),
+      stats: {
+        totalEntities: entities.size,
+        totalRelationships: relationships.size,
+        queryTimeMs: Date.now() - start
+      }
+    };
+  }
+  // ===========================================================================
+  // MAINTENANCE OPERATIONS
+  // ===========================================================================
+  async vacuum() {
+    log.i("GRAPHSTORAGE", "vacuum_requested");
+  }
+  async analyze() {
+    log.i("GRAPHSTORAGE", "analyze_requested");
+  }
+  async getMetrics() {
+    const stats = await this.adapter.getStats();
+    const memoryUsage = process.memoryUsage();
+    return {
+      totalEntities: stats.totalEntities,
+      totalRelationships: stats.totalRelationships,
+      totalFiles: stats.totalFiles,
+      databaseSizeMB: 0,
+      // Not easily available from libsql
+      indexSizeMB: 0,
+      cacheHitRate: 0,
+      lastVacuum: 0,
+      totalEmbeddings: stats.totalEmbeddings,
+      vectorSearchEnabled: true,
+      performanceMetricsCount: 0,
+      memoryUsageMB: Math.round(memoryUsage.heapUsed / 1024 / 1024),
+      concurrentConnections: 1,
+      averageQueryTimeMs: 0
+    };
+  }
+  async getStatistics() {
+    const stats = await this.adapter.getStats();
+    return {
+      totalEntities: stats.totalEntities,
+      totalRelationships: stats.totalRelationships,
+      totalFiles: stats.totalFiles
+    };
+  }
+  // ===========================================================================
+  // PROJECT METADATA
+  // ===========================================================================
+  async updateProjectMetadata(projectPath, isFullIndex = false) {
+    await this.adapter.updateProjectMetadata(projectPath, isFullIndex);
+  }
+  /**
+   * Get incremental tracking info for deciding if full rebuild is needed
+   */
+  async getIncrementalTrackingInfo() {
+    return await this.adapter.getIncrementalTrackingInfo();
+  }
+  /**
+   * Record incremental file changes after an incremental update
+   */
+  async recordIncrementalChanges(changedFileCount) {
+    await this.adapter.recordIncrementalChanges(changedFileCount);
+  }
+  /**
+   * Reset incremental tracking after a full index
+   */
+  async resetIncrementalTracking() {
+    await this.adapter.resetIncrementalTracking();
+  }
+  async listProjects() {
+    return await this.adapter.listProjects();
+  }
+  async listBranches() {
+    return await this.adapter.listBranches();
+  }
+  // ===========================================================================
+  // CLEAR OPERATIONS
+  // ===========================================================================
+  async clear() {
+    await this.adapter.clear();
+  }
+  async clearAll() {
+    await this.adapter.clearAll();
+  }
+  async deleteProject(projectPath) {
+    const currentContext = this.adapter.getProjectContext();
+    const targetHash = getProjectHash(projectPath);
+    const branches = await this.adapter.listBranches();
+    for (const branch of branches) {
+      this.adapter.setProjectContext({ projectHash: targetHash, branchName: branch });
+      await this.adapter.clear();
+    }
+    this.adapter.setProjectContext(currentContext);
+    log.i("GRAPHSTORAGE", "project_deleted", { path: projectPath });
+  }
+  /**
+   * Force flush all pending writes to disk.
+   * Use after bulk operations to ensure data is persisted immediately.
+   */
+  async flush() {
+    await this.adapter.flush();
+  }
+  // ===========================================================================
+  // VECTOR STORE ACCESS
+  // ===========================================================================
+  /**
+   * Get the underlying adapter for direct vector operations
+   */
+  getAdapter() {
+    return this.adapter;
+  }
+  /**
+   * Get the LibSQL adapter for Prolly Tree operations.
+   * Alias for getAdapter() - used by history tools.
+   */
+  getLibSQLAdapter() {
+    return this.adapter;
+  }
+  /**
+   * Get co-occurrence operations for query expansion.
+   * Used by CooccurrenceIndex for term pair storage and retrieval.
+   */
+  getCooccurrenceOps() {
+    return this.adapter.getCooccurrenceOps();
+  }
+  // ===========================================================================
+  // HELPER METHODS
+  // ===========================================================================
+  generateId() {
+    return nanoid(ID_LENGTH);
+  }
+  entityKey(e) {
+    const s = e.location?.start?.index ?? -1;
+    const eIdx = e.location?.end?.index ?? -1;
+    return `${e.filePath}|${e.type}|${e.name}|${s}-${eIdx}`;
+  }
+  stableEntityId(e) {
+    if (!this.xxhashInstance) {
+      return this.generateId();
+    }
+    const key = this.entityKey(e);
+    const hash = this.xxhashInstance.h64ToString(key);
+    return hash.slice(0, ID_LENGTH);
+  }
+  relationshipKey(r) {
+    return `${r.fromId}|${r.toId}|${r.type}`;
+  }
+  stableRelationshipId(r) {
+    if (!this.xxhashInstance) {
+      return this.generateId();
+    }
+    const key = this.relationshipKey(r);
+    const hash = this.xxhashInstance.h64ToString(key);
+    return hash.slice(0, ID_LENGTH);
+  }
+  calculateComplexity(entity) {
+    let score = 1;
+    switch (entity.type) {
+      case "function":
+        score = 2;
+        break;
+      case "class":
+        score = 3;
+        break;
+      case "method":
+        score = 2;
+        break;
+      case "interface":
+        score = 2;
+        break;
+      default:
+        score = 1;
+    }
+    if (entity.metadata?.parameters && Array.isArray(entity.metadata.parameters)) {
+      score += Math.min(entity.metadata.parameters.length * 0.5, 3);
+    }
+    if (entity.metadata?.modifiers && Array.isArray(entity.metadata.modifiers)) {
+      score += Math.min(entity.metadata.modifiers.length * 0.3, 2);
+    }
+    return Math.round(score);
+  }
+  detectLanguage(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    const langMap = {
+      ts: "typescript",
+      tsx: "typescript",
+      mts: "typescript",
+      cts: "typescript",
+      js: "javascript",
+      jsx: "javascript",
+      mjs: "javascript",
+      cjs: "javascript",
+      py: "python",
+      pyi: "python",
+      pyw: "python",
+      java: "java",
+      c: "c",
+      h: "c",
+      cpp: "cpp",
+      cc: "cpp",
+      cxx: "cpp",
+      hpp: "cpp",
+      hxx: "cpp",
+      hh: "cpp",
+      rs: "rust",
+      go: "go",
+      kt: "kotlin",
+      kts: "kotlin",
+      swift: "swift",
+      css: "css",
+      scss: "css",
+      sass: "css",
+      less: "css",
+      html: "html",
+      htm: "html",
+      xml: "xml",
+      php: "php",
+      rb: "ruby"
+    };
+    return langMap[ext || ""] || "unknown";
+  }
+};
+
+// src/storage/libsql-graph-adapter.ts
+init_logging();
+init_storage_paths();
+
+// src/storage/libsql/cache-ops.ts
+var CacheOperations = class {
+  constructor(getClient, vectorToString) {
+    this.getClient = getClient;
+    this.vectorToString = vectorToString;
+  }
+  /**
+   * Get cached embedding by content hash.
+   * Returns null if not found.
+   */
+  async getEmbeddingFromCache(contentHash) {
+    const client = this.getClient();
+    if (!client) return null;
+    try {
+      const result = await client.execute({
+        sql: `SELECT embedding FROM embedding_cache WHERE content_hash = ?`,
+        args: [contentHash]
+      });
+      if (result.rows.length === 0) return null;
+      await client.execute({
+        sql: `UPDATE embedding_cache SET last_used_at = ?, hit_count = hit_count + 1 WHERE content_hash = ?`,
+        args: [Date.now(), contentHash]
+      });
+      const row = result.rows[0];
+      if (!row?.["embedding"]) return null;
+      const embeddingBlob = row["embedding"];
+      return new Float32Array(embeddingBlob);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get multiple cached embeddings by content hashes.
+   * Returns Map of contentHash -> Float32Array for found entries.
+   */
+  async getEmbeddingsFromCache(contentHashes) {
+    const client = this.getClient();
+    if (!client || contentHashes.length === 0) return /* @__PURE__ */ new Map();
+    const result = /* @__PURE__ */ new Map();
+    const now = Date.now();
+    try {
+      const placeholders = contentHashes.map(() => "?").join(",");
+      const queryResult = await client.execute({
+        sql: `SELECT content_hash, embedding FROM embedding_cache WHERE content_hash IN (${placeholders})`,
+        args: contentHashes
+      });
+      const foundHashes = [];
+      for (const row of queryResult.rows) {
+        const hash = row["content_hash"];
+        const embeddingBlob = row["embedding"];
+        result.set(hash, new Float32Array(embeddingBlob));
+        foundHashes.push(hash);
+      }
+      if (foundHashes.length > 0) {
+        const updatePlaceholders = foundHashes.map(() => "?").join(",");
+        await client.execute({
+          sql: `UPDATE embedding_cache SET last_used_at = ?, hit_count = hit_count + 1 WHERE content_hash IN (${updatePlaceholders})`,
+          args: [now, ...foundHashes]
+        });
+      }
+    } catch {
+    }
+    return result;
+  }
+  /**
+   * Store embedding in cache by content hash.
+   */
+  async setEmbeddingInCache(contentHash, model, embedding, textPreview) {
+    const client = this.getClient();
+    if (!client) return;
+    const now = Date.now();
+    try {
+      const vectorStr = this.vectorToString(embedding);
+      await client.execute({
+        sql: `INSERT OR REPLACE INTO embedding_cache
+              (content_hash, model, embedding, text_preview, hit_count, created_at, last_used_at)
+              VALUES (?, ?, vector32(?), ?, 0, ?, ?)`,
+        args: [contentHash, model, vectorStr, textPreview?.slice(0, 100) ?? null, now, now]
+      });
+    } catch {
+    }
+  }
+  /**
+   * Store multiple embeddings in cache (batch operation).
+   */
+  async setEmbeddingsInCache(entries) {
+    const client = this.getClient();
+    if (!client || entries.length === 0) return;
+    const now = Date.now();
+    try {
+      const statements = entries.map((entry) => ({
+        sql: `INSERT OR REPLACE INTO embedding_cache
+              (content_hash, model, embedding, text_preview, hit_count, created_at, last_used_at)
+              VALUES (?, ?, vector32(?), ?, 0, ?, ?)`,
+        args: [
+          entry.contentHash,
+          entry.model,
+          this.vectorToString(entry.embedding),
+          entry.textPreview?.slice(0, 100) ?? null,
+          now,
+          now
+        ]
+      }));
+      await client.batch(statements, "write");
+    } catch {
+    }
+  }
+};
+
+// src/storage/libsql/cooccurrence-ops.ts
+init_logging();
+var CooccurrenceOperations = class {
+  constructor(getClient, getContext) {
+    this.getClient = getClient;
+    this.getContext = getContext;
+  }
+  // ===========================================================================
+  // BATCH UPDATE
+  // ===========================================================================
+  /**
+   * Batch update co-occurrence counts from extracted term pairs.
+   * Uses UPSERT (INSERT OR REPLACE) for atomic updates.
+   *
+   * @param pairs - Map of "term1|term2" → count (terms must be sorted alphabetically)
+   */
+  async batchUpdateCooccurrence(pairs) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    if (pairs.size === 0) return;
+    const { projectHash, branchName } = this.getContext();
+    const now = Date.now();
+    const BATCH_SIZE = 100;
+    const entries = Array.from(pairs.entries());
+    for (let i = 0; i < entries.length; i += BATCH_SIZE) {
+      const batch = entries.slice(i, i + BATCH_SIZE);
+      const values = [];
+      const args = [];
+      for (const [key, count] of batch) {
+        const [term1, term2] = key.split("|");
+        if (!term1 || !term2) continue;
+        values.push("(?, ?, ?, ?, ?, ?)");
+        args.push(term1, term2, count, projectHash, branchName, now);
+      }
+      if (values.length === 0) continue;
+      await client.execute({
+        sql: `
+          INSERT INTO cooccurrence (term1, term2, count, project_hash, branch_name, updated_at)
+          VALUES ${values.join(", ")}
+          ON CONFLICT(term1, term2, project_hash, branch_name)
+          DO UPDATE SET
+            count = cooccurrence.count + excluded.count,
+            updated_at = excluded.updated_at
+        `,
+        args
+      });
+    }
+  }
+  /**
+   * Update term frequencies for PMI calculation.
+   * Called during indexing alongside co-occurrence updates.
+   *
+   * @param termCounts - Map of term → count in the document
+   * @param isNewDocument - Whether this is a new document (for doc_count increment)
+   */
+  async updateTermFrequencies(termCounts, isNewDocument = true) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    if (termCounts.size === 0) return;
+    const { projectHash, branchName } = this.getContext();
+    const BATCH_SIZE = 100;
+    const entries = Array.from(termCounts.entries());
+    for (let i = 0; i < entries.length; i += BATCH_SIZE) {
+      const batch = entries.slice(i, i + BATCH_SIZE);
+      const values = [];
+      const args = [];
+      for (const [term, count] of batch) {
+        values.push("(?, ?, ?, ?, ?)");
+        args.push(term, isNewDocument ? 1 : 0, count, projectHash, branchName);
+      }
+      if (values.length === 0) continue;
+      await client.execute({
+        sql: `
+          INSERT INTO term_frequency (term, doc_count, total_count, project_hash, branch_name)
+          VALUES ${values.join(", ")}
+          ON CONFLICT(term, project_hash, branch_name)
+          DO UPDATE SET
+            doc_count = term_frequency.doc_count + excluded.doc_count,
+            total_count = term_frequency.total_count + excluded.total_count
+        `,
+        args
+      });
+    }
+  }
+  // ===========================================================================
+  // QUERY OPERATIONS
+  // ===========================================================================
+  /**
+   * Get related terms for query expansion.
+   * Returns terms that frequently co-occur with the input term,
+   * sorted by PMI score (if available) or raw count.
+   *
+   * @param term - The term to find related terms for
+   * @param limit - Maximum number of related terms to return
+   */
+  async getRelatedTerms(term, limit = 5) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const normalizedTerm = term.toLowerCase();
+    const result = await client.execute({
+      sql: `
+        SELECT
+          CASE WHEN term1 = ? THEN term2 ELSE term1 END as related_term,
+          count,
+          COALESCE(pmi, 0) as pmi_score
+        FROM cooccurrence
+        WHERE project_hash = ? AND branch_name = ?
+          AND (term1 = ? OR term2 = ?)
+        ORDER BY
+          CASE WHEN pmi IS NOT NULL THEN pmi ELSE count * 0.01 END DESC
+        LIMIT ?
+      `,
+      args: [normalizedTerm, projectHash, branchName, normalizedTerm, normalizedTerm, limit]
+    });
+    return result.rows.map((row) => ({
+      term: row["related_term"],
+      score: row["pmi_score"] || row["count"] * 0.01,
+      count: row["count"]
+    }));
+  }
+  /**
+   * Get multiple related terms for a set of input terms.
+   * More efficient than calling getRelatedTerms multiple times.
+   *
+   * @param terms - Array of terms to find related terms for
+   * @param limitPerTerm - Maximum related terms per input term
+   */
+  async getRelatedTermsBatch(terms, limitPerTerm = 3) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    if (terms.length === 0) return /* @__PURE__ */ new Map();
+    const { projectHash, branchName } = this.getContext();
+    const normalizedTerms = terms.map((t) => t.toLowerCase());
+    const placeholders = normalizedTerms.map(() => "?").join(", ");
+    const result = await client.execute({
+      sql: `
+        SELECT
+          CASE WHEN term1 IN (${placeholders}) THEN term1 ELSE term2 END as source_term,
+          CASE WHEN term1 IN (${placeholders}) THEN term2 ELSE term1 END as related_term,
+          count,
+          COALESCE(pmi, 0) as pmi_score
+        FROM cooccurrence
+        WHERE project_hash = ? AND branch_name = ?
+          AND (term1 IN (${placeholders}) OR term2 IN (${placeholders}))
+        ORDER BY
+          CASE WHEN pmi IS NOT NULL THEN pmi ELSE count * 0.01 END DESC
+      `,
+      args: [...normalizedTerms, ...normalizedTerms, projectHash, branchName, ...normalizedTerms, ...normalizedTerms]
+    });
+    const grouped = /* @__PURE__ */ new Map();
+    for (const term of normalizedTerms) {
+      grouped.set(term, []);
+    }
+    for (const row of result.rows) {
+      const sourceTerm = row["source_term"];
+      const relatedTerm = row["related_term"];
+      const arr = grouped.get(sourceTerm);
+      if (arr && arr.length < limitPerTerm) {
+        arr.push({
+          term: relatedTerm,
+          score: row["pmi_score"] || row["count"] * 0.01,
+          count: row["count"]
+        });
+      }
+    }
+    return grouped;
+  }
+  // ===========================================================================
+  // PMI CALCULATION
+  // ===========================================================================
+  /**
+   * Recalculate PMI (Pointwise Mutual Information) for all co-occurrence pairs.
+   * PMI = log2(P(x,y) / (P(x) * P(y)))
+   *
+   * Uses batched approach: preloads term frequencies, calculates PMI in JS,
+   * then updates in batches with event loop yields to prevent CPU blocking.
+   */
+  async recalculatePMI() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const startTime = Date.now();
+    const tfResult = await client.execute({
+      sql: `SELECT term, total_count, doc_count FROM term_frequency WHERE project_hash = ? AND branch_name = ?`,
+      args: [projectHash, branchName]
+    });
+    const termFreqs = /* @__PURE__ */ new Map();
+    let maxDocCount = 1;
+    for (const row of tfResult.rows) {
+      const term = row["term"];
+      const totalCount = row["total_count"];
+      const docCount = row["doc_count"];
+      termFreqs.set(term, totalCount);
+      if (docCount > maxDocCount) maxDocCount = docCount;
+    }
+    const totalDocs = maxDocCount;
+    const coocResult = await client.execute({
+      sql: `SELECT term1, term2, count FROM cooccurrence WHERE project_hash = ? AND branch_name = ?`,
+      args: [projectHash, branchName]
+    });
+    const totalPairsResult = await client.execute({
+      sql: `SELECT SUM(count) as total FROM cooccurrence WHERE project_hash = ? AND branch_name = ?`,
+      args: [projectHash, branchName]
+    });
+    const totalPairs = totalPairsResult.rows[0]?.["total"] || 1;
+    if (coocResult.rows.length === 0) {
+      log.i("COOCOPS", "pmi_skip", { reason: "no_pairs" });
+      return;
+    }
+    log.i("COOCOPS", "pmi_start", { pairs: coocResult.rows.length, terms: termFreqs.size, totalDocs, totalPairs });
+    const BATCH_SIZE = 500;
+    let updated = 0;
+    for (let i = 0; i < coocResult.rows.length; i += BATCH_SIZE) {
+      const batch = coocResult.rows.slice(i, i + BATCH_SIZE);
+      const statements = [];
+      for (const row of batch) {
+        const term1 = row["term1"];
+        const term2 = row["term2"];
+        const count = row["count"];
+        const tf1 = termFreqs.get(term1) || 0;
+        const tf2 = termFreqs.get(term2) || 0;
+        let pmi = 0;
+        if (tf1 > 0 && tf2 > 0) {
+          const pXY = count / totalPairs;
+          const pX = tf1 / totalDocs;
+          const pY = tf2 / totalDocs;
+          pmi = Math.log2(pXY / (pX * pY));
+        }
+        statements.push({
+          sql: `UPDATE cooccurrence SET pmi = ? WHERE term1 = ? AND term2 = ? AND project_hash = ? AND branch_name = ?`,
+          args: [pmi, term1, term2, projectHash, branchName]
+        });
+      }
+      await client.batch(statements, "write");
+      updated += batch.length;
+      if (i + BATCH_SIZE < coocResult.rows.length) {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      }
+    }
+    const elapsed = Date.now() - startTime;
+    log.i("COOCOPS", "pmi_recalculated", { ms: elapsed, pairs: updated, terms: termFreqs.size, totalDocs });
+  }
+  // ===========================================================================
+  // MAINTENANCE
+  // ===========================================================================
+  /**
+   * Get statistics about the co-occurrence index.
+   */
+  async getStats() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const [pairsResult, termsResult, avgResult] = await Promise.all([
+      client.execute({
+        sql: `SELECT COUNT(*) as cnt FROM cooccurrence WHERE project_hash = ? AND branch_name = ?`,
+        args: [projectHash, branchName]
+      }),
+      client.execute({
+        sql: `SELECT COUNT(*) as cnt FROM term_frequency WHERE project_hash = ? AND branch_name = ?`,
+        args: [projectHash, branchName]
+      }),
+      client.execute({
+        sql: `SELECT AVG(count) as avg FROM cooccurrence WHERE project_hash = ? AND branch_name = ?`,
+        args: [projectHash, branchName]
+      })
+    ]);
+    return {
+      totalPairs: pairsResult.rows[0]?.["cnt"] || 0,
+      totalTerms: termsResult.rows[0]?.["cnt"] || 0,
+      avgPairCount: avgResult.rows[0]?.["avg"] || 0
+    };
+  }
+  /**
+   * Clear all co-occurrence data for current project/branch.
+   */
+  async clear() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    await client.batch(
+      [
+        {
+          sql: "DELETE FROM cooccurrence WHERE project_hash = ? AND branch_name = ?",
+          args: [projectHash, branchName]
+        },
+        {
+          sql: "DELETE FROM term_frequency WHERE project_hash = ? AND branch_name = ?",
+          args: [projectHash, branchName]
+        }
+      ],
+      "write"
+    );
+    log.i("COOCOPS", "cleared", { projectHash, branchName });
+  }
+  /**
+   * Prune low-frequency pairs to reduce index size.
+   * Removes pairs with count below threshold.
+   *
+   * @param minCount - Minimum count to keep (default: 2)
+   */
+  async pruneRarePairs(minCount = 2) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const result = await client.execute({
+      sql: `
+        DELETE FROM cooccurrence
+        WHERE project_hash = ? AND branch_name = ? AND count < ?
+      `,
+      args: [projectHash, branchName, minCount]
+    });
+    const deleted = result.rowsAffected || 0;
+    if (deleted > 0) {
+      log.i("COOCOPS", "pruned", { deleted, minCount });
+    }
+    return deleted;
+  }
+};
+
+// src/storage/libsql/entity-ops.ts
+init_logging();
+function splitToTokens(name) {
+  return name.replace(/[_-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([a-zA-Z])(\d)/g, "$1 $2").replace(/(\d)([a-zA-Z])/g, "$1 $2").toLowerCase().split(/\s+/).filter((t) => t.length >= 2);
+}
+var EntityOperations = class {
+  constructor(getClient, getContext, rowToEntity, genManager) {
+    this.getClient = getClient;
+    this.getContext = getContext;
+    this.rowToEntity = rowToEntity;
+    this.genManager = genManager;
+  }
+  tombstoneAdder;
+  tombstoneGetter;
+  /**
+   * Set tombstone delegates for layered branch support.
+   * Must be called after adapter initialization.
+   */
+  setTombstoneDelegates(adder, getter) {
+    this.tombstoneAdder = adder;
+    this.tombstoneGetter = getter;
+  }
+  /**
+   * Insert a single entity
+   */
+  async insertEntity(entity) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const now = Date.now();
+    if (!this.genManager.isCacheLoaded) {
+      await this.genManager.loadCache();
+    }
+    const newGen = await this.genManager.bumpGeneration(entity.filePath);
+    await client.execute({
+      sql: `
+        INSERT OR REPLACE INTO entities
+        (id, project_hash, branch_name, name, type, file_path, location, metadata, hash,
+         created_at, updated_at, complexity_score, language, size_bytes, embedding_base64, embedding_text, file_gen)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      args: [
+        entity.id,
+        projectHash,
+        branchName,
+        entity.name,
+        entity.type,
+        entity.filePath,
+        JSON.stringify(entity.location),
+        JSON.stringify(entity.metadata),
+        entity.hash || null,
+        entity.createdAt || now,
+        entity.updatedAt || now,
+        entity.complexityScore || 1,
+        entity.language || null,
+        entity.sizeBytes || 0,
+        entity.embeddingBase64 || null,
+        entity.embeddingText || null,
+        newGen
+      ]
+    });
+    const tokens = splitToTokens(entity.name);
+    if (tokens.length > 0 && entity.id) {
+      await client.execute({
+        sql: "DELETE FROM name_tokens WHERE entity_id = ? AND project_hash = ? AND branch_name = ?",
+        args: [entity.id, projectHash, branchName]
+      });
+      const valuePlaceholders = tokens.map(() => "(?, ?, ?, ?)").join(", ");
+      const tokenArgs = [];
+      for (const token of tokens) {
+        tokenArgs.push(token, entity.id, projectHash, branchName);
+      }
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO name_tokens (token, entity_id, project_hash, branch_name) VALUES ${valuePlaceholders}`,
+        args: tokenArgs
+      });
+    }
+  }
+  /**
+   * Insert multiple entities with batch optimization
+   */
+  async insertEntities(entities) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    if (entities.length === 0) return { processed: 0, failed: 0, errors: [], timeMs: 0 };
+    const start = Date.now();
+    const errors = [];
+    const { projectHash, branchName } = this.getContext();
+    const now = Date.now();
+    const withLang = entities.filter((e) => e.language).length;
+    const kotlinCount = entities.filter((e) => e.language === "kotlin").length;
+    const sample = entities.slice(0, 3).map((e) => ({ n: e.name, l: e.language, f: e.filePath?.slice(-30) }));
+    log.w("ENTITY_OPS", "insertEntities", {
+      total: entities.length,
+      withLang,
+      kotlinCount,
+      sample: JSON.stringify(sample)
+    });
+    const seen = /* @__PURE__ */ new Set();
+    const unique = [];
+    for (const e of entities) {
+      if (!seen.has(e.id)) {
+        seen.add(e.id);
+        unique.push(e);
+      }
+    }
+    if (!this.genManager.isCacheLoaded) {
+      await this.genManager.loadCache();
+    }
+    const filePaths = [...new Set(unique.map((e) => e.filePath))];
+    const genMap = await this.genManager.bumpGenerationBatch(filePaths);
+    const batchSize = 900;
+    let processed = 0;
+    for (let i = 0; i < unique.length; i += batchSize) {
+      const batch = unique.slice(i, i + batchSize);
+      const valuePlaceholders = batch.map(() => "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").join(", ");
+      const args = [];
+      for (const entity of batch) {
+        const fileGen = genMap.get(entity.filePath) ?? 1;
+        args.push(
+          entity.id,
+          projectHash,
+          branchName,
+          entity.name,
+          entity.type,
+          entity.filePath,
+          JSON.stringify(entity.location),
+          JSON.stringify(entity.metadata),
+          entity.hash || null,
+          entity.createdAt || now,
+          entity.updatedAt || now,
+          entity.complexityScore || 1,
+          entity.language || null,
+          entity.sizeBytes || 0,
+          entity.embeddingBase64 || null,
+          entity.embeddingText || null,
+          fileGen
+        );
+      }
+      const sql = `
+        INSERT OR REPLACE INTO entities
+        (id, project_hash, branch_name, name, type, file_path, location, metadata, hash,
+         created_at, updated_at, complexity_score, language, size_bytes, embedding_base64, embedding_text, file_gen)
+        VALUES ${valuePlaceholders}
+      `;
+      try {
+        await client.execute({ sql, args });
+        processed += batch.length;
+      } catch (error) {
+        errors.push({
+          item: { batchStart: i, batchEnd: i + batch.length },
+          error: error.message
+        });
+      }
+    }
+    const tokenRows = [];
+    for (const entity of unique) {
+      if (!entity.id) continue;
+      for (const token of splitToTokens(entity.name)) {
+        tokenRows.push([token, entity.id]);
+      }
+    }
+    if (tokenRows.length > 0) {
+      const idsToClean = unique.map((e) => e.id).filter((id) => id);
+      const DELETE_CHUNK = 400;
+      for (let i = 0; i < idsToClean.length; i += DELETE_CHUNK) {
+        const chunk = idsToClean.slice(i, i + DELETE_CHUNK);
+        const placeholders = chunk.map(() => "?").join(",");
+        await client.execute({
+          sql: `DELETE FROM name_tokens WHERE entity_id IN (${placeholders}) AND project_hash = ? AND branch_name = ?`,
+          args: [...chunk, projectHash, branchName]
+        });
+      }
+      const TOKEN_BATCH = 1e3;
+      for (let i = 0; i < tokenRows.length; i += TOKEN_BATCH) {
+        const chunk = tokenRows.slice(i, i + TOKEN_BATCH);
+        const valuePlaceholders = chunk.map(() => "(?, ?, ?, ?)").join(", ");
+        const tokenArgs = [];
+        for (const [token, entityId] of chunk) {
+          tokenArgs.push(token, entityId, projectHash, branchName);
+        }
+        await client.execute({
+          sql: `INSERT OR IGNORE INTO name_tokens (token, entity_id, project_hash, branch_name) VALUES ${valuePlaceholders}`,
+          args: tokenArgs
+        });
+      }
+    }
+    return {
+      processed,
+      failed: errors.length,
+      errors,
+      timeMs: Date.now() - start
+    };
+  }
+  /**
+   * Get entity by ID (layered: delta → base with tombstone check)
+   */
+  async getEntity(id) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    log.w("ENTITY_OPS", "getEntity", { branch: branchName, base: baseBranch || "none" });
+    if (baseBranch && this.tombstoneGetter) {
+      const tombstones = await this.tombstoneGetter("entity");
+      if (tombstones.has(id)) {
+        return null;
+      }
+    }
+    const result = await client.execute({
+      sql: `SELECT e.* FROM entities e
+            JOIN file_generations fg
+              ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+            WHERE e.id = ? AND e.project_hash = ? AND e.branch_name = ?
+              AND e.file_gen = fg.active_gen`,
+      args: [id, projectHash, branchName]
+    });
+    if (result.rows.length > 0) {
+      return this.rowToEntity(result.rows[0]);
+    }
+    if (baseBranch) {
+      const baseResult = await client.execute({
+        sql: `SELECT e.* FROM entities e
+              JOIN file_generations fg
+                ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+              WHERE e.id = ? AND e.project_hash = ? AND e.branch_name = ?
+                AND e.file_gen = fg.active_gen`,
+        args: [id, projectHash, baseBranch]
+      });
+      if (baseResult.rows.length > 0) {
+        return this.rowToEntity(baseResult.rows[0]);
+      }
+    }
+    return null;
+  }
+  /**
+   * Batch fetch entities by IDs in a single SQL query.
+   * Returns Map<id, Entity> for found entities.
+   * Uses IN clause with chunking for large ID sets.
+   */
+  async getEntitiesBatch(ids) {
+    const result = /* @__PURE__ */ new Map();
+    if (ids.length === 0) return result;
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    let tombstones = null;
+    if (baseBranch && this.tombstoneGetter) {
+      tombstones = await this.tombstoneGetter("entity");
+    }
+    const uniqueIds = [...new Set(ids)].filter((id) => !tombstones?.has(id));
+    if (uniqueIds.length === 0) return result;
+    const CHUNK_SIZE = 400;
+    for (let i = 0; i < uniqueIds.length; i += CHUNK_SIZE) {
+      const chunk = uniqueIds.slice(i, i + CHUNK_SIZE);
+      const placeholders = chunk.map(() => "?").join(",");
+      const rows = await client.execute({
+        sql: `SELECT e.* FROM entities e
+              JOIN file_generations fg
+                ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+              WHERE e.id IN (${placeholders}) AND e.project_hash = ? AND e.branch_name = ?
+                AND e.file_gen = fg.active_gen`,
+        args: [...chunk, projectHash, branchName]
+      });
+      for (const row of rows.rows) {
+        const entity = this.rowToEntity(row);
+        result.set(entity.id, entity);
+      }
+      if (baseBranch) {
+        const missingIds = chunk.filter((id) => !result.has(id));
+        if (missingIds.length > 0) {
+          const missingPlaceholders = missingIds.map(() => "?").join(",");
+          const baseRows = await client.execute({
+            sql: `SELECT e.* FROM entities e
+                  JOIN file_generations fg
+                    ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+                  WHERE e.id IN (${missingPlaceholders}) AND e.project_hash = ? AND e.branch_name = ?
+                    AND e.file_gen = fg.active_gen`,
+            args: [...missingIds, projectHash, baseBranch]
+          });
+          for (const row of baseRows.rows) {
+            const entity = this.rowToEntity(row);
+            result.set(entity.id, entity);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Build filter SQL clause and args.
+   * When ctx is provided and the name filter is a simple identifier, uses the
+   * name_tokens B-tree index instead of LIKE '%pattern%' for ~60x speedup.
+   */
+  buildFilterClause(filters, args, ctx) {
+    let sql = "";
+    if (filters) {
+      if (filters.entityType) {
+        const types = Array.isArray(filters.entityType) ? filters.entityType : [filters.entityType];
+        sql += ` AND type IN (${types.map(() => "?").join(",")})`;
+        args.push(...types);
+      }
+      if (filters.filePath) {
+        const paths = Array.isArray(filters.filePath) ? filters.filePath : [filters.filePath];
+        const normalized = [];
+        for (const p of paths) {
+          normalized.push(p);
+          if (p.includes("/")) normalized.push(p.replace(/\//g, "\\"));
+          if (p.includes("\\")) normalized.push(p.replace(/\\/g, "/"));
+        }
+        const unique = [...new Set(normalized)];
+        sql += ` AND e.file_path IN (${unique.map(() => "?").join(",")})`;
+        args.push(...unique);
+      }
+      if (filters.name) {
+        if (filters.name instanceof RegExp) {
+          const source = filters.name.source;
+          if (source.includes("|")) {
+            const alternatives = source.split("|").map((alt) => {
+              let p = alt.replace(/\.\*/g, "%").replace(/\*/g, "%").replace(/\./g, "_");
+              if (!p.includes("%") && !p.includes("_")) p = `%${p}%`;
+              return p;
+            });
+            sql += ` AND (${alternatives.map(() => "name LIKE ?").join(" OR ")})`;
+            args.push(...alternatives);
+          } else if (ctx && /^[a-zA-Z0-9_]+$/.test(source)) {
+            const tokens = splitToTokens(source);
+            if (tokens.length === 1) {
+              sql += " AND id IN (SELECT entity_id FROM name_tokens WHERE token = ? AND project_hash = ? AND branch_name = ?)";
+              args.push(tokens[0], ctx.projectHash, ctx.branchName);
+            } else if (tokens.length > 1) {
+              const placeholders = tokens.map(() => "?").join(",");
+              sql += ` AND id IN (SELECT entity_id FROM name_tokens WHERE token IN (${placeholders}) AND project_hash = ? AND branch_name = ? GROUP BY entity_id HAVING COUNT(DISTINCT token) = ?)`;
+              args.push(...tokens, ctx.projectHash, ctx.branchName, tokens.length);
+            } else {
+              let pattern = source;
+              pattern = pattern.replace(/\.\*/g, "%").replace(/\*/g, "%").replace(/\./g, "_");
+              if (!pattern.includes("%") && !pattern.includes("_")) pattern = `%${pattern}%`;
+              sql += " AND name LIKE ?";
+              args.push(pattern);
+            }
+          } else {
+            let pattern = source;
+            pattern = pattern.replace(/\.\*/g, "%").replace(/\*/g, "%").replace(/\./g, "_");
+            if (!pattern.includes("%") && !pattern.includes("_")) {
+              pattern = `%${pattern}%`;
+            }
+            sql += " AND name LIKE ?";
+            args.push(pattern);
+          }
+        } else {
+          sql += " AND name = ?";
+          args.push(filters.name);
+        }
+      }
+    }
+    return sql;
+  }
+  /**
+   * Find entities with complex filters (layered: delta + base - tombstones)
+   */
+  async findEntities(query) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    log.w("ENTITY_OPS", "findEntities", { hash: projectHash, branch: branchName, base: baseBranch || "none" });
+    const limit = query.limit || 100;
+    const offset = query.offset || 0;
+    if (!baseBranch) {
+      const args = [projectHash, branchName];
+      let sql = `SELECT e.* FROM entities e
+                 JOIN file_generations fg
+                   ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+                 WHERE e.project_hash = ? AND e.branch_name = ? AND e.file_gen = fg.active_gen`;
+      sql += this.buildFilterClause(query.filters, args, { projectHash, branchName });
+      sql += " LIMIT ? OFFSET ?";
+      args.push(limit, offset);
+      const result2 = await client.execute({ sql, args });
+      const withLang = result2.rows.filter((r) => r["language"]).length;
+      const sample = result2.rows.slice(0, 3).map((r) => ({ n: r["name"], l: r["language"] }));
+      log.w("ENTITY_OPS", "findEntities_raw", { total: result2.rows.length, withLang, sample: JSON.stringify(sample) });
+      return result2.rows.map((row) => this.rowToEntity(row));
+    }
+    const tombstones = this.tombstoneGetter ? await this.tombstoneGetter("entity") : /* @__PURE__ */ new Set();
+    const deltaArgs = [projectHash, branchName];
+    let deltaSql = `SELECT e.* FROM entities e
+                    JOIN file_generations fg
+                      ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+                    WHERE e.project_hash = ? AND e.branch_name = ? AND e.file_gen = fg.active_gen`;
+    deltaSql += this.buildFilterClause(query.filters, deltaArgs, { projectHash, branchName });
+    const deltaResult = await client.execute({ sql: deltaSql, args: deltaArgs });
+    const deltaWithLang = deltaResult.rows.filter((r) => r["language"]).length;
+    log.w("ENTITY_OPS", "findEntities_layered", { delta: deltaResult.rows.length, deltaWithLang, branch: branchName });
+    const deltaEntities = deltaResult.rows.map((row) => this.rowToEntity(row));
+    const deltaIds = new Set(deltaEntities.map((e) => e.id));
+    const baseArgs = [projectHash, baseBranch];
+    let baseSql = `SELECT e.* FROM entities e
+                   JOIN file_generations fg
+                     ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+                   WHERE e.project_hash = ? AND e.branch_name = ? AND e.file_gen = fg.active_gen`;
+    baseSql += this.buildFilterClause(query.filters, baseArgs, { projectHash, branchName: baseBranch });
+    const baseResult = await client.execute({ sql: baseSql, args: baseArgs });
+    log.w("ENTITY_OPS", "findEntities_base", { base: baseResult.rows.length, baseBranch });
+    const baseEntities = baseResult.rows.map((row) => this.rowToEntity(row)).filter((e) => !deltaIds.has(e.id) && !tombstones.has(e.id));
+    const combined = [...deltaEntities, ...baseEntities];
+    const result = combined.slice(offset, offset + limit);
+    const retWithLang = result.filter((e) => e.language).length;
+    const retSample = result.slice(0, 3).map((e) => ({ n: e.name, l: e.language }));
+    log.w("ENTITY_OPS", "findEntities_result", {
+      total: result.length,
+      withLang: retWithLang,
+      sample: JSON.stringify(retSample)
+    });
+    return result;
+  }
+  /**
+   * Build search SQL clause and args.
+   * When ctx is provided, uses name_tokens B-tree index for namePattern instead of LIKE.
+   */
+  buildSearchClause(options, args, ctx) {
+    let sql = "";
+    if (options.namePattern) {
+      if (ctx) {
+        const tokens = splitToTokens(options.namePattern);
+        if (tokens.length === 1) {
+          sql += " AND id IN (SELECT entity_id FROM name_tokens WHERE token = ? AND project_hash = ? AND branch_name = ?)";
+          args.push(tokens[0], ctx.projectHash, ctx.branchName);
+        } else if (tokens.length > 1) {
+          const placeholders = tokens.map(() => "?").join(",");
+          sql += ` AND id IN (SELECT entity_id FROM name_tokens WHERE token IN (${placeholders}) AND project_hash = ? AND branch_name = ? GROUP BY entity_id HAVING COUNT(DISTINCT token) = ?)`;
+          args.push(...tokens, ctx.projectHash, ctx.branchName, tokens.length);
+        } else {
+          sql += " AND name LIKE ?";
+          args.push(`%${options.namePattern}%`);
+        }
+      } else {
+        sql += " AND name LIKE ?";
+        args.push(`%${options.namePattern}%`);
+      }
+    }
+    if (options.types && options.types.length > 0) {
+      sql += ` AND type IN (${options.types.map(() => "?").join(",")})`;
+      args.push(...options.types);
+    }
+    if (options.filePath) {
+      const normalizedPath = options.filePath.replace(/\\/g, "/");
+      sql += " AND (e.file_path LIKE ? OR e.file_path LIKE ?)";
+      args.push(`%${normalizedPath}`, `%${normalizedPath.replace(/\//g, "\\")}`);
+    }
+    return sql;
+  }
+  /**
+   * Search entities by name pattern and type (layered: delta + base - tombstones)
+   */
+  async searchEntities(options) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    const limit = options.limit || 100;
+    if (!baseBranch) {
+      const args = [projectHash, branchName];
+      let sql = `SELECT e.* FROM entities e
+                 JOIN file_generations fg
+                   ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+                 WHERE e.project_hash = ? AND e.branch_name = ? AND e.file_gen = fg.active_gen`;
+      sql += this.buildSearchClause(options, args, { projectHash, branchName });
+      sql += " LIMIT ?";
+      args.push(limit);
+      const result = await client.execute({ sql, args });
+      return result.rows.map((row) => this.rowToEntity(row));
+    }
+    const tombstones = this.tombstoneGetter ? await this.tombstoneGetter("entity") : /* @__PURE__ */ new Set();
+    const deltaArgs = [projectHash, branchName];
+    let deltaSql = `SELECT e.* FROM entities e
+                    JOIN file_generations fg
+                      ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+                    WHERE e.project_hash = ? AND e.branch_name = ? AND e.file_gen = fg.active_gen`;
+    deltaSql += this.buildSearchClause(options, deltaArgs, { projectHash, branchName });
+    const deltaResult = await client.execute({ sql: deltaSql, args: deltaArgs });
+    const deltaEntities = deltaResult.rows.map((row) => this.rowToEntity(row));
+    const deltaIds = new Set(deltaEntities.map((e) => e.id));
+    const baseArgs = [projectHash, baseBranch];
+    let baseSql = `SELECT e.* FROM entities e
+                   JOIN file_generations fg
+                     ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+                   WHERE e.project_hash = ? AND e.branch_name = ? AND e.file_gen = fg.active_gen`;
+    baseSql += this.buildSearchClause(options, baseArgs, { projectHash, branchName: baseBranch });
+    const baseResult = await client.execute({ sql: baseSql, args: baseArgs });
+    const baseEntities = baseResult.rows.map((row) => this.rowToEntity(row)).filter((e) => !deltaIds.has(e.id) && !tombstones.has(e.id));
+    return [...deltaEntities, ...baseEntities].slice(0, limit);
+  }
+  /**
+   * Search entities by directory path (LIKE pattern) (layered: delta + base - tombstones)
+   */
+  async searchEntitiesInDirectory(directoryPath) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    const forwardPath = directoryPath.replace(/\\/g, "/");
+    const backPath = directoryPath.replace(/\//g, "\\");
+    if (!baseBranch) {
+      const sql = `
+        SELECT e.* FROM entities e
+        JOIN file_generations fg
+          ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+        WHERE e.project_hash = ? AND e.branch_name = ?
+        AND (e.file_path LIKE ? OR e.file_path LIKE ?)
+        AND e.file_gen = fg.active_gen
+      `;
+      const args = [projectHash, branchName, `${forwardPath}%`, `${backPath}%`];
+      const result = await client.execute({ sql, args });
+      return result.rows.map((row) => this.rowToEntity(row));
+    }
+    const tombstones = this.tombstoneGetter ? await this.tombstoneGetter("entity") : /* @__PURE__ */ new Set();
+    const deltaSql = `
+      SELECT e.* FROM entities e
+      JOIN file_generations fg
+        ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+      WHERE e.project_hash = ? AND e.branch_name = ?
+      AND (e.file_path LIKE ? OR e.file_path LIKE ?)
+      AND e.file_gen = fg.active_gen
+    `;
+    const deltaResult = await client.execute({
+      sql: deltaSql,
+      args: [projectHash, branchName, `${forwardPath}%`, `${backPath}%`]
+    });
+    const deltaEntities = deltaResult.rows.map((row) => this.rowToEntity(row));
+    const deltaIds = new Set(deltaEntities.map((e) => e.id));
+    const baseSql = `
+      SELECT e.* FROM entities e
+      JOIN file_generations fg
+        ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+      WHERE e.project_hash = ? AND e.branch_name = ?
+      AND (e.file_path LIKE ? OR e.file_path LIKE ?)
+      AND e.file_gen = fg.active_gen
+    `;
+    const baseResult = await client.execute({
+      sql: baseSql,
+      args: [projectHash, baseBranch, `${forwardPath}%`, `${backPath}%`]
+    });
+    const baseEntities = baseResult.rows.map((row) => this.rowToEntity(row)).filter((e) => !deltaIds.has(e.id) && !tombstones.has(e.id));
+    return [...deltaEntities, ...baseEntities];
+  }
+  /**
+   * Delete entity by ID.
+   * On feature branches with baseBranch set, adds tombstone instead of deleting.
+   */
+  async deleteEntity(id) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    if (baseBranch && this.tombstoneAdder) {
+      await this.tombstoneAdder(id, "entity");
+    }
+    await client.execute({
+      sql: "DELETE FROM entities WHERE id = ? AND project_hash = ? AND branch_name = ?",
+      args: [id, projectHash, branchName]
+    });
+    await client.execute({
+      sql: "DELETE FROM name_tokens WHERE entity_id = ? AND project_hash = ? AND branch_name = ?",
+      args: [id, projectHash, branchName]
+    });
+  }
+  /**
+   * Get entity IDs by file path (for FAISS cleanup) (layered: delta + base - tombstones)
+   */
+  async getEntityIdsByFilePath(filePath) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    const forwardPath = filePath.replace(/\\/g, "/");
+    const backPath = filePath.replace(/\//g, "\\");
+    if (!baseBranch) {
+      const result = await client.execute({
+        sql: `
+          SELECT e.id FROM entities e
+          JOIN file_generations fg
+            ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+          WHERE e.project_hash = ? AND e.branch_name = ?
+          AND (e.file_path = ? OR e.file_path = ?)
+          AND e.file_gen = fg.active_gen
+        `,
+        args: [projectHash, branchName, forwardPath, backPath]
+      });
+      return result.rows.map((row) => row["id"]);
+    }
+    const tombstones = this.tombstoneGetter ? await this.tombstoneGetter("entity") : /* @__PURE__ */ new Set();
+    const deltaResult = await client.execute({
+      sql: `
+        SELECT e.id FROM entities e
+        JOIN file_generations fg
+          ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+        WHERE e.project_hash = ? AND e.branch_name = ?
+        AND (e.file_path = ? OR e.file_path = ?)
+        AND e.file_gen = fg.active_gen
+      `,
+      args: [projectHash, branchName, forwardPath, backPath]
+    });
+    const deltaIds = new Set(deltaResult.rows.map((row) => row["id"]));
+    const baseResult = await client.execute({
+      sql: `
+        SELECT e.id FROM entities e
+        JOIN file_generations fg
+          ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+        WHERE e.project_hash = ? AND e.branch_name = ?
+        AND (e.file_path = ? OR e.file_path = ?)
+        AND e.file_gen = fg.active_gen
+      `,
+      args: [projectHash, baseBranch, forwardPath, backPath]
+    });
+    const baseIds = baseResult.rows.map((row) => row["id"]).filter((id) => !deltaIds.has(id) && !tombstones.has(id));
+    return [...deltaIds, ...baseIds];
+  }
+  /**
+   * Delete all entities for a file path
+   * Returns the IDs of deleted entities (for FAISS cleanup)
+   */
+  async deleteEntitiesByFilePath(filePath) {
+    const ids = await this.getEntityIdsByFilePath(filePath);
+    if (ids.length === 0) return [];
+    await this.genManager.invalidateFileGeneration(filePath);
+    return ids;
+  }
+  /**
+   * Get all entities for current project/branch (layered: delta + base - tombstones)
+   */
+  async getAllEntities() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    if (!baseBranch) {
+      const result = await client.execute({
+        sql: `SELECT e.* FROM entities e
+              JOIN file_generations fg
+                ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+              WHERE e.project_hash = ? AND e.branch_name = ? AND e.file_gen = fg.active_gen`,
+        args: [projectHash, branchName]
+      });
+      return result.rows.map((row) => this.rowToEntity(row));
+    }
+    const tombstones = this.tombstoneGetter ? await this.tombstoneGetter("entity") : /* @__PURE__ */ new Set();
+    const deltaResult = await client.execute({
+      sql: `SELECT e.* FROM entities e
+            JOIN file_generations fg
+              ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+            WHERE e.project_hash = ? AND e.branch_name = ? AND e.file_gen = fg.active_gen`,
+      args: [projectHash, branchName]
+    });
+    const deltaEntities = deltaResult.rows.map((row) => this.rowToEntity(row));
+    const deltaIds = new Set(deltaEntities.map((e) => e.id));
+    const baseResult = await client.execute({
+      sql: `SELECT e.* FROM entities e
+            JOIN file_generations fg
+              ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+            WHERE e.project_hash = ? AND e.branch_name = ? AND e.file_gen = fg.active_gen`,
+      args: [projectHash, baseBranch]
+    });
+    const baseEntities = baseResult.rows.map((row) => this.rowToEntity(row)).filter((e) => !deltaIds.has(e.id) && !tombstones.has(e.id));
+    return [...deltaEntities, ...baseEntities];
+  }
+  /**
+   * Count entities by language (efficient SQL aggregation for TechnologyDetector).
+   * Excludes external placeholder entities (file_path starting with 'external://').
+   * Returns map of language -> { count, fileCount }
+   */
+  async countByLanguage() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    if (!baseBranch) {
+      const result2 = await client.execute({
+        sql: `
+          SELECT
+            COALESCE(e.language, 'unknown') as lang,
+            COUNT(*) as cnt,
+            COUNT(DISTINCT e.file_path) as file_cnt
+          FROM entities e
+          JOIN file_generations fg
+            ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+          WHERE e.project_hash = ? AND e.branch_name = ?
+            AND e.file_path NOT LIKE 'external://%'
+            AND e.file_gen = fg.active_gen
+          GROUP BY COALESCE(e.language, 'unknown')
+        `,
+        args: [projectHash, branchName]
+      });
+      const counts2 = /* @__PURE__ */ new Map();
+      for (const row of result2.rows) {
+        const lang = row["lang"];
+        counts2.set(lang, {
+          count: Number(row["cnt"]),
+          fileCount: Number(row["file_cnt"])
+        });
+      }
+      return counts2;
+    }
+    const tombstones = this.tombstoneGetter ? await this.tombstoneGetter("entity") : /* @__PURE__ */ new Set();
+    const deltaResult = await client.execute({
+      sql: `SELECT e.id, e.language, e.file_path FROM entities e
+            JOIN file_generations fg
+              ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+            WHERE e.project_hash = ? AND e.branch_name = ? AND e.file_path NOT LIKE 'external://%'
+              AND e.file_gen = fg.active_gen`,
+      args: [projectHash, branchName]
+    });
+    const deltaEntities = deltaResult.rows.map((row) => ({
+      id: row["id"],
+      language: row["language"],
+      filePath: row["file_path"]
+    }));
+    const deltaIds = new Set(deltaEntities.map((e) => e.id));
+    const baseResult = await client.execute({
+      sql: `SELECT e.id, e.language, e.file_path FROM entities e
+            JOIN file_generations fg
+              ON e.file_path = fg.file_path AND e.project_hash = fg.project_hash AND e.branch_name = fg.branch_name
+            WHERE e.project_hash = ? AND e.branch_name = ? AND e.file_path NOT LIKE 'external://%'
+              AND e.file_gen = fg.active_gen`,
+      args: [projectHash, baseBranch]
+    });
+    const baseEntities = baseResult.rows.map((row) => ({
+      id: row["id"],
+      language: row["language"],
+      filePath: row["file_path"]
+    })).filter((e) => !deltaIds.has(e.id) && !tombstones.has(e.id));
+    const allEntities = [...deltaEntities, ...baseEntities];
+    const counts = /* @__PURE__ */ new Map();
+    for (const e of allEntities) {
+      const lang = e.language || "unknown";
+      if (!counts.has(lang)) {
+        counts.set(lang, { count: 0, files: /* @__PURE__ */ new Set() });
+      }
+      const entry = counts.get(lang);
+      entry.count++;
+      entry.files.add(e.filePath);
+    }
+    const result = /* @__PURE__ */ new Map();
+    for (const [lang, data] of counts) {
+      result.set(lang, { count: data.count, fileCount: data.files.size });
+    }
+    return result;
+  }
+};
+
+// src/storage/libsql/generation-ops.ts
+init_logging();
+var GenerationManager = class {
+  constructor(getClient, getContext) {
+    this.getClient = getClient;
+    this.getContext = getContext;
+  }
+  /** In-memory cache: "filePath" → active generation number */
+  cache = /* @__PURE__ */ new Map();
+  cacheLoaded = false;
+  gcRunning = false;
+  /**
+   * Load generation cache from DB for current project/branch.
+   * Call once after setProjectContext().
+   */
+  async loadCache() {
+    const client = this.getClient();
+    if (!client) return;
+    const { projectHash, branchName } = this.getContext();
+    const result = await client.execute({
+      sql: `SELECT file_path, active_gen FROM file_generations
+            WHERE project_hash = ? AND branch_name = ?`,
+      args: [projectHash, branchName]
+    });
+    this.cache.clear();
+    for (const row of result.rows) {
+      this.cache.set(row["file_path"], Number(row["active_gen"]));
+    }
+    this.cacheLoaded = true;
+    log.d("GEN_OPS", "cache_loaded", { entries: this.cache.size });
+  }
+  /**
+   * Get active generation for a file. Returns from cache or DB.
+   * Returns 0 if file has no generation record (new file).
+   */
+  getGeneration(filePath) {
+    return this.cache.get(filePath) ?? 0;
+  }
+  /**
+   * Bump generation for a single file: increment + update cache + DB.
+   * Returns the new generation number.
+   */
+  async bumpGeneration(filePath) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const currentGen = this.getGeneration(filePath);
+    const newGen = currentGen + 1;
+    const now = Date.now();
+    await client.execute({
+      sql: `INSERT OR REPLACE INTO file_generations
+            (file_path, project_hash, branch_name, active_gen, updated_at)
+            VALUES (?, ?, ?, ?, ?)`,
+      args: [filePath, projectHash, branchName, newGen, now]
+    });
+    this.cache.set(filePath, newGen);
+    return newGen;
+  }
+  /**
+   * Bump generation for multiple files in a single batch.
+   * Returns map of filePath → newGen.
+   */
+  async bumpGenerationBatch(filePaths) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    if (filePaths.length === 0) return /* @__PURE__ */ new Map();
+    const { projectHash, branchName } = this.getContext();
+    const now = Date.now();
+    const result = /* @__PURE__ */ new Map();
+    const unique = [...new Set(filePaths)];
+    const BATCH_SIZE = 500;
+    for (let i = 0; i < unique.length; i += BATCH_SIZE) {
+      const batch = unique.slice(i, i + BATCH_SIZE);
+      const valuePlaceholders = batch.map(() => "(?, ?, ?, ?, ?)").join(", ");
+      const args = [];
+      for (const filePath of batch) {
+        const currentGen = this.getGeneration(filePath);
+        const newGen = currentGen + 1;
+        args.push(filePath, projectHash, branchName, newGen, now);
+        this.cache.set(filePath, newGen);
+        result.set(filePath, newGen);
+      }
+      await client.execute({
+        sql: `INSERT OR REPLACE INTO file_generations
+              (file_path, project_hash, branch_name, active_gen, updated_at)
+              VALUES ${valuePlaceholders}`,
+        args
+      });
+    }
+    return result;
+  }
+  /**
+   * Invalidate a file's generation (for deleted files).
+   * Sets active_gen = -1 so all entities for this file become stale.
+   * Returns the old entity IDs for FAISS cleanup.
+   */
+  async invalidateFileGeneration(filePath) {
+    const client = this.getClient();
+    if (!client) return;
+    const { projectHash, branchName } = this.getContext();
+    await client.execute({
+      sql: `INSERT OR REPLACE INTO file_generations
+            (file_path, project_hash, branch_name, active_gen, updated_at)
+            VALUES (?, ?, ?, -1, ?)`,
+      args: [filePath, projectHash, branchName, Date.now()]
+    });
+    this.cache.set(filePath, -1);
+  }
+  /**
+   * GC: Delete stale entities (file_gen < active_gen or active_gen = -1).
+   * Runs in chunks to avoid long locks. Returns number of deleted rows.
+   */
+  async gcStaleEntities(limit = 1e4) {
+    const client = this.getClient();
+    if (!client || this.gcRunning) return 0;
+    this.gcRunning = true;
+    const { projectHash, branchName } = this.getContext();
+    try {
+      const result = await client.execute({
+        sql: `DELETE FROM entities WHERE rowid IN (
+          SELECT e.rowid FROM entities e
+          JOIN file_generations fg
+            ON e.file_path = fg.file_path
+            AND e.project_hash = fg.project_hash
+            AND e.branch_name = fg.branch_name
+          WHERE e.project_hash = ? AND e.branch_name = ?
+            AND e.file_gen != fg.active_gen
+          LIMIT ?
+        )`,
+        args: [projectHash, branchName, limit]
+      });
+      const deleted = result.rowsAffected;
+      await client.execute({
+        sql: `DELETE FROM file_generations
+              WHERE project_hash = ? AND branch_name = ? AND active_gen = -1
+              AND file_path NOT IN (
+                SELECT DISTINCT file_path FROM entities
+                WHERE project_hash = ? AND branch_name = ?
+                AND file_path IN (
+                  SELECT file_path FROM file_generations
+                  WHERE project_hash = ? AND branch_name = ? AND active_gen = -1
+                )
+              )`,
+        args: [projectHash, branchName, projectHash, branchName, projectHash, branchName]
+      });
+      if (deleted > 0) {
+        log.i("GEN_OPS", "gc_stale_entities", { deleted });
+      }
+      return deleted;
+    } finally {
+      this.gcRunning = false;
+    }
+  }
+  /**
+   * GC: Delete orphaned name_tokens whose entities are stale.
+   * Returns number of deleted rows.
+   */
+  async gcStaleNameTokens(limit = 1e4) {
+    const client = this.getClient();
+    if (!client) return 0;
+    const { projectHash, branchName } = this.getContext();
+    const result = await client.execute({
+      sql: `DELETE FROM name_tokens WHERE rowid IN (
+        SELECT nt.rowid FROM name_tokens nt
+        LEFT JOIN entities e
+          ON nt.entity_id = e.id
+          AND nt.project_hash = e.project_hash
+          AND nt.branch_name = e.branch_name
+        LEFT JOIN file_generations fg
+          ON e.file_path = fg.file_path
+          AND e.project_hash = fg.project_hash
+          AND e.branch_name = fg.branch_name
+        WHERE nt.project_hash = ? AND nt.branch_name = ?
+          AND (e.id IS NULL OR e.file_gen != fg.active_gen)
+        LIMIT ?
+      )`,
+      args: [projectHash, branchName, limit]
+    });
+    const deleted = result.rowsAffected;
+    if (deleted > 0) {
+      log.i("GEN_OPS", "gc_stale_tokens", { deleted });
+    }
+    return deleted;
+  }
+  /**
+   * Run full GC cycle: entities first, then orphan tokens.
+   * Repeats in chunks until nothing left to clean.
+   */
+  async runFullGC() {
+    let totalEntities = 0;
+    let totalTokens = 0;
+    let deleted;
+    do {
+      deleted = await this.gcStaleEntities();
+      totalEntities += deleted;
+    } while (deleted > 0);
+    do {
+      deleted = await this.gcStaleNameTokens();
+      totalTokens += deleted;
+    } while (deleted > 0);
+    if (totalEntities > 0 || totalTokens > 0) {
+      log.i("GEN_OPS", "full_gc_complete", { entities: totalEntities, tokens: totalTokens });
+    }
+    return { entities: totalEntities, tokens: totalTokens };
+  }
+  /**
+   * Clear cache (e.g., on branch switch).
+   */
+  clearCache() {
+    this.cache.clear();
+    this.cacheLoaded = false;
+  }
+  get isCacheLoaded() {
+    return this.cacheLoaded;
+  }
+};
+
+// src/storage/libsql/metadata-ops.ts
+init_logging();
+var MetadataOperations = class {
+  constructor(getClient, getContext) {
+    this.getClient = getClient;
+    this.getContext = getContext;
+  }
+  // ===========================================================================
+  // FILE OPERATIONS
+  // ===========================================================================
+  /**
+   * Update or insert file info
+   */
+  async updateFileInfo(info) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    await client.execute({
+      sql: `
+        INSERT OR REPLACE INTO files
+        (path, project_hash, branch_name, hash, last_indexed, entity_count)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `,
+      args: [info.path, projectHash, branchName, info.hash, info.lastIndexed, info.entityCount]
+    });
+  }
+  /**
+   * Batch update or insert multiple file infos in a single DB round-trip.
+   */
+  async batchUpdateFileInfo(infos) {
+    if (infos.length === 0) return;
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const statements = infos.map((info) => ({
+      sql: `
+        INSERT OR REPLACE INTO files
+        (path, project_hash, branch_name, hash, last_indexed, entity_count)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `,
+      args: [info.path, projectHash, branchName, info.hash, info.lastIndexed, info.entityCount]
+    }));
+    await client.batch(statements, "write");
+  }
+  /**
+   * Get file info by path
+   */
+  async getFileInfo(path) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const result = await client.execute({
+      sql: "SELECT * FROM files WHERE path = ? AND project_hash = ? AND branch_name = ?",
+      args: [path, projectHash, branchName]
+    });
+    if (result.rows.length === 0 || !result.rows[0]) return null;
+    const row = result.rows[0];
+    return {
+      path: row["path"],
+      hash: row["hash"],
+      lastIndexed: row["last_indexed"],
+      entityCount: row["entity_count"]
+    };
+  }
+  /**
+   * Get files that were indexed before the specified timestamp
+   */
+  async getOutdatedFiles(since) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const result = await client.execute({
+      sql: `
+        SELECT * FROM files
+        WHERE project_hash = ? AND branch_name = ? AND last_indexed < ?
+      `,
+      args: [projectHash, branchName, since]
+    });
+    return result.rows.map((row) => ({
+      path: row["path"],
+      hash: row["hash"],
+      lastIndexed: row["last_indexed"],
+      entityCount: row["entity_count"]
+    }));
+  }
+  /**
+   * Get all indexed files with their lastIndexed timestamps
+   * Used for incremental indexing to compare with file mtime
+   */
+  async getAllIndexedFiles() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const result = await client.execute({
+      sql: `
+        SELECT path, last_indexed FROM files
+        WHERE project_hash = ? AND branch_name = ?
+      `,
+      args: [projectHash, branchName]
+    });
+    const fileMap = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      const path = row["path"];
+      const lastIndexed = row["last_indexed"];
+      fileMap.set(path.replace(/\\/g, "/"), lastIndexed);
+    }
+    return fileMap;
+  }
+  /**
+   * Delete file info by path
+   */
+  async deleteFileInfo(path) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const forwardPath = path.replace(/\\/g, "/");
+    const backPath = path.replace(/\//g, "\\");
+    await client.execute({
+      sql: `
+        DELETE FROM files
+        WHERE project_hash = ? AND branch_name = ?
+        AND (path = ? OR path = ?)
+      `,
+      args: [projectHash, branchName, forwardPath, backPath]
+    });
+  }
+  // ===========================================================================
+  // PROJECT METADATA
+  // ===========================================================================
+  /**
+   * Update project metadata after indexing
+   */
+  async updateProjectMetadata(projectPath, isFullIndex = false) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const now = Date.now();
+    const entityCount = await client.execute({
+      sql: "SELECT COUNT(*) as count FROM entities WHERE project_hash = ? AND branch_name = ?",
+      args: [projectHash, branchName]
+    });
+    const fileCount = await client.execute({
+      sql: "SELECT COUNT(*) as count FROM files WHERE project_hash = ? AND branch_name = ?",
+      args: [projectHash, branchName]
+    });
+    const existing = await client.execute({
+      sql: `SELECT last_full_index_at, incremental_changes_count, created_at
+            FROM project_metadata WHERE project_hash = ? AND branch_name = ?`,
+      args: [projectHash, branchName]
+    });
+    const existingRow = existing.rows[0];
+    const createdAt = existingRow?.["created_at"] || now;
+    const lastFullIndexAt = isFullIndex ? now : existingRow?.["last_full_index_at"] || 0;
+    const incrementalChangesCount = isFullIndex ? 0 : existingRow?.["incremental_changes_count"] || 0;
+    await client.execute({
+      sql: `
+        INSERT OR REPLACE INTO project_metadata
+        (project_hash, branch_name, project_path, last_indexed_at, entity_count, file_count,
+         created_at, updated_at, last_full_index_at, incremental_changes_count)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      args: [
+        projectHash,
+        branchName,
+        projectPath,
+        now,
+        entityCount.rows[0]?.["count"] || 0,
+        fileCount.rows[0]?.["count"] || 0,
+        createdAt,
+        now,
+        lastFullIndexAt,
+        incrementalChangesCount
+      ]
+    });
+  }
+  /**
+   * Get incremental tracking info for the current project/branch
+   */
+  async getIncrementalTrackingInfo() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const result = await client.execute({
+      sql: `SELECT last_full_index_at, incremental_changes_count, file_count
+            FROM project_metadata WHERE project_hash = ? AND branch_name = ?`,
+      args: [projectHash, branchName]
+    });
+    if (result.rows.length === 0) {
+      return { lastFullIndexAt: 0, incrementalChangesCount: 0, totalFiles: 0 };
+    }
+    const row = result.rows[0];
+    return {
+      lastFullIndexAt: row["last_full_index_at"] || 0,
+      incrementalChangesCount: row["incremental_changes_count"] || 0,
+      totalFiles: row["file_count"] || 0
+    };
+  }
+  /**
+   * Record incremental file changes (called after each incremental update)
+   */
+  async recordIncrementalChanges(changedFileCount) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    await client.execute({
+      sql: `UPDATE project_metadata
+            SET incremental_changes_count = incremental_changes_count + ?,
+                updated_at = ?
+            WHERE project_hash = ? AND branch_name = ?`,
+      args: [changedFileCount, Date.now(), projectHash, branchName]
+    });
+  }
+  /**
+   * Reset incremental tracking (called after full index)
+   */
+  async resetIncrementalTracking() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const now = Date.now();
+    await client.execute({
+      sql: `UPDATE project_metadata
+            SET last_full_index_at = ?,
+                incremental_changes_count = 0,
+                updated_at = ?
+            WHERE project_hash = ? AND branch_name = ?`,
+      args: [now, now, projectHash, branchName]
+    });
+  }
+  /**
+   * List all projects in the database
+   */
+  async listProjects() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const result = await client.execute(`
+      SELECT project_hash, branch_name, project_path, last_indexed_at, entity_count, file_count
+      FROM project_metadata
+      ORDER BY updated_at DESC
+    `);
+    return result.rows.map((r) => ({
+      projectHash: r["project_hash"],
+      branchName: r["branch_name"],
+      projectPath: r["project_path"],
+      lastIndexedAt: r["last_indexed_at"],
+      entityCount: r["entity_count"],
+      fileCount: r["file_count"]
+    }));
+  }
+  /**
+   * List all branches for current project
+   */
+  async listBranches() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash } = this.getContext();
+    const result = await client.execute({
+      sql: `
+        SELECT DISTINCT branch_name FROM project_metadata
+        WHERE project_hash = ?
+        ORDER BY branch_name
+      `,
+      args: [projectHash]
+    });
+    return result.rows.map((r) => r["branch_name"]);
+  }
+  // ===========================================================================
+  // STATS
+  // ===========================================================================
+  /**
+   * Get stats for current project/branch
+   * Uses layered approach: if baseBranch is set and different from current, includes both
+   */
+  async getStats() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    const useLayered = baseBranch && baseBranch !== branchName;
+    const branchFilter = useLayered ? "branch_name IN (?, ?)" : "branch_name = ?";
+    const branchArgs = useLayered ? [baseBranch, branchName] : [branchName];
+    const [entities, relationships, files] = await Promise.all([
+      client.execute({
+        sql: `SELECT COUNT(*) as cnt FROM entities WHERE project_hash = ? AND ${branchFilter}`,
+        args: [projectHash, ...branchArgs]
+      }),
+      client.execute({
+        sql: `SELECT COUNT(*) as cnt FROM relationships WHERE project_hash = ? AND ${branchFilter}`,
+        args: [projectHash, ...branchArgs]
+      }),
+      client.execute({
+        sql: `SELECT COUNT(*) as cnt FROM files WHERE project_hash = ? AND ${branchFilter}`,
+        args: [projectHash, ...branchArgs]
+      })
+    ]);
+    return {
+      totalEntities: entities.rows[0]?.["cnt"] || 0,
+      totalRelationships: relationships.rows[0]?.["cnt"] || 0,
+      totalFiles: files.rows[0]?.["cnt"] || 0,
+      totalEmbeddings: 0
+      // v5: embeddings stored in FAISS, not LibSQL
+    };
+  }
+  /**
+   * Get stats across all projects
+   */
+  async getTotalStats() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const [entities, relationships, files] = await Promise.all([
+      client.execute("SELECT COUNT(*) as cnt FROM entities"),
+      client.execute("SELECT COUNT(*) as cnt FROM relationships"),
+      client.execute("SELECT COUNT(*) as cnt FROM files")
+    ]);
+    return {
+      totalEntities: entities.rows[0]?.["cnt"] || 0,
+      totalRelationships: relationships.rows[0]?.["cnt"] || 0,
+      totalFiles: files.rows[0]?.["cnt"] || 0,
+      totalEmbeddings: 0
+      // v5: embeddings stored in FAISS, not LibSQL
+    };
+  }
+  // ===========================================================================
+  // CLEAR OPERATIONS
+  // ===========================================================================
+  /**
+   * Clear all data for current project/branch.
+   * Auto-detects single-project DB and uses fast truncation path (clearAll)
+   * to avoid SQLite B-tree fragmentation that causes 56x slower INSERTs.
+   */
+  async clear() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const otherProjects = await client.execute({
+      sql: "SELECT 1 FROM entities WHERE project_hash != ? LIMIT 1",
+      args: [projectHash]
+    });
+    if (otherProjects.rows.length === 0) {
+      await this.clearAll();
+      try {
+        await client.execute({ sql: "VACUUM", args: [] });
+      } catch {
+      }
+      log.i("METADATAOPS", "data_cleared_fast", { ctx: `${projectHash}/${branchName}`, mode: "truncate+vacuum" });
+      return;
+    }
+    await client.batch(
+      [
+        // NOTE: embeddings table removed in v5 - FAISS handles vector storage
+        {
+          sql: "DELETE FROM relationships WHERE project_hash = ? AND branch_name = ?",
+          args: [projectHash, branchName]
+        },
+        { sql: "DELETE FROM entities WHERE project_hash = ? AND branch_name = ?", args: [projectHash, branchName] },
+        { sql: "DELETE FROM files WHERE project_hash = ? AND branch_name = ?", args: [projectHash, branchName] },
+        { sql: "DELETE FROM query_cache WHERE project_hash = ? AND branch_name = ?", args: [projectHash, branchName] },
+        {
+          sql: "DELETE FROM project_metadata WHERE project_hash = ? AND branch_name = ?",
+          args: [projectHash, branchName]
+        },
+        {
+          sql: "DELETE FROM name_tokens WHERE project_hash = ? AND branch_name = ?",
+          args: [projectHash, branchName]
+        },
+        {
+          sql: "DELETE FROM cooccurrence WHERE project_hash = ? AND branch_name = ?",
+          args: [projectHash, branchName]
+        },
+        {
+          sql: "DELETE FROM term_frequency WHERE project_hash = ? AND branch_name = ?",
+          args: [projectHash, branchName]
+        }
+      ],
+      "write"
+    );
+    try {
+      await client.execute({ sql: "VACUUM", args: [] });
+      log.i("METADATAOPS", "data_cleared", { ctx: `${projectHash}/${branchName}`, mode: "delete+vacuum" });
+    } catch (error) {
+      log.w("METADATAOPS", "vacuum_fail", { err: error.message });
+      log.i("METADATAOPS", "data_cleared", { ctx: `${projectHash}/${branchName}`, mode: "delete" });
+    }
+  }
+  /**
+   * Clear ALL data in the database
+   */
+  async clearAll() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    await client.batch(
+      [
+        // NOTE: embeddings table removed in v5 - FAISS handles vector storage
+        { sql: "DELETE FROM relationships", args: [] },
+        { sql: "DELETE FROM entities", args: [] },
+        { sql: "DELETE FROM files", args: [] },
+        { sql: "DELETE FROM query_cache", args: [] },
+        { sql: "DELETE FROM project_metadata", args: [] },
+        { sql: "DELETE FROM name_tokens", args: [] },
+        { sql: "DELETE FROM cooccurrence", args: [] },
+        { sql: "DELETE FROM term_frequency", args: [] }
+      ],
+      "write"
+    );
+    try {
+      await client.execute({ sql: "PRAGMA wal_checkpoint(TRUNCATE)", args: [] });
+    } catch {
+    }
+    log.i("METADATAOPS", "all_data_cleared");
+  }
+};
+
+// src/storage/libsql/relationship-ops.ts
+var RelationshipOperations = class {
+  constructor(getClient, getContext, rowToRelationship) {
+    this.getClient = getClient;
+    this.getContext = getContext;
+    this.rowToRelationship = rowToRelationship;
+  }
+  tombstoneAdder;
+  tombstoneGetter;
+  /**
+   * Set tombstone delegates for layered branch support.
+   * Must be called after adapter initialization.
+   */
+  setTombstoneDelegates(adder, getter) {
+    this.tombstoneAdder = adder;
+    this.tombstoneGetter = getter;
+  }
+  /**
+   * Insert a single relationship
+   */
+  async insertRelationship(relationship) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.getContext();
+    const now = Date.now();
+    await client.execute({
+      sql: `
+        INSERT OR REPLACE INTO relationships
+        (id, project_hash, branch_name, from_id, to_id, type, metadata, weight, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      args: [
+        relationship.id,
+        projectHash,
+        branchName,
+        relationship.fromId,
+        relationship.toId,
+        relationship.type,
+        relationship.metadata ? JSON.stringify(relationship.metadata) : null,
+        relationship.weight ?? 1,
+        relationship.createdAt ?? now
+      ]
+    });
+  }
+  /**
+   * Insert multiple relationships with batch optimization
+   */
+  async insertRelationships(relationships) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    if (relationships.length === 0) return { processed: 0, failed: 0, errors: [], timeMs: 0 };
+    const start = Date.now();
+    const errors = [];
+    const { projectHash, branchName } = this.getContext();
+    const now = Date.now();
+    const seen = /* @__PURE__ */ new Set();
+    const unique = [];
+    for (const r of relationships) {
+      if (!seen.has(r.id)) {
+        seen.add(r.id);
+        unique.push(r);
+      }
+    }
+    const batchSize = 1e3;
+    let processed = 0;
+    for (let i = 0; i < unique.length; i += batchSize) {
+      const batch = unique.slice(i, i + batchSize);
+      const valuePlaceholders = batch.map(() => "(?, ?, ?, ?, ?, ?, ?, ?, ?)").join(", ");
+      const args = [];
+      for (const r of batch) {
+        args.push(
+          r.id,
+          projectHash,
+          branchName,
+          r.fromId,
+          r.toId,
+          r.type,
+          r.metadata ? JSON.stringify(r.metadata) : null,
+          r.weight ?? 1,
+          r.createdAt ?? now
+        );
+      }
+      const sql = `
+        INSERT OR REPLACE INTO relationships
+        (id, project_hash, branch_name, from_id, to_id, type, metadata, weight, created_at)
+        VALUES ${valuePlaceholders}
+      `;
+      try {
+        await client.execute({ sql, args });
+        processed += batch.length;
+      } catch (error) {
+        errors.push({
+          item: { batchStart: i, batchEnd: i + batch.length },
+          error: error.message
+        });
+      }
+    }
+    return {
+      processed,
+      failed: errors.length,
+      errors,
+      timeMs: Date.now() - start
+    };
+  }
+  /**
+   * Get all relationships for an entity (as source or target) (layered: delta + base - tombstones)
+   */
+  async getRelationshipsForEntity(entityId, type) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    if (!baseBranch) {
+      let sql = `
+        SELECT * FROM relationships
+        WHERE project_hash = ? AND branch_name = ? AND (from_id = ? OR to_id = ?)
+      `;
+      const args = [projectHash, branchName, entityId, entityId];
+      if (type) {
+        sql += " AND type = ?";
+        args.push(type);
+      }
+      const result = await client.execute({ sql, args });
+      return result.rows.map((row) => this.rowToRelationship(row));
+    }
+    const tombstones = this.tombstoneGetter ? await this.tombstoneGetter("relationship") : /* @__PURE__ */ new Set();
+    let deltaSql = `
+      SELECT * FROM relationships
+      WHERE project_hash = ? AND branch_name = ? AND (from_id = ? OR to_id = ?)
+    `;
+    const deltaArgs = [projectHash, branchName, entityId, entityId];
+    if (type) {
+      deltaSql += " AND type = ?";
+      deltaArgs.push(type);
+    }
+    const deltaResult = await client.execute({ sql: deltaSql, args: deltaArgs });
+    const deltaRels = deltaResult.rows.map((row) => this.rowToRelationship(row));
+    const deltaIds = new Set(deltaRels.map((r) => r.id));
+    let baseSql = `
+      SELECT * FROM relationships
+      WHERE project_hash = ? AND branch_name = ? AND (from_id = ? OR to_id = ?)
+    `;
+    const baseArgs = [projectHash, baseBranch, entityId, entityId];
+    if (type) {
+      baseSql += " AND type = ?";
+      baseArgs.push(type);
+    }
+    const baseResult = await client.execute({ sql: baseSql, args: baseArgs });
+    const baseRels = baseResult.rows.map((row) => this.rowToRelationship(row)).filter((r) => !deltaIds.has(r.id) && !tombstones.has(r.id));
+    return [...deltaRels, ...baseRels];
+  }
+  /**
+   * Build filter clause for relationship type
+   */
+  buildTypeFilter(types, args) {
+    if (!types) return "";
+    const typeArray = Array.isArray(types) ? types : [types];
+    args.push(...typeArray);
+    return ` AND type IN (${typeArray.map(() => "?").join(",")})`;
+  }
+  /**
+   * Build type filter for CTE (static SQL, no parameter mutation)
+   */
+  buildTypeFilterForCTE(types) {
+    if (!types) return "";
+    const typeArray = Array.isArray(types) ? types : [types];
+    const quoted = typeArray.map((t) => `'${t}'`).join(",");
+    return `AND type IN (${quoted})`;
+  }
+  /**
+   * Build fromId filter for direct SQL
+   */
+  buildFromIdFilter(fromIds, args) {
+    if (!fromIds) return "";
+    const idArray = Array.isArray(fromIds) ? fromIds : [fromIds];
+    args.push(...idArray);
+    return ` AND from_id IN (${idArray.map(() => "?").join(",")})`;
+  }
+  /**
+   * Build fromId filter for CTE (static SQL)
+   */
+  buildFromIdFilterForCTE(fromIds) {
+    if (!fromIds) return "";
+    const idArray = Array.isArray(fromIds) ? fromIds : [fromIds];
+    const quoted = idArray.map((id) => `'${id}'`).join(",");
+    return `AND from_id IN (${quoted})`;
+  }
+  /**
+   * Build toId filter for direct SQL
+   */
+  buildToIdFilter(toIds, args) {
+    if (!toIds) return "";
+    const idArray = Array.isArray(toIds) ? toIds : [toIds];
+    args.push(...idArray);
+    return ` AND to_id IN (${idArray.map(() => "?").join(",")})`;
+  }
+  /**
+   * Build toId filter for CTE (static SQL)
+   */
+  buildToIdFilterForCTE(toIds) {
+    if (!toIds) return "";
+    const idArray = Array.isArray(toIds) ? toIds : [toIds];
+    const quoted = idArray.map((id) => `'${id}'`).join(",");
+    return `AND to_id IN (${quoted})`;
+  }
+  /**
+   * Find relationships with complex filters (layered: delta + base - tombstones)
+   * Uses CTE for efficient layered queries with proper LIMIT/OFFSET at SQL level
+   */
+  async findRelationships(query) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    const limit = query.limit || 100;
+    const offset = query.offset || 0;
+    if (!baseBranch) {
+      const args = [projectHash, branchName];
+      let sql2 = "SELECT * FROM relationships WHERE project_hash = ? AND branch_name = ?";
+      sql2 += this.buildTypeFilter(query.filters?.relationshipType, args);
+      sql2 += this.buildFromIdFilter(query.filters?.fromId, args);
+      sql2 += this.buildToIdFilter(query.filters?.toId, args);
+      sql2 += " LIMIT ? OFFSET ?";
+      args.push(limit, offset);
+      const result2 = await client.execute({ sql: sql2, args });
+      return result2.rows.map((row) => this.rowToRelationship(row));
+    }
+    const typeFilter = this.buildTypeFilterForCTE(query.filters?.relationshipType);
+    const fromIdFilter = this.buildFromIdFilterForCTE(query.filters?.fromId);
+    const toIdFilter = this.buildToIdFilterForCTE(query.filters?.toId);
+    const combinedFilters = `${typeFilter} ${fromIdFilter} ${toIdFilter}`;
+    const sql = `
+      WITH
+        delta AS (
+          SELECT * FROM relationships
+          WHERE project_hash = ?1 AND branch_name = ?2 ${combinedFilters}
+        ),
+        tombstone_ids AS (
+          SELECT entity_id FROM tombstones
+          WHERE project_hash = ?1 AND branch_name = ?2 AND entity_type = 'relationship'
+        ),
+        base_filtered AS (
+          SELECT * FROM relationships
+          WHERE project_hash = ?1 AND branch_name = ?3 ${combinedFilters}
+            AND id NOT IN (SELECT id FROM delta)
+            AND id NOT IN (SELECT entity_id FROM tombstone_ids)
+        ),
+        layered AS (
+          SELECT * FROM delta
+          UNION ALL
+          SELECT * FROM base_filtered
+        )
+      SELECT * FROM layered
+      LIMIT ?4 OFFSET ?5
+    `;
+    const result = await client.execute({
+      sql,
+      args: [projectHash, branchName, baseBranch, limit, offset]
+    });
+    return result.rows.map((row) => this.rowToRelationship(row));
+  }
+  /**
+   * Delete relationship by ID.
+   * On feature branches with baseBranch set, adds tombstone instead of deleting.
+   */
+  async deleteRelationship(id) {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    if (baseBranch && this.tombstoneAdder) {
+      await this.tombstoneAdder(id, "relationship");
+    }
+    await client.execute({
+      sql: "DELETE FROM relationships WHERE id = ? AND project_hash = ? AND branch_name = ?",
+      args: [id, projectHash, branchName]
+    });
+  }
+  /**
+   * Get ALL relationships efficiently in a single query.
+   * Layered: returns delta + base - tombstones using CTE.
+   */
+  async getAllRelationships() {
+    const client = this.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName, baseBranch } = this.getContext();
+    if (!baseBranch) {
+      const result2 = await client.execute({
+        sql: "SELECT * FROM relationships WHERE project_hash = ? AND branch_name = ?",
+        args: [projectHash, branchName]
+      });
+      return result2.rows.map((row) => this.rowToRelationship(row));
+    }
+    const sql = `
+      WITH
+        delta AS (
+          SELECT * FROM relationships
+          WHERE project_hash = ?1 AND branch_name = ?2
+        ),
+        tombstone_ids AS (
+          SELECT entity_id FROM tombstones
+          WHERE project_hash = ?1 AND branch_name = ?2 AND entity_type = 'relationship'
+        ),
+        base_filtered AS (
+          SELECT * FROM relationships
+          WHERE project_hash = ?1 AND branch_name = ?3
+            AND id NOT IN (SELECT id FROM delta)
+            AND id NOT IN (SELECT entity_id FROM tombstone_ids)
+        )
+      SELECT * FROM delta
+      UNION ALL
+      SELECT * FROM base_filtered
+    `;
+    const result = await client.execute({
+      sql,
+      args: [projectHash, branchName, baseBranch]
+    });
+    return result.rows.map((row) => this.rowToRelationship(row));
+  }
+};
+var requestContextStorage = new AsyncLocalStorage();
+function runWithRequestContext(ctx, fn) {
+  return requestContextStorage.run(ctx, fn);
+}
+function getRequestContext() {
+  return requestContextStorage.getStore();
+}
+
+// src/storage/libsql/vector-ops.ts
+init_logging();
+var VectorOperations = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Insert a single embedding
+   */
+  async insertEmbedding(embedding) {
+    const client = this.ctx.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.ctx.getContext();
+    const dims = this.ctx.getEffectiveDimensions();
+    const colName = this.ctx.getEmbeddingColumnName();
+    const vectorStr = this.ctx.vectorToString(embedding.vector);
+    const metadataBlob = this.ctx.encodeMetadata(embedding.metadata);
+    await client.execute({
+      sql: `
+        INSERT OR REPLACE INTO embeddings
+        (id, project_hash, branch_name, content, dim_size, ${colName}, metadata, created_at)
+        VALUES (?, ?, ?, ?, ?, vector32(?), ?, ?)
+      `,
+      args: [
+        embedding.id,
+        projectHash,
+        branchName,
+        embedding.content,
+        dims,
+        vectorStr,
+        metadataBlob,
+        embedding.createdAt || Date.now()
+      ]
+    });
+    const cacheKey = `${projectHash}:${branchName}:${embedding.id}`;
+    this.ctx.embeddingCache.set(cacheKey, embedding);
+    this.invalidateSearchCache();
+  }
+  /**
+   * @deprecated Use FaissProvider.addBatch() instead. VectorStore v5 uses Faiss directly.
+   */
+  async insertEmbeddingBatch(embeddings) {
+    const client = this.ctx.getClient();
+    if (!client) throw new Error("Client not initialized");
+    if (embeddings.length === 0) return;
+    const { projectHash, branchName } = this.ctx.getContext();
+    const dims = this.ctx.getEffectiveDimensions();
+    const colName = this.ctx.getEmbeddingColumnName();
+    const now = Date.now();
+    const statements = embeddings.map((e) => ({
+      sql: `
+        INSERT OR REPLACE INTO embeddings
+        (id, project_hash, branch_name, content, dim_size, ${colName}, metadata, created_at)
+        VALUES (?, ?, ?, ?, ?, vector32(?), ?, ?)
+      `,
+      args: [
+        e.id,
+        projectHash,
+        branchName,
+        e.content,
+        dims,
+        this.ctx.vectorToString(e.vector),
+        this.ctx.encodeMetadata(e.metadata),
+        e.createdAt || now
+      ]
+    }));
+    const batchSize = 500;
+    const chunks = [];
+    for (let i = 0; i < statements.length; i += batchSize) {
+      chunks.push(statements.slice(i, i + batchSize));
+    }
+    let totalInserted = 0;
+    const batchPromises = chunks.map(async (batch, index) => {
+      if (!batch || batch.length === 0) return 0;
+      try {
+        await client.batch(batch, "write");
+        return batch.length;
+      } catch (error) {
+        log.e("VECTOROPS", `Batch ${index} failed`, { error: error.message });
+        throw error;
+      }
+    });
+    const results = await Promise.all(batchPromises);
+    totalInserted = results.reduce((sum, count) => sum + count, 0);
+    for (const e of embeddings) {
+      const cacheKey = `${projectHash}:${branchName}:${e.id}`;
+      this.ctx.embeddingCache.set(cacheKey, e);
+    }
+    this.invalidateSearchCache();
+    if (totalInserted >= 500) {
+      try {
+        await client.execute("PRAGMA optimize");
+      } catch {
+      }
+      try {
+        await client.execute("PRAGMA wal_checkpoint(TRUNCATE)");
+      } catch {
+      }
+    }
+  }
+  /**
+   * @deprecated Faiss HNSW handles live updates, no need to drop/rebuild.
+   */
+  async dropVectorIndex() {
+    const client = this.ctx.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash } = this.ctx.getContext();
+    const dims = this.ctx.getEffectiveDimensions();
+    const partialIndexName = `idx_emb_${dims}_${projectHash.substring(0, 8)}`;
+    const start = Date.now();
+    log.t("LIBSQLINDEX", `\u25B6 dropVectorIndex START`, { indexName: partialIndexName, projectHash, dims });
+    try {
+      await client.execute(`DROP INDEX IF EXISTS ${partialIndexName}`);
+      log.t("LIBSQLINDEX", `\u25C0 dropVectorIndex END`, { indexName: partialIndexName, ms: Date.now() - start });
+      log.i("LIBSQLINDEX", `Dropped project vector index`, {
+        indexName: partialIndexName,
+        projectHash,
+        dims,
+        ms: Date.now() - start
+      });
+    } catch (error) {
+      log.w("LIBSQLINDEX", `Failed to drop project vector index`, {
+        indexName: partialIndexName,
+        error: error.message
+      });
+    }
+  }
+  /**
+   * @deprecated Faiss HNSW maintains index automatically, no rebuild needed.
+   */
+  async rebuildVectorIndex() {
+    const client = this.ctx.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash } = this.ctx.getContext();
+    const dims = this.ctx.getEffectiveDimensions();
+    const colName = this.ctx.getEmbeddingColumnName();
+    const indexName = `idx_emb_${dims}_${projectHash.substring(0, 8)}`;
+    const start = Date.now();
+    log.w("LIBSQLINDEX", `[REBUILD] START`, { indexName, projectHash, dims });
+    const indexParams = [
+      `'metric=${this.ctx.config.metric}'`,
+      `'compress_neighbors=${this.ctx.config.compression}'`,
+      `'max_neighbors=${this.ctx.config.maxNeighbors}'`,
+      `'search_l=${this.ctx.config.searchL}'`,
+      `'insert_l=${this.ctx.config.insertL}'`
+    ].join(", ");
+    try {
+      await client.execute(`
+        CREATE INDEX IF NOT EXISTS ${indexName}
+        ON embeddings(libsql_vector_idx(${colName}, ${indexParams}))
+        WHERE project_hash = '${projectHash}' AND dim_size = ${dims}
+      `);
+      const elapsed = Date.now() - start;
+      log.w("LIBSQLINDEX", `[REBUILD] END`, { indexName, dims, ms: elapsed });
+      log.i("LIBSQLINDEX", `Rebuilt project vector index`, { indexName, projectHash, dims, ms: elapsed });
+    } catch (error) {
+      log.w("LIBSQLINDEX", `Failed to rebuild project vector index`, {
+        indexName,
+        error: error.message
+      });
+    }
+  }
+  /**
+   * @deprecated Use FaissProvider.addBatch() instead.
+   */
+  async bulkInsertEmbeddings(embeddings) {
+    const client = this.ctx.getClient();
+    if (!client) throw new Error("Client not initialized");
+    if (embeddings.length === 0) return;
+    const start = Date.now();
+    log.i("LIBSQLBULK", `Starting bulk insert`, { count: embeddings.length });
+    await this.dropVectorIndex();
+    const { projectHash, branchName } = this.ctx.getContext();
+    const dims = this.ctx.getEffectiveDimensions();
+    const colName = this.ctx.getEmbeddingColumnName();
+    const now = Date.now();
+    const statements = embeddings.map((e) => ({
+      sql: `
+        INSERT OR REPLACE INTO embeddings
+        (id, project_hash, branch_name, content, dim_size, ${colName}, metadata, created_at)
+        VALUES (?, ?, ?, ?, ?, vector32(?), ?, ?)
+      `,
+      args: [
+        e.id,
+        projectHash,
+        branchName,
+        e.content,
+        dims,
+        this.ctx.vectorToString(e.vector),
+        this.ctx.encodeMetadata(e.metadata),
+        e.createdAt || now
+      ]
+    }));
+    const batchSize = 500;
+    const totalBatches = Math.ceil(statements.length / batchSize);
+    for (let i = 0; i < statements.length; i += batchSize) {
+      const batch = statements.slice(i, i + batchSize);
+      const batchNum = Math.floor(i / batchSize) + 1;
+      log.t("LIBSQLBULK", `  batch ${batchNum}/${totalBatches}`, { size: batch.length });
+      await client.batch(batch, "write");
+    }
+    for (const e of embeddings) {
+      const cacheKey = `${projectHash}:${branchName}:${e.id}`;
+      this.ctx.embeddingCache.set(cacheKey, e);
+    }
+    await this.rebuildVectorIndex();
+    this.invalidateSearchCache();
+    log.i("LIBSQLBULK", `Bulk insert complete`, { count: embeddings.length, ms: Date.now() - start });
+  }
+  /**
+   * Invalidate search cache
+   */
+  invalidateSearchCache() {
+    this.ctx.searchCache.clear();
+  }
+  /**
+   * @deprecated Use FaissProvider.search() instead.
+   */
+  async searchVectors(queryVector, limit) {
+    const client = this.ctx.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.ctx.getContext();
+    const dims = this.ctx.getEffectiveDimensions();
+    const colName = this.ctx.getEmbeddingColumnName();
+    const vectorStr = this.ctx.vectorToString(queryVector);
+    const cacheKey = `${projectHash}:${branchName}:${dims}:${limit}:${Array.from(queryVector.slice(0, 16)).join(",")}`;
+    const cached = this.ctx.searchCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const countResult = await client.execute({
+      sql: `SELECT COUNT(*) as cnt FROM embeddings WHERE project_hash = ? AND branch_name = ? AND dim_size = ?`,
+      args: [projectHash, branchName, dims]
+    });
+    const embeddingCount = countResult.rows[0]?.["cnt"] || 0;
+    if (embeddingCount === 0) {
+      return [];
+    }
+    let result;
+    if (embeddingCount <= 500) {
+      result = await client.execute({
+        sql: `SELECT id, content, metadata, vector_distance_cos(${colName}, vector32(?)) as distance
+            FROM embeddings WHERE project_hash = ? AND branch_name = ? AND dim_size = ?
+            ORDER BY distance ASC LIMIT ?`,
+        args: [vectorStr, projectHash, branchName, dims, limit]
+      });
+    } else {
+      let partialIndexName = await this.getProjectIndexName();
+      if (!partialIndexName) {
+        await this.ctx.ensureProjectVectorIndex();
+        partialIndexName = await this.getProjectIndexName();
+      }
+      if (!partialIndexName) {
+        throw new Error(
+          `Vector index not available for project ${projectHash}. Ensure embeddings are generated first.`
+        );
+      }
+      result = await client.execute({
+        sql: `SELECT t.id, t.content, t.metadata
+            FROM vector_top_k('${partialIndexName}', vector32(?), ?) AS v
+            JOIN embeddings t ON t.rowid = v.id`,
+        args: [vectorStr, limit]
+      });
+    }
+    const results = this.processVectorResults(result, limit);
+    this.ctx.searchCache.set(cacheKey, results);
+    return results;
+  }
+  /**
+   * Get project-specific index name if it exists
+   */
+  async getProjectIndexName() {
+    const client = this.ctx.getClient();
+    if (!client) return null;
+    const dims = this.ctx.getEffectiveDimensions();
+    const { projectHash } = this.ctx.getContext();
+    const indexName = `idx_emb_${dims}_${projectHash.substring(0, 8)}`;
+    const r = await client.execute({
+      sql: `SELECT name FROM sqlite_master WHERE type='index' AND name=?`,
+      args: [indexName]
+    });
+    return r.rows.length > 0 ? indexName : null;
+  }
+  /**
+   * Process vector search results
+   */
+  processVectorResults(result, limit) {
+    const results = [];
+    for (const row of result.rows) {
+      const position = results.length;
+      const estimatedSimilarity = Math.max(0.1, 1 - position * 0.05);
+      const metadata = row["metadata"] ? this.ctx.decodeMetadata(row["metadata"]) : void 0;
+      results.push({
+        id: row["id"],
+        content: row["content"],
+        similarity: estimatedSimilarity,
+        metadata
+      });
+      if (results.length >= limit) break;
+    }
+    return results;
+  }
+  /**
+   * @deprecated Use FaissProvider.getContent() instead.
+   */
+  async getEmbedding(id) {
+    const client = this.ctx.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.ctx.getContext();
+    const colName = this.ctx.getEmbeddingColumnName();
+    const cacheKey = `${projectHash}:${branchName}:${id}`;
+    const cached = this.ctx.embeddingCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const result = await client.execute({
+      sql: `
+        SELECT id, content, vector_extract(${colName}) as vector, metadata, created_at
+        FROM embeddings
+        WHERE id = ? AND project_hash = ? AND branch_name = ?
+      `,
+      args: [id, projectHash, branchName]
+    });
+    if (result.rows.length === 0 || !result.rows[0]) return null;
+    const row = result.rows[0];
+    const metadataRaw = row["metadata"];
+    const metadata = metadataRaw ? this.ctx.decodeMetadata(metadataRaw) : void 0;
+    const embedding = {
+      id: row["id"],
+      content: row["content"],
+      vector: this.ctx.stringToVector(row["vector"]),
+      metadata,
+      createdAt: row["created_at"]
+    };
+    this.ctx.embeddingCache.set(cacheKey, embedding);
+    return embedding;
+  }
+  /**
+   * @deprecated Use FaissProvider.remove() instead.
+   */
+  async deleteEmbedding(id) {
+    const client = this.ctx.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.ctx.getContext();
+    await client.execute({
+      sql: "DELETE FROM embeddings WHERE id = ? AND project_hash = ? AND branch_name = ?",
+      args: [id, projectHash, branchName]
+    });
+    const cacheKey = `${projectHash}:${branchName}:${id}`;
+    this.ctx.embeddingCache.delete(cacheKey);
+    this.invalidateSearchCache();
+  }
+  /**
+   * @deprecated Use FaissProvider.getVectorCount() instead.
+   */
+  async getEmbeddingCount() {
+    const client = this.ctx.getClient();
+    if (!client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.ctx.getContext();
+    log.t("LIBSQL", "[getEmbeddingCount] Executing SQL...", { projectHash, branchName });
+    const result = await client.execute({
+      sql: "SELECT COUNT(*) as cnt FROM embeddings WHERE project_hash = ? AND branch_name = ?",
+      args: [projectHash, branchName]
+    });
+    log.t("LIBSQL", "[getEmbeddingCount] SQL done", { rowCount: result.rows.length });
+    return result.rows[0]?.["cnt"] || 0;
+  }
+  /**
+   * @deprecated Use FaissProvider.getExistingIds() instead.
+   */
+  async getExistingEmbeddingIds(ids) {
+    const client = this.ctx.getClient();
+    if (!client) throw new Error("Client not initialized");
+    if (ids.length === 0) return /* @__PURE__ */ new Set();
+    const { projectHash, branchName } = this.ctx.getContext();
+    if (ids.length > 0 && ids.length <= 100) {
+      log.t("LIBSQL", `getExistingEmbeddingIds context`, { projectHash, branchName, idsCount: ids.length });
+    }
+    const existingIds = /* @__PURE__ */ new Set();
+    const uncachedIds = [];
+    for (const id of ids) {
+      const cacheKey = `${projectHash}:${branchName}:${id}`;
+      if (this.ctx.embeddingCache.has(cacheKey)) {
+        existingIds.add(id);
+      } else {
+        uncachedIds.push(id);
+      }
+    }
+    if (uncachedIds.length === 0) {
+      return existingIds;
+    }
+    const batchSize = 500;
+    for (let i = 0; i < uncachedIds.length; i += batchSize) {
+      const batch = uncachedIds.slice(i, i + batchSize);
+      const placeholders = batch.map(() => "?").join(",");
+      try {
+        const result = await client.execute({
+          sql: `
+            SELECT id FROM embeddings
+            WHERE id IN (${placeholders})
+            AND project_hash = ? AND branch_name = ?
+          `,
+          args: [...batch, projectHash, branchName]
+        });
+        if (i === 0 && batch.length > 0) {
+          log.t("LIBSQL", `getExistingEmbeddingIds SQL result`, {
+            queriedIds: batch.slice(0, 3),
+            foundCount: result.rows.length,
+            foundIds: result.rows.slice(0, 3).map((r) => r["id"])
+          });
+        }
+        for (const row of result.rows) {
+          existingIds.add(row["id"]);
+        }
+      } catch (error) {
+        if (isCorruptionError(error)) {
+          throw new DatabaseCorruptionError("Database corruption detected during embedding ID check", error);
+        }
+        throw error;
+      }
+    }
+    return existingIds;
+  }
+};
+
+// src/storage/libsql-graph-adapter.ts
+var LibSQLGraphAdapter = class {
+  client = null;
+  config;
+  isInitialized = false;
+  dbPath = "";
+  // Current project context (will be set via setProject before use)
+  currentContext = {
+    projectHash: "_unset_",
+    branchName: "_unset_"
+  };
+  // Performance caches
+  embeddingCache;
+  searchCache;
+  metadataCache;
+  // Delegated operations (composition pattern)
+  entityOps;
+  relationshipOps;
+  vectorOps;
+  cacheOps;
+  metadataOps;
+  cooccurrenceOps;
+  generationManager;
+  // Prolly Tree components for versioned graph storage
+  prollyNodeStore = null;
+  prollyTree = null;
+  commitManager = null;
+  branchDiffCache = null;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.embeddingCache = new LRUCache(CACHE_CONFIG.embeddingCache);
+    this.searchCache = new LRUCache(CACHE_CONFIG.searchCache);
+    this.metadataCache = new LRUCache(CACHE_CONFIG.metadataCache);
+    const getClient = () => this.client;
+    const getContext = () => getRequestContext() ?? this.currentContext;
+    this.generationManager = new GenerationManager(getClient, getContext);
+    this.entityOps = new EntityOperations(
+      getClient,
+      getContext,
+      (row) => this.rowToEntity(row),
+      this.generationManager
+    );
+    this.relationshipOps = new RelationshipOperations(
+      getClient,
+      getContext,
+      (row) => this.rowToRelationship(row)
+    );
+    const vectorOpsContext = {
+      getClient,
+      getContext,
+      config: this.config,
+      getEffectiveDimensions: () => this.getEffectiveDimensions(),
+      getEmbeddingColumnName: () => this.getEmbeddingColumnName(),
+      vectorToString: (v) => this.vectorToString(v),
+      stringToVector: (s) => this.stringToVector(s),
+      encodeMetadata: (m) => this.encodeMetadata(m),
+      decodeMetadata: (d) => this.decodeMetadata(d),
+      embeddingCache: this.embeddingCache,
+      searchCache: this.searchCache,
+      ensureProjectVectorIndex: () => this.ensureProjectVectorIndex()
+    };
+    this.vectorOps = new VectorOperations(vectorOpsContext);
+    this.cacheOps = new CacheOperations(getClient, (v) => this.vectorToString(v));
+    this.metadataOps = new MetadataOperations(getClient, getContext);
+    this.cooccurrenceOps = new CooccurrenceOperations(getClient, getContext);
+  }
+  // ===========================================================================
+  // CBOR SERIALIZATION (faster than JSON for binary/metadata)
+  // ===========================================================================
+  encodeMetadata(metadata) {
+    if (!metadata) return null;
+    try {
+      return Buffer.from(cbor.encode(metadata));
+    } catch {
+      return Buffer.from(JSON.stringify(metadata));
+    }
+  }
+  decodeMetadata(data) {
+    if (!data) return void 0;
+    let cacheKey;
+    if (typeof data === "string") {
+      cacheKey = data.length <= 64 ? data : data.slice(0, 64);
+    } else {
+      const slice = data.length <= 48 ? data : data.slice(0, 48);
+      cacheKey = Buffer.from(slice).toString("base64");
+    }
+    const cached = this.metadataCache.get(cacheKey);
+    if (cached) return cached;
+    try {
+      let result;
+      if (typeof data === "string") {
+        result = JSON.parse(data);
+      } else {
+        try {
+          result = cbor.decode(data instanceof Uint8Array ? data : Buffer.from(data));
+        } catch {
+          result = JSON.parse(Buffer.from(data).toString("utf8"));
+        }
+      }
+      this.metadataCache.set(cacheKey, result);
+      return result;
+    } catch {
+      return void 0;
+    }
+  }
+  // ===========================================================================
+  // INITIALIZATION
+  // ===========================================================================
+  async initialize(dbPath, retryAfterCorruption = true) {
+    const startTime = Date.now();
+    log.t("STORAGE", `[LibSQLGraphAdapter] \u25B6 initialize() START at ${dbPath}`);
+    try {
+      this.dbPath = dbPath;
+      log.t("STORAGE", `[LibSQLGraphAdapter] \u25B6 cleanupStaleLocks`);
+      await this.cleanupStaleLocks(dbPath);
+      log.t("STORAGE", `[LibSQLGraphAdapter] \u25C0 cleanupStaleLocks (${Date.now() - startTime}ms)`);
+      log.t("STORAGE", `[LibSQLGraphAdapter] \u25B6 import @libsql/client`);
+      const importStart = Date.now();
+      const { createClient } = await import('@libsql/client');
+      log.t("STORAGE", `[LibSQLGraphAdapter] \u25C0 import @libsql/client (${Date.now() - importStart}ms)`);
+      log.t("STORAGE", `[LibSQLGraphAdapter] \u25B6 createClient`);
+      const clientStart = Date.now();
+      this.client = createClient({
+        url: `file:${dbPath}`
+      });
+      await this.client.execute("SELECT 1");
+      log.t("STORAGE", `[LibSQLGraphAdapter] \u25C0 createClient + verify (${Date.now() - clientStart}ms)`);
+      await this.client.execute("PRAGMA busy_timeout = 5000");
+      await this.client.execute("PRAGMA cache_size = -8192");
+      await this.client.execute("PRAGMA temp_store = MEMORY");
+      await this.client.execute("PRAGMA mmap_size = 0");
+      await this.client.execute("PRAGMA journal_mode = OFF");
+      await this.client.execute("PRAGMA synchronous = OFF");
+      this.quickIntegrityCheck().then(() => log.i("LIBSQLADAPT", "integrity_passed")).catch((err) => log.e("LIBSQLADAPT", "integrity_error", { err: err.message }));
+      log.t("STORAGE", `[LibSQLGraphAdapter] \u25B6 createTables`);
+      const tablesStart = Date.now();
+      await this.createTables();
+      log.t("STORAGE", `[LibSQLGraphAdapter] \u25C0 createTables (${Date.now() - tablesStart}ms)`);
+      await this.migrateFileGen();
+      this.entityOps.setTombstoneDelegates(
+        (id, type) => this.addTombstone(id, type),
+        (type) => this.getTombstonedIds(type)
+      );
+      this.relationshipOps.setTombstoneDelegates(
+        (id, type) => this.addTombstone(id, type),
+        (type) => this.getTombstonedIds(type)
+      );
+      log.t("STORAGE", `[LibSQLGraphAdapter] \u25B6 initProllyComponents`);
+      const prollyStart = Date.now();
+      await this.initializeProllyComponents();
+      log.t("STORAGE", `[LibSQLGraphAdapter] \u25C0 initProllyComponents (${Date.now() - prollyStart}ms)`);
+      this.isInitialized = true;
+      log.t("STORAGE", `[LibSQLGraphAdapter] \u25C0 initialize() END (${Date.now() - startTime}ms)`);
+      log.i("LIBSQLADAPT", "init_complete", { path: dbPath });
+      return true;
+    } catch (error) {
+      const errorMessage = error.message || String(error);
+      const isCorrupted = errorMessage.includes("SQLITE_CORRUPT") || errorMessage.includes("database disk image is malformed") || errorMessage.includes("file is not a database") || errorMessage.includes("database or disk is full");
+      if (isCorrupted && retryAfterCorruption) {
+        log.e("LIBSQLADAPT", "corruption_detected", { err: errorMessage });
+        log.i("LIBSQLADAPT", "recreating_db");
+        if (this.client) {
+          try {
+            this.client.close();
+          } catch {
+          }
+          this.client = null;
+        }
+        const deleted = await this.deleteCorruptDatabase(dbPath);
+        if (deleted) {
+          log.i("LIBSQLADAPT", "corrupt_db_deleted");
+          return this.initialize(dbPath, false);
+        } else {
+          log.e("LIBSQLADAPT", "corrupt_db_delete_fail");
+          return false;
+        }
+      }
+      const isBusy = errorMessage.includes("SQLITE_BUSY") || errorMessage.includes("database is locked");
+      if (isBusy && retryAfterCorruption) {
+        log.w("LIBSQLADAPT", "busy_retry", { err: errorMessage });
+        if (this.client) {
+          try {
+            this.client.close();
+          } catch {
+          }
+          this.client = null;
+        }
+        for (let attempt = 1; attempt <= 3; attempt++) {
+          const delay = attempt * 2e3;
+          log.i("LIBSQLADAPT", "busy_wait", { attempt, delay });
+          await new Promise((r) => setTimeout(r, delay));
+          try {
+            return await this.initialize(dbPath, false);
+          } catch (retryErr) {
+            const retryMsg = retryErr.message || "";
+            if (!retryMsg.includes("SQLITE_BUSY") && !retryMsg.includes("database is locked")) {
+              throw retryErr;
+            }
+            log.w("LIBSQLADAPT", "busy_retry_fail", { attempt, err: retryMsg });
+          }
+        }
+        log.e("LIBSQLADAPT", "busy_exhausted", { retries: 3 });
+        return false;
+      }
+      log.e("LIBSQLADAPT", "init_fail", { err: String(error) });
+      return false;
+    }
+  }
+  /**
+   * Delete corrupt database and all auxiliary files.
+   * Called automatically when SQLITE_CORRUPT is detected.
+   */
+  async deleteCorruptDatabase(dbPath) {
+    const { unlink, stat } = await import('fs/promises');
+    const filesToDelete = [dbPath, `${dbPath}-journal`, `${dbPath}-wal`, `${dbPath}-shm`];
+    let anyDeleted = false;
+    for (const file of filesToDelete) {
+      try {
+        const fileStats = await stat(file);
+        const sizeMB = (fileStats.size / 1024 / 1024).toFixed(1);
+        await unlink(file);
+        log.i("LIBSQLADAPT", "file_deleted", { file, sizeMB });
+        anyDeleted = true;
+      } catch (error) {
+        const err = error;
+        if (err.code !== "ENOENT") {
+          log.w("LIBSQLADAPT", "file_delete_fail", { file, err: err.message });
+        }
+      }
+    }
+    return anyDeleted;
+  }
+  /**
+   * Quick integrity check to detect corruption early.
+   * Probes tables AND indexes to catch DiskANN corruption.
+   * Much faster than full PRAGMA integrity_check.
+   */
+  async quickIntegrityCheck() {
+    if (!this.client) return;
+    const tables = await this.client.execute(`
+      SELECT name FROM sqlite_master WHERE type='table'
+      AND name IN ('entities', 'relationships', 'embeddings', 'files')
+    `);
+    if (tables.rows.length === 0) {
+      return;
+    }
+    const probes = [
+      "SELECT id FROM entities LIMIT 1",
+      "SELECT id FROM relationships LIMIT 1",
+      "SELECT path FROM files LIMIT 1"
+    ];
+    for (const probe of probes) {
+      try {
+        await this.client.execute(probe);
+      } catch (error) {
+        const msg = error.message || "";
+        if (msg.includes("no such table")) continue;
+        throw error;
+      }
+    }
+    const integrityCheck = await this.client.execute("PRAGMA quick_check");
+    const firstRow = integrityCheck.rows[0];
+    const result = firstRow ? String(Object.values(firstRow)[0]) : "ok";
+    if (result !== "ok") {
+      throw new Error(`SQLITE_CORRUPT: quick_check failed: ${result}`);
+    }
+    try {
+      const shadowTables = await this.client.execute(`
+        SELECT name FROM sqlite_master
+        WHERE type='table' AND name LIKE '%shadow%'
+      `);
+      for (const row of shadowTables.rows) {
+        const tableName = row["name"];
+        try {
+          await this.client.execute(`SELECT COUNT(*) FROM "${tableName}"`);
+        } catch (shadowError) {
+          const smsg = shadowError.message || "";
+          log.e("LIBSQLADAPT", "shadow_table_corrupt", { table: tableName, err: smsg });
+          throw shadowError;
+        }
+      }
+      log.i("LIBSQLADAPT", "shadow_tables_ok");
+    } catch (error) {
+      const msg = error.message || "";
+      if (!msg.includes("no such table") && !msg.includes("All shadow")) {
+        throw error;
+      }
+    }
+    log.i("LIBSQLADAPT", "integrity_passed");
+  }
+  /**
+   * Remove stale SQLite lock files before opening database.
+   * Safe in single-user mode where we're the only consumer.
+   */
+  async cleanupStaleLocks(dbPath) {
+    const { unlink } = await import('fs/promises');
+    const lockFiles = [`${dbPath}-journal`, `${dbPath}-wal`, `${dbPath}-shm`];
+    for (const lockFile of lockFiles) {
+      try {
+        await unlink(lockFile);
+        log.i("LIBSQLADAPT", "stale_lock_removed", { file: lockFile });
+      } catch {
+      }
+    }
+  }
+  async createTables() {
+    if (!this.client) throw new Error("Client not initialized");
+    const startTime = Date.now();
+    await this.client.batch(
+      [
+        // Entities table - composite PK ensures isolation between projects/branches
+        `CREATE TABLE IF NOT EXISTS entities (
+        id TEXT NOT NULL,
+        project_hash TEXT NOT NULL DEFAULT 'legacy',
+        branch_name TEXT NOT NULL DEFAULT 'main',
+        name TEXT NOT NULL,
+        type TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        location TEXT NOT NULL,
+        metadata TEXT,
+        hash TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        complexity_score INTEGER DEFAULT 1,
+        language TEXT,
+        size_bytes INTEGER DEFAULT 0,
+        embedding_base64 TEXT,
+        embedding_text TEXT,
+        file_gen INTEGER NOT NULL DEFAULT 1,
+        PRIMARY KEY (id, project_hash, branch_name)
+      )`,
+        // Relationships table - composite PK ensures isolation between projects/branches
+        `CREATE TABLE IF NOT EXISTS relationships (
+        id TEXT NOT NULL,
+        project_hash TEXT NOT NULL DEFAULT 'legacy',
+        branch_name TEXT NOT NULL DEFAULT 'main',
+        from_id TEXT NOT NULL,
+        to_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        metadata TEXT,
+        weight REAL DEFAULT 1.0,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (id, project_hash, branch_name)
+      )`,
+        // Files table
+        `CREATE TABLE IF NOT EXISTS files (
+        path TEXT NOT NULL,
+        project_hash TEXT NOT NULL DEFAULT 'legacy',
+        branch_name TEXT NOT NULL DEFAULT 'main',
+        hash TEXT,
+        last_indexed INTEGER NOT NULL,
+        entity_count INTEGER DEFAULT 0,
+        PRIMARY KEY (path, project_hash, branch_name)
+      )`,
+        // Project metadata table
+        `CREATE TABLE IF NOT EXISTS project_metadata (
+        project_hash TEXT NOT NULL,
+        branch_name TEXT NOT NULL DEFAULT 'main',
+        project_path TEXT NOT NULL,
+        last_indexed_at INTEGER NOT NULL,
+        entity_count INTEGER DEFAULT 0,
+        file_count INTEGER DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        last_full_index_at INTEGER DEFAULT 0,
+        incremental_changes_count INTEGER DEFAULT 0,
+        PRIMARY KEY (project_hash, branch_name)
+      )`,
+        // Query cache table - composite PK for project isolation
+        `CREATE TABLE IF NOT EXISTS query_cache (
+        id TEXT NOT NULL,
+        project_hash TEXT NOT NULL DEFAULT 'legacy',
+        branch_name TEXT NOT NULL DEFAULT 'main',
+        query_hash TEXT NOT NULL,
+        result TEXT NOT NULL,
+        hit_count INTEGER DEFAULT 0,
+        miss_count INTEGER DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL,
+        PRIMARY KEY (id, project_hash, branch_name)
+      )`,
+        // Performance metrics table
+        `CREATE TABLE IF NOT EXISTS performance_metrics (
+        id TEXT PRIMARY KEY,
+        operation TEXT NOT NULL,
+        duration_ms INTEGER NOT NULL,
+        entity_count INTEGER DEFAULT 0,
+        memory_usage INTEGER DEFAULT 0,
+        created_at INTEGER NOT NULL
+      )`,
+        // Tombstones table - tracks deleted entities/relationships on feature branches
+        // When on feature branch, DELETE adds tombstone instead of removing from base
+        // Layered reads exclude tombstoned IDs from base branch results
+        `CREATE TABLE IF NOT EXISTS tombstones (
+        entity_id TEXT NOT NULL,
+        project_hash TEXT NOT NULL,
+        branch_name TEXT NOT NULL,
+        entity_type TEXT NOT NULL DEFAULT 'entity',
+        deleted_at INTEGER NOT NULL,
+        PRIMARY KEY (entity_id, project_hash, branch_name, entity_type)
+      )`,
+        // File generations table — tracks active generation per file for copy-on-write reindex
+        `CREATE TABLE IF NOT EXISTS file_generations (
+        file_path TEXT NOT NULL,
+        project_hash TEXT NOT NULL,
+        branch_name TEXT NOT NULL,
+        active_gen INTEGER NOT NULL DEFAULT 1,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (file_path, project_hash, branch_name)
+      )`,
+        // Name tokens table — enables fast B-tree token lookup instead of LIKE '%pattern%'
+        // splitToTokens("getAuthToken") → ["get", "auth", "token"]
+        `CREATE TABLE IF NOT EXISTS name_tokens (
+        token TEXT NOT NULL,
+        entity_id TEXT NOT NULL,
+        project_hash TEXT NOT NULL,
+        branch_name TEXT NOT NULL,
+        PRIMARY KEY (token, entity_id, project_hash, branch_name)
+      )`,
+        // NOTE: embeddings table REMOVED in v5 - FAISS is used for all vector operations
+        // See: src/semantic/vector-store.ts (v5: Faiss-only backend)
+        // === INDEXES (batched for speed) ===
+        // Entity indexes
+        `CREATE INDEX IF NOT EXISTS idx_entities_project_branch ON entities(project_hash, branch_name)`,
+        `CREATE INDEX IF NOT EXISTS idx_entities_file_path ON entities(file_path, project_hash, branch_name)`,
+        `CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type, project_hash, branch_name)`,
+        `CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name, project_hash, branch_name)`,
+        // Relationship indexes
+        `CREATE INDEX IF NOT EXISTS idx_relationships_project_branch ON relationships(project_hash, branch_name)`,
+        `CREATE INDEX IF NOT EXISTS idx_relationships_from ON relationships(from_id, project_hash, branch_name)`,
+        `CREATE INDEX IF NOT EXISTS idx_relationships_to ON relationships(to_id, project_hash, branch_name)`,
+        // Files index
+        `CREATE INDEX IF NOT EXISTS idx_files_project_branch ON files(project_hash, branch_name)`,
+        // Tombstones index
+        `CREATE INDEX IF NOT EXISTS idx_tombstones_lookup ON tombstones(project_hash, branch_name, entity_type)`,
+        `CREATE INDEX IF NOT EXISTS idx_name_tokens_lookup ON name_tokens(token, project_hash, branch_name)`,
+        // Generation index for efficient filtering by active generation
+        `CREATE INDEX IF NOT EXISTS idx_entities_file_gen ON entities(file_path, project_hash, branch_name, file_gen)`,
+        // Co-occurrence table for query expansion
+        // Stores term pairs that frequently appear together in comments/docs
+        `CREATE TABLE IF NOT EXISTS cooccurrence (
+          term1 TEXT NOT NULL,
+          term2 TEXT NOT NULL,
+          count INTEGER NOT NULL DEFAULT 1,
+          pmi REAL,
+          project_hash TEXT NOT NULL,
+          branch_name TEXT NOT NULL DEFAULT 'main',
+          updated_at INTEGER NOT NULL,
+          PRIMARY KEY (term1, term2, project_hash, branch_name)
+        )`,
+        // Term frequency table for PMI calculation
+        `CREATE TABLE IF NOT EXISTS term_frequency (
+          term TEXT NOT NULL,
+          doc_count INTEGER NOT NULL DEFAULT 1,
+          total_count INTEGER NOT NULL DEFAULT 1,
+          project_hash TEXT NOT NULL,
+          branch_name TEXT NOT NULL DEFAULT 'main',
+          PRIMARY KEY (term, project_hash, branch_name)
+        )`,
+        // Co-occurrence indexes
+        `CREATE INDEX IF NOT EXISTS idx_cooc_term1 ON cooccurrence(term1, project_hash, branch_name)`,
+        `CREATE INDEX IF NOT EXISTS idx_cooc_pmi ON cooccurrence(pmi DESC, project_hash, branch_name)`,
+        `CREATE INDEX IF NOT EXISTS idx_term_freq_project ON term_frequency(project_hash, branch_name)`
+      ],
+      "write"
+    );
+    const batchElapsed = Date.now() - startTime;
+    log.i("STORAGE", `Tables and basic indexes created`, { ms: batchElapsed });
+    log.i("STORAGE", `Skipping global DiskANN index (using partial indexes per project)`);
+    const totalElapsed = Date.now() - startTime;
+    log.i("STORAGE", `Total initialization complete`, { ms: totalElapsed });
+    await this.logDatabaseStats("after_init");
+  }
+  /**
+   * Log database statistics and memory usage for diagnostics.
+   */
+  async logDatabaseStats(label) {
+    if (!this.client) return;
+    try {
+      const pageCount = await this.client.execute("PRAGMA page_count");
+      const pageSize = await this.client.execute("PRAGMA page_size");
+      const cacheSize = await this.client.execute("PRAGMA cache_size");
+      const freelistCount = await this.client.execute("PRAGMA freelist_count");
+      const pages = Number(pageCount.rows[0]?.["page_count"] ?? 0);
+      const size = Number(pageSize.rows[0]?.["page_size"] ?? 4096);
+      const cache = Number(cacheSize.rows[0]?.["cache_size"] ?? 0);
+      const freelist = Number(freelistCount.rows[0]?.["freelist_count"] ?? 0);
+      const dbSizeMB = pages * size / 1024 / 1024;
+      const cacheMB = cache < 0 ? -cache / 1024 : cache * size / 1024 / 1024;
+      log.i("STORAGE", label, {
+        dbSizeMB: dbSizeMB.toFixed(1),
+        pages,
+        pageSize: size,
+        cacheSizeMB: cacheMB.toFixed(1),
+        freelistPages: freelist
+      });
+      const mem = process.memoryUsage();
+      log.i("STORAGE", label, {
+        rssMB: Math.round(mem.rss / 1024 / 1024),
+        heapUsedMB: Math.round(mem.heapUsed / 1024 / 1024),
+        externalMB: Math.round(mem.external / 1024 / 1024),
+        arrayBuffersMB: Math.round(mem.arrayBuffers / 1024 / 1024)
+      });
+    } catch (error) {
+      log.d("STORAGE", "Failed to get stats", { error: error.message });
+    }
+  }
+  /**
+   * Migration: Add file_gen column to entities table if missing.
+   * Also backfills file_generations for existing data.
+   */
+  async migrateFileGen() {
+    if (!this.client) return;
+    try {
+      await this.client.execute("SELECT file_gen FROM entities LIMIT 0");
+      return;
+    } catch {
+    }
+    log.i("LIBSQLADAPT", "migrate_file_gen_start");
+    const start = Date.now();
+    await this.client.execute("ALTER TABLE entities ADD COLUMN file_gen INTEGER NOT NULL DEFAULT 1");
+    await this.client.execute(`
+      INSERT OR IGNORE INTO file_generations (file_path, project_hash, branch_name, active_gen, updated_at)
+      SELECT DISTINCT file_path, project_hash, branch_name, 1, ${Date.now()}
+      FROM entities
+    `);
+    log.i("LIBSQLADAPT", "migrate_file_gen_done", { ms: Date.now() - start });
+  }
+  isReady() {
+    return this.isInitialized && this.client !== null;
+  }
+  getDbPath() {
+    return this.dbPath;
+  }
+  // ===========================================================================
+  // PROJECT CONTEXT
+  // ===========================================================================
+  setProjectContext(context) {
+    this.currentContext = {
+      projectHash: context.projectHash,
+      branchName: normalizeBranchName(context.branchName),
+      baseBranch: context.baseBranch,
+      // For layered reads on feature branches
+      dimensions: context.dimensions
+    };
+    this.generationManager.clearCache();
+    log.d("LIBSQLADAPT", "setProjectContext", {
+      branch: this.currentContext.branchName,
+      base: context.baseBranch || "none"
+    });
+  }
+  getProjectContext() {
+    return { ...this.currentContext };
+  }
+  /**
+   * Get effective dimensions for current project.
+   * Uses project-specific dimensions if set, otherwise global config.
+   */
+  getEffectiveDimensions() {
+    return this.currentContext.dimensions ?? normalizeToSupportedDimension(this.config.dimensions);
+  }
+  /**
+   * Get embedding column name for current project's dimensions.
+   */
+  getEmbeddingColumnName() {
+    return getEmbeddingColumn(this.getEffectiveDimensions());
+  }
+  async ensureProjectVectorIndex() {
+    if (!this.client) return;
+    const { projectHash } = this.currentContext;
+    const dims = this.getEffectiveDimensions();
+    const colName = getEmbeddingColumn(dims);
+    const indexName = `idx_emb_${dims}_${projectHash.substring(0, 8)}`;
+    try {
+      const check = await this.client.execute({
+        sql: `SELECT name FROM sqlite_master WHERE type='index' AND name=?`,
+        args: [indexName]
+      });
+      if (check.rows.length > 0) return;
+      const params = [
+        `'metric=${this.config.metric}'`,
+        `'compress_neighbors=${this.config.compression}'`,
+        `'max_neighbors=${this.config.maxNeighbors}'`,
+        `'search_l=${this.config.searchL}'`,
+        `'insert_l=${this.config.insertL}'`
+      ].join(", ");
+      const t = Date.now();
+      await this.client.execute(
+        `CREATE INDEX IF NOT EXISTS ${indexName} ON embeddings(libsql_vector_idx(${colName}, ${params})) WHERE project_hash = '${projectHash}' AND dim_size = ${dims}`
+      );
+      log.i("STORAGE", `Created partial index`, { indexName, dims, ms: Date.now() - t });
+    } catch (e) {
+      log.w("STORAGE", `Partial index failed`, { error: e.message });
+    }
+  }
+  // ===========================================================================
+  // ENTITY OPERATIONS (delegated to EntityOperations)
+  // ===========================================================================
+  insertEntity = (entity) => this.entityOps.insertEntity(entity);
+  insertEntities = (entities) => this.entityOps.insertEntities(entities);
+  getEntity = (id) => this.entityOps.getEntity(id);
+  getEntitiesBatch = (ids) => this.entityOps.getEntitiesBatch(ids);
+  findEntities(query) {
+    return this.entityOps.findEntities(query);
+  }
+  searchEntities = (options) => this.entityOps.searchEntities(options);
+  searchEntitiesInDirectory = (directoryPath) => this.entityOps.searchEntitiesInDirectory(directoryPath);
+  deleteEntity = (id) => this.entityOps.deleteEntity(id);
+  getEntityIdsByFilePath = (filePath) => this.entityOps.getEntityIdsByFilePath(filePath);
+  deleteEntitiesByFilePath = (filePath) => this.entityOps.deleteEntitiesByFilePath(filePath);
+  getAllEntities = () => this.entityOps.getAllEntities();
+  countByLanguage = () => this.entityOps.countByLanguage();
+  /** Get GenerationManager for GC scheduling */
+  getGenerationManager() {
+    return this.generationManager;
+  }
+  /** Load generation cache (call after setProjectContext) */
+  async loadGenerationCache() {
+    await this.generationManager.loadCache();
+  }
+  // ===========================================================================
+  // RELATIONSHIP OPERATIONS (delegated to RelationshipOperations)
+  // ===========================================================================
+  insertRelationship = (relationship) => this.relationshipOps.insertRelationship(relationship);
+  insertRelationships = (relationships) => this.relationshipOps.insertRelationships(relationships);
+  getRelationshipsForEntity = (entityId, type) => this.relationshipOps.getRelationshipsForEntity(entityId, type);
+  findRelationships = (query) => this.relationshipOps.findRelationships(query);
+  deleteRelationship = (id) => this.relationshipOps.deleteRelationship(id);
+  getAllRelationships = () => this.relationshipOps.getAllRelationships();
+  // ===========================================================================
+  // FILE/METADATA OPERATIONS (delegated to MetadataOperations)
+  // ===========================================================================
+  updateFileInfo = (info) => this.metadataOps.updateFileInfo(info);
+  batchUpdateFileInfo = (infos) => this.metadataOps.batchUpdateFileInfo(infos);
+  getFileInfo = (path) => this.metadataOps.getFileInfo(path);
+  getOutdatedFiles = (since) => this.metadataOps.getOutdatedFiles(since);
+  getAllIndexedFiles = () => this.metadataOps.getAllIndexedFiles();
+  deleteFileInfo = (path) => this.metadataOps.deleteFileInfo(path);
+  // ===========================================================================
+  // VECTOR OPERATIONS (delegated to VectorOperations)
+  // ===========================================================================
+  /** @deprecated Use FaissProvider.add() instead */
+  insertEmbedding = (embedding) => this.vectorOps.insertEmbedding(embedding);
+  /** @deprecated Use FaissProvider.addBatch() instead */
+  insertEmbeddingBatch = (embeddings) => this.vectorOps.insertEmbeddingBatch(embeddings);
+  /** @deprecated Faiss HNSW handles live updates, no need to drop/rebuild */
+  dropVectorIndex = () => this.vectorOps.dropVectorIndex();
+  /** @deprecated Faiss HNSW maintains index automatically, no rebuild needed */
+  rebuildVectorIndex = () => this.vectorOps.rebuildVectorIndex();
+  /** @deprecated Use FaissProvider.addBatch() instead */
+  bulkInsertEmbeddings = (embeddings) => this.vectorOps.bulkInsertEmbeddings(embeddings);
+  /** @deprecated Use FaissProvider.search() instead */
+  searchVectors = (queryVector, limit) => this.vectorOps.searchVectors(queryVector, limit);
+  /** @deprecated Use FaissProvider.getContent() instead */
+  getEmbedding = (id) => this.vectorOps.getEmbedding(id);
+  /** @deprecated Use FaissProvider.remove() instead */
+  deleteEmbedding = (id) => this.vectorOps.deleteEmbedding(id);
+  /** @deprecated Use FaissProvider.getVectorCount() instead */
+  getEmbeddingCount = () => this.vectorOps.getEmbeddingCount();
+  /** @deprecated Use FaissProvider.getExistingIds() instead */
+  getExistingEmbeddingIds = (ids) => this.vectorOps.getExistingEmbeddingIds(ids);
+  // ===========================================================================
+  // EMBEDDING CACHE OPERATIONS (delegated to CacheOperations)
+  // ===========================================================================
+  getEmbeddingFromCache = (contentHash) => this.cacheOps.getEmbeddingFromCache(contentHash);
+  getEmbeddingsFromCache = (contentHashes) => this.cacheOps.getEmbeddingsFromCache(contentHashes);
+  setEmbeddingInCache = (contentHash, model, embedding, textPreview) => this.cacheOps.setEmbeddingInCache(contentHash, model, embedding, textPreview);
+  setEmbeddingsInCache = (entries) => this.cacheOps.setEmbeddingsInCache(entries);
+  // ===========================================================================
+  // METADATA OPERATIONS (delegated to MetadataOperations)
+  // ===========================================================================
+  updateProjectMetadata = (projectPath, isFullIndex) => this.metadataOps.updateProjectMetadata(projectPath, isFullIndex);
+  getIncrementalTrackingInfo = () => this.metadataOps.getIncrementalTrackingInfo();
+  recordIncrementalChanges = (changedFileCount) => this.metadataOps.recordIncrementalChanges(changedFileCount);
+  resetIncrementalTracking = () => this.metadataOps.resetIncrementalTracking();
+  listProjects = () => this.metadataOps.listProjects();
+  listBranches = () => this.metadataOps.listBranches();
+  // ===========================================================================
+  // METRICS & STATS (delegated to MetadataOperations)
+  // ===========================================================================
+  getStats = () => this.metadataOps.getStats();
+  getTotalStats = () => this.metadataOps.getTotalStats();
+  // ===========================================================================
+  // CLEAR OPERATIONS (delegated to MetadataOperations)
+  // ===========================================================================
+  clear = () => this.metadataOps.clear();
+  clearAll = () => this.metadataOps.clearAll();
+  // ===========================================================================
+  // COOCCURRENCE OPERATIONS (for query expansion)
+  // ===========================================================================
+  /**
+   * Get the CooccurrenceOperations instance for query expansion.
+   * Used by CooccurrenceIndex to update/query term pairs.
+   */
+  getCooccurrenceOps() {
+    return this.cooccurrenceOps;
+  }
+  // ===========================================================================
+  // TOMBSTONE OPERATIONS (for layered branch support)
+  // ===========================================================================
+  /**
+   * Add a tombstone for an entity/relationship deleted on feature branch.
+   * This prevents the deleted item from appearing in layered reads from base.
+   */
+  async addTombstone(entityId, entityType = "entity") {
+    if (!this.client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.currentContext;
+    await this.client.execute({
+      sql: `INSERT OR REPLACE INTO tombstones (entity_id, project_hash, branch_name, entity_type, deleted_at)
+            VALUES (?, ?, ?, ?, ?)`,
+      args: [entityId, projectHash, branchName, entityType, Date.now()]
+    });
+  }
+  /**
+   * Remove a tombstone (when entity is re-added on feature branch).
+   */
+  async removeTombstone(entityId, entityType = "entity") {
+    if (!this.client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.currentContext;
+    await this.client.execute({
+      sql: `DELETE FROM tombstones WHERE entity_id = ? AND project_hash = ? AND branch_name = ? AND entity_type = ?`,
+      args: [entityId, projectHash, branchName, entityType]
+    });
+  }
+  /**
+   * Check if an entity is tombstoned on current feature branch.
+   */
+  async isTombstoned(entityId, entityType = "entity") {
+    if (!this.client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.currentContext;
+    const result = await this.client.execute({
+      sql: `SELECT 1 FROM tombstones WHERE entity_id = ? AND project_hash = ? AND branch_name = ? AND entity_type = ? LIMIT 1`,
+      args: [entityId, projectHash, branchName, entityType]
+    });
+    return result.rows.length > 0;
+  }
+  /**
+   * Get all tombstoned entity IDs for current branch (for batch operations).
+   */
+  async getTombstonedIds(entityType = "entity") {
+    if (!this.client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.currentContext;
+    const result = await this.client.execute({
+      sql: `SELECT entity_id FROM tombstones WHERE project_hash = ? AND branch_name = ? AND entity_type = ?`,
+      args: [projectHash, branchName, entityType]
+    });
+    return new Set(result.rows.map((row) => row["entity_id"]));
+  }
+  /**
+   * Clear all tombstones for current branch (used when merging to base).
+   */
+  async clearTombstones() {
+    if (!this.client) throw new Error("Client not initialized");
+    const { projectHash, branchName } = this.currentContext;
+    await this.client.execute({
+      sql: `DELETE FROM tombstones WHERE project_hash = ? AND branch_name = ?`,
+      args: [projectHash, branchName]
+    });
+  }
+  /**
+   * Force flush all pending writes to disk.
+   * With journal_mode=OFF and synchronous=OFF, we need to close/reopen
+   * to ensure OS buffers are flushed.
+   */
+  async flush() {
+    if (!this.client || !this.dbPath) {
+      log.w("LIBSQLADAPT", "flush_skipped", { hasClient: !!this.client, hasDbPath: !!this.dbPath });
+      return;
+    }
+    const startTime = Date.now();
+    log.d("LIBSQLADAPT", "flush_start");
+    this.client.close();
+    this.client = null;
+    const { createClient } = await import('@libsql/client');
+    this.client = createClient({ url: `file:${this.dbPath}` });
+    await this.client.execute("PRAGMA cache_size = -8192");
+    await this.client.execute("PRAGMA temp_store = MEMORY");
+    await this.client.execute("PRAGMA mmap_size = 0");
+    await this.client.execute("PRAGMA journal_mode = OFF");
+    await this.client.execute("PRAGMA synchronous = OFF");
+    if (this.prollyNodeStore) {
+      this.prollyNodeStore.updateClient(this.client);
+    }
+    if (this.commitManager) {
+      this.commitManager.updateClient(this.client);
+    }
+    try {
+      const { statSync: statSync2 } = await import('fs');
+      const stats = statSync2(this.dbPath);
+      log.i("LIBSQLADAPT", "flush_complete", { ms: Date.now() - startTime, sizeBytes: stats.size });
+    } catch {
+      log.i("LIBSQLADAPT", "flush_complete", { ms: Date.now() - startTime, sizeBytes: "unknown" });
+    }
+  }
+  async close() {
+    if (this.client) {
+      this.client.close();
+      this.client = null;
+      this.isInitialized = false;
+      log.i("LIBSQLADAPT", "connection_closed");
+    }
+  }
+  // ===========================================================================
+  // HELPER METHODS
+  // ===========================================================================
+  _langDebugDone = false;
+  rowToEntity(row) {
+    const rawRow = row;
+    if (!this._langDebugDone && rawRow["language"]) {
+      log.w("ADAPTER", "rowToEntity_debug", {
+        hasLang: "language" in row,
+        langVal: row.language,
+        rawLang: String(rawRow["language"])
+      });
+      this._langDebugDone = true;
+    }
+    return {
+      id: row.id,
+      name: row.name,
+      type: row.type,
+      filePath: row.file_path,
+      location: JSON.parse(row.location),
+      metadata: row.metadata ? JSON.parse(row.metadata) : {},
+      hash: row.hash || "",
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      complexityScore: row.complexity_score ?? void 0,
+      language: row.language ?? void 0,
+      sizeBytes: row.size_bytes ?? void 0,
+      embeddingBase64: row.embedding_base64 ?? void 0,
+      embeddingText: row.embedding_text ?? void 0
+    };
+  }
+  rowToRelationship(row) {
+    return {
+      id: row.id,
+      fromId: row.from_id,
+      toId: row.to_id,
+      type: row.type,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      weight: row.weight,
+      createdAt: row.created_at
+    };
+  }
+  vectorToString(vector) {
+    const values = Array.from(vector).map((v) => v.toFixed(6));
+    return `[${values.join(", ")}]`;
+  }
+  stringToVector(str) {
+    const clean = str.replace(/[[\]]/g, "");
+    const values = clean.split(",").map((s) => parseFloat(s.trim()));
+    return new Float32Array(values);
+  }
+  // ===========================================================================
+  // CACHE MANAGEMENT
+  // ===========================================================================
+  /**
+   * Get cache statistics for monitoring
+   */
+  getCacheStats() {
+    return {
+      embedding: {
+        size: this.embeddingCache.size,
+        maxSize: CACHE_CONFIG.embeddingCache.max
+      },
+      search: {
+        size: this.searchCache.size,
+        maxSize: CACHE_CONFIG.searchCache.max
+      },
+      metadata: {
+        size: this.metadataCache.size,
+        maxSize: CACHE_CONFIG.metadataCache.max
+      }
+    };
+  }
+  /**
+   * Clear all caches (useful after bulk operations or project switch)
+   */
+  clearCaches() {
+    this.embeddingCache.clear();
+    this.searchCache.clear();
+    this.metadataCache.clear();
+    log.i("CACHE", `All caches cleared`);
+  }
+  // ===========================================================================
+  // PROLLY TREE OPERATIONS (versioned graph storage)
+  // ===========================================================================
+  /**
+   * Initialize Prolly Tree components for versioned storage.
+   * Called during adapter initialization.
+   */
+  async initializeProllyComponents() {
+    if (!this.client) throw new Error("Client not initialized");
+    this.prollyNodeStore = new ProllyNodeStore();
+    await this.prollyNodeStore.initialize(this.client);
+    this.commitManager = new CommitManager();
+    await this.commitManager.initialize(this.client);
+    this.prollyTree = new ProllyTree(this.prollyNodeStore);
+    await this.prollyTree.initialize();
+    this.branchDiffCache = new BranchDiffCache(this.prollyNodeStore, this.commitManager);
+    log.i("LIBSQLADAPT", "prolly_components_init", { components: 4 });
+  }
+  /**
+   * Set Prolly Tree context for current project/branch.
+   * Should be called after setProjectContext().
+   */
+  setProllyContext(projectHash, branchName) {
+    if (this.commitManager) {
+      this.commitManager.setContext(projectHash, branchName);
+    }
+    log.d("LIBSQLADAPT", "prolly_context_set", { project: projectHash.slice(0, 8), branch: branchName });
+  }
+  /**
+   * Get the Prolly Node Store for content-addressed storage operations.
+   */
+  getProllyNodeStore() {
+    return this.prollyNodeStore;
+  }
+  /**
+   * Get the Prolly Tree for tree operations (build, insert, delete, diff).
+   */
+  getProllyTree() {
+    return this.prollyTree;
+  }
+  /**
+   * Get the Commit Manager for versioning operations.
+   */
+  getCommitManager() {
+    return this.commitManager;
+  }
+  /**
+   * Get the Branch Diff Cache for optimized branch reads.
+   */
+  getBranchDiffCache() {
+    return this.branchDiffCache;
+  }
+  /**
+   * Create a new commit from current graph state.
+   * Builds Prolly tree from entities and creates a versioned snapshot.
+   */
+  async createGraphCommit(message) {
+    if (!this.prollyTree || !this.commitManager) {
+      log.w("LIBSQLADAPT", "prolly_not_ready");
+      return null;
+    }
+    const entities = await this.entityOps.getAllEntities();
+    const relationships = await this.relationshipOps.getAllRelationships();
+    const entries = entities.map((e) => ({
+      key: e.id,
+      value: serializeEntity(e)
+    }));
+    const rootHash = await this.prollyTree.build(entries);
+    const commit = await this.commitManager.commit(
+      rootHash,
+      null,
+      // fileTreeHash - can be set via MerkleFileTracker
+      { entityCount: entities.length, relationshipCount: relationships.length },
+      message
+    );
+    log.i("LIBSQLADAPT", "commit_created", {
+      hash: commit.commitHash.slice(0, 8),
+      entities: entities.length,
+      relationships: relationships.length
+    });
+    return commit.commitHash;
+  }
+  /** Timestamp of last GC run — used to rate-limit pruneAndGC() */
+  lastGcRunAt = 0;
+  /**
+   * Prune old commits for the current branch and garbage-collect orphaned
+   * Prolly Tree nodes.  Rate-limited to run at most once per 10 minutes
+   * unless `force` is true.
+   *
+   * @param keepCommits  Number of most-recent commits to keep per branch.
+   * @param force        Skip the rate-limit check.
+   * @returns Counts of pruned commits and GC-deleted nodes (or null if skipped).
+   */
+  async pruneAndGC(keepCommits = 20, force = false) {
+    if (!this.commitManager || !this.prollyNodeStore) {
+      return null;
+    }
+    const now = Date.now();
+    if (!force && now - this.lastGcRunAt < 10 * 60 * 1e3) {
+      return null;
+    }
+    this.lastGcRunAt = now;
+    const pruned = await this.commitManager.pruneHistory(keepCommits);
+    if (pruned === 0) return { pruned: 0, gcDeleted: 0 };
+    const roots = await this.commitManager.getAllActiveRootHashes();
+    const gcDeleted = await this.prollyNodeStore.collectGarbage([...roots]);
+    if (gcDeleted > 1e3 && this.client) {
+      await this.client.execute("VACUUM");
+      log.i("LIBSQLADAPT", "vacuum_after_gc", { gcDeleted });
+    }
+    log.i("LIBSQLADAPT", "prune_gc_complete", { pruned, gcDeleted });
+    return { pruned, gcDeleted };
+  }
+  /**
+   * Initialize branch diff cache for optimized reads on feature branches.
+   * Call this when switching to a feature branch with a base branch.
+   */
+  async initBranchDiff(baseBranch) {
+    if (!this.branchDiffCache || !this.prollyTree) {
+      log.w("LIBSQLADAPT", "prolly_not_ready_for_diff");
+      return;
+    }
+    const { branchName } = this.currentContext;
+    await this.branchDiffCache.initForBranch(baseBranch, branchName);
+    log.i("LIBSQLADAPT", "branch_diff_init", { branch: branchName, base: baseBranch });
+  }
+  /**
+   * Check if entity is deleted on current branch (via diff cache).
+   * Returns false if diff cache not initialized.
+   */
+  isEntityDeletedOnBranch(entityId) {
+    if (!this.branchDiffCache) return false;
+    return this.branchDiffCache.isDeleted(entityId);
+  }
+};
+
+// src/storage/graph-storage-factory.ts
+var graphStorage = null;
+var libsqlAdapter = null;
+var initializationPromise = null;
+var globalConfig = {
+  dimensions: 768,
+  // granite-278m = 768, all-MiniLM-L6-v2 = 384
+  metric: "cosine",
+  compression: "float8",
+  // float8 = 1 byte/dim, float32 = 4 bytes/dim (4x savings!)
+  searchL: 150,
+  insertL: 30,
+  maxNeighbors: 12
+  // DiskANN neighbors (lower = smaller index)
+};
+function configureGraphStorage(config) {
+  globalConfig = { ...globalConfig, ...config };
+  log.w("FACTORY", `[CONFIG] DiskANN params`, {
+    dims: globalConfig.dimensions,
+    compression: globalConfig.compression,
+    maxNeighbors: globalConfig.maxNeighbors,
+    insertL: globalConfig.insertL
+  });
+}
+async function getGraphStorage() {
+  if (graphStorage && libsqlAdapter?.isReady()) {
+    return graphStorage;
+  }
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+  initializationPromise = (async () => {
+    try {
+      log.i("STORAGEFACT", "creating_singleton");
+      const paths = getGlobalDbPaths();
+      const unifiedDbPath = join(dirname(paths.graphDbPath), "unified-storage.db");
+      const dbDir = dirname(unifiedDbPath);
+      if (!existsSync(dbDir)) {
+        log.i("STORAGEFACT", "creating_dir", { dir: dbDir });
+        mkdirSync(dbDir, { recursive: true });
+      }
+      libsqlAdapter = new LibSQLGraphAdapter(globalConfig);
+      const initialized = await libsqlAdapter.initialize(unifiedDbPath);
+      if (!initialized) {
+        throw new Error("Failed to initialize LibSQL adapter");
+      }
+      graphStorage = new GraphStorageLibSQL(libsqlAdapter);
+      await graphStorage.initialize();
+      log.i("STORAGEFACT", "init_complete", { path: unifiedDbPath });
+      return graphStorage;
+    } catch (error) {
+      initializationPromise = null;
+      const errMsg = error.message || "";
+      const isBusy = errMsg.includes("SQLITE_BUSY") || errMsg.includes("database is locked");
+      if (isBusy) {
+        log.w("STORAGE", `Initialization failed due to database lock (will retry on next access)`, {
+          error: errMsg
+        });
+        throw error;
+      }
+      const paths = getGlobalDbPaths();
+      const unifiedDbPath = join(dirname(paths.graphDbPath), "unified-storage.db");
+      if (existsSync(unifiedDbPath)) {
+        log.w("STORAGE", `Initialization failed, attempting auto-recovery by deleting corrupt DB`, {
+          path: unifiedDbPath,
+          error: errMsg
+        });
+        try {
+          unlinkSync(unifiedDbPath);
+          const walPath = unifiedDbPath + "-wal";
+          const shmPath = unifiedDbPath + "-shm";
+          if (existsSync(walPath)) unlinkSync(walPath);
+          if (existsSync(shmPath)) unlinkSync(shmPath);
+          log.i("STORAGE", `Deleted corrupt DB, will recreate on next access`);
+        } catch (deleteError) {
+          log.e("STORAGE", `Failed to delete corrupt DB`, {
+            error: deleteError.message
+          });
+        }
+      }
+      throw error;
+    }
+  })();
+  return initializationPromise;
+}
+async function initializeGraphStorage() {
+  return getGraphStorage();
+}
+function getLibSQLAdapter() {
+  return libsqlAdapter;
+}
+async function resetGraphStorage() {
+  if (libsqlAdapter) {
+    await libsqlAdapter.close();
+    libsqlAdapter = null;
+  }
+  graphStorage = null;
+  initializationPromise = null;
+  log.i("STORAGEFACT", "storage_reset");
+}
+function setGlobalProjectContext(projectPath, branchName) {
+  if (graphStorage) {
+    const resolvedBranch = branchName ?? getCurrentGitBranchOrDefault(projectPath);
+    graphStorage.setProject(projectPath, resolvedBranch);
+    log.i("STORAGEFACT", "context_set", { path: projectPath, branch: resolvedBranch });
+  } else {
+    log.w("STORAGEFACT", "context_set_fail", { reason: "not initialized" });
+  }
+}
+function isStorageReady() {
+  return graphStorage !== null && libsqlAdapter?.isReady() === true;
+}
+async function handleDatabaseCorruption() {
+  log.e("STORAGEFACT", "corruption_handler_start");
+  const paths = getGlobalDbPaths();
+  const unifiedDbPath = join(dirname(paths.graphDbPath), "unified-storage.db");
+  if (libsqlAdapter) {
+    try {
+      await libsqlAdapter.close();
+    } catch {
+    }
+    libsqlAdapter = null;
+  }
+  graphStorage = null;
+  initializationPromise = null;
+  const filesToDelete = [unifiedDbPath, `${unifiedDbPath}-journal`, `${unifiedDbPath}-wal`, `${unifiedDbPath}-shm`];
+  for (const file of filesToDelete) {
+    try {
+      if (existsSync(file)) {
+        const size = statSync(file).size;
+        const sizeMB = (size / 1024 / 1024).toFixed(1);
+        unlinkSync(file);
+        log.i("STORAGEFACT", "file_deleted", { file, sizeMB });
+      }
+    } catch (error) {
+      log.w("STORAGEFACT", "file_delete_fail", { file, err: error.message });
+    }
+  }
+  try {
+    log.i("STORAGEFACT", "reinit_start");
+    await getGraphStorage();
+    log.i("STORAGEFACT", "reinit_success");
+    return true;
+  } catch (error) {
+    log.e("STORAGEFACT", "reinit_fail", { err: String(error) });
+    return false;
+  }
+}
+function isDatabaseCorruptionError(error) {
+  return error instanceof DatabaseCorruptionError;
+}
+
+export { configureGraphStorage, createProjectContext, getGraphStorage, getLibSQLAdapter, handleDatabaseCorruption, initializeGraphStorage, isDatabaseCorruptionError, isStorageReady, resetGraphStorage, runWithRequestContext, setGlobalProjectContext };
+//# sourceMappingURL=chunk-XFGXM4CR.js.map
+//# sourceMappingURL=chunk-XFGXM4CR.js.map