@zuvia-software-solutions/code-mapper 1.4.0 → 2.0.0

package/dist/mcp/local/local-backend.js

@@ -2,26 +2,19 @@
 /** @file local-backend.ts
  *  @description Tool implementations using local .code-mapper/ indexes
  *  Supports multiple indexed repositories via a global registry
- *  LadybugDB connections are opened lazily per repo on first query */
+ *  SQLite connections are opened lazily per repo on first query */
 import fs from 'fs/promises';
 import path from 'path';
-import fsSync from 'fs';
 import { execFileSync } from 'child_process';
-import Parser from 'tree-sitter';
-import { initLbug, executeQuery, executeParameterized, closeLbug, isLbugReady } from '../core/lbug-adapter.js';
+import { openDb, closeDb, getNode, findNodesByName, findNodesByFile, rawQuery, searchVector, countEmbeddings, searchFTS } from '../../core/db/adapter.js';
+import { toNodeId, assertEdgeType } from '../../core/db/schema.js';
+import * as queries from '../../core/db/queries.js';
+import { refreshFiles, refreshEmbeddings } from '../../core/incremental/refresh.js';
 import { FileSystemWatcher } from '../../core/incremental/watcher.js';
-import { toRelativeFilePath, toRepoRoot } from '../../core/incremental/types.js';
-import { getLanguageFromFilename, getDefinitionNodeFromCaptures } from '../../core/ingestion/utils.js';
-import { loadParser, loadLanguage, isLanguageAvailable } from '../../core/tree-sitter/parser-loader.js';
-import { LANGUAGE_QUERIES } from '../../core/ingestion/tree-sitter-queries.js';
-import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from '../../core/ingestion/constants.js';
-import { generateId } from '../../lib/utils.js';
-import { NODE_TABLES, REL_TABLE_NAME } from '../../core/lbug/schema.js';
-import { FTS_TABLES } from '../../core/search/types.js';
+import { toRepoRoot, toRelativeFilePath } from '../../core/incremental/types.js';
 import { getTsgoService, stopTsgoService } from '../../core/semantic/tsgo-service.js';
-// Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node
-// at MCP server startup — crashes on unsupported Node ABI versions (#89)
-import { listRegisteredRepos, cleanupOldKuzuFiles, } from '../../storage/repo-manager.js';
+import {} from '../../core/search/types.js';
+import { listRegisteredRepos, } from '../../storage/repo-manager.js';
 /** Quick test-file detection for filtering impact results across all supported languages */
 export function isTestFilePath(filePath) {
     const p = filePath.toLowerCase().replace(/\\/g, '/');
@@ -33,7 +26,7 @@ export function isTestFilePath(filePath) {
         p.endsWith('_spec.rb') || p.endsWith('_test.rb') || p.includes('/spec/') ||
         p.includes('/test_') || p.includes('/conftest.'));
 }
