@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/drift-tracker.test.js

@@ -0,0 +1,582 @@
+/**
+ * P10-TEST-03: Drift tracker tests — drift computation, overlay management.
+ */
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { entityKey } from "../intelligence/ast-extractor.js";
+import { DRIFT_WATCHER_OPTIONS, DriftTracker, MtimeCache, determineOrigin, } from "../tracking/drift-tracker.js";
+import { FileHashManager, contentSha256 } from "../tracking/file-hash-state.js";
+let tempDir;
+let projectRoot;
+let unerrDir;
+beforeEach(() => {
+    tempDir = join(tmpdir(), `unerr-drift-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    projectRoot = join(tempDir, "project");
+    unerrDir = join(projectRoot, ".unerr");
+    mkdirSync(join(unerrDir, "state"), { recursive: true });
+    mkdirSync(join(projectRoot, "src"), { recursive: true });
+});
+afterEach(() => {
+    try {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+    catch {
+        /* ignore */
+    }
+});
+/** Create a mock CozoGraphStore with in-memory drift overlay */
+function createMockGraph(baseEntities = []) {
+    const driftOverlay = new Map();
+    return {
+        driftOverlay,
+        getEntity: (key) => baseEntities.find((e) => e.key === key) ?? null,
+        getCallersOf: () => [],
+        getCalleesOf: () => [],
+        getEntitiesByFile: (fp) => baseEntities.filter((e) => e.file_path === fp),
+        searchEntities: () => [],
+        getImports: () => [],
+        healthCheck: () => ({ status: "up", latencyMs: 0 }),
+        isLoaded: () => true,
+        loadSnapshot: () => { },
+        hasRules: () => false,
+        getRules: () => [],
+        getPatterns: () => [],
+        loadRules: () => { },
+        loadPatterns: () => { },
+        hasJustifications: () => false,
+        getBusinessContext: () => null,
+        getConventions: () => [],
+        loadJustifications: () => { },
+        upsertDriftEntity: (entity) => {
+            driftOverlay.set(entity.key, entity);
+        },
+        removeDriftEntity: (key) => {
+            driftOverlay.delete(key);
+        },
+        getDriftEntitiesForFile: (fp) => {
+            const result = [];
+            for (const [, e] of driftOverlay) {
+                if (e.file_path === fp)
+                    result.push(e);
+            }
+            return result;
+        },
+        clearDriftOverlay: () => {
+            driftOverlay.clear();
+        },
+        findEntityByName: (name) => baseEntities.find((e) => e.name === name) ?? null,
+        getAllDriftEdges: () => [],
+        upsertDriftEdge: () => { },
+        clearDriftEdges: () => { },
+        getDriftSummary: () => {
+            const summary = {
+                added: 0,
+                modified: 0,
+                deleted: 0,
+                dependency_changed: 0,
+                total: 0,
+            };
+            for (const [, e] of driftOverlay) {
+                if (e.drift_status === "added")
+                    summary.added++;
+                else if (e.drift_status === "modified")
+                    summary.modified++;
+                else if (e.drift_status === "deleted")
+                    summary.deleted++;
+                else if (e.drift_status === "dependency_changed")
+                    summary.dependency_changed++;
+            }
+            summary.total =
+                summary.added +
+                    summary.modified +
+                    summary.deleted +
+                    summary.dependency_changed;
+            return summary;
+        },
+    };
+}
+/**
+ * Create a mock graph with caller edge relationships.
+ * `callerMap` maps callee keys → array of caller LocalEntity objects.
+ */
+function createMockGraphWithCallers(baseEntities, callerMap) {
+    const base = createMockGraph(baseEntities);
+    // Override getCallersOf to return from the caller map
+    base.getCallersOf = (key) => callerMap.get(key) ?? [];
+    return base;
+}
+describe("DriftTracker", () => {
+    it("detects added entities (new file)", async () => {
+        const graph = createMockGraph();
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        // Write a TypeScript file with a function
+        writeFileSync(join(projectRoot, "src/new-feature.ts"), `export function newFeature() {
+  return "hello"
+}`);
+        const result = await tracker.processFile("src/new-feature.ts", "abc123");
+        expect(result.filesProcessed).toBe(1);
+        expect(result.entitiesAdded).toBe(1);
+        expect(result.entitiesModified).toBe(0);
+        expect(result.entitiesDeleted).toBe(0);
+        expect(graph.driftOverlay.size).toBe(1);
+        const driftEntity = [...graph.driftOverlay.values()][0];
+        expect(driftEntity.name).toBe("newFeature");
+        expect(driftEntity.drift_status).toBe("added");
+        expect(driftEntity.file_path).toBe("src/new-feature.ts");
+    });
+    it("detects modified entities (content changed)", async () => {
+        // Base entity
+        const baseEntities = [
+            {
+                key: "test-key-1",
+                kind: "function",
+                name: "existingFn",
+                file_path: "src/existing.ts",
+                start_line: 1,
+                end_line: 0,
+                signature: "()",
+                body: "function existingFn() {\n  return 1\n}",
+                fan_in: 0,
+                fan_out: 0,
+                risk_level: "normal",
+                community: -1,
+            },
+        ];
+        const graph = createMockGraph(baseEntities);
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        // Write modified file
+        writeFileSync(join(projectRoot, "src/existing.ts"), `function existingFn() {
+  return 2
+}`);
+        const result = await tracker.processFile("src/existing.ts", "abc123");
+        expect(result.filesProcessed).toBe(1);
+        // Either modified or added depending on key match
+        expect(result.entitiesModified + result.entitiesAdded).toBeGreaterThanOrEqual(1);
+    });
+    it("skips unchanged files", async () => {
+        const graph = createMockGraph();
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        const content = "export function unchanged() { return 1 }";
+        writeFileSync(join(projectRoot, "src/unchanged.ts"), content);
+        // First process — should process
+        const r1 = await tracker.processFile("src/unchanged.ts", "abc123");
+        expect(r1.filesProcessed).toBe(1);
+        // Mark as processed manually
+        const sha = contentSha256(content);
+        fileHashManager.markProcessed("src/unchanged.ts", sha, "abc123");
+        fileHashManager.save();
+        // Second process — should skip
+        const r2 = await tracker.processFile("src/unchanged.ts", "abc123");
+        expect(r2.filesSkipped).toBe(1);
+        expect(r2.filesProcessed).toBe(0);
+    });
+    it("handles deleted files", async () => {
+        const baseEntities = [
+            {
+                key: "del-key-1",
+                kind: "function",
+                name: "deletedFn",
+                file_path: "src/deleted.ts",
+                start_line: 1,
+                end_line: 0,
+                signature: "",
+                body: "",
+                fan_in: 2,
+                fan_out: 1,
+                risk_level: "normal",
+                community: -1,
+            },
+        ];
+        const graph = createMockGraph(baseEntities);
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        // Don't create the file — it's "deleted"
+        const result = await tracker.processFile("src/deleted.ts", "abc123");
+        expect(result.filesProcessed).toBe(1);
+        expect(result.entitiesDeleted).toBe(1);
+        const deletedEntity = [...graph.driftOverlay.values()][0];
+        expect(deletedEntity.drift_status).toBe("deleted");
+        expect(deletedEntity.name).toBe("deletedFn");
+    });
+    it("skips unsupported languages", async () => {
+        const graph = createMockGraph();
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        writeFileSync(join(projectRoot, "data.json"), '{"key": "value"}');
+        const result = await tracker.processFile("data.json", "abc123");
+        expect(result.filesProcessed).toBe(0);
+        expect(result.filesSkipped).toBe(0);
+        expect(graph.driftOverlay.size).toBe(0);
+    });
+    it("processes batch of files", async () => {
+        const graph = createMockGraph();
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        writeFileSync(join(projectRoot, "src/a.ts"), "export function alpha() { return 1 }");
+        writeFileSync(join(projectRoot, "src/b.ts"), "export function beta() { return 2 }");
+        const result = await tracker.processFiles(["src/a.ts", "src/b.ts"], "abc123");
+        expect(result.filesProcessed).toBe(2);
+        expect(result.entitiesAdded).toBe(2);
+    });
+    it("drift summary aggregates correctly", async () => {
+        const baseEntities = [
+            {
+                key: "mod-key-1",
+                kind: "function",
+                name: "oldFn",
+                file_path: "src/old.ts",
+                start_line: 1,
+                end_line: 0,
+                signature: "",
+                body: "function oldFn() { return 1 }",
+                fan_in: 0,
+                fan_out: 0,
+                risk_level: "normal",
+                community: -1,
+            },
+        ];
+        const graph = createMockGraph(baseEntities);
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        // Add a new file
+        writeFileSync(join(projectRoot, "src/new.ts"), "export function newOne() { return 1 }");
+        await tracker.processFile("src/new.ts", "abc123");
+        // Delete an existing file (don't write it)
+        await tracker.processFile("src/old.ts", "abc123");
+        const summary = await tracker.getDriftSummary();
+        expect(summary.total).toBeGreaterThan(0);
+        expect(summary.added + summary.modified + summary.deleted).toBe(summary.total);
+    });
+    it("clears overlay on branch switch", async () => {
+        const graph = createMockGraph();
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        writeFileSync(join(projectRoot, "src/a.ts"), "export function alpha() { return 1 }");
+        await tracker.processFile("src/a.ts", "abc123");
+        expect(graph.driftOverlay.size).toBe(1);
+        // Branch switch — clears and recomputes
+        writeFileSync(join(projectRoot, "src/b.ts"), "export function beta() { return 1 }");
+        await tracker.onBranchSwitch(["src/b.ts"], "def456");
+        // Old overlay should be cleared, new file processed
+        const summary = await tracker.getDriftSummary();
+        expect(summary.added).toBe(1);
+    });
+    it("saves drift summary to disk", async () => {
+        const graph = createMockGraph();
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        writeFileSync(join(projectRoot, "src/a.ts"), "export function alpha() { return 1 }");
+        await tracker.processFiles(["src/a.ts"], "abc123");
+        const summaryPath = join(unerrDir, "drift", "drift_summary.json");
+        expect(existsSync(summaryPath)).toBe(true);
+    });
+    it("mtime cache skips file when mtime unchanged", async () => {
+        const graph = createMockGraph();
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        const filePath = join(projectRoot, "src/stable.ts");
+        writeFileSync(filePath, "export function stable() { return 1 }");
+        // First call — processes the file (mtime is new)
+        const r1 = await tracker.processFile("src/stable.ts", "abc123");
+        expect(r1.filesProcessed).toBe(1);
+        // Second call — mtime unchanged, should skip via mtime cache
+        const r2 = await tracker.processFile("src/stable.ts", "abc123");
+        expect(r2.filesSkipped).toBe(1);
+        expect(r2.filesProcessed).toBe(0);
+    });
+    it("mtime cache processes file when content changes", async () => {
+        const graph = createMockGraph();
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        const filePath = join(projectRoot, "src/changing.ts");
+        writeFileSync(filePath, "export function changing() { return 1 }");
+        // First call — processes
+        await tracker.processFile("src/changing.ts", "abc123");
+        // Modify file — mtime changes
+        writeFileSync(filePath, "export function changing() { return 2 }");
+        // Second call — mtime changed, should process
+        const r2 = await tracker.processFile("src/changing.ts", "abc123");
+        expect(r2.filesProcessed).toBe(1);
+    });
+    it("mtime cache clears on branch switch", async () => {
+        const graph = createMockGraph();
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        const filePath = join(projectRoot, "src/branched.ts");
+        writeFileSync(filePath, "export function branched() { return 1 }");
+        // Process once to populate mtime cache
+        await tracker.processFile("src/branched.ts", "abc123");
+        // Branch switch clears mtime cache
+        await tracker.onBranchSwitch(["src/branched.ts"], "def456");
+        // After branch switch, same file should be reprocessed (mtime cache was cleared)
+        const r = await tracker.processFile("src/branched.ts", "def456");
+        // Will be processed (mtime cache cleared) but may be skipped by file hash manager
+        // since content hasn't changed. The point is mtime cache doesn't block it.
+        expect(r.filesProcessed + r.filesSkipped).toBe(1);
+    });
+});
+describe("MtimeCache", () => {
+    it("returns true for first check (new file)", () => {
+        const cache = new MtimeCache();
+        const filePath = join(projectRoot, "src/first.ts");
+        writeFileSync(filePath, "content");
+        expect(cache.check(filePath)).toBe(true);
+    });
+    it("returns false for unchanged file", () => {
+        const cache = new MtimeCache();
+        const filePath = join(projectRoot, "src/unchanged.ts");
+        writeFileSync(filePath, "content");
+        cache.check(filePath); // populate
+        expect(cache.check(filePath)).toBe(false);
+    });
+    it("returns true after file modification", () => {
+        const cache = new MtimeCache();
+        const filePath = join(projectRoot, "src/modified.ts");
+        writeFileSync(filePath, "content v1");
+        cache.check(filePath); // populate
+        // Modify — mtime changes
+        writeFileSync(filePath, "content v2");
+        expect(cache.check(filePath)).toBe(true);
+    });
+    it("returns true for non-existent file and evicts cache", () => {
+        const cache = new MtimeCache();
+        expect(cache.check("/nonexistent/file.ts")).toBe(true);
+        expect(cache.size).toBe(0);
+    });
+    it("evict removes file from cache", () => {
+        const cache = new MtimeCache();
+        const filePath = join(projectRoot, "src/evicted.ts");
+        writeFileSync(filePath, "content");
+        cache.check(filePath); // populate
+        expect(cache.size).toBe(1);
+        cache.evict(filePath);
+        expect(cache.size).toBe(0);
+        // Next check should return true (new entry)
+        expect(cache.check(filePath)).toBe(true);
+    });
+    it("clear removes all entries", () => {
+        const cache = new MtimeCache();
+        const file1 = join(projectRoot, "src/a.ts");
+        const file2 = join(projectRoot, "src/b.ts");
+        writeFileSync(file1, "a");
+        writeFileSync(file2, "b");
+        cache.check(file1);
+        cache.check(file2);
+        expect(cache.size).toBe(2);
+        cache.clear();
+        expect(cache.size).toBe(0);
+    });
+});
+describe("DRIFT_WATCHER_OPTIONS", () => {
+    it("has awaitWriteFinish with stabilityThreshold 300ms", () => {
+        expect(DRIFT_WATCHER_OPTIONS.awaitWriteFinish.stabilityThreshold).toBe(300);
+        expect(DRIFT_WATCHER_OPTIONS.awaitWriteFinish.pollInterval).toBe(100);
+    });
+});
+describe("determineOrigin", () => {
+    it("returns 'human' when lastSyncTimestamp is 0 (no sync)", () => {
+        expect(determineOrigin(0)).toBe("human");
+    });
+    it("returns 'ai' when <10s after sync", () => {
+        const recentSync = Date.now() - 5_000; // 5s ago
+        expect(determineOrigin(recentSync)).toBe("ai");
+    });
+    it("returns 'mixed' when 10-60s after sync", () => {
+        const mediumSync = Date.now() - 30_000; // 30s ago
+        expect(determineOrigin(mediumSync)).toBe("mixed");
+    });
+    it("returns 'human' when >60s after sync", () => {
+        const oldSync = Date.now() - 120_000; // 2min ago
+        expect(determineOrigin(oldSync)).toBe("human");
+    });
+    it("returns 'ai' at exactly 0ms after sync", () => {
+        const justNow = Date.now();
+        expect(determineOrigin(justNow)).toBe("ai");
+    });
+});
+describe("DriftTracker origin attribution", () => {
+    it("sets origin on added entities based on sync timestamp", async () => {
+        const graph = createMockGraph();
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        // Simulate recent AI sync
+        tracker.setLastSyncTimestamp(Date.now() - 3_000);
+        writeFileSync(join(projectRoot, "src/ai-created.ts"), "export function aiCreated() { return 1 }");
+        await tracker.processFile("src/ai-created.ts", "abc123");
+        const entity = [...graph.driftOverlay.values()][0];
+        expect(entity?.origin).toBe("ai");
+    });
+    it("sets origin to 'human' when no sync has occurred", async () => {
+        const graph = createMockGraph();
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        // No setLastSyncTimestamp call — default is 0
+        writeFileSync(join(projectRoot, "src/human-created.ts"), "export function humanCreated() { return 1 }");
+        await tracker.processFile("src/human-created.ts", "abc123");
+        const entity = [...graph.driftOverlay.values()][0];
+        expect(entity?.origin).toBe("human");
+    });
+    it("sets origin on deleted entities", async () => {
+        const baseEntities = [
+            {
+                key: "del-origin-key",
+                kind: "function",
+                name: "aboutToDelete",
+                file_path: "src/will-delete.ts",
+                start_line: 1,
+                end_line: 0,
+                signature: "",
+                body: "",
+                fan_in: 0,
+                fan_out: 0,
+                risk_level: "normal",
+                community: -1,
+            },
+        ];
+        const graph = createMockGraph(baseEntities);
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId: "repo1", unerrDir }, graph, fileHashManager);
+        // Simulate mixed timing
+        tracker.setLastSyncTimestamp(Date.now() - 25_000);
+        // File doesn't exist — deleted
+        await tracker.processFile("src/will-delete.ts", "abc123");
+        const entity = [...graph.driftOverlay.values()][0];
+        expect(entity?.origin).toBe("mixed");
+        expect(entity?.drift_status).toBe("deleted");
+    });
+});
+describe("Cross-file drift invalidation", () => {
+    const repoId = "repo1";
+    /** Build a base entity with a computable key */
+    function makeBaseEntity(filePath, name, kind, body) {
+        const key = entityKey(repoId, filePath, kind, name, "()");
+        return {
+            key,
+            kind,
+            name,
+            file_path: filePath,
+            start_line: 1,
+            end_line: 0,
+            signature: "()",
+            body,
+            fan_in: 0,
+            fan_out: 0,
+            risk_level: "normal",
+            community: -1,
+        };
+    }
+    it("propagates dependency_changed to callers in other files", async () => {
+        // File A has function `helperFn`, File B has function `callerFn` that calls it
+        const helperEntity = makeBaseEntity("src/helper.ts", "helperFn", "function", "function helperFn() {\n  return 1\n}");
+        const callerEntity = makeBaseEntity("src/caller.ts", "callerFn", "function", "function callerFn() {\n  return helperFn()\n}");
+        const callerMap = new Map();
+        callerMap.set(helperEntity.key, [callerEntity]);
+        const graph = createMockGraphWithCallers([helperEntity, callerEntity], callerMap);
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId, unerrDir }, graph, fileHashManager);
+        // Write modified helper (body changed)
+        writeFileSync(join(projectRoot, "src/helper.ts"), "export function helperFn() {\n  return 999\n}");
+        // Write caller file (unchanged, but needs to exist)
+        writeFileSync(join(projectRoot, "src/caller.ts"), "export function callerFn() {\n  return helperFn()\n}");
+        const result = await tracker.processFile("src/helper.ts", "abc123");
+        expect(result.crossFileInvalidated).toBe(1);
+        // callerFn should have dependency_changed in the overlay
+        const callerDrift = graph.driftOverlay.get(callerEntity.key);
+        expect(callerDrift).toBeDefined();
+        expect(callerDrift?.drift_status).toBe("dependency_changed");
+        expect(callerDrift?.file_path).toBe("src/caller.ts");
+    });
+    it("does NOT invalidate callers in the same file", async () => {
+        // Both entities in the same file
+        const entity1 = makeBaseEntity("src/same-file.ts", "baseFunc", "function", "function baseFunc() {\n  return 1\n}");
+        const entity2 = makeBaseEntity("src/same-file.ts", "callerFunc", "function", "function callerFunc() {\n  return baseFunc()\n}");
+        const callerMap = new Map();
+        callerMap.set(entity1.key, [entity2]); // callerFunc calls baseFunc, same file
+        const graph = createMockGraphWithCallers([entity1, entity2], callerMap);
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId, unerrDir }, graph, fileHashManager);
+        writeFileSync(join(projectRoot, "src/same-file.ts"), "export function baseFunc() {\n  return 999\n}\nexport function callerFunc() {\n  return baseFunc()\n}");
+        const result = await tracker.processFile("src/same-file.ts", "abc123");
+        // Same-file callers should NOT be cross-file invalidated
+        expect(result.crossFileInvalidated).toBe(0);
+    });
+    it("does NOT overwrite stronger drift status with dependency_changed", async () => {
+        const helperEntity = makeBaseEntity("src/dep.ts", "depFn", "function", "function depFn() {\n  return 1\n}");
+        const callerEntity = makeBaseEntity("src/consumer.ts", "consumerFn", "function", "function consumerFn() {\n  return depFn()\n}");
+        const callerMap = new Map();
+        callerMap.set(helperEntity.key, [callerEntity]);
+        const graph = createMockGraphWithCallers([helperEntity, callerEntity], callerMap);
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId, unerrDir }, graph, fileHashManager);
+        // Pre-populate overlay with a "modified" status for the caller
+        graph.driftOverlay.set(callerEntity.key, {
+            key: callerEntity.key,
+            name: "consumerFn",
+            kind: "function",
+            signature: "()",
+            body: "function consumerFn() { return depFn() }",
+            file_path: "src/consumer.ts",
+            line_start: 1,
+            line_end: 3,
+            content_hash: "abc",
+            drift_status: "modified",
+            intent_id: "",
+            modified_at: new Date().toISOString(),
+            origin: "human",
+            previous_body: "",
+            previous_signature: "",
+        });
+        // Modify the dependency
+        writeFileSync(join(projectRoot, "src/dep.ts"), "export function depFn() {\n  return 999\n}");
+        const result = await tracker.processFile("src/dep.ts", "abc123");
+        // Should NOT overwrite the "modified" status
+        expect(result.crossFileInvalidated).toBe(0);
+        const callerDrift = graph.driftOverlay.get(callerEntity.key);
+        expect(callerDrift?.drift_status).toBe("modified");
+    });
+    it("propagates dependency_changed when entity is deleted", async () => {
+        const deletedEntity = makeBaseEntity("src/removed.ts", "removedFn", "function", "function removedFn() {\n  return 1\n}");
+        const callerEntity = makeBaseEntity("src/uses-removed.ts", "usesFn", "function", "function usesFn() {\n  return removedFn()\n}");
+        const callerMap = new Map();
+        callerMap.set(deletedEntity.key, [callerEntity]);
+        const graph = createMockGraphWithCallers([deletedEntity, callerEntity], callerMap);
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId, unerrDir }, graph, fileHashManager);
+        // Write the caller file (exists), but don't write removed.ts (deleted)
+        writeFileSync(join(projectRoot, "src/uses-removed.ts"), "export function usesFn() {\n  return removedFn()\n}");
+        // Process the deleted file — entities should propagate dependency_changed
+        const result = await tracker.processFile("src/removed.ts", "abc123");
+        expect(result.entitiesDeleted).toBe(1);
+        // The caller in another file should get dependency_changed
+        const callerDrift = graph.driftOverlay.get(callerEntity.key);
+        expect(callerDrift).toBeDefined();
+        expect(callerDrift?.drift_status).toBe("dependency_changed");
+    });
+    it("counts crossFileInvalidated correctly in batch", async () => {
+        const entityA = makeBaseEntity("src/a.ts", "funcA", "function", "function funcA() {\n  return 1\n}");
+        const callerB = makeBaseEntity("src/b.ts", "funcB", "function", "function funcB() {\n  return funcA()\n}");
+        const callerC = makeBaseEntity("src/c.ts", "funcC", "function", "function funcC() {\n  return funcA()\n}");
+        const callerMap = new Map();
+        callerMap.set(entityA.key, [callerB, callerC]);
+        const graph = createMockGraphWithCallers([entityA, callerB, callerC], callerMap);
+        const fileHashManager = new FileHashManager(unerrDir);
+        const tracker = new DriftTracker({ projectRoot, repoId, unerrDir }, graph, fileHashManager);
+        // Modify source entity
+        writeFileSync(join(projectRoot, "src/a.ts"), "export function funcA() {\n  return 999\n}");
+        writeFileSync(join(projectRoot, "src/b.ts"), "export function funcB() {\n  return funcA()\n}");
+        writeFileSync(join(projectRoot, "src/c.ts"), "export function funcC() {\n  return funcA()\n}");
+        const result = await tracker.processFiles(["src/a.ts"], "abc123");
+        expect(result.crossFileInvalidated).toBe(2);
+        // Both callers should be in the overlay
+        expect(graph.driftOverlay.get(callerB.key)?.drift_status).toBe("dependency_changed");
+        expect(graph.driftOverlay.get(callerC.key)?.drift_status).toBe("dependency_changed");
+        // Summary should reflect it
+        const summary = await tracker.getDriftSummary();
+        expect(summary.dependency_changed).toBe(2);
+    });
+});