devsmind-mcp 2.0.4 → 2.1.1

package/dist/db/database.js

@@ -45,6 +45,7 @@ const path = __importStar(require("path"));
 const zlib = __importStar(require("zlib"));
 const schema_1 = require("./schema");
 const config_1 = require("../utils/config");
+const ast_1 = require("../utils/ast");
 function compressText(text) {
     return zlib.deflateSync(Buffer.from(text, 'utf-8'));
 }
@@ -146,6 +147,72 @@ class DevMindDatabase {
             console.warn('⚠️ SQLite VACUUM failed:', err);
         }
     }
+    /**
+     * Wipes all nodes, connections, history, and system_meta from the DB, and clears
+     * the committed graph/ and history/ JSON directories on disk. Used by `--from-scratch`
+     * reindexing. This is destructive and irreversible from within the app — callers are
+     * responsible for confirming with the user first.
+     */
+    resetAll() {
+        this.db.exec('DELETE FROM node_connections');
+        this.db.exec('DELETE FROM history');
+        this.db.exec('DELETE FROM nodes');
+        this.db.exec('DELETE FROM system_meta');
+        const workspaceRoot = path.dirname(this.dbPath);
+        for (const dir of ['graph', 'history']) {
+            const p = path.join(workspaceRoot, dir);
+            if (fs.existsSync(p)) {
+                fs.rmSync(p, { recursive: true, force: true });
+            }
+            fs.mkdirSync(p, { recursive: true });
+        }
+        this.vacuum();
+    }
+    /**
+     * Deletes every connection from both the DB and (by rewriting each affected file's
+     * graph JSON) from disk. Used by `--edges-only` to rebuild the edge graph from
+     * scratch without touching nodes or history.
+     */
+    clearAllConnections() {
+        const rows = this.db.prepare('SELECT DISTINCT file_path FROM nodes WHERE deprecated = 0').all();
+        const affectedFilePaths = new Set();
+        for (const row of rows) {
+            for (const p of row.file_path.split(',').map(s => s.trim()).filter(Boolean)) {
+                affectedFilePaths.add(p);
+            }
+        }
+        this.db.exec('DELETE FROM node_connections');
+        for (const filePath of affectedFilePaths) {
+            this.writeGraphToDisk(filePath);
+        }
+    }
+    /**
+     * Deletes only the OUTGOING connections of the given source nodes (and re-syncs the
+     * affected files' graph JSON). Used by repo-scoped `--edges-only` so that rebuilding
+     * one repo's edges doesn't wipe every other repo's edges.
+     */
+    clearConnectionsForSources(nodeIds) {
+        if (nodeIds.length === 0)
+            return;
+        const affectedFilePaths = new Set();
+        const del = this.db.prepare('DELETE FROM node_connections WHERE source_node_id = ?');
+        const getFp = this.db.prepare('SELECT file_path FROM nodes WHERE id = ?');
+        const tx = this.db.transaction((ids) => {
+            for (const id of ids) {
+                const row = getFp.get(id);
+                if (row?.file_path) {
+                    for (const p of row.file_path.split(',').map(s => s.trim()).filter(Boolean)) {
+                        affectedFilePaths.add(p);
+                    }
+                }
+                del.run(id);
+            }
+        });
+        tx(nodeIds);
+        for (const filePath of affectedFilePaths) {
+            this.writeGraphToDisk(filePath);
+        }
+    }
     // --- Node Operations ---
     upsertNode(node) {
         const existing = this.getNode(node.id);
@@ -194,15 +261,26 @@ class DevMindDatabase {
     deleteNode(id) {
         const node = this.getNode(id);
         const resolvedId = node ? node.id : id;
+        // Capture caller files, and delete the node's history JSONs, BEFORE the row (and its
+        // cascade-deleted history rows / edges) is gone. Without the JSON cleanup, syncFromDisk()
+        // would resurrect the node from its lingering history/[id].json on the next server start.
+        const inboundSourceFiles = this.collectInboundSourceFiles(resolvedId);
+        this.deleteHistoryFilesForNode(resolvedId);
         const stmt = this.db.prepare('DELETE FROM nodes WHERE id = ?');
         stmt.run(resolvedId);
         if (node && node.file_path) {
             this.writeGraphToDisk(node.file_path);
         }
+        for (const p of inboundSourceFiles) {
+            this.writeGraphToDisk(p);
+        }
     }
     deprecateNode(id) {
         const node = this.getNode(id);
         const resolvedId = node ? node.id : id;
+        // Capture the caller files BEFORE we delete the inbound edges — afterwards the join
+        // that finds them returns nothing.
+        const inboundSourceFiles = this.collectInboundSourceFiles(resolvedId);
         const updateStmt = this.db.prepare('UPDATE nodes SET deprecated = 1 WHERE id = ?');
         const deleteConnStmt = this.db.prepare('DELETE FROM node_connections WHERE source_node_id = ? OR target_node_id = ?');
         const tx = this.db.transaction(() => {
@@ -210,9 +288,14 @@ class DevMindDatabase {
             deleteConnStmt.run(resolvedId, resolvedId);
         });
         tx();
+        // Rewrite the node's own file (now carrying deprecated:1) and every caller file (so their
+        // stale inbound edges don't resurrect the connection on the next syncFromDisk()).
         if (node && node.file_path) {
             this.writeGraphToDisk(node.file_path);
         }
+        for (const p of inboundSourceFiles) {
+            this.writeGraphToDisk(p);
+        }
     }
     renameNode(oldId, newId, newName) {
         const node = this.getNode(oldId);
@@ -247,17 +330,118 @@ class DevMindDatabase {
             if (node.file_path) {
                 this.writeGraphToDisk(node.file_path);
             }
+            // Edges pointing INTO the renamed node live in the SOURCE nodes' files' graph JSONs
+            // (which still reference oldId on disk). The DB was already repointed to newId above,
+            // so rewrite each such file — otherwise syncFromDisk reloads the stale oldId edge and
+            // the renamed node silently loses all its inbound ("used-by") edges.
+            this.rewriteInboundSourceFiles(newId);
+            // Keep the committed history/*.json files in sync with the rename. Without this,
+            // syncFromDisk() on the next server start would find the old node_id (which no
+            // longer exists in the DB) and re-insert it right back, undoing the rename.
+            const historyIds = this.db.prepare('SELECT id FROM history WHERE node_id = ?').all(newId);
+            for (const row of historyIds) {
+                this.patchHistoryDiskIdentity(row.id, newId, name, node.type, node.file_path, node.signature);
+            }
         }
         finally {
             this.db.pragma('foreign_keys = ON');
         }
     }
+    /**
+     * Rewrites a history/[id].json file's identifying fields (node_id, node_metadata) in
+     * place, leaving code_snapshot/reasoning/timestamps untouched. Used after a rename so
+     * disk stays consistent with the DB without needing the full code_snapshot/reasoning
+     * to be re-passed in.
+     */
+    patchHistoryDiskIdentity(historyId, nodeId, name, type, filePath, signature) {
+        try {
+            const historyDir = path.join(path.dirname(this.dbPath), 'history');
+            const filePathOnDisk = path.join(historyDir, `${historyId}.json`);
+            if (!fs.existsSync(filePathOnDisk))
+                return;
+            const data = JSON.parse(fs.readFileSync(filePathOnDisk, 'utf-8'));
+            data.node_id = nodeId;
+            data.node_metadata = {
+                name,
+                type,
+                file_path: this.toRepoRelativePath(filePath),
+                signature
+            };
+            fs.writeFileSync(filePathOnDisk, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch (err) {
+            console.warn('⚠️ SQLite warning: Failed to patch history JSON identity on disk:', err);
+        }
+    }
+    /**
+     * Collects the distinct file paths of every SOURCE node that has an OUTGOING edge pointing
+     * INTO `nodeId` (i.e. this node's "used-by" callers). Those inbound edges live on disk in the
+     * source nodes' files, not in the target's own file. Callers that DELETE the inbound edges
+     * (deprecate/delete) must call this BEFORE the deletion to capture the affected files;
+     * callers that merely repoint them (rename) can rewrite after the fact.
+     */
+    collectInboundSourceFiles(nodeId) {
+        const rows = this.db.prepare(`
+      SELECT DISTINCT n.file_path AS file_path
+      FROM node_connections c JOIN nodes n ON n.id = c.source_node_id
+      WHERE c.target_node_id = ?
+    `).all(nodeId);
+        const files = new Set();
+        for (const row of rows) {
+            if (!row.file_path)
+                continue;
+            for (const p of row.file_path.split(',').map(s => s.trim()).filter(Boolean)) {
+                files.add(p);
+            }
+        }
+        return Array.from(files);
+    }
+    /**
+     * Re-syncs each given source file's graph JSON. Used after the DB has been mutated so that
+     * syncFromDisk() won't reload a stale inbound ("used-by") edge on the next server start.
+     */
+    rewriteInboundSourceFiles(nodeId) {
+        for (const p of this.collectInboundSourceFiles(nodeId)) {
+            this.writeGraphToDisk(p);
+        }
+    }
+    /**
+     * Deletes the committed history/[id].json files for every history record of `nodeId`.
+     * Used on HARD delete so that syncFromDisk()'s history pass can't resurrect the node
+     * (and its metadata) from a lingering JSON on the next server start. Reads the history
+     * ids BEFORE the DB rows are removed, so call this while they still exist (or pass ids in).
+     */
+    deleteHistoryFilesForNode(nodeId) {
+        try {
+            const historyDir = path.join(path.dirname(this.dbPath), 'history');
+            const rows = this.db.prepare('SELECT id FROM history WHERE node_id = ?').all(nodeId);
+            for (const row of rows) {
+                const filePath = path.join(historyDir, `${row.id}.json`);
+                if (fs.existsSync(filePath))
+                    fs.unlinkSync(filePath);
+            }
+        }
+        catch (err) {
+            console.warn('⚠️ SQLite warning: Failed to delete history JSON(s) on disk:', err);
+        }
+    }
     // --- Connection Operations ---
     addConnection(sourceNodeId, targetNodeId) {
         const srcNode = this.getNode(sourceNodeId);
         const tgtNode = this.getNode(targetNodeId);
         const resolvedSrc = srcNode ? srcNode.id : sourceNodeId;
         const resolvedTgt = tgtNode ? tgtNode.id : targetNodeId;
+        // The on-disk graph format is node-anchored: each file's JSON lists its nodes and their
+        // OUTGOING edges. An edge whose SOURCE node doesn't exist has nowhere to be written on
+        // disk, so it would live only in brain.db and be silently dropped by syncFromDisk() on the
+        // next server start. Rather than leak that DB-only orphan, refuse the edge and tell the
+        // caller to add the source node first (the two-phase indexing protocol already does this).
+        if (!srcNode) {
+            console.warn(`⚠️ DevsMind: connection skipped — source node "${sourceNodeId}" does not exist in ` +
+                `the graph. Add it (stage_change / update_history) before connecting it, otherwise the edge ` +
+                `cannot be persisted to disk and would not survive a restart.`);
+            return;
+        }
         this.db.pragma('foreign_keys = OFF');
         try {
             const stmt = this.db.prepare(`
@@ -265,7 +449,7 @@ class DevMindDatabase {
         VALUES (?, ?)
       `);
             stmt.run(resolvedSrc, resolvedTgt);
-            if (srcNode && srcNode.file_path) {
+            if (srcNode.file_path) {
                 this.writeGraphToDisk(srcNode.file_path);
             }
         }
@@ -350,6 +534,13 @@ class DevMindDatabase {
         const rows = stmt.all(resolvedId);
         return rows.map(row => this.populateHistoryFromDisk(row));
     }
+    /** Distinct source node ids of edges pointing INTO this node (its "used-by" callers). */
+    getInboundSources(nodeId) {
+        const rows = this.db
+            .prepare('SELECT DISTINCT source_node_id FROM node_connections WHERE target_node_id = ?')
+            .all(nodeId);
+        return rows.map(r => r.source_node_id);
+    }
     getLatestCode(nodeId) {
         const node = this.getNode(nodeId);
         const resolvedId = node ? node.id : nodeId;
@@ -361,10 +552,74 @@ class DevMindDatabase {
             code_snapshot: history.code_snapshot
         };
     }
-    getGraph(nodeId, maxDepth = 6) {
+    /**
+     * Parse a node's CURRENT source straight off disk via the AST, bypassing the stored snapshot.
+     * `nodes.file_path` is already absolute, and may be a ", "-joined list when a symbol spans
+     * files — try each until one resolves. Returns null for non-TS/JS files, or when the symbol
+     * no longer exists in the file (renamed / moved / deleted).
+     */
+    extractLiveCode(node) {
+        const parsed = (0, ast_1.parseNodeId)(node.id);
+        // Pass the FULL symbol name ("Foo.bar") — extractNodeFromFile re-derives the class itself.
+        const symbol = parsed ? parsed.symbolName : node.id.split('#').pop() || node.name;
+        if (!symbol)
+            return null;
+        for (const p of String(node.file_path).split(',').map(s => s.trim()).filter(Boolean)) {
+            const derived = (0, ast_1.extractNodeFromFile)(p, symbol);
+            if (derived)
+                return derived.codeSnapshot;
+        }
+        return null;
+    }
+    /**
+     * Current code for a node, read from the file on disk (the source of truth) rather than the
+     * cached snapshot. Falls back to the snapshot only when the file can't be parsed for this
+     * symbol, and flags that fallback as unverified. When live code IS available, comparing it to
+     * the snapshot is free — so drift between the graph and disk is reported rather than hidden.
+     */
+    getLiveCode(nodeId) {
+        const node = this.getNode(nodeId);
+        const resolvedId = node ? node.id : nodeId;
+        const snapshot = this.getLatestCode(resolvedId);
+        if (node) {
+            const live = this.extractLiveCode(node);
+            if (live !== null) {
+                return {
+                    exists: true,
+                    node_id: node.id,
+                    file_path: node.file_path,
+                    code: live,
+                    source: 'live',
+                    // Snapshot exists but disagrees with disk → the graph has drifted.
+                    snapshot_outdated: snapshot ? snapshot.code_snapshot !== live : undefined,
+                    updated_at: snapshot?.updated_at
+                };
+            }
+        }
+        if (snapshot) {
+            return {
+                exists: true,
+                node_id: resolvedId,
+                file_path: node?.file_path,
+                code: snapshot.code_snapshot,
+                source: 'cached',
+                // Could not confirm against disk (non-TS/JS file, or symbol gone) — treat as suspect.
+                snapshot_outdated: true,
+                updated_at: snapshot.updated_at,
+                message: 'Could not locate this symbol in its source file — the file may not be TS/JS, or the symbol was renamed, moved, or deleted. Returning the last cached snapshot, which may be out of date. Verify against the file before relying on it.'
+            };
+        }
+        return {
+            exists: false,
+            node_id: resolvedId,
+            message: 'No code found on disk or in cache. Read the source file, then stage_change + commit_changes so future agents skip the file read entirely.'
+        };
+    }
+    getGraph(nodeId, maxDepth = 6, opts = {}) {
+        const direction = opts.direction ?? 'both';
+        const codeCharBudget = opts.codeCharBudget ?? 60_000;
         const maxNodesLimit = 500;
         const visited = new Set();
-        const queue = [{ id: nodeId, depth: 0 }];
         const nodes = [];
         const connections = [];
         const connSet = new Set();
@@ -372,7 +627,11 @@ class DevMindDatabase {
         if (!rootNode) {
             return { nodes, connections };
         }
-        visited.add(nodeId);
+        // Seed with the CANONICAL id. getNode() resolves a bare, unqualified symbol name, but
+        // node_connections is keyed by the fully-qualified id — seeding the queue with the raw
+        // argument would find zero edges and return a lone root.
+        const queue = [{ id: rootNode.id, depth: 0 }];
+        visited.add(rootNode.id);
         nodes.push(rootNode);
         const usesStmt = this.db.prepare(`
       SELECT target_node_id FROM node_connections WHERE source_node_id = ?
@@ -385,50 +644,84 @@ class DevMindDatabase {
             if (current.depth >= maxDepth) {
                 continue;
             }
-            // Get outbound connections (what this node uses)
-            const outbound = usesStmt.all(current.id);
-            for (const row of outbound) {
-                const targetId = row.target_node_id;
-                const connKey = `${current.id}->${targetId}`;
-                if (!connSet.has(connKey)) {
-                    connSet.add(connKey);
-                    connections.push({ source_node_id: current.id, target_node_id: targetId });
-                }
-                if (!visited.has(targetId)) {
-                    visited.add(targetId);
-                    const targetNode = this.getNode(targetId);
-                    if (targetNode) {
-                        nodes.push(targetNode);
-                        if (nodes.length >= maxNodesLimit)
-                            break;
+            // Outbound — what this node uses (callees). Skipped when tracing callers only.
+            if (direction !== 'in') {
+                const outbound = usesStmt.all(current.id);
+                for (const row of outbound) {
+                    const targetId = row.target_node_id;
+                    const connKey = `${current.id}->${targetId}`;
+                    if (!connSet.has(connKey)) {
+                        connSet.add(connKey);
+                        connections.push({ source_node_id: current.id, target_node_id: targetId });
+                    }
+                    if (!visited.has(targetId)) {
+                        visited.add(targetId);
+                        const targetNode = this.getNode(targetId);
+                        if (targetNode) {
+                            nodes.push(targetNode);
+                            if (nodes.length >= maxNodesLimit)
+                                break;
+                        }
+                        queue.push({ id: targetId, depth: current.depth + 1 });
                     }
-                    queue.push({ id: targetId, depth: current.depth + 1 });
                 }
             }
             if (nodes.length >= maxNodesLimit)
                 break;
-            // Get inbound connections (what uses this node)
-            const inbound = usedByStmt.all(current.id);
-            for (const row of inbound) {
-                const sourceId = row.source_node_id;
-                const connKey = `${sourceId}->${current.id}`;
-                if (!connSet.has(connKey)) {
-                    connSet.add(connKey);
-                    connections.push({ source_node_id: sourceId, target_node_id: current.id });
-                }
-                if (!visited.has(sourceId)) {
-                    visited.add(sourceId);
-                    const sourceNode = this.getNode(sourceId);
-                    if (sourceNode) {
-                        nodes.push(sourceNode);
-                        if (nodes.length >= maxNodesLimit)
-                            break;
+            // Inbound — what uses this node (callers). Skipped when tracing a call flow outward.
+            if (direction !== 'out') {
+                const inbound = usedByStmt.all(current.id);
+                for (const row of inbound) {
+                    const sourceId = row.source_node_id;
+                    const connKey = `${sourceId}->${current.id}`;
+                    if (!connSet.has(connKey)) {
+                        connSet.add(connKey);
+                        connections.push({ source_node_id: sourceId, target_node_id: current.id });
+                    }
+                    if (!visited.has(sourceId)) {
+                        visited.add(sourceId);
+                        const sourceNode = this.getNode(sourceId);
+                        if (sourceNode) {
+                            nodes.push(sourceNode);
+                            if (nodes.length >= maxNodesLimit)
+                                break;
+                        }
+                        queue.push({ id: sourceId, depth: current.depth + 1 });
                     }
-                    queue.push({ id: sourceId, depth: current.depth + 1 });
                 }
             }
         }
-        return { nodes, connections };
+        const result = { nodes, connections };
+        if (opts.includeCode) {
+            let spent = 0;
+            let withoutCode = 0;
+            // `nodes` is in BFS order (nearest the root first), so the budget is spent on the most
+            // relevant code before anything is dropped.
+            for (const [i, n] of nodes.entries()) {
+                const live = this.extractLiveCode(n);
+                const code = live ?? this.getLatestCode(n.id)?.code_snapshot ?? null;
+                if (!code) {
+                    withoutCode++;
+                    continue;
+                }
+                // The root always gets its code — it is what was asked for, and dropping it would make
+                // the response useless. Every other node must fit in the REMAINING budget, so a single
+                // large node can't blow past the cap (it is skipped and counted, not truncated).
+                if (i > 0 && spent + code.length > codeCharBudget) {
+                    withoutCode++;
+                    continue;
+                }
+                n.code = code;
+                n.code_source = live !== null ? 'live' : 'cached';
+                spent += code.length;
+            }
+            result.code_chars = spent;
+            if (withoutCode > 0) {
+                result.code_truncated = true;
+                result.nodes_without_code = withoutCode;
+            }
+        }
+        return result;
     }
     updateHistory(params) {
         const { node_id, code_snapshot, reasoning } = params;
@@ -561,6 +854,73 @@ class DevMindDatabase {
         const wildcard = `%Decision: %${query}%`;
         return stmt.all(wildcard);
     }
+    searchCode(params) {
+        const { query, is_regex = false, case_insensitive = true } = params;
+        const historyDir = path.join(path.dirname(this.dbPath), 'history');
+        const stmt = this.db.prepare(`
+      SELECT h.id, n.id AS node_id, n.name AS node_name, n.file_path
+      FROM nodes n
+      JOIN history h ON h.node_id = n.id
+      WHERE n.deprecated = 0
+        AND h.id = (
+          SELECT id FROM history
+          WHERE node_id = n.id
+          ORDER BY updated_at DESC
+          LIMIT 1
+        )
+    `);
+        const rows = stmt.all();
+        let matcher;
+        if (is_regex) {
+            try {
+                matcher = new RegExp(query, case_insensitive ? 'i' : '');
+            }
+            catch (err) {
+                throw new Error(`Invalid regex pattern: ${err.message}`);
+            }
+        }
+        else {
+            const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            matcher = new RegExp(escaped, case_insensitive ? 'i' : '');
+        }
+        const results = [];
+        for (const row of rows) {
+            const filePath = path.join(historyDir, `${row.id}.json`);
+            if (!fs.existsSync(filePath))
+                continue;
+            try {
+                const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                const code = data.code_snapshot || '';
+                if (!code)
+                    continue;
+                const lines = code.split('\n');
+                const nodeMatches = [];
+                lines.forEach((line, idx) => {
+                    if (matcher.test(line)) {
+                        nodeMatches.push({
+                            line_number: idx + 1,
+                            line_content: line
+                        });
+                    }
+                });
+                if (nodeMatches.length > 0) {
+                    results.push({
+                        node_id: row.node_id,
+                        node_name: row.node_name,
+                        file_path: row.file_path,
+                        matches: nodeMatches,
+                        match_count: nodeMatches.length,
+                        total_lines: lines.length,
+                        match_ratio: parseFloat((nodeMatches.length / lines.length).toFixed(4))
+                    });
+                }
+            }
+            catch {
+                // Skip corrupted or unreadable history files
+            }
+        }
+        return results.sort((a, b) => b.match_count - a.match_count);
+    }
     getOrphanedNodes() {
         const stmt = this.db.prepare(`
       SELECT * FROM nodes
@@ -613,6 +973,7 @@ class DevMindDatabase {
         const candidates = stmt.all();
         const idsToDelete = [];
         const namesDeleted = [];
+        const affectedFilePaths = new Set();
         for (const node of candidates) {
             const lowerName = node.name.toLowerCase();
             // 1. Check if name is in the spurious list
@@ -636,9 +997,24 @@ class DevMindDatabase {
             if (isSpurious || fileMissing) {
                 idsToDelete.push(node.id);
                 namesDeleted.push(`${node.name} (${node.id})`);
+                if (node.file_path) {
+                    for (const p of node.file_path.split(',').map(s => s.trim()).filter(Boolean)) {
+                        affectedFilePaths.add(p);
+                    }
+                }
             }
         }
         if (idsToDelete.length > 0) {
+            // Capture caller files and drop the pruned nodes' history JSONs BEFORE the tx: the
+            // inbound-edge join goes empty once edges are deleted, and the history rows (whose ids
+            // name the JSON files) are removed by deleteHistoryStmt. Without the JSON cleanup, a
+            // pruned node would resurrect from its history/[id].json on the next syncFromDisk().
+            for (const id of idsToDelete) {
+                for (const p of this.collectInboundSourceFiles(id)) {
+                    affectedFilePaths.add(p);
+                }
+                this.deleteHistoryFilesForNode(id);
+            }
             const updateStmt = this.db.prepare('UPDATE nodes SET deprecated = 1 WHERE id = ?');
             const deleteConnStmt = this.db.prepare('DELETE FROM node_connections WHERE source_node_id = ? OR target_node_id = ?');
             const deleteHistoryStmt = this.db.prepare('DELETE FROM history WHERE node_id = ?');
@@ -650,6 +1026,12 @@ class DevMindDatabase {
                 }
             });
             deprecateTx(idsToDelete);
+            // Keep the committed graph/*.json files in sync with the DB. Pruned nodes are written
+            // with deprecated:1 (so they don't come back as active), and every caller file is
+            // rewritten so its stale inbound edge doesn't resurrect the connection on next start.
+            for (const filePath of affectedFilePaths) {
+                this.writeGraphToDisk(filePath);
+            }
         }
         return {
             prunedCount: idsToDelete.length,
@@ -716,7 +1098,7 @@ class DevMindDatabase {
             const repoPath = (0, config_1.resolveRepoPath)(this.context, repo.name);
             if (repoPath) {
                 const normalizedRepoPath = path.resolve(repoPath).replace(/\\/g, '/');
-                if (abs.startsWith(normalizedRepoPath)) {
+                if (abs === normalizedRepoPath || abs.startsWith(normalizedRepoPath + '/')) {
                     const relative = path.relative(normalizedRepoPath, abs).replace(/\\/g, '/');
                     return `{${repo.name}}/${relative}`;
                 }
@@ -805,11 +1187,11 @@ class DevMindDatabase {
                 };
                 const jsonFiles = walkSync(graphDir);
                 if (jsonFiles.length > 0) {
-                    const deleteNodesForFileStmt = this.db.prepare('DELETE FROM nodes WHERE file_path = ? OR file_path LIKE ?');
+                    const deleteNodesForFileStmt = this.db.prepare('DELETE FROM nodes WHERE file_path = ?');
                     const deleteConnsForNodesStmt = this.db.prepare('DELETE FROM node_connections WHERE source_node_id = ?');
                     const insertNodeStmt = this.db.prepare(`
             INSERT OR REPLACE INTO nodes (id, type, name, file_path, signature, deprecated)
-            VALUES (?, ?, ?, ?, ?, 0)
+            VALUES (?, ?, ?, ?, ?, ?)
           `);
                     const insertConnStmt = this.db.prepare(`
             INSERT OR IGNORE INTO node_connections (source_node_id, target_node_id)
@@ -824,16 +1206,17 @@ class DevMindDatabase {
                                     continue;
                                 const fileRelPath = data.file_path; // E.g. "{harrir-web}/app/page.tsx" or relative path
                                 const fileAbsPath = this.toAbsolutePath(fileRelPath);
-                                // Strip leading {repo} or ../ and normalize separators for matching
-                                const cleanRelPath = fileRelPath.replace(/^\{[^}]+\}\//, '').replace(/^(\.\.\/)+/, '').replace(/\\/g, '/');
-                                const fileQueryPath = `%${cleanRelPath.replace(/\//g, path.sep)}`;
-                                // Clean existing nodes in SQLite for this file
-                                deleteNodesForFileStmt.run(fileAbsPath, fileQueryPath);
+                                // Clean existing nodes in SQLite for this file BEFORE re-inserting from
+                                // the JSON (so removed/renamed symbols are cleared). Match ONLY the exact
+                                // absolute path: the previous suffix `LIKE '%<relpath>'` matched the same
+                                // relative path in EVERY repo, so syncing one repo's file deleted another
+                                // repo's same-named file nodes (cross-repo data loss).
+                                deleteNodesForFileStmt.run(fileAbsPath);
                                 // Insert nodes
                                 const nodes = data.nodes || [];
                                 for (const n of nodes) {
                                     deleteConnsForNodesStmt.run(n.id);
-                                    insertNodeStmt.run(n.id, n.type, n.name, fileAbsPath, n.signature || null);
+                                    insertNodeStmt.run(n.id, n.type, n.name, fileAbsPath, n.signature || null, n.deprecated ? 1 : 0);
                                 }
                                 // Insert connections
                                 const connections = data.connections || [];
@@ -857,6 +1240,10 @@ class DevMindDatabase {
             this.db.pragma('foreign_keys = ON');
         }
     }
+    /** Escape LIKE metacharacters so a path is matched literally (use with ESCAPE '\\'). */
+    likeEscape(s) {
+        return s.replace(/[\\%_]/g, ch => '\\' + ch);
+    }
     writeGraphToDisk(filePath) {
         try {
             if (!filePath)
@@ -864,17 +1251,29 @@ class DevMindDatabase {
             const workspaceRoot = path.dirname(this.dbPath);
             // Clean/resolve the file path
             const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(workspaceRoot, filePath);
-            const relPath = path.relative(workspaceRoot, absPath).replace(/\\/g, '/');
             const repoRelPath = this.toRepoRelativePath(absPath);
             // E.g., "{harrir-web}/app/page.tsx" -> "graph/harrir-web/app/page.json"
             const diskRelPath = repoRelPath.replace(/^\{([^}]+)\}/, '$1').replace(/\.[^/.]+$/, '.json');
             const graphJsonPath = path.join(workspaceRoot, 'graph', diskRelPath);
-            // Get all active nodes in this file
+            // Get all nodes in this file (active AND deprecated). A node's file_path is either
+            // exactly this absolute path, or (for the rare node spanning multiple files) a ", "-joined
+            // list containing it. We anchor on the FULL absolute path with ", " boundaries and escape
+            // LIKE metacharacters — the old `%<relpath>%` / `%<relpath>` matched short relative
+            // suffixes shared across repos, pulling in (and later corrupting) other repos' nodes.
+            // Deprecated nodes are INCLUDED (and carry deprecated:1 in the JSON) so that deprecation
+            // is durable across a syncFromDisk() restart and propagates to teammates via git —
+            // otherwise the node's history JSON would resurrect it as active on the next start.
+            const absEsc = this.likeEscape(absPath);
             const stmtNodes = this.db.prepare(`
         SELECT * FROM nodes
-        WHERE deprecated = 0 AND (file_path = ? OR file_path LIKE ? OR file_path LIKE ? OR file_path LIKE ?)
+        WHERE (
+          file_path = ? OR
+          file_path LIKE ? ESCAPE '\\' OR
+          file_path LIKE ? ESCAPE '\\' OR
+          file_path LIKE ? ESCAPE '\\'
+        )
       `);
-            const nodes = stmtNodes.all(absPath, `%${relPath}%`, `%${absPath}%`, `%${relPath}`);
+            const nodes = stmtNodes.all(absPath, `${absEsc}, %`, `%, ${absEsc}`, `%, ${absEsc}, %`);
             if (nodes.length === 0) {
                 // If no nodes left, delete the JSON file if it exists
                 if (fs.existsSync(graphJsonPath)) {
@@ -902,7 +1301,8 @@ class DevMindDatabase {
                     id: n.id,
                     name: n.name,
                     type: n.type,
-                    signature: n.signature
+                    signature: n.signature,
+                    deprecated: n.deprecated ? 1 : 0
                 })),
                 connections: connections.map(c => ({
                     source_node_id: c.source_node_id,