-/** Valid LadybugDB node labels for safe Cypher query construction */
+/** Valid node labels for safe query construction */
 export const VALID_NODE_LABELS = new Set([
     'File', 'Folder', 'Function', 'Class', 'Interface', 'Method', 'CodeElement',
     'Community', 'Process', 'Struct', 'Enum', 'Macro', 'Typedef', 'Union',
@@ -42,11 +35,11 @@ export const VALID_NODE_LABELS = new Set([
 ]);
 /** Valid relation types for impact analysis filtering */
 export const VALID_RELATION_TYPES = new Set(['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'DEPENDS_ON', 'PROVIDES']);
-/** Regex to detect write operations in user-supplied Cypher queries */
-export const CYPHER_WRITE_RE = /\b(CREATE|DELETE|SET|MERGE|REMOVE|DROP|ALTER|COPY|DETACH)\b/i;
-/** Check if a Cypher query contains write operations */
+/** Regex to detect write operations in user-supplied SQL queries */
+export const SQL_WRITE_RE = /\b(INSERT|UPDATE|DELETE|DROP|ALTER|CREATE\s+TABLE|CREATE\s+INDEX|REPLACE\s+INTO)\b/i;
+/** Check if a SQL query contains write operations */
 export function isWriteQuery(query) {
-    return CYPHER_WRITE_RE.test(query);
+    return SQL_WRITE_RE.test(query);
 }
 /** Structured error logging for query failures — replaces empty catch blocks */
 function logQueryError(context, err) {
@@ -56,15 +49,39 @@ function logQueryError(context, err) {
 export class LocalBackend {
     repos = new Map();
     contextCache = new Map();
-    initializedRepos = new Set();
     watchers = new Map();
     /** Per-repo promise chain that serializes ensureFresh calls.
      *  Prevents race: Call 2 skipping refresh while Call 1 is still writing. */
     refreshLocks = new Map();
+    /** Per-repo tsgo LSP service instances for live semantic enrichment */
+    tsgoServices = new Map();
+    /** Get (or lazily start) a tsgo LSP service for a repo. Returns null if unavailable. */
+    async getTsgo(repo) {
+        const existing = this.tsgoServices.get(repo.id);
+        if (existing?.isReady())
+            return existing;
+        try {
+            const service = getTsgoService(repo.repoPath);
+            if (await service.start()) {
+                this.tsgoServices.set(repo.id, service);
+                return service;
+            }
+        }
+        catch {
+            // tsgo not available — completely fine, graph-only mode
+        }
+        return null;
+    }
+    /** Get (or lazily open) the SQLite database for a repo. */
+    getDb(repoId) {
+        const handle = this.repos.get(repoId);
+        if (!handle)
+            throw new Error(`Unknown repo: ${repoId}`);
+        const dbPath = path.join(handle.storagePath, 'index.db');
+        return openDb(dbPath);
+    }
     /** Hard ceiling — beyond this, incremental is unreliable, warn prominently */
     static MAX_INCREMENTAL_FILES = 200;
-    /** Optional tsgo LSP service for confidence-1.0 semantic resolution */
-    tsgoEnabled = false;
     /** Start file system watcher for a repo to detect source changes */
     startWatcher(repoId, handle) {
         if (this.watchers.has(repoId))
@@ -152,8 +169,6 @@ export class LocalBackend {
         const watcher = this.watchers.get(repo.id);
         if (!watcher)
             return;
-        // Flush pending debounce timers — edits within the 500ms window become
-        // visible immediately so no tool call can miss a recent save
         await watcher.flush();
         if (!watcher.hasDirtyFiles())
             return;
@@ -162,463 +177,45 @@ export class LocalBackend {
             return;
         const dirtyFiles = [...dirtyMap.values()];
         const totalChanged = dirtyFiles.length;
-        // Hard ceiling — incremental is unreliable for huge diffs (branch switch, etc.)
         if (totalChanged > LocalBackend.MAX_INCREMENTAL_FILES) {
-            // Re-inject so the files aren't lost; user must run full analyze
             watcher.inject(dirtyFiles);
             console.error(`Code Mapper: ${totalChanged} files changed — exceeds incremental limit (${LocalBackend.MAX_INCREMENTAL_FILES}), run: code-mapper analyze`);
-            // Don't silently serve stale — the staleness warning from getStalenessWarning
-            // will flag the tool response since git HEAD will differ from meta.lastCommit
             return;
         }
         try {
-            // In-process incremental refresh — uses the existing read-write connection
-            // pool directly. No child process fork needed, no lock conflicts.
-            await this.ensureInitialized(repo.id);
             const result = await this.inProcessRefresh(repo, dirtyFiles);
             console.error(`Code Mapper: Refreshed ${result.filesProcessed} file(s) in ${result.durationMs}ms (${result.nodesInserted} nodes, ${result.edgesInserted} edges)`);
-            // Incremental embedding refresh — keep embeddings in sync with the graph
-            await this.refreshEmbeddings(repo, dirtyFiles);
+            const db = this.getDb(repo.id);
+            const hasEmb = (repo.stats?.embeddings ?? 0) > 0;
+            await refreshEmbeddings(db, dirtyFiles, hasEmb);
         }
         catch (err) {
-            // Re-inject dirty files so the next tool call retries them
             watcher.inject(dirtyFiles);
             console.error(`Code Mapper: Incremental refresh failed (will retry next call): ${err instanceof Error ? err.message : err}`);
         }
     }
     /**
-     * Tables that are global metadata — NOT deleted per-file during incremental refresh.
-     */
-    static SKIP_DELETE_TABLES = new Set(['Community', 'Process']);
-    /** Tables requiring backtick-quoting in Cypher (reserved words) */
-    static BACKTICK_TABLES = new Set([
-        'Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl',
-        'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation',
-        'Constructor', 'Template', 'Module',
-    ]);
-    static quoteTable(table) {
-        return LocalBackend.BACKTICK_TABLES.has(table) ? `\`${table}\`` : table;
-    }
-    static escapeCypher(value) {
-        return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-    }
-    /**
-     * In-process incremental refresh — parses dirty files with tree-sitter and
-     * writes directly to the DB through the existing connection pool.
-     *
-     * This avoids the LadybugDB lock conflict that prevented the child-process
-     * approach from working: LadybugDB on macOS holds an exclusive file lock
-     * even for read-only connections, and db.close() segfaults via N-API.
+     * In-process incremental refresh — delegates to the shared refreshFiles module.
      */
     async inProcessRefresh(repo, dirtyFiles) {
-        const t0 = Date.now();
-        const esc = LocalBackend.escapeCypher;
-        const qt = LocalBackend.quoteTable;
-        let nodesDeleted = 0;
-        let nodesInserted = 0;
-        let edgesInserted = 0;
-        let filesSkipped = 0;
-        // Phase 1: Delete old nodes for all dirty files
-        for (const entry of dirtyFiles) {
-            const escaped = esc(entry.relativePath);
-            for (const table of NODE_TABLES) {
-                if (LocalBackend.SKIP_DELETE_TABLES.has(table))
-                    continue;
-                try {
-                    await executeQuery(repo.id, `MATCH (n:${qt(table)}) WHERE n.filePath = '${escaped}' DETACH DELETE n`);
-                    nodesDeleted++;
-                }
-                catch (err) {
-                    console.error(`Code Mapper: [refresh] DELETE ${table} for ${entry.relativePath}: ${err instanceof Error ? err.message : err}`);
-                }
-            }
-        }
-        // Phase 2: Parse modified/created files with tree-sitter
-        const parser = await loadParser();
-        const filesToProcess = dirtyFiles.filter(f => f.changeKind === 'modified' || f.changeKind === 'created');
-        const allDefinitions = [];
-        const callSites = [];
-        const insertedFilePaths = new Set();
-        for (const entry of filesToProcess) {
-            const relPath = entry.relativePath;
-            const absPath = path.resolve(repo.repoPath, relPath);
-            const language = getLanguageFromFilename(relPath);
-            if (!language || !isLanguageAvailable(language)) {
-                filesSkipped++;
-                continue;
-            }
-            let content;
-            try {
-                content = fsSync.readFileSync(absPath, 'utf-8');
-            }
-            catch {
-                filesSkipped++;
-                continue;
-            }
-            if (content.length > TREE_SITTER_MAX_BUFFER) {
-                filesSkipped++;
-                continue;
-            }
-            try {
-                await loadLanguage(language, relPath);
-            }
-            catch {
-                filesSkipped++;
-                continue;
-            }
-            let tree;
-            try {
-                tree = parser.parse(content, undefined, { bufferSize: getTreeSitterBufferSize(content.length) });
-            }
-            catch {
-                filesSkipped++;
-                continue;
-            }
-            const queryString = LANGUAGE_QUERIES[language];
-            if (!queryString) {
-                filesSkipped++;
-                continue;
-            }
-            let matches;
-            try {
-                const tsLang = parser.getLanguage();
-                const query = new Parser.Query(tsLang, queryString);
-                matches = query.matches(tree.rootNode);
-            }
-            catch {
-                filesSkipped++;
-                continue;
-            }
-            insertedFilePaths.add(relPath);
-            for (const match of matches) {
-                const captureMap = {};
-                for (const c of match.captures)
-                    captureMap[c.name] = c.node;
-                // Skip imports/heritage captures — only extract definitions and calls
-                if (captureMap['import'] || captureMap['import.source'])
-                    continue;
-                if (captureMap['heritage'] || captureMap['heritage.impl'])
-                    continue;
-                // Collect call sites for tsgo resolution
-                if (captureMap['call'] || captureMap['call.name']) {
-                    const callNameNode = captureMap['call.name'];
-                    if (callNameNode) {
-                        callSites.push({
-                            filePath: relPath,
-                            absPath: absPath,
-                            name: callNameNode.text,
-                            line: callNameNode.startPosition.row,
-                            character: callNameNode.startPosition.column,
-                        });
-                    }
-                    continue;
-                }
-                const nameNode = captureMap['name'];
-                if (!nameNode && !captureMap['definition.constructor'])
-                    continue;
-                const nodeName = nameNode ? nameNode.text : 'init';
-                let nodeLabel = 'CodeElement';
-                if (captureMap['definition.function'])
-                    nodeLabel = 'Function';
-                else if (captureMap['definition.class'])
-                    nodeLabel = 'Class';
-                else if (captureMap['definition.interface'])
-                    nodeLabel = 'Interface';
-                else if (captureMap['definition.method'])
-                    nodeLabel = 'Method';
-                else if (captureMap['definition.struct'])
-                    nodeLabel = 'Struct';
-                else if (captureMap['definition.enum'])
-                    nodeLabel = 'Enum';
-                else if (captureMap['definition.namespace'])
-                    nodeLabel = 'Namespace';
-                else if (captureMap['definition.module'])
-                    nodeLabel = 'Module';
-                else if (captureMap['definition.trait'])
-                    nodeLabel = 'Trait';
-                else if (captureMap['definition.impl'])
-                    nodeLabel = 'Impl';
-                else if (captureMap['definition.type'])
-                    nodeLabel = 'TypeAlias';
-                else if (captureMap['definition.const'])
-                    nodeLabel = 'Const';
-                else if (captureMap['definition.static'])
-                    nodeLabel = 'Static';
-                else if (captureMap['definition.typedef'])
-                    nodeLabel = 'Typedef';
-                else if (captureMap['definition.macro'])
-                    nodeLabel = 'Macro';
-                else if (captureMap['definition.union'])
-                    nodeLabel = 'Union';
-                else if (captureMap['definition.property'])
-                    nodeLabel = 'Property';
-                else if (captureMap['definition.record'])
-                    nodeLabel = 'Record';
-                else if (captureMap['definition.delegate'])
-                    nodeLabel = 'Delegate';
-                else if (captureMap['definition.annotation'])
-                    nodeLabel = 'Annotation';
-                else if (captureMap['definition.constructor'])
-                    nodeLabel = 'Constructor';
-                else if (captureMap['definition.template'])
-                    nodeLabel = 'Template';
-                const defNode = getDefinitionNodeFromCaptures(captureMap);
-                const startLine = defNode ? defNode.startPosition.row : (nameNode ? nameNode.startPosition.row : 0);
-                const endLine = defNode ? defNode.endPosition.row : startLine;
-                const nodeContent = defNode ? (defNode.text || '').slice(0, 50_000) : '';
-                allDefinitions.push({
-                    nodeId: generateId(nodeLabel, `${relPath}:${nodeName}`),
-                    name: nodeName,
-                    label: nodeLabel,
-                    filePath: relPath,
-                    startLine,
-                    endLine,
-                    content: nodeContent,
-                });
-            }
-        }
-        // Phase 3: Insert File nodes + symbol nodes
-        for (const filePath of insertedFilePaths) {
-            const fileId = generateId('File', filePath);
-            try {
-                await executeQuery(repo.id, `CREATE (n:File {id: '${esc(fileId)}', name: '${esc(path.basename(filePath))}', filePath: '${esc(filePath)}', content: ''})`);
-                nodesInserted++;
-            }
-            catch (err) {
-                console.error(`Code Mapper: [refresh] CREATE File ${filePath}: ${err instanceof Error ? err.message : err}`);
-            }
-        }
-        for (const def of allDefinitions) {
-            try {
-                await executeQuery(repo.id, `CREATE (n:${qt(def.label)} {id: '${esc(def.nodeId)}', name: '${esc(def.name)}', filePath: '${esc(def.filePath)}', startLine: ${def.startLine}, endLine: ${def.endLine}, content: '${esc(def.content)}', description: ''})`);
-                nodesInserted++;
-            }
-            catch (err) {
-                console.error(`Code Mapper: [refresh] CREATE ${def.label} ${def.name}: ${err instanceof Error ? err.message : err}`);
-            }
-            const fileId = generateId('File', def.filePath);
-            try {
-                await executeQuery(repo.id, `MATCH (a:File), (b:${qt(def.label)}) WHERE a.id = '${esc(fileId)}' AND b.id = '${esc(def.nodeId)}' CREATE (a)-[:${REL_TABLE_NAME} {type: 'DEFINES', confidence: 1.0, reason: '', step: 0}]->(b)`);
-                edgesInserted++;
-            }
-            catch (err) {
-                console.error(`Code Mapper: [refresh] CREATE DEFINES edge for ${def.name}: ${err instanceof Error ? err.message : err}`);
-            }
-        }
-        // Phase 4: Resolve call edges via tsgo (if enabled)
-        if (this.tsgoEnabled && callSites.length > 0) {
-            const tsgo = getTsgoService(repo.repoPath);
-            if (await tsgo.start()) {
-                // Notify tsgo about changed files so it has fresh state
-                for (const entry of filesToProcess) {
-                    const absPath = path.resolve(repo.repoPath, entry.relativePath);
-                    await tsgo.notifyFileChanged(absPath);
-                }
-                let tsgoResolved = 0;
-                for (const call of callSites) {
-                    try {
-                        const def = await tsgo.resolveDefinition(call.absPath, call.line, call.character);
-                        if (!def)
-                            continue;
-                        // Find the target node in the DB by file path + name match
-                        const targetRows = await executeQuery(repo.id, `MATCH (n) WHERE n.filePath = '${esc(def.filePath)}' AND n.startLine <= ${def.line} AND n.endLine >= ${def.line} RETURN n.id AS id LIMIT 1`);
-                        if (targetRows.length === 0)
-                            continue;
-                        const targetId = String(targetRows[0].id ?? '');
-                        if (!targetId)
-                            continue;
-                        // Find the caller node (the function/method containing this call site)
-                        const callerRows = await executeQuery(repo.id, `MATCH (n) WHERE n.filePath = '${esc(call.filePath)}' AND n.startLine <= ${call.line} AND n.endLine >= ${call.line} AND NOT n:File RETURN n.id AS id LIMIT 1`);
-                        const callerId = callerRows.length > 0
-                            ? String(callerRows[0].id ?? '')
-                            : generateId('File', call.filePath);
-                        if (callerId === targetId)
-                            continue; // self-call
-                        try {
-                            await executeQuery(repo.id, `MATCH (a), (b) WHERE a.id = '${esc(callerId)}' AND b.id = '${esc(targetId)}' CREATE (a)-[:${REL_TABLE_NAME} {type: 'CALLS', confidence: 1.0, reason: 'tsgo-semantic', step: 0}]->(b)`);
-                            edgesInserted++;
-                            tsgoResolved++;
-                        }
-                        catch { /* duplicate edge */ }
-                    }
-                    catch { /* resolution failed for this call */ }
-                }
-                if (tsgoResolved > 0) {
-                    console.error(`Code Mapper: tsgo resolved ${tsgoResolved}/${callSites.length} call(s) at confidence 1.0`);
-                }
-            }
-        }
-        // Phase 5: Rebuild FTS indexes
-        for (const { table, index } of FTS_TABLES) {
-            try {
-                await executeQuery(repo.id, `CALL DROP_FTS_INDEX('${table}', '${index}')`);
-            }
-            catch { /* may not exist */ }
-            try {
-                await executeQuery(repo.id, `CALL CREATE_FTS_INDEX('${table}', '${index}', ['name', 'content'], stemmer := 'porter')`);
-            }
-            catch { /* non-fatal */ }
-        }
-        return {
-            filesProcessed: filesToProcess.length,
-            filesSkipped,
-            nodesDeleted,
-            nodesInserted,
-            edgesInserted,
-            durationMs: Date.now() - t0,
-        };
-    }
-    /**
-     * Update CodeEmbedding rows for dirty files so semantic search is never stale.
-     *
-     * Runs ONLY when the repo previously had embeddings (stats.embeddings > 0).
-     * Steps:
-     *   1. Delete stale CodeEmbedding rows for all dirty file paths (always)
-     *   2. Query new embeddable nodes for modified/created files
-     *   3. Generate text → batch embed using the warm MCP singleton model
-     *   4. Insert new CodeEmbedding rows
-     *   5. Drop + recreate HNSW vector index
-     *
-     * If the embedding model fails to load, stale rows are still deleted —
-     * semantic search returns fewer results but never wrong ones.
-     */
-    async refreshEmbeddings(repo, dirtyFiles) {
-        if (!repo.stats?.embeddings || repo.stats.embeddings === 0)
-            return;
-        if (dirtyFiles.length === 0)
-            return;
-        const esc = LocalBackend.escapeCypher;
-        const dirtyRelPaths = dirtyFiles.map((f) => f.relativePath);
-        try {
-            // Step 1: Delete stale embeddings for all dirty files
-            for (const relPath of dirtyRelPaths) {
-                try {
-                    const rows = await executeQuery(repo.id, `MATCH (n) WHERE n.filePath = '${esc(relPath)}' RETURN n.id AS id`);
-                    for (const row of rows) {
-                        const nodeId = String(row.id ?? '');
-                        if (!nodeId)
-                            continue;
-                        try {
-                            await executeQuery(repo.id, `MATCH (e:CodeEmbedding) WHERE e.nodeId = '${esc(nodeId)}' DETACH DELETE e`);
-                        }
-                        catch { /* row may not exist */ }
-                    }
-                }
-                catch { /* file may not have nodes */ }
-            }
-            // Step 2: Query new embeddable nodes
-            const embeddableLabels = ['Function', 'Class', 'Method', 'Interface', 'File'];
-            const modifiedPaths = dirtyFiles
-                .filter((f) => f.changeKind === 'modified' || f.changeKind === 'created')
-                .map((f) => f.relativePath);
-            if (modifiedPaths.length === 0) {
-                await this.rebuildVectorIndex(repo.id);
-                return;
-            }
-            const newNodes = [];
-            for (const relPath of modifiedPaths) {
-                for (const label of embeddableLabels) {
-                    try {
-                        const q = label === 'File'
-                            ? `MATCH (n:File) WHERE n.filePath = '${esc(relPath)}' RETURN n.id AS id, n.name AS name, 'File' AS label, n.filePath AS filePath, n.content AS content`
-                            : `MATCH (n:${label}) WHERE n.filePath = '${esc(relPath)}' RETURN n.id AS id, n.name AS name, '${label}' AS label, n.filePath AS filePath, n.content AS content, n.startLine AS startLine, n.endLine AS endLine`;
-                        const rows = await executeQuery(repo.id, q);
-                        for (const row of rows) {
-                            const r = row;
-                            newNodes.push({
-                                id: String(r.id ?? ''), name: String(r.name ?? ''), label: String(r.label ?? label),
-                                filePath: String(r.filePath ?? ''), content: String(r.content ?? ''),
-                                startLine: r.startLine != null ? Number(r.startLine) : undefined,
-                                endLine: r.endLine != null ? Number(r.endLine) : undefined,
-                            });
-                        }
-                    }
-                    catch { /* table may not exist */ }
-                }
-            }
-            // Step 3: Embed + insert
-            if (newNodes.length > 0) {
-                try {
-                    const { generateEmbeddingText } = await import('../../core/embeddings/text-generator.js');
-                    const { embedBatch } = await import('../core/embedder.js');
-                    const texts = newNodes.map((node) => generateEmbeddingText(node));
-                    const embeddings = await embedBatch(texts);
-                    for (let i = 0; i < newNodes.length; i++) {
-                        const vecStr = `[${embeddings[i].join(',')}]`;
-                        try {
-                            await executeQuery(repo.id, `CREATE (e:CodeEmbedding {nodeId: '${esc(newNodes[i].id)}', embedding: CAST(${vecStr} AS FLOAT[256])})`);
-                        }
-                        catch { /* duplicate */ }
-                    }
-                    console.error(`Code Mapper: Embedded ${newNodes.length} node(s) incrementally`);
-                }
-                catch (err) {
-                    console.error(`Code Mapper: Incremental embedding failed (stale entries removed): ${err instanceof Error ? err.message : err}`);
-                }
-            }
-            // Step 4: Rebuild vector index
-            await this.rebuildVectorIndex(repo.id);
-        }
-        catch (err) {
-            console.error(`Code Mapper: Embedding refresh failed: ${err instanceof Error ? err.message : err}`);
-        }
-    }
-    async rebuildVectorIndex(repoId) {
-        try {
-            await executeQuery(repoId, 'INSTALL VECTOR');
-        }
-        catch { }
-        try {
-            await executeQuery(repoId, 'LOAD EXTENSION VECTOR');
-        }
-        catch { }
-        try {
-            await executeQuery(repoId, `CALL DROP_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx')`);
-        }
-        catch { }
-        try {
-            const rows = await executeQuery(repoId, `MATCH (e:CodeEmbedding) RETURN COUNT(*) AS cnt`);
-            const cnt = Number(rows[0]?.cnt ?? 0);
-            if (cnt === 0)
-                return;
-        }
-        catch {
-            return;
-        }
-        try {
-            await executeQuery(repoId, `CALL CREATE_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 'embedding', metric := 'cosine')`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : '';
-            if (!msg.includes('already exists')) {
-                console.error(`Code Mapper: Vector index rebuild failed: ${msg}`);
-            }
-        }
+        const db = this.getDb(repo.id);
+        return refreshFiles(db, repo.repoPath, dirtyFiles);
     }
     // Initialization
-    /**
-     * Initialize from the global registry, returns true if at least one repo is available.
-     * @param opts.tsgo — Enable tsgo semantic resolution (confidence-1.0 call edges)
-     */
-    async init(opts) {
-        this.tsgoEnabled = opts?.tsgo ?? false;
+    /** Initialize from the global registry, returns true if at least one repo is available */
+    async init() {
         await this.refreshRepos();
         // Start file watchers for incremental refresh
         for (const [id, handle] of this.repos) {
             this.startWatcher(id, handle);
             // Seed watcher with changes that happened while the server was down
             this.seedWatcherFromGit(id, handle);
-            // Start tsgo LSP for semantic resolution (optional, non-blocking)
-            if (this.tsgoEnabled) {
-                const svc = getTsgoService(handle.repoPath);
-                svc.start().catch(() => { }); // warm up in background
-            }
         }
         return this.repos.size > 0;
     }
     /**
      * Re-read the global registry and update the in-memory repo map
-     * LadybugDB connections for removed repos idle-timeout naturally
+     * SQLite connections for removed repos are cleaned up on prune
      */
     async refreshRepos() {
         const entries = await listRegisteredRepos({ validate: true });
@@ -627,25 +224,17 @@ export class LocalBackend {
             const id = this.repoId(entry.name, entry.path);
             freshIds.add(id);
             const storagePath = entry.storagePath;
-            const lbugPath = path.join(storagePath, 'lbug');
-            // Clean up leftover KuzuDB files from before the LadybugDB migration
-            // Warn if kuzu exists but lbug doesn't (re-analyze needed)
-            const kuzu = await cleanupOldKuzuFiles(storagePath);
-            if (kuzu.found && kuzu.needsReindex) {
-                console.error(`Code Mapper: "${entry.name}" has a stale KuzuDB index. Run: code-mapper analyze ${entry.path}`);
-            }
             const handle = {
                 id,
                 name: entry.name,
                 repoPath: entry.path,
                 storagePath,
-                lbugPath,
                 indexedAt: entry.indexedAt,
                 lastCommit: entry.lastCommit,
                 stats: entry.stats,
             };
             this.repos.set(id, handle);
-            // Build lightweight context (no LadybugDB needed)
+            // Build lightweight context from registry stats
             const s = entry.stats || {};
             this.contextCache.set(id, {
                 projectName: entry.name,
@@ -662,7 +251,6 @@ export class LocalBackend {
             if (!freshIds.has(id)) {
                 this.repos.delete(id);
                 this.contextCache.delete(id);
-                this.initializedRepos.delete(id);
             }
         }
     }
@@ -736,23 +324,9 @@ export class LocalBackend {
         }
         return null; // Multiple repos, no param — ambiguous
     }
-    // Lazy LadybugDB Init
+    // Lazy DB Init
     async ensureInitialized(repoId) {
-        // Always check the actual pool — the idle timer may have evicted the connection
-        if (this.initializedRepos.has(repoId) && isLbugReady(repoId))
-            return;
-        const handle = this.repos.get(repoId);
-        if (!handle)
-            throw new Error(`Unknown repo: ${repoId}`);
-        try {
-            await initLbug(repoId, handle.lbugPath);
-            this.initializedRepos.add(repoId);
-        }
-        catch (err) {
-            // If lock error, mark as not initialized so next call retries
-            this.initializedRepos.delete(repoId);
-            throw err;
-        }
+        this.getDb(repoId); // openDb is idempotent
     }
     // Public Getters
     /** Get context for a specific repo (or the single repo if only one) */
@@ -776,22 +350,48 @@ export class LocalBackend {
             stats: h.stats,
         }));
     }
+    /** Find the narrowest symbol node enclosing a given file position (for tsgo ref merging) */
+    findNodeAtPosition(db, filePath, line) {
+        try {
+            const rows = rawQuery(db, `SELECT name, label, filePath FROM nodes
+         WHERE filePath = ? AND startLine <= ? AND endLine >= ?
+         AND label NOT IN ('File', 'Folder', 'Community', 'Process')
+         ORDER BY (endLine - startLine) ASC
+         LIMIT 1`, [filePath, line + 1, line + 1]);
+            return rows[0] ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
     // ── Compact text formatters — optimized for LLM token efficiency ────
-    /** Extract signature from content: the declaration line(s), not the full body */
+    /** Extract signature from content. For interfaces/types, returns the full body (fields ARE the signature). */
     extractSignature(content, name, _type) {
         if (!content)
             return name || '?';
+        // For interfaces and type aliases, the body IS the signature — return it fully
+        // (capped at 20 lines to prevent huge classes from flooding context)
+        if (_type === 'Interface' || _type === 'TypeAlias' || _type === 'Enum' || _type === 'Const') {
+            const trimmed = content.trim();
+            const lines = trimmed.split('\n');
+            if (lines.length <= 20)
+                return trimmed;
+            return lines.slice(0, 20).join('\n') + '\n  // ... and more fields';
+        }
         const lines = content.split('\n');
         const declKeywords = /^\s*(export\s+)?(default\s+)?(async\s+)?(function|class|interface|type|const|let|var|enum|struct|trait|impl|pub\s|fn\s|def\s|private|protected|public|static|abstract|override|readonly)/;
         const namePattern = name ? new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`) : null;
         // Helper: collect multi-line signature (for arrow functions with params on multiple lines)
         const collectSignature = (startIdx) => {
-            let sig = lines[startIdx].trim();
+            const startLine = lines[startIdx];
+            if (!startLine)
+                return name || '?';
+            let sig = startLine.trim();
             // If the line ends with '(' or has unmatched parens, collect continuation lines
             let openParens = (sig.match(/\(/g) || []).length - (sig.match(/\)/g) || []).length;
             let i = startIdx + 1;
             while (openParens > 0 && i < lines.length && i < startIdx + 8) {
-                const next = lines[i].trim();
+                const next = (lines[i] ?? '').trim();
                 if (!next || next.startsWith('//') || next.startsWith('*')) {
                     i++;
                     continue;
@@ -814,14 +414,20 @@ export class LocalBackend {
         };
         // Strategy 1: Find the line containing the symbol name AND a declaration keyword
         for (let i = 0; i < lines.length; i++) {
-            const trimmed = lines[i].trim();
+            const line = lines[i];
+            if (!line)
+                continue;
+            const trimmed = line.trim();
             if (namePattern && namePattern.test(trimmed) && (declKeywords.test(trimmed) || trimmed.includes('(') || trimmed.includes(':'))) {
                 return collectSignature(i);
             }
         }
         // Strategy 2: Find any line with a declaration keyword
         for (let i = 0; i < lines.length; i++) {
-            const trimmed = lines[i].trim();
+            const line = lines[i];
+            if (!line)
+                continue;
+            const trimmed = line.trim();
             if (declKeywords.test(trimmed)) {
                 return collectSignature(i);
             }
@@ -859,12 +465,12 @@ export class LocalBackend {
             .replace(/([a-z])([A-Z])/g, '$1 $2')
             .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
             .toLowerCase();
-        const first = humanize(stepNames[0]);
-        const last = humanize(stepNames[stepNames.length - 1]);
+        const first = humanize(stepNames[0] ?? '');
+        const last = humanize(stepNames[stepNames.length - 1] ?? '');
         if (stepNames.length <= 2)
             return `${first} → ${last}`;
         // Step 2 is the dispatch point — where the flow specializes
-        const dispatch = humanize(stepNames[1]);
+        const dispatch = humanize(stepNames[1] ?? '');
         return `${first} → ${dispatch} → ${last}`;
     }
     formatQueryAsText(result) {
@@ -933,15 +539,23 @@ export class LocalBackend {
             const toShow = maxFlows ? flows.slice(0, maxFlows) : flows;
             let i = 0;
             while (i < toShow.length) {
-                const group = [toShow[i]];
+                const current = toShow[i];
+                if (!current) {
+                    i++;
+                    continue;
+                }
+                const group = [current];
                 for (let j = i + 1; j < toShow.length; j++) {
-                    if (this.sharedPrefixLength(toShow[i].syms, toShow[j].syms) >= 3)
-                        group.push(toShow[j]);
+                    const candidate = toShow[j];
+                    if (candidate && this.sharedPrefixLength(current.syms, candidate.syms) >= 3)
+                        group.push(candidate);
                 }
-                if (group.length >= 2) {
-                    const prefixLen = this.sharedPrefixLength(group[0].syms, group[1].syms);
-                    const prefix = group[0].syms.slice(0, prefixLen);
-                    const desc = this.describeFlow(group[0].syms.map((s) => s.name));
+                const first = group[0];
+                const second = group[1];
+                if (group.length >= 2 && first && second) {
+                    const prefixLen = this.sharedPrefixLength(first.syms, second.syms);
+                    const prefix = first.syms.slice(0, prefixLen);
+                    const desc = this.describeFlow(first.syms.map((s) => s.name));
                     lines.push('');
                     lines.push(`## ${group.length} flows: ${desc} (shared prefix: ${prefixLen} steps)`);
                     for (const sym of prefix) {
@@ -959,11 +573,10 @@ export class LocalBackend {
                     i += group.length;
                 }
                 else {
-                    const flow = toShow[i];
-                    const desc = this.describeFlow(flow.syms.map((s) => s.name));
+                    const desc = this.describeFlow(current.syms.map((s) => s.name));
                     lines.push('');
-                    lines.push(`## ${flow.proc.summary}: ${desc} (${flow.proc.step_count} steps)`);
-                    for (const sym of flow.syms) {
+                    lines.push(`## ${current.proc.summary}: ${desc} (${current.proc.step_count} steps)`);
+                    for (const sym of current.syms) {
                         lines.push(formatStep(sym));
                     }
                     i++;
@@ -989,6 +602,50 @@ export class LocalBackend {
     formatContextAsText(result) {
         if (result.error)
             return `Error: ${result.error}`;
+        // File overview mode
+        if (result.status === 'file_overview') {
+            const lines = [];
+            const modTag = result.module ? ` [${result.module}]` : '';
+            lines.push(`## ${result.fileName}${modTag}`);
+            lines.push(`${result.file} | ${result.symbolCount} symbols`);
+            // Fallback for files with no symbols
+            if (result.note) {
+                lines.push(`_${result.note}_`);
+            }
+            if (result.imports?.length > 0) {
+                lines.push('');
+                lines.push(`### Imports (${result.imports.length})`);
+                for (const imp of result.imports) {
+                    lines.push(`  ${imp.name} — ${imp.filePath}`);
+                }
+            }
+            if (result.preview) {
+                lines.push('');
+                lines.push('### Content preview');
+                lines.push('```');
+                lines.push(result.preview);
+                lines.push('```');
+            }
+            lines.push('');
+            // Group by kind
+            const byKind = new Map();
+            for (const sym of result.symbols) {
+                const list = byKind.get(sym.kind) ?? [];
+                list.push(sym);
+                byKind.set(sym.kind, list);
+            }
+            for (const [kind, syms] of byKind) {
+                lines.push(`### ${kind}s (${syms.length})`);
+                for (const sym of syms) {
+                    const sig = sym.signature ? ` — \`${sym.signature}\`` : '';
+                    const calls = sym.callers > 0 || sym.callees > 0 ? ` (${sym.callers} callers, ${sym.callees} callees)` : '';
+                    const mod = sym.module ? ` [${sym.module}]` : '';
+                    lines.push(`  ${sym.name}${sig}${calls}${mod}`);
+                }
+                lines.push('');
+            }
+            return lines.join('\n').trim();
+        }
         if (result.status === 'ambiguous') {
             const lines = [`Ambiguous: ${result.candidates.length} matches for '${result.message}'`];
             for (const c of result.candidates) {
@@ -999,7 +656,6 @@ export class LocalBackend {
         const sym = result.symbol;
         const lines = [];
         // Header with signature + C5 module
-        const sig = sym.signature || sym.name;
         const modTag = sym.module ? ` [${sym.module}]` : '';
         lines.push(`## ${sym.name}`);
         lines.push(`${sym.kind || sym.type || 'Symbol'} @ ${sym.filePath}:${sym.startLine || '?'}-${sym.endLine || '?'}${modTag}`);
@@ -1127,7 +783,8 @@ export class LocalBackend {
             for (const [fp, syms] of sortedFiles) {
                 const names = syms.slice(0, 5).map((s) => s.name).join(', ');
                 const more = syms.length > 5 ? ` +${syms.length - 5} more` : '';
-                const stat = diffStats[fp] || diffStats[fp.split('/').slice(-1)[0]] || '';
+                const basename = fp.split('/').slice(-1)[0] ?? '';
+                const stat = diffStats[fp] || diffStats[basename] || '';
                 const statSuffix = stat ? ` (${stat})` : '';
                 lines.push(`  ${this.shortPath(fp)}${statSuffix} — ${syms.length} symbols: ${names}${more}`);
             }
@@ -1148,15 +805,21 @@ export class LocalBackend {
     // ── Staleness check ────────────────────────────────────────────────
     /** C3: Check if index is behind HEAD and return a warning prefix */
     getStalenessWarning(repo) {
+        const warnings = [];
         try {
             const { checkStaleness } = require('../staleness.js');
             const info = checkStaleness(repo.repoPath, repo.lastCommit);
             if (info.isStale) {
-                return `⚠ index ${info.commitsBehind} commit${info.commitsBehind > 1 ? 's' : ''} behind HEAD\n\n`;
+                warnings.push(`⚠ index ${info.commitsBehind} commit${info.commitsBehind > 1 ? 's' : ''} behind HEAD`);
             }
         }
         catch { }
-        return '';
+        // Warn if tsgo is unavailable — agents should know call resolution is heuristic-only
+        const tsgo = this.tsgoServices.get(repo.id);
+        if (!tsgo?.isReady()) {
+            warnings.push('⚠ tsgo unavailable — call resolution uses heuristic matching (install @typescript/native-preview for compiler-verified accuracy)');
+        }
+        return warnings.length > 0 ? warnings.join('\n') + '\n\n' : '';
     }
     // ── Tool Dispatch ─────────────────────────────────────────────────
     async callTool(method, params) {
@@ -1166,14 +829,24 @@ export class LocalBackend {
         // Resolve repo from optional param (re-reads registry on miss)
         const repo = await this.resolveRepo(params?.repo);
         await this.ensureFresh(repo);
+        // Eagerly attempt tsgo start so the staleness warning is accurate
+        // Agents can opt out with tsgo: false for faster responses
+        if (params?.tsgo !== false) {
+            await this.getTsgo(repo);
+        }
         // C3: Prepend staleness warning to all tool responses
         const staleWarning = this.getStalenessWarning(repo);
         switch (method) {
-            case 'query':
-                return staleWarning + this.formatQueryAsText(await this.query(repo, params));
-            case 'cypher': {
-                const raw = await this.cypher(repo, params);
-                return this.formatCypherAsMarkdown(raw);
+            case 'query': {
+                const queryResult = await this.query(repo, params);
+                // Overview/architecture queries return pre-formatted strings
+                if (typeof queryResult === 'string')
+                    return staleWarning + queryResult;
+                return staleWarning + this.formatQueryAsText(queryResult);
+            }
+            case 'sql': {
+                const raw = await this.sqlQuery(repo, params);
+                return this.formatSqlAsMarkdown(raw);
             }
             case 'context': {
                 // F5: Bulk context — if names array provided, fetch context for each
@@ -1222,19 +895,15 @@ export class LocalBackend {
         if (searchQuery.toLowerCase() === 'overview' || searchQuery.toLowerCase() === 'architecture') {
             // Return top clusters with their key symbols instead of search results
             const clusterResult = await this.queryClusters(repo.name, 10);
+            const overviewDb = this.getDb(repo.id);
             const lines = [`## Codebase Overview: ${repo.name}`];
             for (const cluster of (clusterResult.clusters || []).slice(0, 8)) {
                 lines.push(`\n### ${cluster.heuristicLabel || cluster.label} (${cluster.symbolCount} symbols, cohesion: ${(cluster.cohesion || 0).toFixed(2)})`);
                 // Fetch top 5 symbols from this cluster
                 try {
-                    const members = await executeQuery(repo.id, `
-            MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community {heuristicLabel: '${(cluster.heuristicLabel || cluster.label || '').replace(/'/g, "''")}'})
-            RETURN n.name AS name, labels(n) AS type, n.filePath AS filePath
-            ORDER BY n.startLine
-            LIMIT 5
-          `);
+                    const members = queries.getCommunityMembers(overviewDb, cluster.heuristicLabel || cluster.label || '', 5);
                     for (const m of members) {
-                        lines.push(`  ${m.name || m[0]} — ${m.type || m[1]} @ ${m.filePath || m[2]}`);
+                        lines.push(`  ${m.name} — ${m.label} @ ${m.filePath}`);
                     }
                 }
                 catch { }
@@ -1265,13 +934,14 @@ export class LocalBackend {
             filePath: String(r.filePath ?? ''),
             score: Number(r.bm25Score ?? 0),
             rank: i + 1,
-            startLine: r.startLine,
-            endLine: r.endLine,
+            ...(r.startLine != null ? { startLine: r.startLine } : {}),
+            ...(r.endLine != null ? { endLine: r.endLine } : {}),
         }));
         const semanticForRRF = semanticResults.map((r) => ({
             nodeId: String(r.nodeId ?? ''), name: String(r.name ?? ''), label: String(r.type ?? ''),
             filePath: String(r.filePath ?? ''), distance: Number(r.distance ?? 1),
-            startLine: r.startLine, endLine: r.endLine,
+            ...(r.startLine != null ? { startLine: r.startLine } : {}),
+            ...(r.endLine != null ? { endLine: r.endLine } : {}),
         }));
         const rrfMerged = mergeWithRRF(bm25ForRRF, semanticForRRF, { limit: searchLimit });
         // Build lookup from original search data (keyed by both nodeId and filePath for cross-referencing)
@@ -1347,14 +1017,12 @@ export class LocalBackend {
             try {
                 const rerankCandidates = merged.filter(m => m.data.nodeId).slice(0, 30);
                 if (rerankCandidates.length > 1) {
-                    const nodeIdList = rerankCandidates.map(c => `'${String(c.data.nodeId).replace(/'/g, "''")}'`).join(', ');
-                    const snippetRows = await executeQuery(repo.id, `
-            MATCH (n) WHERE n.id IN [${nodeIdList}]
-            RETURN n.id AS nodeId, COALESCE(n.content, n.name) AS snippet
-          `);
+                    const rerankDb = this.getDb(repo.id);
+                    const rerankIds = rerankCandidates.map(c => toNodeId(String(c.data.nodeId)));
+                    const snippetNodes = queries.findNodesByIds(rerankDb, rerankIds);
                     const snippetMap = new Map();
-                    for (const row of snippetRows) {
-                        snippetMap.set(String(row.nodeId ?? row[0]), String(row.snippet ?? row[1] ?? ''));
+                    for (const node of snippetNodes) {
+                        snippetMap.set(node.id, node.content || node.name || '');
                     }
                     const passages = rerankCandidates
                         .map(c => ({ id: String(c.data.nodeId), text: snippetMap.get(c.data.nodeId) ?? String(c.data.name ?? '') }))
@@ -1424,80 +1092,49 @@ export class LocalBackend {
         let signatureMap = new Map();
         let clusterByNode = new Map();
         if (symbolsWithNodeId.length > 0) {
-            const nodeIdList = symbolsWithNodeId.map(s => `'${String(s.nodeId).replace(/'/g, "''")}'`).join(', ');
+            const queryDb = this.getDb(repo.id);
+            const nodeIds = symbolsWithNodeId.map(s => toNodeId(String(s.nodeId)));
             // Batch process lookup
-            let processRows = [];
-            try {
-                processRows = await executeQuery(repo.id, `
-          MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-          WHERE n.id IN [${nodeIdList}]
-          RETURN n.id AS nodeId, p.id AS pid, p.label AS label, p.heuristicLabel AS heuristicLabel,
-                 p.processType AS processType, p.stepCount AS stepCount, r.step AS step
-        `);
-            }
-            catch (e) {
-                logQueryError('query:batch-process-lookup', e);
-            }
+            const processRows = queries.batchFindProcesses(queryDb, nodeIds);
             // Batch cluster lookup
-            let clusterRows = [];
-            try {
-                clusterRows = await executeQuery(repo.id, `
-          MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-          WHERE n.id IN [${nodeIdList}]
-          RETURN n.id AS nodeId, c.cohesion AS cohesion, c.heuristicLabel AS module
-        `);
-            }
-            catch (e) {
-                logQueryError('query:batch-cluster-info', e);
-            }
+            const clusterRows = queries.batchFindCommunities(queryDb, nodeIds);
             // Always fetch content for signature extraction (eliminates follow-up Read calls)
             const contentMap = new Map();
-            // signatureMap hoisted above for F1 access
-            try {
-                const contentRows = await executeQuery(repo.id, `
-          MATCH (n) WHERE n.id IN [${nodeIdList}] RETURN n.id AS nodeId, n.content AS content
-        `);
-                // Build a name lookup for signature extraction
-                const nodeNameMap = new Map();
-                for (const s of symbolsWithNodeId) {
-                    nodeNameMap.set(s.nodeId, String(s.data.name ?? ''));
-                }
-                for (const row of contentRows) {
-                    const nid = String(row.nodeId ?? row[0]);
-                    const cnt = row.content ?? row[1];
-                    if (cnt) {
-                        const full = String(cnt);
-                        // Extract signature: the declaration line only
-                        signatureMap.set(nid, this.extractSignature(full, nodeNameMap.get(nid) || '', ''));
-                        if (includeContent) {
-                            const lines = full.split('\n');
-                            let snippet = '';
-                            for (const line of lines) {
-                                snippet += (snippet ? '\n' : '') + line;
-                                if (snippet.length > 200 || line.includes('{') || line.includes('=>'))
-                                    break;
-                            }
-                            contentMap.set(nid, snippet);
+            const contentNodes = queries.findNodesByIds(queryDb, nodeIds);
+            const nodeNameMap = new Map();
+            for (const s of symbolsWithNodeId) {
+                nodeNameMap.set(s.nodeId, String(s.data.name ?? ''));
+            }
+            for (const node of contentNodes) {
+                const nid = node.id;
+                if (node.content) {
+                    const full = String(node.content);
+                    signatureMap.set(nid, this.extractSignature(full, nodeNameMap.get(nid) || '', node.label));
+                    if (includeContent) {
+                        const contentLines = full.split('\n');
+                        let snippet = '';
+                        for (const line of contentLines) {
+                            snippet += (snippet ? '\n' : '') + line;
+                            if (snippet.length > 200 || line.includes('{') || line.includes('=>'))
+                                break;
                         }
+                        contentMap.set(nid, snippet);
                     }
                 }
             }
-            catch (e) {
-                logQueryError('query:batch-content-fetch', e);
-            }
             // Index batched results by nodeId
             const processRowsByNode = new Map();
             for (const row of processRows) {
-                const nid = String(row.nodeId ?? row[0]);
+                const nid = row.nodeId;
                 if (!processRowsByNode.has(nid))
                     processRowsByNode.set(nid, []);
                 processRowsByNode.get(nid).push(row);
             }
             // clusterByNode hoisted above for F1 access
             for (const row of clusterRows) {
-                const nid = String(row.nodeId ?? row[0]);
+                const nid = row.nodeId;
                 if (!clusterByNode.has(nid)) {
-                    clusterByNode.set(nid, { cohesion: Number(row.cohesion ?? row[1] ?? 0), module: String(row.module ?? row[2] ?? '') });
+                    clusterByNode.set(nid, { cohesion: row.cohesion, module: row.module });
                 }
             }
             // Assemble using batched data
@@ -1521,13 +1158,13 @@ export class LocalBackend {
                 }
                 else {
                     for (const row of symProcessRows) {
-                        const pid = String(row.pid ?? row[1]);
+                        const pid = row.processId;
                         if (!processMap.has(pid)) {
                             processMap.set(pid, {
-                                id: pid, label: String(row.label ?? row[2] ?? ''),
-                                heuristicLabel: String(row.heuristicLabel ?? row[3] ?? ''),
-                                processType: String(row.processType ?? row[4] ?? ''),
-                                stepCount: Number(row.stepCount ?? row[5] ?? 0),
+                                id: pid, label: row.label,
+                                heuristicLabel: row.heuristicLabel,
+                                processType: row.processType,
+                                stepCount: row.stepCount,
                                 bestScore: 0, symbolScoreSum: 0, symbolCount: 0, cohesionBoost: 0, symbols: [],
                             });
                         }
@@ -1536,7 +1173,7 @@ export class LocalBackend {
                         proc.symbolScoreSum += symInfo.score;
                         proc.symbolCount++;
                         proc.cohesionBoost = Math.max(proc.cohesionBoost, cluster?.cohesion ?? 0);
-                        proc.symbols.push({ ...symbolEntry, process_id: pid, step_index: Number(row.step ?? row[6] ?? 0) });
+                        proc.symbols.push({ ...symbolEntry, process_id: pid, step_index: row.step });
                     }
                 }
             }
@@ -1573,7 +1210,7 @@ export class LocalBackend {
         if (!queryMentionsServer && rankedProcesses.length > 1) {
             const SERVER_ENTRY_PREFIXES = ['createserver', 'mcpcommand', 'startmcpserver', 'handlerequest', 'servecommand', 'setupcommand', 'statuscommand', 'listcommand', 'cleancommand'];
             for (const proc of rankedProcesses) {
-                const entryName = (proc.heuristicLabel || proc.label || '').toLowerCase().split(' ')[0];
+                const entryName = (proc.heuristicLabel || proc.label || '').toLowerCase().split(' ')[0] ?? '';
                 if (SERVER_ENTRY_PREFIXES.some(p => entryName.includes(p))) {
                     proc.priority *= 0.5;
                 }
@@ -1591,29 +1228,23 @@ export class LocalBackend {
         let allStepsMap = new Map(); // pid -> all steps
         if (topProcIds.length > 0) {
             try {
-                const procIdList = topProcIds.map(id => `'${id.replace(/'/g, "''")}'`).join(', ');
-                const allStepsRows = await executeQuery(repo.id, `
-          MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-          WHERE p.id IN [${procIdList}]
-          RETURN s.id AS nodeId, s.name AS name, labels(s) AS type, s.filePath AS filePath, s.startLine AS startLine,
-                 p.id AS pid, r.step AS step
-          ORDER BY p.id, r.step
-        `);
+                const stepsDb = this.getDb(repo.id);
+                const allStepsRows = queries.batchGetProcessSteps(stepsDb, topProcIds.map(id => toNodeId(id)));
                 for (const row of allStepsRows) {
-                    const pid = String(row.pid ?? row[5]);
+                    const pid = row.processId;
                     if (!allStepsMap.has(pid))
                         allStepsMap.set(pid, []);
-                    const nodeId = String(row.nodeId ?? row[0]);
+                    const nodeId = row.nodeId;
                     const sig = signatureMap.get(nodeId);
                     allStepsMap.get(pid).push({
                         nodeId,
-                        name: String(row.name ?? row[1]),
-                        type: String(row.type ?? row[2] ?? 'Symbol'),
-                        filePath: String(row.filePath ?? row[3] ?? ''),
-                        startLine: row.startLine ?? row[4],
-                        step_index: Number(row.step ?? row[6] ?? 0),
+                        name: row.name,
+                        type: row.label,
+                        filePath: row.filePath,
+                        startLine: row.startLine,
+                        step_index: row.step,
                         matched: matchedNodeIds.has(nodeId),
-                        signature: sig || String(row.name ?? row[1]),
+                        signature: sig || row.name,
                         module: clusterByNode.get(nodeId)?.module,
                     });
                 }
@@ -1650,45 +1281,58 @@ export class LocalBackend {
         return { processes, process_symbols: dedupedSymbols, definitions: definitions.slice(0, DEFAULT_MAX_DEFINITIONS), _searchQuery: searchQuery };
     }
     /**
-     * BM25 keyword search helper - uses LadybugDB FTS for always-fresh results
+     * BM25 keyword search helper — uses SQLite FTS5 for always-fresh results
      */
     async bm25Search(repo, query, limit) {
-        const { searchFTSFromLbug } = await import('../../core/search/bm25-index.js');
         const { expandQuery } = await import('../../core/search/query-expansion.js');
         const { PRF_SPARSE_THRESHOLD, PRF_WEAK_SCORE_THRESHOLD } = await import('../../core/search/types.js');
         try {
-            let results = await searchFTSFromLbug(query, limit, repo.id);
+            const ftsDb = this.getDb(repo.id);
+            let results = searchFTS(ftsDb, query, limit);
             // Pseudo-relevance feedback: expand when results are sparse OR top score is weak
-            const topScore = results.length > 0 ? results[0].score : 0;
+            const firstResult = results[0];
+            const topScore = firstResult ? firstResult.score : 0;
             const shouldExpand = results.length > 0 && (results.length < PRF_SPARSE_THRESHOLD || topScore < PRF_WEAK_SCORE_THRESHOLD);
             if (shouldExpand) {
                 const topSymbolNames = results.slice(0, 3).map(r => r.name);
                 const expandedQuery = expandQuery(query, topSymbolNames);
                 if (expandedQuery !== query) {
-                    const expandedResults = await searchFTSFromLbug(expandedQuery, limit, repo.id);
-                    const seen = new Set(results.map(r => r.nodeId));
+                    const expandedResults = searchFTS(ftsDb, expandedQuery, limit);
+                    const seen = new Set(results.map(r => r.id));
                     for (const r of expandedResults) {
-                        if (!seen.has(r.nodeId)) {
+                        if (!seen.has(r.id)) {
                             results.push(r);
-                            seen.add(r.nodeId);
+                            seen.add(r.id);
                         }
                     }
                     results = results.slice(0, limit);
                 }
             }
+            // Fetch full node data for startLine/endLine
+            const nodeIds = results.map(r => r.id);
+            const nodeMap = new Map();
+            if (nodeIds.length > 0) {
+                const fullNodes = queries.findNodesByIds(ftsDb, nodeIds);
+                for (const n of fullNodes) {
+                    nodeMap.set(n.id, n);
+                }
+            }
             // Map to the shape expected by the query pipeline
-            return results.map(r => ({
-                nodeId: r.nodeId,
-                name: r.name,
-                type: r.type,
-                filePath: r.filePath,
-                startLine: r.startLine,
-                endLine: r.endLine,
-                bm25Score: r.score,
-            }));
+            return results.map(r => {
+                const node = nodeMap.get(r.id);
+                return {
+                    nodeId: r.id,
+                    name: r.name,
+                    type: r.label,
+                    filePath: r.filePath,
+                    startLine: node?.startLine,
+                    endLine: node?.endLine,
+                    bm25Score: r.score,
+                };
+            });
         }
         catch (err) {
-            console.error('Code Mapper: BM25/FTS search failed (FTS indexes may not exist) -', err.message);
+            console.error('Code Mapper: BM25/FTS search failed -', err instanceof Error ? err.message : err);
             return [];
         }
     }
@@ -1697,85 +1341,62 @@ export class LocalBackend {
      */
     async semanticSearch(repo, query, limit) {
         try {
-            // Check if embedding table exists before loading the model (avoids heavy model init when embeddings are off)
-            const tableCheck = await executeQuery(repo.id, `MATCH (e:CodeEmbedding) RETURN COUNT(*) AS cnt LIMIT 1`);
-            if (!tableCheck.length || (tableCheck[0].cnt ?? tableCheck[0][0]) === 0)
+            // Check if embeddings exist before loading the model (avoids heavy model init when embeddings are off)
+            const semDb = this.getDb(repo.id);
+            const embCount = countEmbeddings(semDb);
+            if (embCount === 0)
                 return [];
             const { DEFAULT_MAX_SEMANTIC_DISTANCE } = await import('../../core/search/types.js');
-            const { embedQuery, getEmbeddingDims } = await import('../core/embedder.js');
+            const { embedQuery } = await import('../../core/embeddings/embedder.js');
             const queryVec = await embedQuery(query);
-            const dims = getEmbeddingDims();
-            const queryVecStr = `[${queryVec.join(',')}]`;
-            const vectorQuery = `
-        CALL QUERY_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx',
-          CAST(${queryVecStr} AS FLOAT[${dims}]), ${limit})
-        YIELD node AS emb, distance
-        RETURN emb.nodeId AS nodeId, distance
-        ORDER BY distance
-      `;
-            const embResults = await executeQuery(repo.id, vectorQuery);
-            if (embResults.length === 0)
-                return [];
-            // Filter by distance threshold — cut irrelevant results before RRF merge
-            const filteredResults = embResults.filter(r => Number(r.distance ?? r[1] ?? 1) < DEFAULT_MAX_SEMANTIC_DISTANCE);
-            if (filteredResults.length === 0)
+            // Brute-force cosine search via adapter (fast enough for <200K vectors at 256 dims)
+            const vecResults = searchVector(semDb, queryVec, limit, DEFAULT_MAX_SEMANTIC_DISTANCE);
+            if (vecResults.length === 0)
                 return [];
-            // Batch metadata fetch — single query instead of N per-row queries
-            const nodeIds = filteredResults.map(r => String(r.nodeId ?? r[0]));
+            // Batch metadata fetch
+            const vecNodeIds = vecResults.map(r => r.nodeId);
             const distanceMap = new Map();
-            for (const r of filteredResults) {
-                distanceMap.set(String(r.nodeId ?? r[0]), Number(r.distance ?? r[1] ?? 1));
-            }
-            const idList = nodeIds.map(id => `'${id.replace(/'/g, "''")}'`).join(', ');
-            let metaRows = [];
-            try {
-                metaRows = await executeQuery(repo.id, `
-          MATCH (n) WHERE n.id IN [${idList}]
-          RETURN n.id AS nodeId, n.name AS name, labels(n) AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine
-        `);
-            }
-            catch { }
-            return metaRows.map(row => {
-                const nid = String(row.nodeId ?? row[0]);
-                return {
-                    nodeId: nid,
-                    name: String(row.name ?? row[1] ?? ''),
-                    type: String(row.type ?? row[2] ?? 'Unknown'),
-                    filePath: String(row.filePath ?? row[3] ?? ''),
-                    distance: distanceMap.get(nid) ?? 1,
-                    startLine: row.startLine ?? row[4],
-                    endLine: row.endLine ?? row[5],
-                };
-            });
+            for (const r of vecResults) {
+                distanceMap.set(r.nodeId, r.distance);
+            }
+            const metaNodes = queries.findNodesByIds(semDb, vecNodeIds);
+            return metaNodes.map(node => ({
+                nodeId: node.id,
+                name: node.name,
+                type: node.label,
+                filePath: node.filePath,
+                distance: distanceMap.get(node.id) ?? 1,
+                startLine: node.startLine,
+                endLine: node.endLine,
+            }));
         }
         catch {
             // Expected when embeddings are disabled — silently fall back to BM25-only
             return [];
         }
     }
-    async executeCypher(repoName, query) {
+    async executeSql(repoName, query) {
         const repo = await this.resolveRepo(repoName);
-        return this.cypher(repo, { query });
+        return this.sqlQuery(repo, { query });
     }
-    async cypher(repo, params) {
+    async sqlQuery(repo, params) {
         await this.ensureInitialized(repo.id);
-        if (!isLbugReady(repo.id)) {
-            return { error: 'LadybugDB not ready. Index may be corrupted.' };
-        }
+        const db = this.getDb(repo.id);
         // Block write operations (defense-in-depth — DB is already read-only)
-        if (CYPHER_WRITE_RE.test(params.query)) {
-            return { error: 'Write operations (CREATE, DELETE, SET, MERGE, REMOVE, DROP, ALTER, COPY, DETACH) are not allowed. The knowledge graph is read-only.' };
+        const SQL_WRITE_RE = /\b(INSERT|UPDATE|DELETE|DROP|ALTER|CREATE\s+TABLE|CREATE\s+INDEX|REPLACE\s+INTO)\b/i;
+        if (SQL_WRITE_RE.test(params.query)) {
+            return { error: 'Write operations are not allowed. The knowledge graph is read-only.' };
         }
         try {
-            const result = await executeQuery(repo.id, params.query);
+            const result = rawQuery(db, params.query);
             return result;
         }
         catch (err) {
-            return { error: err.message || 'Query failed' };
+            return { error: err instanceof Error ? err.message : 'Query failed' };
         }
     }
-    /** Format raw Cypher result rows as a markdown table, with raw fallback */
-    formatCypherAsMarkdown(result) {
+    /** Format raw SQL result rows as a markdown table, with raw fallback */
+    formatSqlAsMarkdown(result) {
         if (!Array.isArray(result) || result.length === 0)
             return result;
         const firstRow = result[0];
@@ -1843,20 +1464,12 @@ export class LocalBackend {
         };
         if (params.showClusters !== false) {
             try {
-                // Fetch more raw communities than the display limit so aggregation has enough data
+                const db = this.getDb(repo.id);
                 const rawLimit = Math.max(limit * 5, 200);
-                const clusters = await executeQuery(repo.id, `
-          MATCH (c:Community)
-          RETURN c.id AS id, c.label AS label, c.heuristicLabel AS heuristicLabel, c.cohesion AS cohesion, c.symbolCount AS symbolCount
-          ORDER BY c.symbolCount DESC
-          LIMIT ${rawLimit}
-        `);
-                const rawClusters = clusters.map((c) => ({
-                    id: c.id || c[0],
-                    label: c.label || c[1],
-                    heuristicLabel: c.heuristicLabel || c[2],
-                    cohesion: c.cohesion || c[3],
-                    symbolCount: c.symbolCount || c[4],
+                const clusterNodes = queries.listCommunities(db, rawLimit);
+                const rawClusters = clusterNodes.map(c => ({
+                    id: c.id, label: c.name, heuristicLabel: c.heuristicLabel || c.name,
+                    cohesion: c.cohesion, symbolCount: c.symbolCount,
                 }));
                 result.clusters = this.aggregateClusters(rawClusters).slice(0, limit);
             }
@@ -1866,18 +1479,11 @@ export class LocalBackend {
         }
         if (params.showProcesses !== false) {
             try {
-                const processes = await executeQuery(repo.id, `
-          MATCH (p:Process)
-          RETURN p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount
-          ORDER BY p.stepCount DESC
-          LIMIT ${limit}
-        `);
-                result.processes = processes.map((p) => ({
-                    id: p.id || p[0],
-                    label: p.label || p[1],
-                    heuristicLabel: p.heuristicLabel || p[2],
-                    processType: p.processType || p[3],
-                    stepCount: p.stepCount || p[4],
+                const db = this.getDb(repo.id);
+                const processNodes = queries.listProcesses(db, limit);
+                result.processes = processNodes.map(p => ({
+                    id: p.id, label: p.name, heuristicLabel: p.heuristicLabel || p.name,
+                    processType: p.processType, stepCount: p.stepCount,
                 }));
             }
             catch {
@@ -1886,46 +1492,208 @@ export class LocalBackend {
         }
         return result;
     }
-    /** Context tool: 360-degree symbol view with categorized refs and disambiguation */
+    /**
+     * File overview: list all symbols in a file with signatures and caller/callee counts.
+     * Triggered when context() is called with file_path only (no name/uid).
+     */
+    async fileOverview(repo, filePath, includeContent, enableTsgo) {
+        const db = this.getDb(repo.id);
+        // Find the file node and all symbols in it
+        const fileNodes = findNodesByFile(db, filePath);
+        if (fileNodes.length === 0) {
+            // Try substring match
+            const allFiles = db.prepare("SELECT DISTINCT filePath FROM nodes WHERE filePath LIKE ? AND label = 'File' LIMIT 5").all(`%${filePath}%`);
+            if (allFiles.length === 0)
+                return { error: `No file matching '${filePath}' found in index.` };
+            if (allFiles.length > 1) {
+                return {
+                    status: 'ambiguous',
+                    message: `Multiple files match '${filePath}'. Be more specific.`,
+                    candidates: allFiles.map(f => ({
+                        name: f.filePath.split('/').pop() ?? f.filePath,
+                        kind: 'File',
+                        filePath: f.filePath,
+                        line: null,
+                    })),
+                };
+            }
+            // Exact single match — re-query
+            return this.fileOverview(repo, allFiles[0].filePath, includeContent, enableTsgo);
+        }
+        const symbols = fileNodes.filter(n => n.label !== 'File' && n.label !== 'Folder');
+        // Fallback: file has no extractable symbols (e.g., imperative entry points, config files)
+        // Return imports + file content preview so the agent can still orient
+        if (symbols.length === 0) {
+            const fileNode = fileNodes.find(n => n.label === 'File');
+            const actualPath = fileNode?.filePath ?? filePath;
+            // Get outgoing IMPORTS edges from this file
+            const imports = fileNode
+                ? db.prepare(`SELECT t.name, t.filePath FROM edges e JOIN nodes t ON t.id = e.targetId
+             WHERE e.sourceId = ? AND e.type = 'IMPORTS'`).all(fileNode.id)
+                : [];
+            // Read first 30 lines of file content from the stored content or disk
+            let preview = fileNode?.content ?? '';
+            if (preview.length > 2000)
+                preview = preview.slice(0, 2000) + '\n// ...truncated';
+            return {
+                status: 'file_overview',
+                file: actualPath,
+                fileName: actualPath.split('/').pop() ?? filePath,
+                module: null,
+                symbolCount: 0,
+                note: 'No extractable symbols (entry point or config file). Showing imports and content preview.',
+                imports: imports.map(i => ({ name: i.name, filePath: i.filePath })),
+                preview,
+                symbols: [],
+            };
+        }
+        // Batch-fetch caller and callee counts per symbol
+        const symbolIds = symbols.map(s => s.id);
+        const callerCounts = new Map();
+        const calleeCounts = new Map();
+        if (symbolIds.length > 0) {
+            const ph = symbolIds.map(() => '?').join(',');
+            const callerRows = db.prepare(`SELECT targetId, COUNT(*) as cnt FROM edges WHERE targetId IN (${ph}) AND type = 'CALLS' GROUP BY targetId`).all(...symbolIds);
+            for (const r of callerRows)
+                callerCounts.set(r.targetId, r.cnt);
+            const calleeRows = db.prepare(`SELECT sourceId, COUNT(*) as cnt FROM edges WHERE sourceId IN (${ph}) AND type = 'CALLS' GROUP BY sourceId`).all(...symbolIds);
+            for (const r of calleeRows)
+                calleeCounts.set(r.sourceId, r.cnt);
+        }
+        // Get community membership for symbols
+        const communityMap = new Map();
+        if (symbolIds.length > 0) {
+            const ph = symbolIds.map(() => '?').join(',');
+            const memberRows = db.prepare(`SELECT e.sourceId, c.heuristicLabel FROM edges e JOIN nodes c ON c.id = e.targetId
+         WHERE e.sourceId IN (${ph}) AND e.type = 'MEMBER_OF' AND c.label = 'Community'`).all(...symbolIds);
+            for (const r of memberRows)
+                communityMap.set(r.sourceId, r.heuristicLabel);
+        }
+        // Optionally enrich with tsgo hover for real type signatures
+        const signatures = new Map();
+        if (enableTsgo !== false) {
+            const tsgo = await this.getTsgo(repo);
+            if (tsgo) {
+                const absBase = repo.repoPath;
+                for (const sym of symbols.slice(0, 30)) { // cap to avoid slow
+                    if (sym.startLine != null && /\.(ts|tsx|js|jsx|mts|mjs)$/.test(sym.filePath)) {
+                        try {
+                            const hover = await tsgo.getHover(path.resolve(absBase, sym.filePath), sym.startLine - 1, 0);
+                            if (hover) {
+                                const clean = hover.replace(/```\w*\n?/g, '').replace(/```/g, '').trim();
+                                signatures.set(sym.id, clean);
+                            }
+                        }
+                        catch { }
+                    }
+                }
+            }
+        }
+        // Build result
+        const actualFilePath = fileNodes.find(n => n.label === 'File')?.filePath ?? filePath;
+        const fileName = actualFilePath.split('/').pop() ?? filePath;
+        const module = communityMap.values().next().value ?? null;
+        // Group by label
+        const grouped = new Map();
+        for (const sym of symbols) {
+            const list = grouped.get(sym.label) ?? [];
+            list.push(sym);
+            grouped.set(sym.label, list);
+        }
+        return {
+            status: 'file_overview',
+            file: actualFilePath,
+            fileName,
+            module,
+            symbolCount: symbols.length,
+            symbols: symbols.map(sym => ({
+                uid: sym.id,
+                name: sym.name,
+                kind: sym.label,
+                startLine: sym.startLine,
+                endLine: sym.endLine,
+                signature: signatures.get(sym.id) ?? null,
+                callers: callerCounts.get(sym.id) ?? 0,
+                callees: calleeCounts.get(sym.id) ?? 0,
+                module: communityMap.get(sym.id) ?? null,
+                ...(includeContent ? { content: sym.content } : {}),
+            })),
+        };
+    }
+    /** Context tool: 360-degree symbol view, file overview, or disambiguation */
     async context(repo, params) {
         await this.ensureInitialized(repo.id);
         const { name, uid, file_path, include_content } = params;
+        // File overview mode: file_path only, no symbol name
+        if (file_path && !name && !uid) {
+            return this.fileOverview(repo, file_path, include_content, params.tsgo);
+        }
         if (!name && !uid) {
-            return { error: 'Either "name" or "uid" parameter is required.' };
+            return { error: 'Either "name", "uid", or "file_path" parameter is required.' };
         }
         // Step 1: Find the symbol
         let symbols;
+        const db = this.getDb(repo.id);
         if (uid) {
-            // Always fetch content for signature extraction (token-efficient alternative to full Read calls)
-            symbols = await executeParameterized(repo.id, `
-        MATCH (n {id: $uid})
-        RETURN n.id AS id, n.name AS name, labels(n) AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine, n.content AS content
-        LIMIT 1
-      `, { uid });
+            const node = getNode(db, toNodeId(uid));
+            symbols = node ? [{ id: node.id, name: node.name, type: node.label, filePath: node.filePath, startLine: node.startLine, endLine: node.endLine, content: node.content }] : [];
         }
         else {
             const isQualified = name.includes('/') || name.includes(':');
-            let whereClause;
-            let queryParams;
+            let matchedNodes;
             if (file_path) {
-                whereClause = `WHERE n.name = $symName AND n.filePath CONTAINS $filePath`;
-                queryParams = { symName: name, filePath: file_path };
+                matchedNodes = findNodesByName(db, name).filter(n => n.filePath.includes(file_path));
             }
             else if (isQualified) {
-                whereClause = `WHERE n.id = $symName OR n.name = $symName`;
-                queryParams = { symName: name };
+                const byId = getNode(db, toNodeId(name));
+                matchedNodes = byId ? [byId] : findNodesByName(db, name, undefined, 10);
             }
             else {
-                whereClause = `WHERE n.name = $symName`;
-                queryParams = { symName: name };
+                matchedNodes = findNodesByName(db, name, undefined, 10);
             }
-            symbols = await executeParameterized(repo.id, `
-        MATCH (n) ${whereClause}
-        RETURN n.id AS id, n.name AS name, labels(n) AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine, n.content AS content
-        LIMIT 10
-      `, queryParams);
+            symbols = matchedNodes.map(n => ({ id: n.id, name: n.name, type: n.label, filePath: n.filePath, startLine: n.startLine, endLine: n.endLine, content: n.content }));
         }
+        // Symbol not found in graph — try tsgo live lookup for recently created symbols
         if (symbols.length === 0) {
+            try {
+                const tsgoFallback = params?.tsgo !== false ? await this.getTsgo(repo) : null;
+                if (tsgoFallback && name) {
+                    // Search FTS for files that mention this symbol, then ask tsgo for the type
+                    const searchResults = searchFTS(db, name, 5);
+                    for (const sr of searchResults) {
+                        if (sr.filePath && /\.(ts|tsx|js|jsx|mts|mjs)$/.test(sr.filePath)) {
+                            // Look up the full node to get startLine/endLine
+                            const fullNode = getNode(db, sr.id);
+                            const startLine = fullNode?.startLine ?? 1;
+                            const absPath = path.resolve(repo.repoPath, sr.filePath);
+                            const hover = await tsgoFallback.getHover(absPath, startLine - 1, 0);
+                            if (hover) {
+                                // Found it via tsgo — return a minimal context with live data
+                                const cleaned = hover.replace(/^```\w*\n?/, '').replace(/\n?```$/, '').trim();
+                                return {
+                                    status: 'found',
+                                    symbol: {
+                                        uid: sr.id,
+                                        name: sr.name ?? name,
+                                        kind: sr.label ?? 'Symbol',
+                                        filePath: sr.filePath,
+                                        startLine: fullNode?.startLine ?? null,
+                                        endLine: fullNode?.endLine ?? null,
+                                        signature: cleaned || name,
+                                        _source: 'tsgo-live',
+                                    },
+                                    incoming: {},
+                                    outgoing: {},
+                                    processes: [],
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // tsgo fallback lookup failed — return normal not-found error
+            }
             return { error: `Symbol '${name || uid}' not found` };
         }
         // Step 2: Disambiguation
@@ -1934,74 +1702,102 @@ export class LocalBackend {
                 status: 'ambiguous',
                 message: `Found ${symbols.length} symbols matching '${name}'. Use uid or file_path to disambiguate.`,
                 candidates: symbols.map((s) => ({
-                    uid: s.id || s[0],
-                    name: s.name || s[1],
-                    kind: s.type || s[2],
-                    filePath: s.filePath || s[3],
-                    line: s.startLine || s[4],
+                    uid: s.id,
+                    name: s.name,
+                    kind: s.type,
+                    filePath: s.filePath,
+                    line: s.startLine,
                 })),
             };
         }
         // Step 3: Build full context
         const sym = symbols[0];
-        const symId = sym.id || sym[0];
-        // Categorized incoming refs (F3: line numbers, E1: UNION ALL for single round-trip)
-        // KuzuDB bug: `r.type IN [list]` drops results. Use UNION ALL as workaround.
+        const symId = sym.id;
+        // Categorized incoming refs
         const REL_TYPES = ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'DEPENDS_ON', 'PROVIDES'];
-        // Incoming: use lower confidence threshold (0.5) — callers are more important to see even if fuzzy
-        const incomingUnion = REL_TYPES.map(t => `MATCH (caller)-[r:CodeRelation {type: '${t}'}]->(n {id: '${symId.replace(/'/g, "''")}'}) WHERE r.confidence >= 0.5 RETURN '${t}' AS relType, caller.id AS uid, caller.name AS name, caller.filePath AS filePath, labels(caller) AS kind, caller.startLine AS startLine, r.reason AS reason LIMIT 15`).join(' UNION ALL ');
         let incomingRows = [];
-        try {
-            incomingRows = await executeQuery(repo.id, incomingUnion);
+        for (const relType of REL_TYPES) {
+            const edges = queries.findIncomingEdges(db, toNodeId(symId), relType, { minConfidence: 0.5, limit: 15 });
+            for (const { edge, node } of edges) {
+                incomingRows.push({
+                    relType, uid: node.id, name: node.name, filePath: node.filePath,
+                    kind: node.label, startLine: node.startLine, reason: edge.reason,
+                });
+            }
         }
-        catch { }
-        // Outgoing refs — lower threshold to 0.5 so dynamic imports (global tier) show up,
-        // but exclude generic method names that produce false positives at low confidence
-        const GENERIC_NAMES_EXCLUDE = ['has', 'get', 'set', 'add', 'remove', 'delete', 'close', 'stop', 'clear', 'reset', 'toString', 'valueOf', 'push', 'pop', 'entries', 'keys', 'values'];
-        const genericExclude = GENERIC_NAMES_EXCLUDE.map(n => `'${n}'`).join(', ');
-        const outgoingUnion = REL_TYPES.map(t => `MATCH (n {id: '${symId.replace(/'/g, "''")}'} )-[r:CodeRelation {type: '${t}'}]->(target) WHERE r.confidence >= 0.5 AND NOT target.name IN [${genericExclude}] RETURN '${t}' AS relType, target.id AS uid, target.name AS name, target.filePath AS filePath, labels(target) AS kind, target.startLine AS startLine, r.reason AS reason, r.callLine AS callLine LIMIT 15`).join(' UNION ALL ');
+        // Enrich incoming refs with tsgo live references (supplements stale graph)
+        // Agents can disable with tsgo: false for faster responses
+        const tsgo = params?.tsgo !== false ? await this.getTsgo(repo) : null;
+        if (tsgo && sym.filePath && /\.(ts|tsx|js|jsx|mts|mjs)$/.test(sym.filePath)) {
+            try {
+                const absPath = path.resolve(repo.repoPath, sym.filePath);
+                const liveRefs = await tsgo.findReferences(absPath, (sym.startLine ?? 1) - 1, 0);
+                // Merge live refs with graph refs — live refs may contain callers not in the graph
+                for (const ref of liveRefs) {
+                    // Skip self-references (same file, same line as the symbol definition)
+                    if (ref.filePath === sym.filePath && Math.abs(ref.line - ((sym.startLine ?? 1) - 1)) <= 1)
+                        continue;
+                    // Check if this reference is already known from the graph
+                    const alreadyKnown = incomingRows.some(row => row.filePath === ref.filePath && Math.abs((row.startLine ?? 0) - (ref.line + 1)) <= 2);
+                    if (!alreadyKnown) {
+                        // Find the enclosing function at this reference location
+                        const refNode = this.findNodeAtPosition(db, ref.filePath, ref.line);
+                        if (refNode) {
+                            incomingRows.push({
+                                relType: 'CALLS',
+                                uid: '',
+                                name: refNode.name,
+                                filePath: ref.filePath,
+                                kind: refNode.label,
+                                startLine: ref.line + 1,
+                                reason: 'tsgo-live',
+                            });
+                        }
+                    }
+                }
+            }
+            catch {
+                // tsgo reference lookup failed — non-fatal, graph results still available
+            }
+        }
+        // Outgoing refs — exclude generic method names that produce false positives at low confidence
+        const GENERIC_NAMES_EXCLUDE = new Set(['has', 'get', 'set', 'add', 'remove', 'delete', 'close', 'stop', 'clear', 'reset', 'toString', 'valueOf', 'push', 'pop', 'entries', 'keys', 'values']);
         let outgoingRows = [];
-        try {
-            outgoingRows = await executeQuery(repo.id, outgoingUnion);
+        for (const relType of REL_TYPES) {
+            const edges = queries.findOutgoingEdges(db, toNodeId(symId), relType, { minConfidence: 0.5, limit: 15 });
+            for (const { edge, node } of edges) {
+                if (edge.confidence < 0.6 && GENERIC_NAMES_EXCLUDE.has(node.name))
+                    continue;
+                outgoingRows.push({
+                    relType, uid: node.id, name: node.name, filePath: node.filePath,
+                    kind: node.label, startLine: node.startLine, reason: edge.reason, callLine: edge.callLine,
+                });
+            }
         }
-        catch { }
         // Process participation
-        let processRows = [];
-        try {
-            processRows = await executeParameterized(repo.id, `
-        MATCH (n {id: $symId})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-        RETURN p.id AS pid, p.heuristicLabel AS label, r.step AS step, p.stepCount AS stepCount
-      `, { symId });
-        }
-        catch (e) {
-            logQueryError('context:process-participation', e);
-        }
+        const procParticipation = queries.findProcessesForNode(db, toNodeId(symId));
+        const processRows = procParticipation.map(r => ({
+            pid: r.processId, label: r.heuristicLabel || r.label, step: r.step, stepCount: r.stepCount,
+        }));
         // C5: Module/cluster membership
+        const community = queries.findCommunityForNode(db, toNodeId(symId));
         let module;
-        try {
-            const clusterRows = await executeParameterized(repo.id, `
-        MATCH (n {id: $symId})-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-        RETURN c.heuristicLabel AS module
-        LIMIT 1
-      `, { symId });
-            if (clusterRows.length > 0) {
-                module = String(clusterRows[0].module ?? clusterRows[0][0] ?? '');
-            }
+        if (community) {
+            module = community.label;
         }
-        catch { }
-        // Helper to categorize refs
+        // Helper to categorize refs by relationship type
         const categorize = (rows) => {
             const cats = {};
             for (const row of rows) {
-                const relType = (row.relType || row[0] || '').toLowerCase();
+                const relType = row.relType.toLowerCase();
                 const entry = {
-                    uid: row.uid || row[1],
-                    name: row.name || row[2],
-                    filePath: row.filePath || row[3],
-                    kind: row.kind || row[4] || 'Symbol',
-                    startLine: row.startLine ?? row[5],
-                    reason: row.reason || row[6] || '',
-                    callLine: row.callLine ?? row[7],
+                    uid: row.uid,
+                    name: row.name,
+                    filePath: row.filePath,
+                    kind: row.kind || 'Symbol',
+                    startLine: row.startLine,
+                    reason: row.reason || '',
+                    callLine: row.callLine ?? null,
                 };
                 if (!cats[relType])
                     cats[relType] = [];
@@ -2010,104 +1806,47 @@ export class LocalBackend {
             return cats;
         };
         // Always extract signature for compact display
-        const rawContent = sym.content || sym[6] || '';
-        const signature = rawContent ? this.extractSignature(String(rawContent), sym.name || sym[1], sym.type || sym[2]) : (sym.name || sym[1]);
+        const rawContent = sym.content || '';
+        let signature = rawContent ? this.extractSignature(String(rawContent), sym.name, sym.type) : sym.name;
+        // Enrich with tsgo for live type information (TS/JS files only)
+        if (tsgo && sym.filePath && /\.(ts|tsx|js|jsx|mts|mjs)$/.test(sym.filePath)) {
+            try {
+                const absPath = path.resolve(repo.repoPath, sym.filePath);
+                const hover = await tsgo.getHover(absPath, (sym.startLine ?? 1) - 1, 0);
+                if (hover) {
+                    // Strip markdown code fences if present (```typescript ... ```)
+                    const cleaned = hover.replace(/^```\w*\n?/, '').replace(/\n?```$/, '').trim();
+                    if (cleaned)
+                        signature = cleaned;
+                }
+            }
+            catch {
+                // tsgo hover failed — non-fatal, use regex-based signature
+            }
+        }
         return {
             status: 'found',
             symbol: {
-                uid: sym.id || sym[0],
-                name: sym.name || sym[1],
-                kind: sym.type || sym[2],
-                filePath: sym.filePath || sym[3],
-                startLine: sym.startLine || sym[4],
-                endLine: sym.endLine || sym[5],
+                uid: sym.id,
+                name: sym.name,
+                kind: sym.type,
+                filePath: sym.filePath,
+                startLine: sym.startLine,
+                endLine: sym.endLine,
                 signature,
                 ...(module ? { module } : {}),
                 ...(include_content && rawContent ? { content: rawContent } : {}),
             },
             incoming: categorize(incomingRows),
             outgoing: categorize(outgoingRows),
-            processes: processRows.map((r) => ({
-                id: r.pid || r[0],
-                name: r.label || r[1],
-                step_index: r.step || r[2],
-                step_count: r.stepCount || r[3],
+            processes: processRows.map(r => ({
+                id: r.pid,
+                name: r.label,
+                step_index: r.step,
+                step_count: r.stepCount,
             })),
         };
     }
-    /** Legacy explore for backwards compatibility with resources.ts */
-    async explore(repo, params) {
-        await this.ensureInitialized(repo.id);
-        const { name, type } = params;
-        if (type === 'symbol') {
-            return this.context(repo, { name });
-        }
-        if (type === 'cluster') {
-            const clusters = await executeParameterized(repo.id, `
-        MATCH (c:Community)
-        WHERE c.label = $clusterName OR c.heuristicLabel = $clusterName
-        RETURN c.id AS id, c.label AS label, c.heuristicLabel AS heuristicLabel, c.cohesion AS cohesion, c.symbolCount AS symbolCount
-      `, { clusterName: name });
-            if (clusters.length === 0)
-                return { error: `Cluster '${name}' not found` };
-            const rawClusters = clusters.map((c) => ({
-                id: c.id || c[0], label: c.label || c[1], heuristicLabel: c.heuristicLabel || c[2],
-                cohesion: c.cohesion || c[3], symbolCount: c.symbolCount || c[4],
-            }));
-            let totalSymbols = 0, weightedCohesion = 0;
-            for (const c of rawClusters) {
-                const s = c.symbolCount || 0;
-                totalSymbols += s;
-                weightedCohesion += (c.cohesion || 0) * s;
-            }
-            const members = await executeParameterized(repo.id, `
-        MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-        WHERE c.label = $clusterName OR c.heuristicLabel = $clusterName
-        RETURN DISTINCT n.name AS name, labels(n) AS type, n.filePath AS filePath
-        LIMIT 30
-      `, { clusterName: name });
-            return {
-                cluster: {
-                    id: rawClusters[0].id,
-                    label: rawClusters[0].heuristicLabel || rawClusters[0].label,
-                    heuristicLabel: rawClusters[0].heuristicLabel || rawClusters[0].label,
-                    cohesion: totalSymbols > 0 ? weightedCohesion / totalSymbols : 0,
-                    symbolCount: totalSymbols,
-                    subCommunities: rawClusters.length,
-                },
-                members: members.map((m) => ({
-                    name: m.name || m[0], type: m.type || m[1], filePath: m.filePath || m[2],
-                })),
-            };
-        }
-        if (type === 'process') {
-            const processes = await executeParameterized(repo.id, `
-        MATCH (p:Process)
-        WHERE p.label = $processName OR p.heuristicLabel = $processName
-        RETURN p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount
-        LIMIT 1
-      `, { processName: name });
-            if (processes.length === 0)
-                return { error: `Process '${name}' not found` };
-            const proc = processes[0];
-            const procId = proc.id || proc[0];
-            const steps = await executeParameterized(repo.id, `
-        MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p {id: $procId})
-        RETURN n.name AS name, labels(n) AS type, n.filePath AS filePath, r.step AS step
-        ORDER BY r.step
-      `, { procId });
-            return {
-                process: {
-                    id: procId, label: proc.label || proc[1], heuristicLabel: proc.heuristicLabel || proc[2],
-                    processType: proc.processType || proc[3], stepCount: proc.stepCount || proc[4],
-                },
-                steps: steps.map((s) => ({
-                    step: s.step || s[3], name: s.name || s[0], type: s.type || s[1], filePath: s.filePath || s[2],
-                })),
-            };
-        }
-        return { error: 'Invalid type. Use: symbol, cluster, or process' };
-    }
     /** Detect changes: git-diff impact analysis mapping changed lines to symbols and processes */
     async detectChanges(repo, params) {
         await this.ensureInitialized(repo.id);
@@ -2147,10 +1886,13 @@ export class LocalBackend {
             const statOutput = execFileSync('git', statArgs, { cwd: repo.repoPath, encoding: 'utf-8' });
             for (const line of statOutput.trim().split('\n')) {
                 const parts = line.split('\t');
-                if (parts.length >= 3) {
-                    const added = parts[0] === '-' ? '?' : parts[0];
-                    const removed = parts[1] === '-' ? '?' : parts[1];
-                    diffStatMap.set(parts[2], `+${added}/-${removed}`);
+                const p0 = parts[0];
+                const p1 = parts[1];
+                const p2 = parts[2];
+                if (parts.length >= 3 && p0 && p1 && p2) {
+                    const added = p0 === '-' ? '?' : p0;
+                    const removed = p1 === '-' ? '?' : p1;
+                    diffStatMap.set(p2, `+${added}/-${removed}`);
                 }
             }
         }
@@ -2163,28 +1905,16 @@ export class LocalBackend {
             };
         }
         // Map changed files to indexed symbols
+        const db = this.getDb(repo.id);
         const changedSymbols = [];
         for (const file of changedFiles) {
             const normalizedFile = file.replace(/\\/g, '/');
-            try {
-                const symbols = await executeParameterized(repo.id, `
-          MATCH (n) WHERE n.filePath CONTAINS $filePath
-          RETURN n.id AS id, n.name AS name, labels(n) AS type, n.filePath AS filePath, n.startLine AS startLine
-          LIMIT 20
-        `, { filePath: normalizedFile });
-                for (const sym of symbols) {
-                    changedSymbols.push({
-                        id: sym.id || sym[0],
-                        name: sym.name || sym[1],
-                        type: sym.type || sym[2],
-                        filePath: sym.filePath || sym[3],
-                        startLine: sym.startLine ?? sym[4],
-                        change_type: 'Modified',
-                    });
-                }
-            }
-            catch (e) {
-                logQueryError('detect-changes:file-symbols', e);
+            const nodes = findNodesByFile(db, normalizedFile);
+            for (const node of nodes) {
+                changedSymbols.push({
+                    id: node.id, name: node.name, type: node.label,
+                    filePath: node.filePath, startLine: node.startLine, change_type: 'Modified',
+                });
             }
         }
         // Fix 7: Detect REAL interface changes by comparing signature text
@@ -2206,23 +1936,15 @@ export class LocalBackend {
             }
         };
         // Batch-fetch stored signatures from graph for changed symbols
-        const symIds = changedSymbols.filter(s => s.id).map(s => `'${String(s.id).replace(/'/g, "''")}'`);
         const storedSigs = new Map();
-        if (symIds.length > 0) {
-            try {
-                const sigRows = await executeParameterized(repo.id, `
-          MATCH (n) WHERE n.id IN [${symIds.join(', ')}]
-          RETURN n.id AS id, n.content AS content
-        `, {});
-                for (const row of sigRows) {
-                    const id = String(row.id ?? row[0]);
-                    const content = row.content ?? row[1];
-                    if (content) {
-                        storedSigs.set(id, this.extractSignature(String(content), '', ''));
-                    }
+        const sigNodeIds = changedSymbols.filter(s => s.id).map(s => toNodeId(String(s.id)));
+        if (sigNodeIds.length > 0) {
+            const sigNodes = queries.findNodesByIds(db, sigNodeIds);
+            for (const node of sigNodes) {
+                if (node.content) {
+                    storedSigs.set(node.id, this.extractSignature(String(node.content), '', ''));
                 }
             }
-            catch { }
         }
         // Compare stored signatures against current file content
         for (const sym of changedSymbols) {
@@ -2241,7 +1963,8 @@ export class LocalBackend {
             let currentSig = null;
             const namePattern = new RegExp(`\\b${sym.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`);
             for (let i = searchStart; i < searchEnd; i++) {
-                if (namePattern.test(lines[i])) {
+                const line = lines[i];
+                if (line && namePattern.test(line)) {
                     currentSig = this.extractSignature(lines.slice(Math.max(0, i - 1), i + 5).join('\n'), sym.name, sym.type);
                     break;
                 }
@@ -2253,30 +1976,24 @@ export class LocalBackend {
         // Find affected processes
         const affectedProcesses = new Map();
         for (const sym of changedSymbols) {
-            try {
-                const procs = await executeParameterized(repo.id, `
-          MATCH (n {id: $nodeId})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-          RETURN p.id AS pid, p.heuristicLabel AS label, p.processType AS processType, p.stepCount AS stepCount, r.step AS step
-        `, { nodeId: sym.id });
-                for (const proc of procs) {
-                    const pid = proc.pid || proc[0];
-                    if (!affectedProcesses.has(pid)) {
-                        affectedProcesses.set(pid, {
-                            id: pid,
-                            name: proc.label || proc[1],
-                            process_type: proc.processType || proc[2],
-                            step_count: proc.stepCount || proc[3],
-                            changed_steps: [],
-                        });
-                    }
-                    affectedProcesses.get(pid).changed_steps.push({
-                        symbol: sym.name,
-                        step: proc.step || proc[4],
+            if (!sym.id)
+                continue;
+            const procData = queries.findProcessesForNode(db, toNodeId(String(sym.id)));
+            for (const proc of procData) {
+                const pid = proc.processId;
+                if (!affectedProcesses.has(pid)) {
+                    affectedProcesses.set(pid, {
+                        id: pid,
+                        name: proc.heuristicLabel || proc.label,
+                        process_type: proc.processType,
+                        step_count: proc.stepCount,
+                        changed_steps: [],
                     });
                 }
-            }
-            catch (e) {
-                logQueryError('detect-changes:process-lookup', e);
+                affectedProcesses.get(pid).changed_steps.push({
+                    symbol: sym.name,
+                    step: proc.step,
+                });
             }
         }
         const processCount = affectedProcesses.size;
@@ -2310,11 +2027,14 @@ export class LocalBackend {
             return full;
         };
         // Step 1: Find the target symbol (reuse context's lookup)
-        const lookupResult = await this.context(repo, {
-            name: params.symbol_name,
-            uid: params.symbol_uid,
-            file_path,
-        });
+        const contextParams = {};
+        if (params.symbol_name)
+            contextParams.name = params.symbol_name;
+        if (params.symbol_uid)
+            contextParams.uid = params.symbol_uid;
+        if (file_path)
+            contextParams.file_path = file_path;
+        const lookupResult = await this.context(repo, contextParams);
         if (lookupResult.status === 'ambiguous') {
             return lookupResult; // pass disambiguation through
         }
@@ -2340,9 +2060,10 @@ export class LocalBackend {
                 const content = await fs.readFile(assertSafePath(sym.filePath), 'utf-8');
                 const lines = content.split('\n');
                 const lineIdx = sym.startLine - 1;
-                if (lineIdx >= 0 && lineIdx < lines.length && lines[lineIdx].includes(oldName)) {
+                const defLine = lines[lineIdx];
+                if (lineIdx >= 0 && lineIdx < lines.length && defLine && defLine.includes(oldName)) {
                     const defRegex = new RegExp(`\\b${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g');
-                    addEdit(sym.filePath, sym.startLine, lines[lineIdx].trim(), lines[lineIdx].replace(defRegex, new_name).trim(), 'graph');
+                    addEdit(sym.filePath, sym.startLine, defLine.trim(), defLine.replace(defRegex, new_name).trim(), 'graph');
                 }
             }
             catch (e) {
@@ -2364,8 +2085,9 @@ export class LocalBackend {
                 const content = await fs.readFile(assertSafePath(ref.filePath), 'utf-8');
                 const lines = content.split('\n');
                 for (let i = 0; i < lines.length; i++) {
-                    if (lines[i].includes(oldName)) {
-                        addEdit(ref.filePath, i + 1, lines[i].trim(), lines[i].replace(new RegExp(`\\b${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g'), new_name).trim(), 'graph');
+                    const refLine = lines[i];
+                    if (refLine && refLine.includes(oldName)) {
+                        addEdit(ref.filePath, i + 1, refLine.trim(), refLine.replace(new RegExp(`\\b${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g'), new_name).trim(), 'graph');
                         graphEdits++;
                         break; // one edit per file from graph refs
                     }
@@ -2399,10 +2121,13 @@ export class LocalBackend {
                     const lines = content.split('\n');
                     const regex = new RegExp(`\\b${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g');
                     for (let i = 0; i < lines.length; i++) {
+                        const searchLine = lines[i];
+                        if (!searchLine)
+                            continue;
                         regex.lastIndex = 0;
-                        if (regex.test(lines[i])) {
+                        if (regex.test(searchLine)) {
                             regex.lastIndex = 0;
-                            addEdit(normalizedFile, i + 1, lines[i].trim(), lines[i].replace(regex, new_name).trim(), 'text_search');
+                            addEdit(normalizedFile, i + 1, searchLine.trim(), searchLine.replace(regex, new_name).trim(), 'text_search');
                             astSearchEdits++;
                         }
                     }
@@ -2447,144 +2172,133 @@ export class LocalBackend {
     }
     async impact(repo, params) {
         await this.ensureInitialized(repo.id);
+        const db = this.getDb(repo.id);
         const { target, direction } = params;
         const maxDepth = params.maxDepth || 3;
         const rawRelTypes = params.relationTypes && params.relationTypes.length > 0
             ? params.relationTypes.filter(t => VALID_RELATION_TYPES.has(t))
             : ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'DEPENDS_ON', 'PROVIDES'];
         const relationTypes = rawRelTypes.length > 0 ? rawRelTypes : ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'DEPENDS_ON', 'PROVIDES'];
-        const includeTests = params.includeTests ?? false;
+        const includeTests = params.includeTests ?? true;
         const minConfidence = params.minConfidence ?? 0.6;
-        // d=1 uses lower threshold (0.5) — direct callers are critical, even dynamic imports
-        // d=2+ uses 0.6 to avoid noise explosion from transitive fuzzy edges
-        const d1Confidence = Math.min(minConfidence, 0.5);
-        // C6: Use OR chain instead of IN list — KuzuDB IN list silently drops results
-        const relTypeFilter = relationTypes.map(t => `r.type = '${t}'`).join(' OR ');
-        // Generic method names that produce false positives at low confidence
-        const IMPACT_GENERIC_NAMES = new Set(['has', 'get', 'set', 'add', 'remove', 'delete', 'close', 'stop', 'clear', 'reset', 'toString', 'valueOf', 'push', 'pop', 'entries', 'keys', 'values']);
-        const targets = await executeParameterized(repo.id, `
-      MATCH (n)
-      WHERE n.name = $targetName
-      RETURN n.id AS id, n.name AS name, labels(n) AS type, n.filePath AS filePath
-      LIMIT 1
-    `, { targetName: target });
-        if (targets.length === 0)
-            return { error: `Target '${target}' not found` };
-        const sym = targets[0];
-        const symId = sym.id || sym[0];
-        // Safety caps: prevent OOM / segfaults on high-fan-in graphs.
-        // Without caps, a hub with 50 callers explodes: d1=50, d2=1500, d3=45000,
-        // producing ~400KB Cypher WHERE-IN clauses that crash LadybugDB.
-        const MAX_IMPACTED = 500;
-        const MAX_FRONTIER_PER_DEPTH = 200;
-        const impacted = [];
-        const visited = new Set([symId]);
-        let frontier = [symId];
-        let truncated = false;
-        for (let depth = 1; depth <= maxDepth && frontier.length > 0; depth++) {
-            const nextFrontier = [];
-            // Cap frontier to prevent massive Cypher queries
-            const effectiveFrontier = frontier.length > MAX_FRONTIER_PER_DEPTH
-                ? (truncated = true, frontier.slice(0, MAX_FRONTIER_PER_DEPTH))
-                : frontier;
-            // Batch frontier nodes into a single Cypher query per depth level
-            const idList = effectiveFrontier.map(id => `'${id.replace(/'/g, "''")}'`).join(', ');
-            // Per-depth confidence: d=1 uses lower threshold to catch dynamic imports
-            const depthConfidence = depth === 1 ? d1Confidence : minConfidence;
-            const confidenceFilter = depthConfidence > 0 ? ` AND r.confidence >= ${depthConfidence}` : '';
-            const query = direction === 'upstream'
-                ? `MATCH (caller)-[r:CodeRelation]->(n) WHERE n.id IN [${idList}] AND (${relTypeFilter})${confidenceFilter} RETURN n.id AS sourceId, caller.id AS id, caller.name AS name, labels(caller) AS nodeType, caller.filePath AS filePath, r.type AS relType, r.confidence AS confidence`
-                : `MATCH (n)-[r:CodeRelation]->(callee) WHERE n.id IN [${idList}] AND (${relTypeFilter})${confidenceFilter} RETURN n.id AS sourceId, callee.id AS id, callee.name AS name, labels(callee) AS nodeType, callee.filePath AS filePath, r.type AS relType, r.confidence AS confidence`;
-            try {
-                const related = await executeQuery(repo.id, query);
-                for (const rel of related) {
-                    const relId = rel.id || rel[1];
-                    const filePath = rel.filePath || rel[4] || '';
-                    if (!includeTests && isTestFilePath(filePath))
-                        continue;
-                    // Skip generic method names at low confidence (false positives like Map.has → type-env.has)
-                    const relName = rel.name || rel[2] || '';
-                    const relConf = rel.confidence || rel[6] || 1.0;
-                    if (relConf < 0.6 && IMPACT_GENERIC_NAMES.has(relName))
-                        continue;
-                    if (!visited.has(relId)) {
-                        visited.add(relId);
-                        nextFrontier.push(relId);
-                        impacted.push({
-                            depth,
-                            id: relId,
-                            name: rel.name || rel[2],
-                            type: rel.nodeType || rel[3] || 'Symbol',
-                            filePath,
-                            relationType: rel.relType || rel[5],
-                            confidence: rel.confidence || rel[6] || 1.0,
-                        });
-                        // Cap total impacted count
-                        if (impacted.length >= MAX_IMPACTED) {
-                            truncated = true;
-                            break;
-                        }
-                    }
+        // Find target symbol — disambiguate by file_path if provided
+        let targetNodes = findNodesByName(db, target, undefined, 20);
+        if (params.file_path && targetNodes.length > 1) {
+            const fp = params.file_path;
+            const filtered = targetNodes.filter(n => n.filePath.includes(fp));
+            if (filtered.length > 0)
+                targetNodes = filtered;
+        }
+        // If still ambiguous, prefer the symbol with the most callers (most impactful)
+        let sym = targetNodes[0];
+        if (targetNodes.length > 1) {
+            let maxCallers = -1;
+            for (const node of targetNodes) {
+                const callerCount = db.prepare(`SELECT COUNT(*) as cnt FROM edges WHERE targetId = ? AND type = 'CALLS'`).get(node.id)?.cnt ?? 0;
+                if (callerCount > maxCallers) {
+                    maxCallers = callerCount;
+                    sym = node;
                 }
             }
-            catch (e) {
-                logQueryError('impact:depth-traversal', e);
+        }
+        if (!sym)
+            return { error: `Target '${target}' not found` };
+        const symId = sym.id;
+        // RC-F: For Class/Interface/Struct nodes, also traverse through their methods.
+        // Impact on a class should include impact on all its methods (via HAS_METHOD edges).
+        const startIds = [symId];
+        if (sym.label === 'Class' || sym.label === 'Interface' || sym.label === 'Struct') {
+            const methodRows = db.prepare(`SELECT targetId FROM edges WHERE sourceId = ? AND type = 'HAS_METHOD'`).all(symId);
+            for (const row of methodRows) {
+                startIds.push(toNodeId(row.targetId));
+            }
+        }
+        // Validate each edge type from user input
+        const validatedEdgeTypes = relationTypes.map(rt => {
+            assertEdgeType(rt);
+            return rt;
+        });
+        // Multi-hop BFS traversal via queries.traverseImpact
+        // For classes, traverse from each method start ID and merge results
+        const mergedNodes = [];
+        const seenIds = new Set();
+        let anyTruncated = false;
+        for (const sid of startIds) {
+            const partial = queries.traverseImpact(db, sid, direction, {
+                maxDepth,
+                edgeTypes: validatedEdgeTypes,
+                minConfidence,
+                includeTests,
+                maxImpacted: 500,
+                maxFrontierPerDepth: 200,
+            });
+            if (partial.truncated)
+                anyTruncated = true;
+            for (const node of partial.nodes) {
+                // Skip the class's own methods and the start node itself
+                if (startIds.some(s => s === node.id))
+                    continue;
+                if (!seenIds.has(node.id)) {
+                    seenIds.add(node.id);
+                    mergedNodes.push(node);
+                }
             }
-            if (impacted.length >= MAX_IMPACTED)
-                break;
-            frontier = nextFrontier;
         }
+        const impacted = mergedNodes;
+        const truncated = anyTruncated;
         const grouped = {};
         for (const item of impacted) {
-            if (!grouped[item.depth])
-                grouped[item.depth] = [];
-            grouped[item.depth].push(item);
+            let bucket = grouped[item.depth];
+            if (!bucket) {
+                bucket = [];
+                grouped[item.depth] = bucket;
+            }
+            bucket.push(item);
         }
-        // ── Enrichment: affected processes, modules, risk ──────────────
+        // Enrichment: affected processes, modules, risk
         const directCount = (grouped[1] || []).length;
         let affectedProcesses = [];
         let affectedModules = [];
         if (impacted.length > 0) {
-            const allIds = impacted.map(i => `'${i.id.replace(/'/g, "''")}'`).join(', ');
-            const d1Ids = (grouped[1] || []).map((i) => `'${i.id.replace(/'/g, "''")}'`).join(', ');
-            // Affected processes: which execution flows are broken and at which step
-            const [processRows, moduleRows, directModuleRows] = await Promise.all([
-                executeQuery(repo.id, `
-          MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-          WHERE s.id IN [${allIds}]
-          RETURN p.heuristicLabel AS name, COUNT(DISTINCT s.id) AS hits, MIN(r.step) AS minStep, p.stepCount AS stepCount
-          ORDER BY hits DESC
-          LIMIT 20
-        `).catch(() => []),
-                executeQuery(repo.id, `
-          MATCH (s)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-          WHERE s.id IN [${allIds}]
-          RETURN c.heuristicLabel AS name, COUNT(DISTINCT s.id) AS hits
-          ORDER BY hits DESC
-          LIMIT 20
-        `).catch(() => []),
-                d1Ids ? executeQuery(repo.id, `
-          MATCH (s)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-          WHERE s.id IN [${d1Ids}]
-          RETURN DISTINCT c.heuristicLabel AS name
-          LIMIT 20
-        `).catch(() => []) : Promise.resolve([]),
-            ]);
-            affectedProcesses = processRows.map((r) => ({
-                name: r.name || r[0],
-                hits: r.hits || r[1],
-                broken_at_step: r.minStep ?? r[2],
-                step_count: r.stepCount ?? r[3],
-            }));
-            const directModuleSet = new Set(directModuleRows.map((r) => r.name || r[0]));
-            affectedModules = moduleRows.map((r) => {
-                const name = r.name || r[0];
-                return {
-                    name,
-                    hits: r.hits || r[1],
-                    impact: directModuleSet.has(name) ? 'direct' : 'indirect',
-                };
-            });
+            const allImpactedIds = impacted.map(i => i.id);
+            const d1Ids = impacted.filter(i => i.depth === 1).map(i => i.id);
+            // Batch process lookup for all impacted nodes
+            try {
+                const processHits = queries.batchFindProcesses(db, allImpactedIds);
+                const procMap = new Map();
+                for (const r of processHits) {
+                    const key = r.processId;
+                    const existing = procMap.get(key);
+                    if (!existing) {
+                        procMap.set(key, { name: r.heuristicLabel || r.label, hits: 1, minStep: r.step, stepCount: r.stepCount });
+                    }
+                    else {
+                        existing.hits++;
+                        if (r.step < existing.minStep)
+                            existing.minStep = r.step;
+                    }
+                }
+                affectedProcesses = Array.from(procMap.values())
+                    .sort((a, b) => b.hits - a.hits)
+                    .slice(0, 20)
+                    .map(p => ({ name: p.name, hits: p.hits, broken_at_step: p.minStep, step_count: p.stepCount }));
+            }
+            catch { }
+            // Batch community lookup for all impacted + d1 nodes
+            try {
+                const communityHits = queries.batchFindCommunities(db, allImpactedIds);
+                const modMap = new Map();
+                for (const r of communityHits) {
+                    modMap.set(r.module, (modMap.get(r.module) || 0) + 1);
+                }
+                const d1CommunityHits = queries.batchFindCommunities(db, d1Ids);
+                const directModuleSet = new Set(d1CommunityHits.map(r => r.module));
+                affectedModules = Array.from(modMap.entries())
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, 20)
+                    .map(([name, hits]) => ({ name, hits, impact: directModuleSet.has(name) ? 'direct' : 'indirect' }));
+            }
+            catch { }
         }
         // Risk scoring
         const processCount = affectedProcesses.length;
@@ -2602,9 +2316,9 @@ export class LocalBackend {
         return {
             target: {
                 id: symId,
-                name: sym.name || sym[1],
-                type: sym.type || sym[2],
-                filePath: sym.filePath || sym[3],
+                name: sym.name,
+                type: sym.label,
+                filePath: sym.filePath,
             },
             direction,
             impactedCount: impacted.length,
@@ -2625,20 +2339,13 @@ export class LocalBackend {
     async queryClusters(repoName, limit = 100) {
         const repo = await this.resolveRepo(repoName);
         await this.ensureInitialized(repo.id);
+        const db = this.getDb(repo.id);
         try {
             const rawLimit = Math.max(limit * 5, 200);
-            const clusters = await executeQuery(repo.id, `
-        MATCH (c:Community)
-        RETURN c.id AS id, c.label AS label, c.heuristicLabel AS heuristicLabel, c.cohesion AS cohesion, c.symbolCount AS symbolCount
-        ORDER BY c.symbolCount DESC
-        LIMIT ${rawLimit}
-      `);
-            const rawClusters = clusters.map((c) => ({
-                id: c.id || c[0],
-                label: c.label || c[1],
-                heuristicLabel: c.heuristicLabel || c[2],
-                cohesion: c.cohesion || c[3],
-                symbolCount: c.symbolCount || c[4],
+            const clusterNodes = queries.listCommunities(db, rawLimit);
+            const rawClusters = clusterNodes.map(c => ({
+                id: c.id, label: c.name, heuristicLabel: c.heuristicLabel || c.name,
+                cohesion: c.cohesion, symbolCount: c.symbolCount,
             }));
             return { clusters: this.aggregateClusters(rawClusters).slice(0, limit) };
         }
@@ -2650,20 +2357,13 @@ export class LocalBackend {
     async queryProcesses(repoName, limit = 50) {
         const repo = await this.resolveRepo(repoName);
         await this.ensureInitialized(repo.id);
+        const db = this.getDb(repo.id);
         try {
-            const processes = await executeQuery(repo.id, `
-        MATCH (p:Process)
-        RETURN p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount
-        ORDER BY p.stepCount DESC
-        LIMIT ${limit}
-      `);
+            const processNodes = queries.listProcesses(db, limit);
             return {
-                processes: processes.map((p) => ({
-                    id: p.id || p[0],
-                    label: p.label || p[1],
-                    heuristicLabel: p.heuristicLabel || p[2],
-                    processType: p.processType || p[3],
-                    stepCount: p.stepCount || p[4],
+                processes: processNodes.map(p => ({
+                    id: p.id, label: p.name, heuristicLabel: p.heuristicLabel || p.name,
+                    processType: p.processType, stepCount: p.stepCount,
                 })),
             };
         }
@@ -2675,16 +2375,13 @@ export class LocalBackend {
     async queryClusterDetail(name, repoName) {
         const repo = await this.resolveRepo(repoName);
         await this.ensureInitialized(repo.id);
-        const clusters = await executeParameterized(repo.id, `
-      MATCH (c:Community)
-      WHERE c.label = $clusterName OR c.heuristicLabel = $clusterName
-      RETURN c.id AS id, c.label AS label, c.heuristicLabel AS heuristicLabel, c.cohesion AS cohesion, c.symbolCount AS symbolCount
-    `, { clusterName: name });
-        if (clusters.length === 0)
+        const db = this.getDb(repo.id);
+        const communityNodes = queries.findCommunitiesByName(db, name);
+        if (communityNodes.length === 0)
             return { error: `Cluster '${name}' not found` };
-        const rawClusters = clusters.map((c) => ({
-            id: c.id || c[0], label: c.label || c[1], heuristicLabel: c.heuristicLabel || c[2],
-            cohesion: c.cohesion || c[3], symbolCount: c.symbolCount || c[4],
+        const rawClusters = communityNodes.map(c => ({
+            id: c.id, label: c.name, heuristicLabel: c.heuristicLabel || c.name,
+            cohesion: c.cohesion, symbolCount: c.symbolCount,
         }));
         let totalSymbols = 0, weightedCohesion = 0;
         for (const c of rawClusters) {
@@ -2692,23 +2389,21 @@ export class LocalBackend {
             totalSymbols += s;
             weightedCohesion += (c.cohesion || 0) * s;
         }
-        const members = await executeParameterized(repo.id, `
-      MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-      WHERE c.label = $clusterName OR c.heuristicLabel = $clusterName
-      RETURN DISTINCT n.name AS name, labels(n) AS type, n.filePath AS filePath
-      LIMIT 30
-    `, { clusterName: name });
+        const memberNodes = queries.getCommunityMembers(db, name, 30);
+        const firstCluster = rawClusters[0];
+        if (!firstCluster)
+            return { error: `Cluster '${name}' not found` };
         return {
             cluster: {
-                id: rawClusters[0].id,
-                label: rawClusters[0].heuristicLabel || rawClusters[0].label,
-                heuristicLabel: rawClusters[0].heuristicLabel || rawClusters[0].label,
+                id: firstCluster.id,
+                label: firstCluster.heuristicLabel || firstCluster.label,
+                heuristicLabel: firstCluster.heuristicLabel || firstCluster.label,
                 cohesion: totalSymbols > 0 ? weightedCohesion / totalSymbols : 0,
                 symbolCount: totalSymbols,
                 subCommunities: rawClusters.length,
             },
-            members: members.map((m) => ({
-                name: m.name || m[0], type: m.type || m[1], filePath: m.filePath || m[2],
+            members: memberNodes.map(m => ({
+                name: m.name, type: m.label, filePath: m.filePath,
             })),
         };
     }
@@ -2716,28 +2411,19 @@ export class LocalBackend {
     async queryProcessDetail(name, repoName) {
         const repo = await this.resolveRepo(repoName);
         await this.ensureInitialized(repo.id);
-        const processes = await executeParameterized(repo.id, `
-      MATCH (p:Process)
-      WHERE p.label = $processName OR p.heuristicLabel = $processName
-      RETURN p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount
-      LIMIT 1
-    `, { processName: name });
-        if (processes.length === 0)
+        const db = this.getDb(repo.id);
+        const processNodes = queries.findProcessesByName(db, name);
+        const proc = processNodes[0];
+        if (!proc)
             return { error: `Process '${name}' not found` };
-        const proc = processes[0];
-        const procId = proc.id || proc[0];
-        const steps = await executeParameterized(repo.id, `
-      MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p {id: $procId})
-      RETURN n.name AS name, labels(n) AS type, n.filePath AS filePath, r.step AS step
-      ORDER BY r.step
-    `, { procId });
+        const steps = queries.getProcessSteps(db, proc.id);
         return {
             process: {
-                id: procId, label: proc.label || proc[1], heuristicLabel: proc.heuristicLabel || proc[2],
-                processType: proc.processType || proc[3], stepCount: proc.stepCount || proc[4],
+                id: proc.id, label: proc.name, heuristicLabel: proc.heuristicLabel || proc.name,
+                processType: proc.processType, stepCount: proc.stepCount,
             },
-            steps: steps.map((s) => ({
-                step: s.step || s[3], name: s.name || s[0], type: s.type || s[1], filePath: s.filePath || s[2],
+            steps: steps.map(s => ({
+                step: s.step, name: s.node.name, type: s.node.label, filePath: s.node.filePath,
             })),
         };
     }
@@ -2745,8 +2431,13 @@ export class LocalBackend {
         for (const watcher of this.watchers.values())
             watcher.stop();
         this.watchers.clear();
-        stopTsgoService();
-        await closeLbug(); // close all connections
+        // Stop all per-repo tsgo LSP services
+        for (const service of this.tsgoServices.values()) {
+            service.stop();
+        }
+        this.tsgoServices.clear();
+        stopTsgoService(); // also stop the global singleton
+        closeDb(); // close all SQLite connections
         // Note: we intentionally do NOT call disposeEmbedder() here.
         // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs,
         // and importing the embedder module on Node v24+ crashes if onnxruntime
@@ -2754,6 +2445,5 @@ export class LocalBackend {
         // immediately after disconnect(), the OS reclaims everything. See #38, #89.
         this.repos.clear();
         this.contextCache.clear();
-        this.initializedRepos.clear();
     }
 }