pi-context-engine 0.1.4 → 0.3.0

package/src/indexer/pipeline.ts

@@ -8,16 +8,17 @@ import fs from "node:fs";
 import path from "node:path";
 import { promisify } from "node:util";
 import type { Config } from "../config.js";
-import { projectStorageDir, sha256Hex } from "../utils.js";
+import { projectStorageDir, sha256Hex, yieldToEventLoop } from "../utils.js";
 import { Chunker, isAstLanguage, warmupLanguages } from "./chunker.js";
+import { applyContextHeaderToChunk, stripContextHeader } from "./context-header.js";
 import { Embedder, selectBackend } from "./embedder.js";
 import { EmbeddingCache } from "./embedding-cache.js";
-import { Manifest } from "./manifest.js";
+import { Manifest, CURRENT_SCHEMA_VERSION } from "./manifest.js";
 import { loadIgnorePatterns, matchesAny } from "./ignorefile.js";
 import { isSecretFile, redactSecrets } from "./secrets.js";
 import { LocalBackend } from "../storage/local-backend.js";
 import type { Chunk, ChunkType, GraphEdge, GraphNode, NodeType } from "../types.js";
-import { resolveOllamaUrl } from "../config.js";
+import { resolveOllamaUrl, ROOT_ONLY_IGNORE } from "../config.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -159,13 +160,16 @@ function cceignoreMatchesDir(relPosix: string, patterns: string[]): boolean {
  */
 function targetExcluded(
 	relPosix: string,
-	opts: { isDir: boolean; ignoreSet: Set<string>; redactSecrets: boolean; patterns: string[] },
+	opts: { isDir: boolean; ignoreSet: Set<string>; rootIgnoreSet: Set<string>; redactSecrets: boolean; patterns: string[] },
 ): boolean {
 	if (relPosix === "") return false;
 	const segments = relPosix.split("/");
 	for (const seg of segments) {
 		if (opts.ignoreSet.has(seg)) return true;
 	}
+	// Only the first segment is project-root level; root-only names must not
+	// reject nested paths like `src/storage/x.ts`.
+	if (opts.rootIgnoreSet.has(segments[0]!)) return true;
 	// The walker only classifies secret names on file entries; a secret-named
 	// directory's contents are still gated per file.
 	if (!opts.isDir && opts.redactSecrets && isSecretFile(segments[segments.length - 1]!)) return true;
@@ -187,6 +191,7 @@ function* iterProjectFiles(
 	/** Project root: `.cceignore` patterns are matched against project-relative paths even when walking from a target. */
 	relRoot: string,
 	ignoreSet: Set<string>,
+	rootIgnoreSet: Set<string>,
 	opts: { redactSecrets: boolean; cceignorePatterns: string[] },
 ): Generator<string> {
 	const seen = new Set<string>();
@@ -200,7 +205,10 @@ function* iterProjectFiles(
 		}
 		entries.sort((a, b) => a.name.localeCompare(b.name));
 		for (const entry of entries) {
-			if (ignoreSet.has(entry.name)) continue;
+			// Root-only names (`storage`, `logs`, ...) only match at the project
+			// root — nested `src/storage/` is real source and must be indexed.
+			const atProjectRoot = directory === relRoot;
+			if (ignoreSet.has(entry.name) || (atProjectRoot && rootIgnoreSet.has(entry.name))) continue;
 			const full = path.join(directory, entry.name);
 			if (entry.isSymbolicLink()) continue;
 			let resolved: string;
@@ -394,7 +402,8 @@ async function runIndexingLocked(
 	options: { full?: boolean; targetPath?: string | null; callbacks?: IndexCallbacks },
 	runtime?: { backend: LocalBackend; embedder: Embedder },
 ): Promise<IndexResult> {
-	const { full = false, targetPath = null, callbacks = {} } = options;
+	let { full = false, targetPath = null } = options;
+	const { callbacks = {} } = options;
 	const { log, progress, phase } = callbacks;
 
 	const ownsBackend = runtime === undefined;
@@ -411,12 +420,39 @@ async function runIndexingLocked(
 		cacheMisses: 0,
 	};
 
-	if (backend.metricRebuilt) {
+	// PR #7 review fix: migrations below call manifest.clearEntries(), which
+	// also erases the file list pruneFilesNotIn() needs to detect files that
+	// vanished BEFORE this run. Snapshot the paths first so the prune step
+	// can still delete their indexed chunks instead of orphaning them.
+	const preMigrationPaths = Object.keys(manifest.fileEntries);
+
+	// Refuse unrecognized index formats outright (no compat reading): a
+	// manifest we can't recognize — pre-versioning, corrupt, or a future
+	// format — wipes every store and rebuilds from source below. The same gate
+	// covers format changes (e.g. v3 added R1 context headers) that alter chunk
+	// content WITHOUT changing the file on disk, which the content hash alone
+	// would never catch.
+	if (manifest.needsStoreReset) {
+		log?.(
+			`  [rebuild] index format v${manifest.schemaVersion} → v${CURRENT_SCHEMA_VERSION} — wiping stores, reindexing all files`,
+		);
+		backend.clear();
 		manifest.clearEntries();
-		log?.("  [migration] vector index rebuilt (cosine metric) — reindexing all files");
+		// The wipe dropped the git-history chunks too; without resetting the
+		// pointer the next full run would only fetch NEW commits and the old
+		// ones would never come back.
+		manifest.lastGitSha = null;
+		// A wipe must rebuild everything in THIS run — a targeted run would
+		// leave the index empty except for the one target file.
+		if (targetPath !== null) {
+			log?.("  [rebuild] escalating targeted run to full reindex after store reset");
+			targetPath = null;
+		}
+		full = true;
 	}
 
 	const ignoreSet = new Set(config.indexerIgnore);
+	const rootIgnoreSet = new Set(ROOT_ONLY_IGNORE);
 	const cceignorePatterns = loadIgnorePatterns(projectDir);
 	if (cceignorePatterns.length > 0) log?.(`  [.cceignore] ${cceignorePatterns.length} pattern(s) loaded`);
 
@@ -449,6 +485,7 @@ async function runIndexingLocked(
 				targetExcluded(rel, {
 					isDir: false,
 					ignoreSet,
+					rootIgnoreSet,
 					redactSecrets: config.indexerRedactSecrets,
 					patterns: cceignorePatterns,
 				})
@@ -471,6 +508,7 @@ async function runIndexingLocked(
 			const excluded = targetExcluded(rel, {
 				isDir: true,
 				ignoreSet,
+				rootIgnoreSet,
 				redactSecrets: config.indexerRedactSecrets,
 				patterns: cceignorePatterns,
 			});
@@ -479,7 +517,7 @@ async function runIndexingLocked(
 				fileList = [];
 			} else {
 				fileList = [
-					...iterProjectFiles(target, projectDir, ignoreSet, {
+					...iterProjectFiles(target, projectDir, ignoreSet, rootIgnoreSet, {
 						redactSecrets: config.indexerRedactSecrets,
 						cceignorePatterns,
 					}),
@@ -507,7 +545,7 @@ async function runIndexingLocked(
 		}
 	} else {
 		fileList = [
-			...iterProjectFiles(projectDir, projectDir, ignoreSet, {
+			...iterProjectFiles(projectDir, projectDir, ignoreSet, rootIgnoreSet, {
 				redactSecrets: config.indexerRedactSecrets,
 				cceignorePatterns,
 			}),
@@ -522,6 +560,18 @@ async function runIndexingLocked(
 	}
 	if (languages.size > 0) await warmupLanguages(languages);
 
+	// R7: every rel path this run touches (changed or not) plus everything
+	// already indexed forms the resolution universe for import specifiers.
+	const knownFiles = new Set<string>(Object.keys(manifest.fileEntries));
+	for (const f of fileList) knownFiles.add(path.relative(projectDir, f).replace(/\\/g, "/"));
+	// R7: cross-file call-graph state, filled during the batch loop, emitted
+	// as chunk-to-chunk `calls` edges after ALL batches (so early files can
+	// call symbols defined in late ones — order-independent).
+	const runChunks: { id: string; filePath: string; identifiers: string[] }[] = [];
+	const symbolOwners = new Map<string, { id: string; filePath: string }[]>();
+	// PR #7 review: files whose chunks were (re)built this run, across ALL batches.
+	const changedRelPaths = new Set<string>();
+
 	// ── Lazy embedder + cache ─────────────────────────────────────────────
 	const holders: { embedder: Embedder | null; cache: EmbeddingCache | null } = {
 		embedder: runtime?.embedder ?? null,
@@ -544,218 +594,338 @@ async function runIndexingLocked(
 		return { embedder: holders.embedder, cache: holders.cache };
 	};
 
-	// Dimension migration: a backend swap invalidates every stored vector.
-	if (fileList.length > 0 && manifest.embeddingDim !== null && manifest.hasEntries) {
-		const { embedder: emb } = await ensureEmbedder();
-		if (manifest.embeddingDim !== emb.dimension) {
-			log?.(
-				`  [migration] embedding dim changed (${manifest.embeddingDim} → ${emb.dimension}, backend=${emb.backendName}) — forcing full reindex`,
-			);
-			manifest.clearEntries();
-		}
-	}
+	// Everything after this point can reject (embed failures, backend
+	// crashes, IO). The finally at the end of the function releases the
+	// cache/backend handles on every path: an open handle wedges re-runs
+	// and tests (on Windows an open handle makes the storage directory
+	// undeletable, which is how this was caught).
+	try {
 
-	const currentRelPaths = new Set<string>();
-	const totalBatches = Math.max(1, Math.ceil(fileList.length / BATCH));
-	let announced = false;
-	let totalCacheHits = 0;
-	let totalCacheMisses = 0;
-
-	for (let batchIndex = 0; batchIndex < fileList.length; batchIndex += BATCH) {
-		const batchPaths = fileList.slice(batchIndex, batchIndex + BATCH);
-		const toChunk: { filePath: string; relPath: string; content: string; contentHash: string; language: string }[] = [];
-
-		for (const filePath of batchPaths) {
-			const relPath = path.relative(projectDir, filePath).replace(/\\/g, "/");
-			currentRelPaths.add(relPath);
-			let content = safeRead(filePath);
-			if (content === null) {
-				result.skippedFiles.push(relPath);
-				log?.(`  [skip] ${relPath} (binary or unreadable)`);
-				continue;
-			}
-			if (config.indexerRedactSecrets) {
-				const redacted = redactSecrets(content);
-				if (redacted.labels.length > 0) {
-					content = redacted.text;
-					log?.(`  [redact] ${relPath} (${redacted.labels.length} secret(s))`);
-				}
-			}
-			const contentHash = sha256Hex(content);
-			if (!full && !manifest.hasChanged(relPath, contentHash)) {
-				log?.(`  [skip] ${relPath} (unchanged)`);
-				continue;
+		// Dimension migration: a backend swap invalidates every stored vector.
+		if (fileList.length > 0 && manifest.embeddingDim !== null && manifest.hasEntries) {
+			const { embedder: emb } = await ensureEmbedder();
+			if (manifest.embeddingDim !== emb.dimension) {
+				log?.(
+					`  [migration] embedding dim changed (${manifest.embeddingDim} → ${emb.dimension}, backend=${emb.backendName}) — forcing full reindex`,
+				);
+				manifest.clearEntries();
+				// The dim swap dropped stored vectors (git history included); reset
+				// the pointer so the next full run re-fetches those commits too.
+				manifest.lastGitSha = null;
 			}
-			toChunk.push({
-				filePath,
-				relPath,
-				content,
-				contentHash,
-				language: LANGUAGE_MAP[path.extname(filePath).toLowerCase()] ?? "plaintext",
-			});
 		}
 
-		const batchChunks: Chunk[] = [];
-		const batchNodes: GraphNode[] = [];
-		const batchEdges: GraphEdge[] = [];
-		const batchFilesToReplace: string[] = [];
-		const batchManifestUpdates: [string, string][] = [];
-		const batchIndexed: string[] = [];
-
-		for (const item of toChunk) {
-			let chunks: Chunk[] = [];
-			let importedModules: string[] = [];
-			try {
-				if (isAstLanguage(item.language)) {
-					const out = chunker.chunkWithImports(item.content, item.relPath, item.language);
-					chunks = out.chunks;
-					importedModules = out.imports;
+		const currentRelPaths = new Set<string>();
+		const totalBatches = Math.max(1, Math.ceil(fileList.length / BATCH));
+		let announced = false;
+		let totalCacheHits = 0;
+		let totalCacheMisses = 0;
+
+		for (let batchIndex = 0; batchIndex < fileList.length; batchIndex += BATCH) {
+			// Cooperative yield: the loops below do sync I/O, tree-sitter parsing
+			// and ONNX inference on the main thread. Without a breather per unit
+			// of work the pi UI starves for the whole run (bench-event-loop.mts:
+			// ~0.5-0.9 s event-loop stalls per batch before this).
+			await yieldToEventLoop();
+			const batchPaths = fileList.slice(batchIndex, batchIndex + BATCH);
+			const toChunk: { filePath: string; relPath: string; content: string; contentHash: string; language: string }[] = [];
+
+			for (const filePath of batchPaths) {
+				await yieldToEventLoop();
+				const relPath = path.relative(projectDir, filePath).replace(/\\/g, "/");
+				currentRelPaths.add(relPath);
+				let content = safeRead(filePath);
+				if (content === null) {
+					result.skippedFiles.push(relPath);
+					log?.(`  [skip] ${relPath} (binary or unreadable)`);
+					continue;
 				}
-				if (chunks.length === 0) {
-					// Fallback: module-level chunk (upstream _fallback_chunk).
-					chunks = [
-						{
-							id: sha256Hex(`${item.relPath}:module`).slice(0, 16),
-							content: item.content,
-							chunkType: "module",
-							filePath: item.relPath,
-							startLine: 1,
-							endLine: Math.max(1, item.content.trim().split("\n").length),
-							language: item.language,
-							metadata: {},
-							embedding: null,
-							confidenceScore: 0,
-							compressedContent: null,
-						},
-					];
+				if (config.indexerRedactSecrets) {
+					const redacted = redactSecrets(content);
+					if (redacted.labels.length > 0) {
+						content = redacted.text;
+						log?.(`  [redact] ${relPath} (${redacted.labels.length} secret(s))`);
+					}
 				}
-			} catch (err) {
-				result.errors.push(`Chunking failed for ${item.relPath}: ${(err as Error).message}`);
-				continue;
-			}
-
-			// Stamp mtime so the recency weight has real signal.
-			let mtime: number | null = null;
-			try {
-				mtime = fs.statSync(item.filePath).mtimeMs / 1000;
-			} catch {
-				mtime = null;
-			}
-			if (mtime !== null) for (const c of chunks) c.metadata["modified_ts"] = mtime;
-
-			batchFilesToReplace.push(item.relPath);
-			const fileNodeId = `file_${item.relPath}`;
-			batchNodes.push({
-				id: fileNodeId,
-				nodeType: "file",
-				name: path.basename(item.filePath),
-				filePath: item.relPath,
-				properties: {},
-			});
-			for (const module of importedModules) {
-				batchEdges.push({
-					sourceId: fileNodeId,
-					targetId: `module_${module}`,
-					edgeType: "imports",
-					properties: {},
+				const contentHash = sha256Hex(content);
+				if (!full && !manifest.hasChanged(relPath, contentHash)) {
+					log?.(`  [skip] ${relPath} (unchanged)`);
+					continue;
+				}
+				toChunk.push({
+					filePath,
+					relPath,
+					content,
+					contentHash,
+					language: LANGUAGE_MAP[path.extname(filePath).toLowerCase()] ?? "plaintext",
 				});
 			}
-			for (const chunk of chunks) {
-				const nodeName = chunk.content.includes("(")
-					? chunk.content.split("(")[0]!.split(":").pop()!.trim()
-					: chunk.id;
+
+			const batchChunks: Chunk[] = [];
+			const batchNodes: GraphNode[] = [];
+			const batchEdges: GraphEdge[] = [];
+			const batchFilesToReplace: string[] = [];
+			const batchManifestUpdates: [string, string][] = [];
+			const batchIndexed: string[] = [];
+
+			for (const item of toChunk) {
+				await yieldToEventLoop();
+				changedRelPaths.add(item.relPath);
+				let chunks: Chunk[] = [];
+				let importedModules: string[] = [];
+				let importSpecs: string[] = [];
+				try {
+					if (isAstLanguage(item.language)) {
+						const out = chunker.chunkWithImports(item.content, item.relPath, item.language, {
+								chunking: config.indexerChunking,
+								budgetChars: config.indexerChunkBudgetChars,
+							});
+						chunks = out.chunks;
+						importedModules = out.imports;
+						importSpecs = out.importSpecs;
+					}
+					if (chunks.length === 0) {
+						// Fallback: module-level chunk (upstream _fallback_chunk).
+						chunks = [
+							{
+								id: sha256Hex(`${item.relPath}:module`).slice(0, 16),
+								content: item.content,
+								chunkType: "module",
+								filePath: item.relPath,
+								startLine: 1,
+								endLine: Math.max(1, item.content.trim().split("\n").length),
+								language: item.language,
+								metadata: {},
+								embedding: null,
+								confidenceScore: 0,
+								compressedContent: null,
+							},
+						];
+					}
+				} catch (err) {
+					result.errors.push(`Chunking failed for ${item.relPath}: ${(err as Error).message}`);
+					continue;
+				}
+
+				// Stamp mtime so the recency weight has real signal.
+				let mtime: number | null = null;
+				try {
+					mtime = fs.statSync(item.filePath).mtimeMs / 1000;
+				} catch {
+					mtime = null;
+				}
+				if (mtime !== null) for (const c of chunks) c.metadata["modified_ts"] = mtime;
+
+				batchFilesToReplace.push(item.relPath);
+				const fileNodeId = `file_${item.relPath}`;
 				batchNodes.push({
-					id: chunk.id,
-					nodeType: CHUNK_TO_NODE_TYPE[chunk.chunkType] ?? "module",
-					name: nodeName,
+					id: fileNodeId,
+					nodeType: "file",
+					name: path.basename(item.filePath),
 					filePath: item.relPath,
 					properties: {},
 				});
-				batchEdges.push({
-					sourceId: fileNodeId,
-					targetId: chunk.id,
-					edgeType: "defines",
-					properties: {},
-				});
+				for (const spec of importSpecs) {
+					// R7: resolve relative specifiers to a real indexed file. Before this,
+					// edges pointed at `module_<spec>` nodes that were never created, so
+					// every imports-edge JOIN silently produced nothing and
+					// related_context / getRelatedFilePaths were dead code. Bare package
+					// imports ("react", "node:fs") stay out: they resolve to nothing in
+					// the index and would only add noise.
+					const resolved = resolveImportPath(spec, item.relPath, knownFiles);
+					if (resolved) {
+						batchEdges.push({
+							sourceId: fileNodeId,
+							targetId: `file_${resolved}`,
+							edgeType: "imports",
+							properties: {},
+						});
+					}
+				}
+				for (const chunk of chunks) {
+					const nodeName =
+						(typeof chunk.metadata["unit"] === "string" && chunk.metadata["unit"]) ||
+						(chunk.content.includes("(") ? chunk.content.split("(")[0]!.split(":").pop()!.trim() : chunk.id);
+					batchNodes.push({
+						id: chunk.id,
+						nodeType: CHUNK_TO_NODE_TYPE[chunk.chunkType] ?? "module",
+						name: nodeName,
+						filePath: item.relPath,
+						properties: {},
+					});
+					batchEdges.push({
+						sourceId: fileNodeId,
+						targetId: chunk.id,
+						edgeType: "defines",
+						properties: {},
+					});
+					// R7 calls-graph collection (raw content, before the context header
+					// prepends file paths and `defines:` lists that would pollute the
+					// identifier set).
+					const unit = typeof chunk.metadata["unit"] === "string" ? chunk.metadata["unit"] : "";
+					if (chunk.chunkType === "function" || chunk.chunkType === "class") {
+						const short = unit.includes(".") ? unit.slice(unit.lastIndexOf(".") + 1) : unit;
+						if (short.length >= 3 && !CALL_GRAPH_STOPLIST.has(short)) {
+							let owners = symbolOwners.get(short);
+							if (!owners) symbolOwners.set(short, (owners = []));
+							owners.push({ id: chunk.id, filePath: item.relPath });
+						}
+					}
+					if (chunk.chunkType !== "module") {
+						runChunks.push({
+							id: chunk.id,
+							filePath: item.relPath,
+							identifiers: extractIdentifiers(chunk.content),
+						});
+					}
+				}
+				// R1 context headers go on LAST: graph node names above derive from raw
+				// content, and every downstream consumer (embed, FTS, compression,
+				// expand_chunk) reads `chunk.content`, so one prepend covers them all.
+				if (config.indexerContextHeaders) {
+					for (const chunk of chunks) applyContextHeaderToChunk(chunk, importedModules);
+				}
+				batchChunks.push(...chunks);
+				batchManifestUpdates.push([item.relPath, item.contentHash]);
+				batchIndexed.push(item.relPath);
 			}
-			batchChunks.push(...chunks);
-			batchManifestUpdates.push([item.relPath, item.contentHash]);
-			batchIndexed.push(item.relPath);
-		}
-
-		progress?.(Math.min(batchIndex + batchPaths.length, fileList.length), fileList.length);
 
-		if (batchChunks.length > 0) {
-			const { embedder: emb, cache: cch } = await ensureEmbedder();
-			if (phase && !announced) {
-				phase(`Embedding ${batchChunks.length.toLocaleString()} chunks${totalBatches > 1 ? ` (batch ${Math.floor(batchIndex / BATCH) + 1}/${totalBatches})` : ""}…`);
-				announced = true;
-			}
-			const stats = await embedChunks(batchChunks, emb, cch);
-			totalCacheHits += stats.hits;
-			totalCacheMisses += stats.misses;
-			// Per-batch deletes happen AFTER embed succeeds, so an embed failure
-			// can never wipe previously-indexed rows.
-			backend.deleteByFiles(batchFilesToReplace);
-			backend.ingest(batchChunks, batchNodes, batchEdges);
-			for (const [rel, hash] of batchManifestUpdates) manifest.update(rel, hash);
-			result.indexedFiles.push(...batchIndexed);
-			result.totalChunks += batchChunks.length;
-		} else if (batchFilesToReplace.length > 0) {
-			backend.deleteByFiles(batchFilesToReplace);
-			for (const [rel, hash] of batchManifestUpdates) manifest.update(rel, hash);
-			result.indexedFiles.push(...batchIndexed);
-		}
-		result.skippedFiles.push(...toChunk.filter((t) => !batchIndexed.includes(t.relPath)).map((t) => t.relPath));
-	}
+			progress?.(Math.min(batchIndex + batchPaths.length, fileList.length), fileList.length);
 
-	// ── Git history on full runs ──────────────────────────────────────────
-	if (full && !targetPath && fs.existsSync(path.join(projectDir, ".git"))) {
-		try {
-			const git = await indexCommits(projectDir, manifest.lastGitSha);
-			if (git.chunks.length > 0) {
+			if (batchChunks.length > 0) {
 				const { embedder: emb, cache: cch } = await ensureEmbedder();
-				phase?.(`Embedding ${git.chunks.length} git commits…`);
-				const stats = await embedChunks(git.chunks, emb, cch);
+				if (phase && !announced) {
+					phase(`Embedding ${batchChunks.length.toLocaleString()} chunks${totalBatches > 1 ? ` (batch ${Math.floor(batchIndex / BATCH) + 1}/${totalBatches})` : ""}…`);
+					announced = true;
+				}
+				const stats = await embedChunks(batchChunks, emb, cch);
 				totalCacheHits += stats.hits;
 				totalCacheMisses += stats.misses;
-				backend.ingest(git.chunks, git.nodes, git.edges);
-				result.totalChunks += git.chunks.length;
-				if (git.headSha) manifest.lastGitSha = git.headSha;
-				log?.(`  [git] ${git.chunks.length} commit(s) indexed`);
+				// Per-batch deletes happen AFTER embed succeeds, so an embed failure
+				// can never wipe previously-indexed rows.
+				backend.deleteByFiles(batchFilesToReplace);
+				backend.ingest(batchChunks, batchNodes, batchEdges);
+				for (const [rel, hash] of batchManifestUpdates) manifest.update(rel, hash);
+				result.indexedFiles.push(...batchIndexed);
+				result.totalChunks += batchChunks.length;
+			} else if (batchFilesToReplace.length > 0) {
+				backend.deleteByFiles(batchFilesToReplace);
+				for (const [rel, hash] of batchManifestUpdates) manifest.update(rel, hash);
+				result.indexedFiles.push(...batchIndexed);
 			}
-		} catch (err) {
-			result.errors.push(`git history indexing failed: ${(err as Error).message}`);
+			result.skippedFiles.push(...toChunk.filter((t) => !batchIndexed.includes(t.relPath)).map((t) => t.relPath));
 		}
-	}
 
-	// ── Prune files that vanished from disk ───────────────────────────────
-	if (!targetPath) {
-		const previousPaths = new Set(Object.keys(manifest.fileEntries));
-		const removed = [...previousPaths].filter((rel) => !currentRelPaths.has(rel));
-		if (removed.length > 0) {
-			backend.deleteByFiles(removed);
-			for (const rel of removed) {
-				manifest.remove(rel);
-				result.deletedFiles.push(rel);
-				log?.(`  [delete] ${rel} (no longer on disk)`);
+		// ── R7: emit chunk→chunk calls edges ──────────────────────────────────
+		// Runs AFTER all batches so the symbol table is complete regardless of
+		// batch order. Cross-file only: intra-file structure is already covered
+		// by file/defines edges. Capped per chunk — a retrieval prior, not a
+		// faithful call graph.
+		{
+			// PR #7 review fix (incremental call graph): derive over ALL indexed
+			// files, not just this run's changes. deleteByFiles(changed) removes
+			// call edges touching changed chunk nodes in BOTH directions, so a
+			// run-only derivation silently dropped (a) changed files' calls into
+			// unchanged files and (b) unchanged callers' edges into changed files.
+			// Re-deriving from every indexed file recreates exactly the deleted
+			// edges; unchanged→unchanged duplicates collapse on the edge PK
+			// (INSERT OR REPLACE).
+			const callsEdges: GraphEdge[] = [];
+			const derivationSources = [...runChunks];
+			const changedThisRun = changedRelPaths;
+			for (const rel of Object.keys(manifest.fileEntries)) {
+				if (changedThisRun.has(rel)) continue;
+				for (const stored of backend.chunksByFile(rel, 500)) {
+					if (stored.chunkType === "module") continue;
+					derivationSources.push({
+						id: stored.id,
+						filePath: rel,
+						// Stored content carries the R1 context header; strip it so
+						// header tokens cannot pollute the identifier set.
+						identifiers: extractIdentifiers(stripContextHeader(stored.content)),
+					});
+				}
 			}
+			// Symbol owners over all files: run chunks first (fresh), then graph
+			// nodes of files that did not change (they are still valid).
+			for (const node of backend.listSymbolNodes()) {
+				if (changedThisRun.has(node.filePath)) continue;
+				const short = node.name.includes(".") ? node.name.slice(node.name.lastIndexOf(".") + 1) : node.name;
+				if (short.length < 3 || CALL_GRAPH_STOPLIST.has(short)) continue;
+				let owners = symbolOwners.get(short);
+				if (!owners) symbolOwners.set(short, (owners = []));
+				owners.push({ id: node.id, filePath: node.filePath });
+			}
+			for (const src of derivationSources) {
+				let out = 0;
+				for (const ident of src.identifiers) {
+					if (out >= CALLS_EDGES_PER_CHUNK) break;
+					for (const owner of symbolOwners.get(ident) ?? []) {
+						if (owner.filePath === src.filePath) continue;
+						callsEdges.push({ sourceId: src.id, targetId: owner.id, edgeType: "calls", properties: {} });
+						out += 1;
+						if (out >= CALLS_EDGES_PER_CHUNK) break;
+					}
+				}
+			}
+			if (callsEdges.length > 0) {
+					backend.ingest([], [], callsEdges);
+					log?.(`  [graph] ${callsEdges.length} cross-file call edge(s)`);
+				}
 		}
-	}
 
-	if (holders.cache) {
-		result.cacheHits = holders.cache.hitCount;
-		result.cacheMisses = holders.cache.missCount;
-		holders.cache.close();
-	} else {
-		result.cacheHits = totalCacheHits;
-		result.cacheMisses = totalCacheMisses;
-	}
+		// ── Git history on full runs ──────────────────────────────────────────
+		if (full && !targetPath && fs.existsSync(path.join(projectDir, ".git"))) {
+			try {
+				const git = await indexCommits(projectDir, manifest.lastGitSha);
+				if (git.chunks.length > 0) {
+					const { embedder: emb, cache: cch } = await ensureEmbedder();
+					phase?.(`Embedding ${git.chunks.length} git commits…`);
+					const stats = await embedChunks(git.chunks, emb, cch);
+					totalCacheHits += stats.hits;
+					totalCacheMisses += stats.misses;
+					backend.ingest(git.chunks, git.nodes, git.edges);
+					result.totalChunks += git.chunks.length;
+					if (git.headSha) manifest.lastGitSha = git.headSha;
+					log?.(`  [git] ${git.chunks.length} commit(s) indexed`);
+				}
+			} catch (err) {
+				result.errors.push(`git history indexing failed: ${(err as Error).message}`);
+			}
+		}
 
-	if (holders.embedder) manifest.embeddingDim = holders.embedder.dimension;
-	manifest.save();
-	if (ownsBackend) backend.close();
-	return result;
+		// ── Prune files that vanished from disk ───────────────────────────────
+		if (!targetPath) {
+			const previousPaths = new Set([...Object.keys(manifest.fileEntries), ...preMigrationPaths]);
+			const removed = [...previousPaths].filter((rel) => !currentRelPaths.has(rel));
+			if (removed.length > 0) {
+				backend.deleteByFiles(removed);
+				for (const rel of removed) {
+					manifest.remove(rel);
+					result.deletedFiles.push(rel);
+					log?.(`  [delete] ${rel} (no longer on disk)`);
+				}
+			}
+		}
+
+		if (holders.cache) {
+			result.cacheHits = holders.cache.hitCount;
+			result.cacheMisses = holders.cache.missCount;
+		} else {
+			result.cacheHits = totalCacheHits;
+			result.cacheMisses = totalCacheMisses;
+		}
+
+		if (holders.embedder) manifest.embeddingDim = holders.embedder.dimension;
+		manifest.save();
+		return result;
+	} finally {
+		// Release handles on EVERY path: a mid-run rejection (embed failure,
+		// backend crash) must not leak them. Success-path bookkeeping above
+		// reads the live counters before this closes the cache.
+		if (holders.cache) holders.cache.close();
+		if (ownsBackend) backend.close();
+	}
 }
 
 /** Directory patterns need re-checking against every ancestor for single files. */
@@ -767,3 +937,71 @@ function cceignoreMatchesFile(relPosix: string, patterns: string[]): boolean {
 	}
 	return false;
 }
+
+// ── R7 helpers: import resolution + call-graph vocabulary ─────────────────
+
+/** Cap per chunk for calls edges: a prior, not a faithful call graph. */
+const CALLS_EDGES_PER_CHUNK = 8;
+/** Max unique identifiers kept per chunk (first occurrences win). */
+const IDENTIFIERS_PER_CHUNK = 60;
+
+/** Words that name a chunk never worth a calls edge. */
+const CALL_GRAPH_STOPLIST = new Set([
+	"const", "let", "var", "function", "class", "return", "string", "number", "boolean", "object",
+	"void", "null", "undefined", "true", "false", "this", "import", "export", "default", "type",
+	"interface", "extends", "implements", "constructor", "static", "readonly", "public", "private",
+	"protected", "async", "await", "Promise", "Object", "Array", "String", "Number", "Boolean",
+	"Math", "JSON", "Error", "console", "process", "require", "module", "exports", "Map", "Set",
+	"Date", "Symbol", "Buffer", "path", "fs", "os", "unknown", "never", "text", "params", "options",
+	"value", "values", "result", "results", "data", "content", "item", "items", "name", "file", "files",
+	"line", "lines", "index", "length", "score", "query", "chunk", "chunks",
+]);
+
+/** Unique identifier-ish words in a chunk, capped (first occurrences win). */
+function extractIdentifiers(content: string): string[] {
+	const seen = new Set<string>();
+	const re = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+	let m: RegExpExecArray | null;
+	while ((m = re.exec(content)) !== null && seen.size < IDENTIFIERS_PER_CHUNK) {
+		const w = m[0];
+		if (w.length >= 3 && !CALL_GRAPH_STOPLIST.has(w)) seen.add(w);
+	}
+	return [...seen];
+}
+
+/**
+ * Resolve a relative import specifier against the set of indexed files.
+ * Handles extensionless specs ("./chunker"), .js to .ts rewrites (TypeScript
+ * emits .js specifiers), and directory index files. Returns null for bare
+ * package imports and unresolvable specs.
+ */
+function resolveImportPath(spec: string, importerRel: string, knownFiles: Set<string>): string | null {
+	if (!spec.startsWith(".") && !spec.startsWith("/")) return null;
+	const dir = importerRel.includes("/") ? importerRel.slice(0, importerRel.lastIndexOf("/")) : "";
+	const joined = spec.startsWith("/") ? spec.slice(1) : `${dir}/${spec}`;
+	const stack = joined.split("/");
+	const outStack: string[] = [];
+	for (const part of stack) {
+		if (part === "" || part === ".") continue;
+		if (part === "..") outStack.pop();
+		else outStack.push(part);
+	}
+	const base = outStack.join("/");
+	if (base === "") return null;
+	const candidates = [base];
+	const lower = base.toLowerCase();
+	if (lower.endsWith(".js")) {
+		candidates.push(base.slice(0, -3) + ".ts", base.slice(0, -3) + ".tsx");
+	} else if (lower.endsWith(".mjs") || lower.endsWith(".cjs")) {
+		candidates.push(base.slice(0, -4) + ".ts");
+	} else if (!/\.[a-z]+$/i.test(base)) {
+		candidates.push(base + ".ts", base + ".tsx", base + ".mts", base + ".js");
+	}
+	for (const c of candidates) {
+		if (knownFiles.has(c)) return c;
+	}
+	for (const ext of ["/index.ts", "/index.tsx", "/index.js"]) {
+		if (knownFiles.has(base + ext)) return base + ext;
+	}
+	return null;
+}