devsmind-mcp 2.0.2 → 2.1.0

package/dist/db/database.js

@@ -146,6 +146,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 +260,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 +287,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 +329,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 +448,7 @@ class DevMindDatabase {
         VALUES (?, ?)
       `);
             stmt.run(resolvedSrc, resolvedTgt);
-            if (srcNode && srcNode.file_path) {
+            if (srcNode.file_path) {
                 this.writeGraphToDisk(srcNode.file_path);
             }
         }
@@ -350,11 +533,18 @@ 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;
         const history = this.getLatestHistory(resolvedId);
-        if (!history)
+        if (!history || !history.code_snapshot || history.code_snapshot.trim() === '')
             return null;
         return {
             updated_at: history.updated_at,
@@ -447,10 +637,10 @@ class DevMindDatabase {
             if (diffMs < 3600000) {
                 const updateStmt = this.db.prepare(`
           UPDATE history
-          SET code_snapshot = '', reasoning = '', updated_at = ?
+          SET code_snapshot = '', reasoning = ?, updated_at = ?
           WHERE id = ?
         `);
-                updateStmt.run(nowStr, latest.id);
+                updateStmt.run(formattedReasoning, nowStr, latest.id);
                 // Write/Update on disk
                 this.writeHistoryToDisk(latest.id, resolvedId, latest.session_id, latest.created_at, nowStr, code_snapshot, formattedReasoning);
                 return {
@@ -466,9 +656,9 @@ class DevMindDatabase {
         const sessionId = params.session_id || crypto.randomUUID();
         const insertStmt = this.db.prepare(`
       INSERT INTO history (id, node_id, session_id, created_at, updated_at, code_snapshot, reasoning)
-      VALUES (?, ?, ?, ?, ?, '', '')
+      VALUES (?, ?, ?, ?, ?, '', ?)
     `);
-        insertStmt.run(newId, resolvedId, sessionId, nowStr, nowStr);
+        insertStmt.run(newId, resolvedId, sessionId, nowStr, nowStr, formattedReasoning);
         // Write to disk
         this.writeHistoryToDisk(newId, resolvedId, sessionId, nowStr, nowStr, code_snapshot, formattedReasoning);
         return {
@@ -494,13 +684,18 @@ class DevMindDatabase {
     }
     getRecentChanges(hours = 24, analyzeImpact = true) {
         const stmt = this.db.prepare(`
-      SELECT h.node_id, n.name as node_name, n.file_path, h.updated_at, h.reasoning
+      SELECT h.id, h.node_id, n.name as node_name, n.file_path, h.updated_at, h.reasoning
       FROM history h
       JOIN nodes n ON h.node_id = n.id
       WHERE h.updated_at >= datetime('now', ?)
       ORDER BY h.updated_at DESC
     `);
         const recentChanges = stmt.all(`-${hours} hours`);
+        for (const change of recentChanges) {
+            const populated = this.populateHistoryFromDisk({ id: change.id, reasoning: change.reasoning });
+            change.reasoning = populated.reasoning;
+            delete change.id;
+        }
         if (!analyzeImpact) {
             return recentChanges;
         }
@@ -556,6 +751,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
@@ -592,11 +854,7 @@ class DevMindDatabase {
     getAllHistory() {
         const stmt = this.db.prepare('SELECT * FROM history ORDER BY updated_at DESC');
         const rows = stmt.all();
-        return rows.map(row => ({
-            ...row,
-            code_snapshot: decompressText(row.code_snapshot),
-            reasoning: decompressText(row.reasoning)
-        }));
+        return rows.map(row => this.populateHistoryFromDisk(row));
     }
     pruneSpuriousNodes(workspaceRoot) {
         const spuriousNames = new Set([
@@ -612,6 +870,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
@@ -635,9 +894,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 = ?');
@@ -649,6 +923,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,
@@ -715,7 +995,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}`;
                 }
@@ -758,7 +1038,7 @@ class DevMindDatabase {
           `);
                     const insertHistoryStmt = this.db.prepare(`
             INSERT INTO history (id, node_id, session_id, created_at, updated_at, code_snapshot, reasoning)
-            VALUES (?, ?, ?, ?, ?, '', '')
+            VALUES (?, ?, ?, ?, ?, '', ?)
           `);
                     const syncHistoryTx = this.db.transaction(() => {
                         for (const file of files) {
@@ -772,7 +1052,10 @@ class DevMindDatabase {
                                 if (!checkNodeStmt.get(data.node_id) && data.node_metadata) {
                                     insertNodeStmt.run(data.node_id, data.node_metadata.type, data.node_metadata.name, this.toAbsolutePath(data.node_metadata.file_path), data.node_metadata.signature);
                                 }
-                                insertHistoryStmt.run(data.id, data.node_id, data.session_id, data.created_at, data.updated_at);
+                                const formattedReasoning = typeof data.reasoning === 'string'
+                                    ? data.reasoning
+                                    : formatReasoning(data.reasoning || '');
+                                insertHistoryStmt.run(data.id, data.node_id, data.session_id, data.created_at, data.updated_at, formattedReasoning);
                             }
                             catch (err) {
                                 // ignore
@@ -801,11 +1084,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)
@@ -820,16 +1103,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 || [];
@@ -853,6 +1137,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)
@@ -860,17 +1148,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)) {
@@ -898,7 +1198,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,