devsmind-mcp 2.0.4 → 2.1.1

package/dist/cli/runner.js

@@ -32,6 +32,9 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runBackgroundIndexing = runBackgroundIndexing;
 exports.runBackgroundReindexing = runBackgroundReindexing;
@@ -40,10 +43,14 @@ const path = __importStar(require("path"));
 const http = __importStar(require("http"));
 const https = __importStar(require("https"));
 const crypto = __importStar(require("crypto"));
+const prompts_1 = __importDefault(require("prompts"));
 const database_1 = require("../db/database");
 const indexer_1 = require("../db/indexer");
 const scanner_1 = require("../utils/scanner");
+const config_1 = require("../utils/config");
 const json_1 = require("../utils/json");
+const ast_1 = require("../utils/ast");
+const edges_1 = require("../db/edges");
 function makeHttpRequest(urlStr, method, headers, body) {
     return new Promise((resolve, reject) => {
         const isHttps = urlStr.startsWith('https');
@@ -84,6 +91,21 @@ function makeHttpRequest(urlStr, method, headers, body) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+// ── LLM request pacing ───────────────────────────────────────────────────
+// Off by default — requests fire as fast as possible and 429s are handled by
+// the retry/backoff in extractNodesFromCode. Pass --rpm to proactively space
+// out requests and stay under a known quota instead of reacting after the fact.
+let lastLlmCallAt = 0;
+async function throttleRpm(rpm) {
+    if (!rpm || rpm <= 0)
+        return;
+    const minIntervalMs = 60000 / rpm;
+    const wait = lastLlmCallAt + minIntervalMs - Date.now();
+    if (wait > 0) {
+        await sleep(wait);
+    }
+    lastLlmCallAt = Date.now();
+}
 // ── Progress Display ─────────────────────────────────────────────────────
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const BAR_WIDTH = 28;
@@ -406,55 +428,6 @@ CRITICAL RULES:
     }
     return (0, json_1.safeJsonParse)(text, {});
 }
-async function resolveConnectionsWithVertex(model, token, projectId, location, sourceNodeId, code, candidateNodeIds) {
-    const url = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${model}:generateContent`;
-    const systemPrompt = `You are a codebase indexing assistant. Your job is to analyze the source code of a specific code entity and identify which other known code entities from the provided candidate list it calls or references.
-Return ONLY a valid JSON object matching the schema:
-{
-  "connections": [
-    "target_node_id_1",
-    "target_node_id_2"
-  ]
-}
-CRITICAL RULES:
-1. ONLY return target node IDs that are present in the provided list of known candidates. Do NOT invent new node IDs.
-2. DO NOT include connections to third-party libraries, language built-ins, or the source node itself.
-3. DO NOT wrap JSON in markdown blocks (e.g. no \`\`\`json). Return raw JSON.
-4. If no connections are found, return an empty array.`;
-    const payload = {
-        contents: [
-            {
-                role: 'user',
-                parts: [
-                    {
-                        text: `Source Node ID: ${sourceNodeId}\n\nSource Code:\n${code}\n\nCandidate Target Node IDs in the Codebase:\n${JSON.stringify(candidateNodeIds, null, 2)}`
-                    }
-                ]
-            }
-        ],
-        systemInstruction: {
-            parts: [
-                {
-                    text: systemPrompt
-                }
-            ]
-        },
-        generationConfig: {
-            responseMimeType: 'application/json'
-        }
-    };
-    const responseText = await makeHttpRequest(url, 'POST', {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${token}`
-    }, JSON.stringify(payload));
-    const parsed = (0, json_1.safeJsonParse)(responseText, {});
-    const text = parsed.candidates?.[0]?.content?.parts?.[0]?.text;
-    if (!text) {
-        return [];
-    }
-    const result = (0, json_1.safeJsonParse)(text, {});
-    return result.connections || [];
-}
 async function extractWithGemini(model, key, filePath, code) {
     const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${key}`;
     const systemPrompt = `You are a codebase indexing assistant. Your job is to analyze the source code file provided and extract all code structures (functions, methods, classes, controllers, services, interfaces, schema models, types) defined in the file.
@@ -543,149 +516,209 @@ CRITICAL RULES:
     }
     return (0, json_1.safeJsonParse)(text, {});
 }
-async function resolveConnectionsWithGemini(model, key, sourceNodeId, code, candidateNodeIds) {
-    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${key}`;
-    const systemPrompt = `You are a codebase indexing assistant. Your job is to analyze the source code of a specific code entity and identify which other known code entities from the provided candidate list it calls or references.
-Return ONLY a valid JSON object matching the schema:
-{
-  "connections": [
-    "target_node_id_1",
-    "target_node_id_2"
-  ]
-}
-CRITICAL RULES:
-1. ONLY return target node IDs that are present in the provided list of known candidates. Do NOT invent new node IDs.
-2. DO NOT include connections to third-party libraries, language built-ins, or the source node itself.
-3. DO NOT wrap JSON in markdown blocks (e.g. no \`\`\`json). Return raw JSON.
-4. If no connections are found, return an empty array.`;
-    const payload = {
-        contents: [
-            {
-                parts: [
-                    {
-                        text: `Source Node ID: ${sourceNodeId}\n\nSource Code:\n${code}\n\nCandidate Target Node IDs in the Codebase:\n${JSON.stringify(candidateNodeIds, null, 2)}`
-                    }
-                ]
+async function extractNodesFromCode(provider, modelName, key, url, filePath, code, getVertexToken, vertexProjectId, vertexLocation, progress, chunkSize, chunkOverlap, rpm) {
+    // Chunking is opt-in: with no --chunk-size, the whole file always goes in one call.
+    const maxLines = chunkSize;
+    const overlap = chunkOverlap ?? 50;
+    const lines = code.split('\n');
+    const executeExtraction = async (codeChunk) => {
+        let retries = 5;
+        let backoffMs = 10000;
+        while (retries > 0) {
+            try {
+                await throttleRpm(rpm);
+                if (provider === 'gemini') {
+                    return await extractWithGemini(modelName, key, filePath, codeChunk);
+                }
+                else if (provider === 'vertex') {
+                    const token = await getVertexToken();
+                    return await extractWithVertex(modelName, token, vertexProjectId, vertexLocation, filePath, codeChunk);
+                }
+                else {
+                    return await extractWithOllama(url, modelName, filePath, codeChunk);
+                }
             }
-        ],
-        systemInstruction: {
-            parts: [
-                {
-                    text: systemPrompt
+            catch (err) {
+                retries--;
+                if (retries === 0) {
+                    throw err;
                 }
-            ]
-        },
-        generationConfig: {
-            responseMimeType: 'application/json'
+                const errMsg = err.message;
+                if (errMsg.includes('429')) {
+                    progress.updateStatus(`Rate limited (429). Retrying in ${backoffMs / 1000}s...`);
+                    await sleep(backoffMs);
+                    backoffMs *= 2;
+                }
+                else {
+                    progress.updateStatus(`API error. Retrying in 2s...`);
+                    await sleep(2000);
+                }
+            }
         }
+        return {};
     };
-    const responseText = await makeHttpRequest(url, 'POST', { 'Content-Type': 'application/json' }, JSON.stringify(payload));
-    const parsed = (0, json_1.safeJsonParse)(responseText, {});
-    const text = parsed.candidates?.[0]?.content?.parts?.[0]?.text;
-    if (!text) {
-        return [];
+    if (!maxLines || lines.length <= maxLines) {
+        return await executeExtraction(code);
     }
-    const result = (0, json_1.safeJsonParse)(text, {});
-    return result.connections || [];
-}
-async function resolveConnectionsWithOllama(url, model, sourceNodeId, code, candidateNodeIds) {
-    const endpoint = `${url.replace(/\/$/, '')}/api/chat`;
-    const systemPrompt = `You are a codebase indexing assistant. Analyze this source code of a code entity and identify which other known entities from the provided candidate list it calls or references.
-Return ONLY a valid JSON object matching the schema:
-{
-  "connections": [
-    "target_node_id_1",
-    "target_node_id_2"
-  ]
-}
-CRITICAL RULES:
-1. ONLY return target node IDs that are present in the provided list of known candidates. Do NOT invent new node IDs.
-2. Return a clean, valid JSON object.`;
-    const userPrompt = `Source Node ID: ${sourceNodeId}\n\nSource Code:\n${code}\n\nCandidate Target Node IDs:\n${JSON.stringify(candidateNodeIds, null, 2)}`;
-    const payload = {
-        model,
-        messages: [
-            { role: 'system', content: systemPrompt },
-            { role: 'user', content: userPrompt }
-        ],
-        stream: false,
-        format: 'json'
-    };
-    const responseText = await makeHttpRequest(endpoint, 'POST', { 'Content-Type': 'application/json' }, JSON.stringify(payload));
-    const parsed = (0, json_1.safeJsonParse)(responseText, {});
-    const text = parsed.message?.content;
-    if (!text) {
-        return [];
+    const relPath = path.relative(process.cwd(), filePath);
+    progress.log(`\x1B[90m[${relPath}] Large file (${lines.length} lines) - parsing in chunks to prevent LLM output truncation...\x1B[0m`);
+    const chunks = [];
+    let start = 0;
+    // Guard against overlap >= chunkSize, which would make the step <= 0 and loop forever.
+    const step = Math.max(1, maxLines - overlap);
+    while (start < lines.length) {
+        const end = Math.min(start + maxLines, lines.length);
+        chunks.push(lines.slice(start, end).join('\n'));
+        if (end === lines.length)
+            break;
+        start += step;
     }
-    const result = (0, json_1.safeJsonParse)(text, {});
-    return result.connections || [];
-}
-function filterCandidates(codeSnapshot, allNodeIds) {
-    const lowerCode = codeSnapshot.toLowerCase();
-    return allNodeIds.filter(id => {
-        const symbolName = id.includes('#') ? id.split('#').pop() : id;
-        const shortName = symbolName.includes('.') ? symbolName.split('.').pop() : symbolName;
-        if (!shortName || shortName.trim().length === 0)
-            return false;
-        if (shortName.length < 3)
-            return false;
-        return lowerCode.includes(shortName.toLowerCase());
-    });
+    const seenNodeIds = new Map();
+    for (let i = 0; i < chunks.length; i++) {
+        progress.updateStatus(`Sending chunk ${i + 1}/${chunks.length} to AI…`);
+        const chunkCode = chunks[i];
+        try {
+            const chunkResult = await executeExtraction(chunkCode);
+            if (chunkResult.nodes && Array.isArray(chunkResult.nodes)) {
+                for (const node of chunkResult.nodes) {
+                    if (!node.node_id)
+                        continue;
+                    const existing = seenNodeIds.get(node.node_id);
+                    if (!existing || (node.code_snapshot && (!existing.code_snapshot || node.code_snapshot.length > existing.code_snapshot.length))) {
+                        seenNodeIds.set(node.node_id, node);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            progress.log(`\x1B[31mError extracting chunk ${i + 1}/${chunks.length}: ${err.message}\x1B[0m`);
+            throw err;
+        }
+        if (i < chunks.length - 1) {
+            if (provider === 'gemini' || provider === 'vertex') {
+                await sleep(1500);
+            }
+            else {
+                await sleep(100);
+            }
+        }
+    }
+    return { nodes: Array.from(seenNodeIds.values()) };
 }
 async function runBackgroundIndexing(opts) {
     const resolvedDevmind = path.resolve(opts.devmindPath);
+    const chunkSize = opts.chunkSize;
+    const chunkOverlap = opts.chunkOverlap;
+    const fromScratch = !!opts.fromScratch;
+    const nodesOnly = !!opts.nodesOnly;
+    const edgesOnly = !!opts.edgesOnly;
+    const rpm = opts.rpm;
+    // Repo scoping: restrict the whole operation to the named repos. Standalone-only.
+    const scopedRepos = opts.repos && opts.repos.length ? opts.repos : null;
+    const inScope = (nodeId) => !scopedRepos || scopedRepos.some(r => nodeId.startsWith(`{${r}}/`));
+    if (scopedRepos) {
+        let ctx;
+        try {
+            ctx = (0, config_1.loadProjectContext)(resolvedDevmind);
+        }
+        catch (err) {
+            console.error(`❌ Error: ${err.message}`);
+            process.exit(1);
+        }
+        if (ctx.config.mode !== 'standalone') {
+            console.error('❌ Error: --repos only works in standalone mode (embedded projects share one root, so per-repo scoping does not apply).');
+            process.exit(1);
+        }
+        if (fromScratch) {
+            console.error('❌ Error: --from-scratch wipes the entire graph, so it cannot be combined with --repos. Drop one of them.');
+            process.exit(1);
+        }
+        const known = new Set(ctx.config.repos.map(r => r.name));
+        const unknown = scopedRepos.filter(r => !known.has(r));
+        if (unknown.length) {
+            console.error(`❌ Error: unknown repo name(s): ${unknown.join(', ')}`);
+            console.error(`   Valid repos: ${[...known].join(', ')}`);
+            process.exit(1);
+        }
+        console.log(`   Scope           : repos = ${scopedRepos.join(', ')}`);
+    }
+    // Scoped runs use a SEPARATE scratchpad so they can't clobber (or mark "complete") the
+    // global session — otherwise a later full `index --run` would see the scoped run's
+    // "complete" and skip every un-indexed repo.
+    const padFile = scopedRepos ? 'index_scratchpad.scoped.json' : undefined;
+    // Missing-node detection: resolveConnectionsLocally reports references that resolve to a
+    // real repo file with no node (a Phase-1 extraction gap). Deduped by (file, symbol); these
+    // are auto-created from the AST and reported at the end of every edge-resolution run.
+    const missingRefs = new Map();
+    const onMissing = (rec) => {
+        const key = rec.targetFile + '' + rec.name;
+        let e = missingRefs.get(key);
+        if (!e) {
+            e = { file: rec.targetFile, symbol: rec.name, referenced_by: new Set() };
+            missingRefs.set(key, e);
+        }
+        e.referenced_by.add(rec.sourceNodeId);
+    };
     console.log(`\n🧠 DevsMind Background Indexer`);
     console.log(`   Brain directory : ${resolvedDevmind}`);
     console.log(`   Provider        : ${opts.provider}`);
+    console.log(`   Connections     : local AST resolution (always)`);
+    console.log(`   Chunking        : ${chunkSize ? `${chunkSize} lines (overlap: ${chunkOverlap ?? 50})` : 'off — whole file per call'}`);
+    console.log(`   Rate limit      : ${rpm ? `${rpm} req/min` : 'unthrottled'}`);
     let modelName = opts.model || '';
     let vertexSaData = null;
     let vertexToken = null;
     let vertexProjectId = '';
     let vertexLocation = 'us-central1';
-    if (opts.provider === 'gemini') {
-        modelName = modelName || 'gemini-2.0-flash';
-        const apiKey = opts.key || process.env.GEMINI_API_KEY || '';
-        if (!apiKey) {
-            console.error('❌ Error: Gemini API key is required. Pass --key or set GEMINI_API_KEY environment variable.');
-            process.exit(1);
-        }
-        opts.key = apiKey;
-    }
-    else if (opts.provider === 'vertex') {
-        modelName = modelName || 'gemini-1.5-flash';
-        const inputKey = opts.key || process.env.GOOGLE_APPLICATION_CREDENTIALS || process.env.VERTEX_API_KEY || process.env.GEMINI_API_KEY || '';
-        if (!inputKey) {
-            console.error('❌ Error: Vertex AI requires a Service Account JSON path or Bearer Token. Pass --key or set GOOGLE_APPLICATION_CREDENTIALS / VERTEX_API_KEY environment variable.');
-            process.exit(1);
+    // --edges-only never calls the LLM (Phase 1 is skipped entirely), so it shouldn't
+    // require provider credentials at all.
+    if (!edgesOnly) {
+        if (opts.provider === 'gemini') {
+            modelName = modelName || 'gemini-2.0-flash';
+            const apiKey = opts.key || process.env.GEMINI_API_KEY || '';
+            if (!apiKey) {
+                console.error('❌ Error: Gemini API key is required. Pass --key or set GEMINI_API_KEY environment variable.');
+                process.exit(1);
+            }
+            opts.key = apiKey;
         }
-        try {
-            if (inputKey.trim().startsWith('{')) {
-                vertexSaData = JSON.parse(inputKey);
+        else if (opts.provider === 'vertex') {
+            modelName = modelName || 'gemini-1.5-flash';
+            const inputKey = opts.key || process.env.GOOGLE_APPLICATION_CREDENTIALS || process.env.VERTEX_API_KEY || process.env.GEMINI_API_KEY || '';
+            if (!inputKey) {
+                console.error('❌ Error: Vertex AI requires a Service Account JSON path or Bearer Token. Pass --key or set GOOGLE_APPLICATION_CREDENTIALS / VERTEX_API_KEY environment variable.');
+                process.exit(1);
             }
-            else if (fs.existsSync(inputKey)) {
-                vertexSaData = JSON.parse(fs.readFileSync(inputKey, 'utf-8'));
+            try {
+                if (inputKey.trim().startsWith('{')) {
+                    vertexSaData = JSON.parse(inputKey);
+                }
+                else if (fs.existsSync(inputKey)) {
+                    vertexSaData = JSON.parse(fs.readFileSync(inputKey, 'utf-8'));
+                }
+            }
+            catch (e) {
+                // Treat as raw token
+            }
+            vertexProjectId = vertexSaData?.project_id || process.env.GCP_PROJECT_ID || process.env.VERTEX_PROJECT_ID || '';
+            vertexLocation = process.env.GCP_LOCATION || process.env.VERTEX_LOCATION || 'us-central1';
+            if (!vertexSaData && !inputKey.startsWith('ya29.')) {
+                console.error('❌ Error: Vertex key must be a valid Service Account JSON file path, inline JSON, or raw OAuth access token starting with "ya29."');
+                process.exit(1);
+            }
+            if (!vertexProjectId) {
+                console.error('❌ Error: Vertex Project ID could not be determined. Please set GCP_PROJECT_ID environment variable or specify it in your service account JSON.');
+                process.exit(1);
+            }
+            if (!vertexSaData) {
+                vertexToken = inputKey; // Raw Bearer token
             }
         }
-        catch (e) {
-            // Treat as raw token
-        }
-        vertexProjectId = vertexSaData?.project_id || process.env.GCP_PROJECT_ID || process.env.VERTEX_PROJECT_ID || '';
-        vertexLocation = process.env.GCP_LOCATION || process.env.VERTEX_LOCATION || 'us-central1';
-        if (!vertexSaData && !inputKey.startsWith('ya29.')) {
-            console.error('❌ Error: Vertex key must be a valid Service Account JSON file path, inline JSON, or raw OAuth access token starting with "ya29."');
-            process.exit(1);
-        }
-        if (!vertexProjectId) {
-            console.error('❌ Error: Vertex Project ID could not be determined. Please set GCP_PROJECT_ID environment variable or specify it in your service account JSON.');
-            process.exit(1);
-        }
-        if (!vertexSaData) {
-            vertexToken = inputKey; // Raw Bearer token
+        else {
+            modelName = modelName || 'qwen2.5-coder';
+            opts.url = opts.url || 'http://localhost:11434';
         }
-    }
-    else {
-        modelName = modelName || 'qwen2.5-coder';
-        opts.url = opts.url || 'http://localhost:11434';
+        console.log(`   Model           : ${modelName}`);
     }
     const getVertexToken = async () => {
         if (vertexToken)
@@ -695,21 +728,127 @@ async function runBackgroundIndexing(opts) {
         }
         throw new Error('No Vertex credentials available');
     };
-    console.log(`   Model           : ${modelName}`);
     // 1. Open DB
     const dbFile = path.join(resolvedDevmind, 'brain.db');
     const db = new database_1.DevMindDatabase(dbFile);
-    // 2. Scan for repos & files
-    const { repos, total_files } = (0, scanner_1.scanRepoFiles)(resolvedDevmind);
+    // --from-scratch: wipe everything (with confirmation) before proceeding.
+    if (fromScratch) {
+        if (!opts.yes) {
+            const confirmResult = await (0, prompts_1.default)({
+                type: 'confirm',
+                name: 'yes',
+                message: '🚨 WARNING: --from-scratch will permanently delete ALL nodes, connections, history, and the committed graph/ and history/ folders, then reindex from zero. Are you absolutely sure?',
+                initial: false
+            });
+            if (!confirmResult.yes) {
+                console.log('Aborted — nothing was changed.');
+                db.close();
+                return;
+            }
+        }
+        console.log('💥 Wiping all nodes, connections, history, and graph/history folders...');
+        db.resetAll();
+        const scratchpadFile = path.join(resolvedDevmind, 'index_scratchpad.json');
+        if (fs.existsSync(scratchpadFile)) {
+            fs.unlinkSync(scratchpadFile);
+        }
+    }
+    // --edges-only: skip Phase 1 entirely, wipe existing edges, rebuild them fresh
+    // across every currently-active node using the AST resolver. Requires nodes to
+    // already exist (from a prior full index or a --nodes-only run).
+    if (edgesOnly) {
+        // All nodes stay in the candidate pool (targets can live in any repo/file), but when
+        // scoped we only rebuild edges ORIGINATING from the named repos' nodes.
+        const allNodes = db.listNodes();
+        if (allNodes.length === 0) {
+            console.error('❌ Error: --edges-only requires nodes to already exist. Run without --edges-only first (or with --nodes-only) to extract nodes.');
+            db.close();
+            process.exit(1);
+        }
+        const existingNodes = scopedRepos ? allNodes.filter(n => inScope(n.id)) : allNodes;
+        if (existingNodes.length === 0) {
+            console.error(`❌ Error: no nodes found for repo(s): ${scopedRepos?.join(', ')}. Extract nodes first.`);
+            db.close();
+            process.exit(1);
+        }
+        let edgePad = (0, indexer_1.readScratchpad)(resolvedDevmind, padFile);
+        let resumeIndex = 0;
+        // Scoped runs never resume the shared scratchpad (its counts describe a different set).
+        if (!scopedRepos && edgePad && edgePad.phase === 2 && edgePad.status === 'in_progress' && edgePad.nodes_total === existingNodes.length) {
+            resumeIndex = edgePad.nodes_done || 0;
+            console.log(`↻ Resuming edge rebuild from node ${resumeIndex + 1}/${existingNodes.length}`);
+        }
+        else {
+            if (scopedRepos) {
+                console.log(`🧹 Clearing connections for ${existingNodes.length} node(s) in scope...`);
+                db.clearConnectionsForSources(existingNodes.map(n => n.id));
+            }
+            else {
+                console.log('🧹 Clearing existing connections...');
+                db.clearAllConnections();
+            }
+            edgePad = (0, indexer_1.createScratchpad)(resolvedDevmind, 0, padFile);
+            edgePad.phase = 2;
+            edgePad.nodes_total = existingNodes.length;
+            (0, indexer_1.writeScratchpad)(resolvedDevmind, edgePad, padFile);
+        }
+        const edgeProgress = new ProgressDisplay();
+        const allNodeIds = allNodes.map(n => n.id);
+        edgeProgress.startPhase(2, 'AI Connection Resolution', existingNodes.length, resumeIndex);
+        for (let i = resumeIndex; i < existingNodes.length; i++) {
+            const node = existingNodes[i];
+            edgeProgress.beginItem(node.id);
+            const latestCode = db.getLatestCode(node.id);
+            if (!latestCode || !latestCode.code_snapshot || latestCode.code_snapshot.trim().length === 0) {
+                edgePad.nodes_done = i + 1;
+                (0, indexer_1.writeScratchpad)(resolvedDevmind, edgePad, padFile);
+                edgeProgress.skipItem('no code snapshot');
+                continue;
+            }
+            edgeProgress.updateStatus(`Resolving connections locally via AST…`);
+            const connections = (0, ast_1.resolveConnectionsLocally)(node.id, node.file_path, allNodes, resolvedDevmind, onMissing);
+            let addedCount = 0;
+            for (const targetId of connections) {
+                if (allNodeIds.includes(targetId)) {
+                    edgeProgress.log(`Linked: \x1B[36m${node.id}\x1B[0m → \x1B[36m${targetId}\x1B[0m`);
+                    db.addConnection(node.id, targetId);
+                    addedCount++;
+                }
+            }
+            edgePad.nodes_done = i + 1;
+            edgePad.connections_created += addedCount;
+            (0, indexer_1.writeScratchpad)(resolvedDevmind, edgePad, padFile);
+            edgeProgress.completeItem(`${edgePad.connections_created} connection(s) created so far`);
+        }
+        edgeProgress.finishPhase(`Phase 2 done — ${edgePad.connections_created} connection(s) linked across ${existingNodes.length} node(s)`);
+        (0, edges_1.finalizeMissingNodes)(resolvedDevmind, db, missingRefs);
+        edgePad.status = 'complete';
+        edgePad.updated_at = new Date().toISOString();
+        (0, indexer_1.writeScratchpad)(resolvedDevmind, edgePad, padFile);
+        db.vacuum();
+        db.close();
+        console.log('');
+        console.log('\x1B[1m\x1B[32m  ✔ Edge rebuild complete!\x1B[0m');
+        console.log(`  └─ Connections    : \x1B[33m${edgePad.connections_created}\x1B[0m`);
+        console.log('');
+        return;
+    }
+    // 2. Scan for repos & files (restricted to scoped repos when --repos is given)
+    const scanResult = (0, scanner_1.scanRepoFiles)(resolvedDevmind);
+    const repos = scopedRepos
+        ? scanResult.repos.filter(r => scopedRepos.includes(r.repo_name))
+        : scanResult.repos;
+    const total_files = repos.reduce((sum, r) => sum + r.files.length, 0);
     if (total_files === 0) {
         console.log('⚠️ No files found to index. Make sure config.json repositories are configured properly.');
         db.close();
         return;
     }
-    // 3. Read or create scratchpad
-    let pad = (0, indexer_1.readScratchpad)(resolvedDevmind);
-    if (!pad) {
-        pad = (0, indexer_1.createScratchpad)(resolvedDevmind, total_files);
+    // 3. Read or create scratchpad. Scoped runs always start a fresh scratchpad — they are
+    // targeted re-runs, so they must not be blocked by (or resume) a prior global session.
+    let pad = (0, indexer_1.readScratchpad)(resolvedDevmind, padFile);
+    if (scopedRepos || !pad) {
+        pad = (0, indexer_1.createScratchpad)(resolvedDevmind, total_files, padFile);
     }
     else if (pad.status === 'complete') {
         console.log('✅ Indexing is already completed!');
@@ -754,48 +893,21 @@ async function runBackgroundIndexing(opts) {
             if (code.trim().length === 0) {
                 pad.files_done++;
                 pad.last_file_indexed = fileObj.absolutePath;
-                (0, indexer_1.writeScratchpad)(resolvedDevmind, pad);
+                (0, indexer_1.writeScratchpad)(resolvedDevmind, pad, padFile);
                 progress.skipItem('empty file');
                 continue;
             }
             const fileLines = code.split('\n').length;
             progress.updateStatus(`Reading ${fileLines} lines — sending to AI…`);
             let result = {};
-            let retries = 5;
-            let backoffMs = 10000;
-            while (retries > 0) {
-                try {
-                    if (opts.provider === 'gemini') {
-                        result = await extractWithGemini(modelName, opts.key, fileObj.absolutePath, code);
-                    }
-                    else if (opts.provider === 'vertex') {
-                        const token = await getVertexToken();
-                        result = await extractWithVertex(modelName, token, vertexProjectId, vertexLocation, fileObj.absolutePath, code);
-                    }
-                    else {
-                        result = await extractWithOllama(opts.url, modelName, fileObj.absolutePath, code);
-                    }
-                    break;
-                }
-                catch (err) {
-                    retries--;
-                    if (retries === 0) {
-                        progress.finishPhase(`Paused — API error. Run again to resume.`);
-                        console.error(`❌ ${err.message}`);
-                        db.close();
-                        process.exit(1);
-                    }
-                    const errMsg = err.message;
-                    if (errMsg.includes('429')) {
-                        progress.updateStatus(`Rate limited (429). Retrying in ${backoffMs / 1000}s...`);
-                        await sleep(backoffMs);
-                        backoffMs *= 2;
-                    }
-                    else {
-                        progress.updateStatus(`API error. Retrying in 2s...`);
-                        await sleep(2000);
-                    }
-                }
+            try {
+                result = await extractNodesFromCode(opts.provider, modelName, opts.key, opts.url, fileObj.absolutePath, code, getVertexToken, vertexProjectId, vertexLocation, progress, chunkSize, chunkOverlap, rpm);
+            }
+            catch (err) {
+                progress.finishPhase(`Paused — API error. Run again to resume.`);
+                console.error(`❌ ${err.message}`);
+                db.close();
+                process.exit(1);
             }
             let newNodesCount = 0;
             const totalNodesFound = result.nodes?.length ?? 0;
@@ -854,29 +966,44 @@ async function runBackgroundIndexing(opts) {
             if (isRepoDone && !pad.repos_done.includes(fileObj.repoName)) {
                 pad.repos_done.push(fileObj.repoName);
             }
-            (0, indexer_1.writeScratchpad)(resolvedDevmind, pad);
+            (0, indexer_1.writeScratchpad)(resolvedDevmind, pad, padFile);
             progress.completeItem(`${pad.nodes_created} node(s) found so far`);
             if (opts.provider === 'gemini' || opts.provider === 'vertex')
                 await sleep(2000);
             else
                 await sleep(200);
         }
-        // Transition to Phase 2
         const activeNodes = db.listNodes();
-        pad.phase = 2;
-        pad.nodes_total = activeNodes.length;
-        pad.nodes_done = 0;
-        pad.updated_at = new Date().toISOString();
-        (0, indexer_1.writeScratchpad)(resolvedDevmind, pad);
         progress.finishPhase(`Phase 1 done — ${activeNodes.length} node(s) extracted from ${pad.files_done} file(s)`);
+        if (nodesOnly) {
+            pad.status = 'complete';
+            pad.updated_at = new Date().toISOString();
+            (0, indexer_1.writeScratchpad)(resolvedDevmind, pad, padFile);
+        }
+        else {
+            // Transition to Phase 2
+            pad.phase = 2;
+            pad.nodes_total = activeNodes.length;
+            pad.nodes_done = 0;
+            pad.updated_at = new Date().toISOString();
+            (0, indexer_1.writeScratchpad)(resolvedDevmind, pad, padFile);
+        }
     }
     // =========================================================================
     // PHASE 2: AI CONNECTION RESOLUTION / LINKING
     // =========================================================================
-    if (pad.phase === 2) {
-        const activeNodes = db.listNodes();
-        const allNodeIds = activeNodes.map(n => n.id);
+    if (pad.phase === 2 && !nodesOnly) {
+        const allNodes = db.listNodes();
+        const allNodeIds = allNodes.map(n => n.id);
+        // Candidates are always all nodes; when scoped we only (re)build edges from the
+        // named repos' nodes and clear just those first so we don't wipe other repos' edges.
+        const activeNodes = scopedRepos ? allNodes.filter(n => inScope(n.id)) : allNodes;
         const resumeIndex = pad.nodes_done || 0;
+        if (scopedRepos && resumeIndex === 0) {
+            console.log(`🧹 Clearing connections for ${activeNodes.length} node(s) in scope...`);
+            db.clearConnectionsForSources(activeNodes.map(n => n.id));
+        }
+        pad.nodes_total = activeNodes.length;
         // Use total node count and resume offset so bar shows true progress
         progress.startPhase(2, 'AI Connection Resolution', activeNodes.length, resumeIndex);
         let nodeIndex = resumeIndex;
@@ -887,56 +1014,12 @@ async function runBackgroundIndexing(opts) {
             if (!latestCode || !latestCode.code_snapshot || latestCode.code_snapshot.trim().length === 0) {
                 pad.nodes_done = nodeIndex + 1;
                 pad.updated_at = new Date().toISOString();
-                (0, indexer_1.writeScratchpad)(resolvedDevmind, pad);
+                (0, indexer_1.writeScratchpad)(resolvedDevmind, pad, padFile);
                 progress.skipItem('no code snapshot');
                 continue;
             }
-            const candidates = filterCandidates(latestCode.code_snapshot, allNodeIds);
-            const filteredCandidates = candidates.filter(id => id !== node.id);
-            if (filteredCandidates.length === 0) {
-                pad.nodes_done = nodeIndex + 1;
-                pad.updated_at = new Date().toISOString();
-                (0, indexer_1.writeScratchpad)(resolvedDevmind, pad);
-                progress.skipItem('no matching candidates');
-                continue;
-            }
-            let connections = [];
-            let retries = 5;
-            let backoffMs = 10000;
-            while (retries > 0) {
-                try {
-                    if (opts.provider === 'gemini') {
-                        connections = await resolveConnectionsWithGemini(modelName, opts.key, node.id, latestCode.code_snapshot, filteredCandidates);
-                    }
-                    else if (opts.provider === 'vertex') {
-                        const token = await getVertexToken();
-                        connections = await resolveConnectionsWithVertex(modelName, token, vertexProjectId, vertexLocation, node.id, latestCode.code_snapshot, filteredCandidates);
-                    }
-                    else {
-                        connections = await resolveConnectionsWithOllama(opts.url, modelName, node.id, latestCode.code_snapshot, filteredCandidates);
-                    }
-                    break;
-                }
-                catch (err) {
-                    retries--;
-                    if (retries === 0) {
-                        progress.finishPhase('Paused — API error. Run again to resume.');
-                        console.error(`❌ ${err.message}`);
-                        db.close();
-                        process.exit(1);
-                    }
-                    const errMsg = err.message;
-                    if (errMsg.includes('429')) {
-                        progress.updateStatus(`Rate limited (429). Retrying in ${backoffMs / 1000}s...`);
-                        await sleep(backoffMs);
-                        backoffMs *= 2;
-                    }
-                    else {
-                        progress.updateStatus(`API error. Retrying in 2s...`);
-                        await sleep(2000);
-                    }
-                }
-            }
+            progress.updateStatus(`Resolving connections locally via AST…`);
+            const connections = (0, ast_1.resolveConnectionsLocally)(node.id, node.file_path, allNodes, resolvedDevmind, onMissing);
             let addedCount = 0;
             for (const targetId of connections) {
                 if (allNodeIds.includes(targetId)) {
@@ -948,19 +1031,16 @@ async function runBackgroundIndexing(opts) {
             pad.nodes_done = nodeIndex + 1;
             pad.connections_created += addedCount;
             pad.updated_at = new Date().toISOString();
-            (0, indexer_1.writeScratchpad)(resolvedDevmind, pad);
+            (0, indexer_1.writeScratchpad)(resolvedDevmind, pad, padFile);
             progress.completeItem(`${pad.connections_created} connection(s) created so far`);
-            if (opts.provider === 'gemini' || opts.provider === 'vertex')
-                await sleep(2000);
-            else
-                await sleep(200);
         }
         progress.finishPhase(`Phase 2 done — ${pad.connections_created} connection(s) linked across ${pad.nodes_total} node(s)`);
+        (0, edges_1.finalizeMissingNodes)(resolvedDevmind, db, missingRefs);
     }
     // Mark indexing session as fully complete
     pad.status = 'complete';
     pad.updated_at = new Date().toISOString();
-    (0, indexer_1.writeScratchpad)(resolvedDevmind, pad);
+    (0, indexer_1.writeScratchpad)(resolvedDevmind, pad, padFile);
     db.vacuum();
     db.close();
     console.log('');
@@ -972,9 +1052,16 @@ async function runBackgroundIndexing(opts) {
 }
 async function runBackgroundReindexing(opts) {
     const resolvedDevmind = path.resolve(opts.devmindPath);
+    const chunkSize = opts.chunkSize;
+    const chunkOverlap = opts.chunkOverlap;
+    const rpm = opts.rpm;
+    const fillGaps = !!opts.fillGaps;
     console.log(`\n🧠 DevsMind Background Reindexer`);
     console.log(`   Brain directory : ${resolvedDevmind}`);
     console.log(`   Provider        : ${opts.provider}`);
+    console.log(`   Connections     : local AST resolution (always)`);
+    console.log(`   Chunking        : ${chunkSize ? `${chunkSize} lines (overlap: ${chunkOverlap ?? 50})` : 'off — whole file per call'}`);
+    console.log(`   Rate limit      : ${rpm ? `${rpm} req/min` : 'unthrottled'}`);
     let modelName = opts.model || '';
     let vertexSaData = null;
     let vertexToken = null;
@@ -1051,36 +1138,62 @@ async function runBackgroundReindexing(opts) {
         db.close();
         return;
     }
-    // 4. Retrieve last reindexing timestamp
-    const lastReindexVal = db.getSystemMeta('last_reindex_at');
-    const lastReindexTime = lastReindexVal ? new Date(lastReindexVal).getTime() : 0;
-    console.log(`   Last reindex    : ${lastReindexVal ? new Date(lastReindexVal).toLocaleString() : 'Never'}`);
-    // 5. Detect modified or newly added files
+    // 4 & 5. Select files to process.
     const modifiedFiles = [];
-    for (const repo of repos) {
-        for (const f of repo.files) {
-            try {
-                const stat = fs.statSync(f);
-                if (stat.mtimeMs > lastReindexTime) {
+    if (fillGaps) {
+        console.log('   Mode            : gap-fill (files with zero graph nodes)');
+        for (const repo of repos) {
+            for (const f of repo.files) {
+                if (db.getNodesByFilePath(f).length === 0) {
                     modifiedFiles.push({ repoName: repo.repo_name, absolutePath: f });
                 }
             }
-            catch (err) {
-                // ignore errors
-            }
         }
+        if (modifiedFiles.length === 0) {
+            console.log('\n✅ No gaps found — every indexable file already has at least one graph node.');
+            db.close();
+            return;
+        }
+        console.log(`\n📝 Found ${modifiedFiles.length} file(s) with zero nodes (never indexed, or dropped by a prior failed run).`);
     }
-    if (modifiedFiles.length === 0) {
-        console.log('\n✅ Code graph is already up to date. No modified files detected.');
-        db.setSystemMeta('last_reindex_at', new Date().toISOString());
-        db.close();
-        return;
+    else {
+        const lastReindexVal = db.getSystemMeta('last_reindex_at');
+        const lastReindexTime = lastReindexVal ? new Date(lastReindexVal).getTime() : 0;
+        console.log(`   Last reindex    : ${lastReindexVal ? new Date(lastReindexVal).toLocaleString() : 'Never'}`);
+        for (const repo of repos) {
+            for (const f of repo.files) {
+                try {
+                    const stat = fs.statSync(f);
+                    if (stat.mtimeMs > lastReindexTime) {
+                        modifiedFiles.push({ repoName: repo.repo_name, absolutePath: f });
+                    }
+                }
+                catch (err) {
+                    // ignore errors
+                }
+            }
+        }
+        if (modifiedFiles.length === 0) {
+            console.log('\n✅ Code graph is already up to date. No modified files detected.');
+            db.setSystemMeta('last_reindex_at', new Date().toISOString());
+            db.close();
+            return;
+        }
+        console.log(`\n📝 Detected ${modifiedFiles.length} modified/new file(s) since last reindex.`);
     }
-    console.log(`\n📝 Detected ${modifiedFiles.length} modified/new file(s) since last reindex.`);
     // 6. Extraction & Upserting of modified nodes
     const progress = new ProgressDisplay();
-    progress.startPhase(1, 'Incremental Node Extraction', modifiedFiles.length, 0);
+    progress.startPhase(1, fillGaps ? 'Gap-Fill Node Extraction' : 'Incremental Node Extraction', modifiedFiles.length, 0);
     const newOrUpdatedNodeIds = [];
+    // Source nodes (in possibly-unmodified files) that had edges pointing INTO the modified
+    // files. deprecateNode below deletes those inbound edges, so we capture their sources here
+    // and re-resolve them after Phase 2 to rebuild the "used-by" edges (else every reindex
+    // silently strips incoming edges from unmodified callers).
+    const inboundSourceIds = new Set();
+    // Gap-fill mode only: files that failed extraction after retries. Logged and skipped
+    // instead of aborting the whole run, so a persistently-failing file never blocks the
+    // rest of the gaps — the run is safe to repeat until this list is empty.
+    const stillFailedFiles = [];
     for (let fileIndex = 0; fileIndex < modifiedFiles.length; fileIndex++) {
         const fileObj = modifiedFiles[fileIndex];
         const relPath = path.relative(process.cwd(), fileObj.absolutePath);
@@ -1093,9 +1206,12 @@ async function runBackgroundReindexing(opts) {
             progress.skipItem(`read error: ${err.message}`);
             continue;
         }
-        // Deprecate existing nodes for this file path before parsing
+        // Deprecate existing nodes for this file path before parsing. Capture inbound-edge
+        // sources FIRST (deprecateNode deletes edges in both directions).
         const oldNodes = db.getNodesByFilePath(fileObj.absolutePath);
         for (const oldNode of oldNodes) {
+            for (const src of db.getInboundSources(oldNode.id))
+                inboundSourceIds.add(src);
             db.deprecateNode(oldNode.id);
         }
         if (code.trim().length === 0) {
@@ -1105,41 +1221,19 @@ async function runBackgroundReindexing(opts) {
         const fileLines = code.split('\n').length;
         progress.updateStatus(`Reading ${fileLines} lines — sending to AI…`);
         let result = {};
-        let retries = 5;
-        let backoffMs = 10000;
-        while (retries > 0) {
-            try {
-                if (opts.provider === 'gemini') {
-                    result = await extractWithGemini(modelName, opts.key, fileObj.absolutePath, code);
-                }
-                else if (opts.provider === 'vertex') {
-                    const token = await getVertexToken();
-                    result = await extractWithVertex(modelName, token, vertexProjectId, vertexLocation, fileObj.absolutePath, code);
-                }
-                else {
-                    result = await extractWithOllama(opts.url, modelName, fileObj.absolutePath, code);
-                }
-                break;
-            }
-            catch (err) {
-                retries--;
-                if (retries === 0) {
-                    progress.finishPhase(`Paused — API error.`);
-                    console.error(`❌ ${err.message}`);
-                    db.close();
-                    process.exit(1);
-                }
-                const errMsg = err.message;
-                if (errMsg.includes('429')) {
-                    progress.updateStatus(`Rate limited (429). Retrying in ${backoffMs / 1000}s...`);
-                    await sleep(backoffMs);
-                    backoffMs *= 2;
-                }
-                else {
-                    progress.updateStatus(`API error. Retrying in 2s...`);
-                    await sleep(2000);
-                }
+        try {
+            result = await extractNodesFromCode(opts.provider, modelName, opts.key, opts.url, fileObj.absolutePath, code, getVertexToken, vertexProjectId, vertexLocation, progress, chunkSize, chunkOverlap, rpm);
+        }
+        catch (err) {
+            if (fillGaps) {
+                stillFailedFiles.push(relPath);
+                progress.skipItem(`extraction failed: ${err.message}`);
+                continue;
             }
+            progress.finishPhase(`Paused — API error.`);
+            console.error(`❌ ${err.message}`);
+            db.close();
+            process.exit(1);
         }
         let fileNodesCount = 0;
         if (result.nodes && Array.isArray(result.nodes)) {
@@ -1190,6 +1284,52 @@ async function runBackgroundReindexing(opts) {
             await sleep(200);
     }
     progress.finishPhase(`Phase 1 done — parsed ${modifiedFiles.length} file(s), found ${newOrUpdatedNodeIds.length} new/updated node(s)`);
+    if (fillGaps) {
+        // Full graph-wide edge rebuild instead of the incremental Phase 2/2b: a newly-added
+        // node can be the TARGET of edges from files that were already indexed (the resolver
+        // couldn't create those edges earlier because the target didn't exist yet), so only
+        // re-resolving the new nodes' own outbound edges isn't enough. This is local AST
+        // resolution (no LLM calls), so rebuilding it across the whole graph is cheap and
+        // safe to repeat.
+        const activeNodes = db.listNodes();
+        const allNodeIds = new Set(activeNodes.map(n => n.id));
+        console.log('\n🧹 Clearing existing connections for a full rebuild...');
+        db.clearAllConnections();
+        progress.startPhase(2, 'Full Graph Edge Rebuild', activeNodes.length, 0);
+        let totalConnections = 0;
+        for (const node of activeNodes) {
+            progress.beginItem(node.id);
+            if (!node.file_path) {
+                progress.skipItem('no file_path');
+                continue;
+            }
+            progress.updateStatus(`Resolving connections locally via AST…`);
+            const connections = (0, ast_1.resolveConnectionsLocally)(node.id, node.file_path, activeNodes, resolvedDevmind);
+            let added = 0;
+            for (const targetId of connections) {
+                if (allNodeIds.has(targetId)) {
+                    db.addConnection(node.id, targetId);
+                    added++;
+                }
+            }
+            totalConnections += added;
+            progress.completeItem(`${added} connection(s)`);
+        }
+        progress.finishPhase(`Phase 2 done — ${totalConnections} connection(s) rebuilt across ${activeNodes.length} node(s)`);
+        db.vacuum();
+        db.close();
+        console.log('\n\x1B[1m\x1B[32m  ✔ Gap-fill complete!\x1B[0m');
+        console.log(`  └─ Files backfilled : ${modifiedFiles.length - stillFailedFiles.length}/${modifiedFiles.length}`);
+        console.log(`  └─ Nodes added      : ${newOrUpdatedNodeIds.length}`);
+        console.log(`  └─ Connections      : ${totalConnections}`);
+        if (stillFailedFiles.length > 0) {
+            console.log(`\n\x1B[33m⚠️  ${stillFailedFiles.length} file(s) still failed extraction — re-run --fill-gaps to retry them:\x1B[0m`);
+            for (const f of stillFailedFiles)
+                console.log(`     - ${f}`);
+        }
+        console.log('');
+        return;
+    }
     // Phase 2: Resolving connections for modified nodes
     if (newOrUpdatedNodeIds.length > 0) {
         const activeNodes = db.listNodes();
@@ -1203,48 +1343,11 @@ async function runBackgroundReindexing(opts) {
                 progress.skipItem('no code snapshot');
                 continue;
             }
-            const candidates = filterCandidates(latestCode.code_snapshot, allNodeIds);
-            const filteredCandidates = candidates.filter(id => id !== nodeId);
-            if (filteredCandidates.length === 0) {
-                progress.skipItem('no matching candidates');
-                continue;
-            }
+            progress.updateStatus(`Resolving connections locally via AST…`);
             let connections = [];
-            let retries = 5;
-            let backoffMs = 10000;
-            while (retries > 0) {
-                try {
-                    if (opts.provider === 'gemini') {
-                        connections = await resolveConnectionsWithGemini(modelName, opts.key, nodeId, latestCode.code_snapshot, filteredCandidates);
-                    }
-                    else if (opts.provider === 'vertex') {
-                        const token = await getVertexToken();
-                        connections = await resolveConnectionsWithVertex(modelName, token, vertexProjectId, vertexLocation, nodeId, latestCode.code_snapshot, filteredCandidates);
-                    }
-                    else {
-                        connections = await resolveConnectionsWithOllama(opts.url, modelName, nodeId, latestCode.code_snapshot, filteredCandidates);
-                    }
-                    break;
-                }
-                catch (err) {
-                    retries--;
-                    if (retries === 0) {
-                        progress.finishPhase('Paused — API error.');
-                        console.error(`❌ ${err.message}`);
-                        db.close();
-                        process.exit(1);
-                    }
-                    const errMsg = err.message;
-                    if (errMsg.includes('429')) {
-                        progress.updateStatus(`Rate limited (429). Retrying in ${backoffMs / 1000}s...`);
-                        await sleep(backoffMs);
-                        backoffMs *= 2;
-                    }
-                    else {
-                        progress.updateStatus(`API error. Retrying in 2s...`);
-                        await sleep(2000);
-                    }
-                }
+            const nodeObj = db.getNode(nodeId);
+            if (nodeObj && nodeObj.file_path) {
+                connections = (0, ast_1.resolveConnectionsLocally)(nodeId, nodeObj.file_path, activeNodes, resolvedDevmind);
             }
             let connectionsAdded = 0;
             for (const targetId of connections) {
@@ -1255,13 +1358,36 @@ async function runBackgroundReindexing(opts) {
                 }
             }
             progress.completeItem(`${connectionsAdded} connection(s) created`);
-            if (opts.provider === 'gemini' || opts.provider === 'vertex')
-                await sleep(2000);
-            else
-                await sleep(200);
         }
         progress.finishPhase('Phase 2 done — finished reindexing connections');
     }
+    // Phase 2b: rebuild inbound edges. Callers in unmodified files had their edges into the
+    // modified files deleted by deprecateNode; re-resolve those callers so their links to the
+    // modified files' NEW nodes are restored (addConnection is idempotent for unchanged edges).
+    const reresolveSources = [...inboundSourceIds].filter(id => !newOrUpdatedNodeIds.includes(id) && db.getNode(id));
+    if (reresolveSources.length > 0) {
+        const activeNodes = db.listNodes();
+        const allNodeIds = new Set(activeNodes.map(n => n.id));
+        progress.startPhase(2, 'Inbound Edge Rebuild', reresolveSources.length, 0);
+        for (const srcId of reresolveSources) {
+            progress.beginItem(srcId);
+            const srcNode = db.getNode(srcId);
+            if (!srcNode || !srcNode.file_path) {
+                progress.skipItem('missing');
+                continue;
+            }
+            const conns = (0, ast_1.resolveConnectionsLocally)(srcId, srcNode.file_path, activeNodes, resolvedDevmind);
+            let added = 0;
+            for (const targetId of conns) {
+                if (allNodeIds.has(targetId)) {
+                    db.addConnection(srcId, targetId);
+                    added++;
+                }
+            }
+            progress.completeItem(`${added} connection(s)`);
+        }
+        progress.finishPhase('Phase 2b done — inbound edges rebuilt');
+    }
     // Update last_reindex_at
     db.setSystemMeta('last_reindex_at', new Date().toISOString());
     db.vacuum();