@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/startup-display.test.js

@@ -0,0 +1,302 @@
+/**
+ * Tests for StartupDisplay + StartupRenderer (Task 1.3).
+ *
+ * Tests validate:
+ *   - Three-Act structure: Banner (Act 1), HealthCard (Act 2), Invitation (Act 3)
+ *   - Step status progression: pending → active → done
+ *   - Health Shock display: full card on first boot, compact on subsequent
+ *   - Invitation references specific entity from health data
+ *   - Deep link included when repo ID available
+ *   - Proxy mode displayed when not "full"
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { render } from "ink-testing-library";
+import React from "react";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { StartupDisplay, } from "../components/StartupDisplay.js";
+import { ThemeProvider } from "../components/Theme.js";
+function renderStartup(state) {
+    return render(React.createElement(ThemeProvider, null, React.createElement(StartupDisplay, { state })));
+}
+describe("StartupDisplay (1.3)", () => {
+    // ── Act 1: Instant Competence ──────────────────────────────────
+    describe("Act 1: Banner + Steps", () => {
+        it("renders brand banner", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [],
+                firstBoot: false,
+                ready: false,
+            });
+            expect(lastFrame()).toContain("unerr");
+            expect(lastFrame()).toContain("▸");
+        });
+        it("renders steps with correct status icons", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [
+                    { label: "Authenticated", value: "Org", status: "done" },
+                    { label: "Repository", value: "acme/repo", status: "done" },
+                    { label: "Graph loaded", status: "active" },
+                ],
+                firstBoot: false,
+                ready: false,
+            });
+            const frame = lastFrame() ?? "";
+            expect(frame).toContain("✓");
+            expect(frame).toContain("Authenticated");
+            expect(frame).toContain("Org");
+            expect(frame).toContain("●");
+            expect(frame).toContain("Graph loaded");
+        });
+        it("shows step values alongside labels", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [
+                    {
+                        label: "Graph loaded",
+                        value: "2,341 entities · 1,892 edges",
+                        status: "done",
+                    },
+                ],
+                firstBoot: false,
+                ready: false,
+            });
+            expect(lastFrame()).toContain("2,341 entities");
+            expect(lastFrame()).toContain("1,892 edges");
+        });
+    });
+    // ── Act 2: Revelation (Health Shock) ───────────────────────────
+    describe("Act 2: Health Shock", () => {
+        const health = {
+            grade: "C+",
+            totalEntities: 2341,
+            totalEdges: 1892,
+            totalRules: 12,
+            deadFunctionCount: 23,
+            highRiskEntities: [
+                {
+                    name: "processPayment",
+                    kind: "function",
+                    file_path: "src/billing.ts",
+                    fan_in: 14,
+                    fan_out: 8,
+                },
+            ],
+            score: 62,
+        };
+        it("renders full health card on first boot", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [],
+                health,
+                firstBoot: true,
+                ready: false,
+            });
+            const frame = lastFrame() ?? "";
+            expect(frame).toContain("First Look");
+            expect(frame).toContain("C+");
+            expect(frame).toContain("62/100");
+            expect(frame).toContain("23 dead functions");
+            expect(frame).toContain("processPayment");
+        });
+        it("renders compact health line on subsequent boots", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [],
+                health,
+                firstBoot: false,
+                ready: false,
+            });
+            const frame = lastFrame() ?? "";
+            expect(frame).toContain("C+");
+            expect(frame).toContain("2341 entities");
+            // Should NOT show full dead function detail in compact
+            expect(frame).not.toContain("23 dead functions");
+        });
+        it("does not render health section when no health data", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [],
+                firstBoot: false,
+                ready: false,
+            });
+            expect(lastFrame()).not.toContain("First Look");
+        });
+    });
+    // ── Act 3: Invitation ──────────────────────────────────────────
+    describe("Act 3: Invitation", () => {
+        it("renders invitation with specific entity name", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [],
+                firstBoot: false,
+                ready: true,
+                invitationEntity: "processPayment",
+            });
+            const frame = lastFrame() ?? "";
+            expect(frame).toContain("What depends on processPayment?");
+            expect(frame).toContain("blast radius");
+        });
+        it("renders proxy ready message", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [],
+                firstBoot: false,
+                ready: true,
+            });
+            expect(lastFrame()).toContain("Proxy ready");
+            expect(lastFrame()).toContain("MCP on stdio");
+        });
+        it("shows proxy mode when not full", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [],
+                firstBoot: false,
+                ready: true,
+                proxyMode: "parse",
+            });
+            expect(lastFrame()).toContain("parse mode");
+        });
+        it("shows local mode label when proxyMode is local", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [],
+                firstBoot: false,
+                ready: true,
+                proxyMode: "local",
+            });
+            expect(lastFrame()).toContain("local mode");
+        });
+        it("renders deep link when available", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [],
+                firstBoot: false,
+                ready: true,
+                deepLink: "https://app.unerr.dev/r/repo_123?utm_source=cli_startup",
+            });
+            expect(lastFrame()).toContain("https://app.unerr.dev/r/repo_123");
+        });
+        it("does not render invitation when not ready", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [],
+                firstBoot: false,
+                ready: false,
+                invitationEntity: "processPayment",
+            });
+            expect(lastFrame()).not.toContain("What depends on");
+        });
+    });
+    // ── Full Three-Act integration ─────────────────────────────────
+    describe("Full Three-Act integration", () => {
+        it("renders all three acts together", () => {
+            const { lastFrame } = renderStartup({
+                localMode: false,
+                steps: [
+                    { label: "Authenticated", value: "Jaswanth's Org", status: "done" },
+                    { label: "Repository", value: "unerr-server (main)", status: "done" },
+                    {
+                        label: "Graph loaded",
+                        value: "2,341 entities · 1,892 edges",
+                        status: "done",
+                    },
+                    {
+                        label: "MCP ready",
+                        value: "15 tools (all local)",
+                        status: "done",
+                    },
+                ],
+                health: {
+                    grade: "C+",
+                    totalEntities: 2341,
+                    totalEdges: 1892,
+                    totalRules: 12,
+                    deadFunctionCount: 23,
+                    highRiskEntities: [
+                        {
+                            name: "processPayment",
+                            kind: "function",
+                            file_path: "src/billing.ts",
+                            fan_in: 14,
+                            fan_out: 8,
+                        },
+                    ],
+                    score: 62,
+                },
+                firstBoot: true,
+                ready: true,
+                invitationEntity: "processPayment",
+                deepLink: "https://app.unerr.dev/r/repo_123?utm_source=cli_startup",
+            });
+            const frame = lastFrame() ?? "";
+            // Act 1
+            expect(frame).toContain("unerr");
+            expect(frame).toContain("Authenticated");
+            expect(frame).toContain("Jaswanth's Org");
+            // Act 2
+            expect(frame).toContain("First Look");
+            expect(frame).toContain("C+");
+            expect(frame).toContain("23 dead functions");
+            // Act 3
+            expect(frame).toContain("What depends on processPayment?");
+            expect(frame).toContain("Proxy ready");
+            expect(frame).toContain("https://app.unerr.dev/r/repo_123");
+        });
+    });
+});
+// ── StartupRenderer unit tests ───────────────────────────────────
+describe("StartupRenderer", () => {
+    let tmpDir;
+    let origCwd;
+    beforeEach(() => {
+        tmpDir = path.join(os.tmpdir(), `unerr-startup-test-${Date.now()}`);
+        fs.mkdirSync(path.join(tmpDir, ".unerr", "state"), { recursive: true });
+        origCwd = process.cwd();
+        process.chdir(tmpDir);
+    });
+    afterEach(() => {
+        process.chdir(origCwd);
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("tracks first_boot_shown flag", async () => {
+        const { StartupRenderer } = await import("../proxy/startup-renderer.js");
+        const renderer = new StartupRenderer();
+        // No graph_version.json → first boot
+        renderer.setHealth({
+            grade: "C+",
+            totalEntities: 100,
+            totalEdges: 50,
+            totalRules: 5,
+            deadFunctionCount: 10,
+            highRiskEntities: [],
+            score: 62,
+        }, "repo_test");
+        // Should have written first_boot_shown = true
+        const versionPath = path.join(tmpDir, ".unerr", "state", "graph_version.json");
+        const data = JSON.parse(fs.readFileSync(versionPath, "utf-8"));
+        expect(data.first_boot_shown).toBe(true);
+    });
+    it("detects subsequent boot after first_boot_shown is set", async () => {
+        const versionPath = path.join(tmpDir, ".unerr", "state", "graph_version.json");
+        fs.writeFileSync(versionPath, JSON.stringify({ first_boot_shown: true }));
+        const { StartupRenderer } = await import("../proxy/startup-renderer.js");
+        const renderer = new StartupRenderer();
+        renderer.setHealth({
+            grade: "A",
+            totalEntities: 100,
+            totalEdges: 50,
+            totalRules: 5,
+            deadFunctionCount: 0,
+            highRiskEntities: [],
+            score: 95,
+        }, "repo_test");
+        // firstBoot should be false since flag was already set
+        // We verify indirectly — the renderer won't overwrite the flag
+        const data = JSON.parse(fs.readFileSync(versionPath, "utf-8"));
+        expect(data.first_boot_shown).toBe(true);
+    });
+});

package/dist/__tests__/startup-log-file.test.js

@@ -0,0 +1,97 @@
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import os from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { initFileLog, startupLog } from "../utils/startup-log.js";
+describe("startup-log file logging", () => {
+    let tmpDir;
+    let logPath;
+    beforeEach(() => {
+        tmpDir = join(os.tmpdir(), `unerr-log-test-${Date.now()}`);
+        mkdirSync(tmpDir, { recursive: true });
+        initFileLog(tmpDir);
+        logPath = join(tmpDir, ".unerr", "logs", "unerr.jsonl");
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("creates .unerr/logs/unerr.jsonl on initFileLog", () => {
+        // initFileLog creates the directory; file created on first write
+        startupLog.step("test step");
+        expect(existsSync(logPath)).toBe(true);
+    });
+    it("step() writes a JSONL entry with level=step", () => {
+        startupLog.step("indexing files");
+        const lines = readFileSync(logPath, "utf-8").trim().split("\n");
+        const entry = JSON.parse(lines[lines.length - 1]);
+        expect(entry.level).toBe("step");
+        expect(entry.msg).toContain("indexing files");
+        expect(entry.ts).toBeDefined();
+        expect(entry.pid).toBe(process.pid);
+    });
+    it("done() includes ms metadata when provided", () => {
+        startupLog.done("graph loaded", 42);
+        const lines = readFileSync(logPath, "utf-8").trim().split("\n");
+        const entry = JSON.parse(lines[lines.length - 1]);
+        expect(entry.level).toBe("done");
+        expect(entry.ms).toBe(42);
+    });
+    it("metric() includes raw value and unit", () => {
+        startupLog.metric("entities", 1234, "nodes");
+        const lines = readFileSync(logPath, "utf-8").trim().split("\n");
+        const entry = JSON.parse(lines[lines.length - 1]);
+        expect(entry.level).toBe("metric");
+        expect(entry.value).toBe(1234);
+        expect(entry.unit).toBe("nodes");
+    });
+    it("warn() and error() write correct levels", () => {
+        startupLog.warn("something odd");
+        startupLog.error("something broke");
+        const lines = readFileSync(logPath, "utf-8").trim().split("\n");
+        const entries = lines.map((l) => JSON.parse(l));
+        const warn = entries.find((e) => e.level === "warn");
+        const err = entries.find((e) => e.level === "error");
+        expect(warn).toBeDefined();
+        expect(warn.msg).toContain("something odd");
+        expect(err).toBeDefined();
+        expect(err.msg).toContain("something broke");
+    });
+    it("graphLoaded() writes full stats object", () => {
+        startupLog.graphLoaded({
+            entities: 500,
+            edges: 1200,
+            files: 80,
+            communities: 5,
+            patterns: 12,
+            rules: 3,
+            ms: 150,
+            hottestFile: "src/main.ts",
+            hottestCount: 25,
+        });
+        const lines = readFileSync(logPath, "utf-8").trim().split("\n");
+        const entry = JSON.parse(lines[lines.length - 1]);
+        expect(entry.level).toBe("graph_loaded");
+        expect(entry.entities).toBe(500);
+        expect(entry.edges).toBe(1200);
+        expect(entry.files).toBe(80);
+        expect(entry.communities).toBe(5);
+        expect(entry.patterns).toBe(12);
+        expect(entry.rules).toBe(3);
+        expect(entry.ms).toBe(150);
+        expect(entry.hottestFile).toBe("src/main.ts");
+        expect(entry.hottestCount).toBe(25);
+    });
+    it("file entries have no ANSI escape codes", () => {
+        startupLog.step("test with colors");
+        const content = readFileSync(logPath, "utf-8");
+        expect(content).not.toContain("\x1b[");
+    });
+    it("ready() includes toolCount and mode", () => {
+        startupLog.ready(17, "local");
+        const lines = readFileSync(logPath, "utf-8").trim().split("\n");
+        const entry = JSON.parse(lines[lines.length - 1]);
+        expect(entry.level).toBe("ready");
+        expect(entry.toolCount).toBe(17);
+        expect(entry.mode).toBe("local");
+    });
+});

package/dist/__tests__/stash-manager.test.js

@@ -0,0 +1,229 @@
+/**
+ * Sprint 7.1: Git stash awareness tests.
+ */
+import { mkdirSync, mkdtempSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { StashManager } from "../tracking/stash-manager.js";
+/** Minimal mock CozoGraphStore backed by a Map for drift overlay. */
+function createMockGraph(driftEntities = []) {
+    const entities = new Map();
+    for (const e of driftEntities) {
+        entities.set(e.key, e);
+    }
+    return {
+        entities,
+        getAllDriftEntities: () => [...entities.values()],
+        getAllDriftEdges: () => [],
+        upsertDriftEntity: (entity) => {
+            entities.set(entity.key, entity);
+        },
+        upsertDriftEdge: () => { },
+        removeDriftEntity: (key) => {
+            entities.delete(key);
+        },
+        clearDriftOverlay: () => {
+            entities.clear();
+        },
+    };
+}
+function makeDrift(overrides) {
+    return {
+        kind: "function",
+        signature: "()",
+        body: "function test() {}",
+        file_path: "src/test.ts",
+        line_start: 1,
+        line_end: 3,
+        content_hash: "abc123",
+        drift_status: "modified",
+        intent_id: "",
+        modified_at: new Date().toISOString(),
+        origin: "human",
+        previous_body: "",
+        previous_signature: "",
+        ...overrides,
+    };
+}
+function setupProjectWithGit() {
+    const projectRoot = mkdtempSync(join(tmpdir(), "stash-"));
+    const unerrDir = join(projectRoot, ".unerr");
+    const gitDir = join(projectRoot, ".git");
+    mkdirSync(unerrDir, { recursive: true });
+    mkdirSync(join(gitDir, "refs"), { recursive: true });
+    mkdirSync(join(gitDir, "logs", "refs"), { recursive: true });
+    return { projectRoot, unerrDir, gitDir };
+}
+function writeStashRef(gitDir, ref) {
+    writeFileSync(join(gitDir, "refs", "stash"), `${ref}\n`, "utf-8");
+}
+function writeStashLog(gitDir, count) {
+    const lines = Array.from({ length: count }, (_, i) => `0000000 abcdef${i} Author <a@b.com> ${Date.now()} +0000\tstash@{${i}}: WIP`);
+    writeFileSync(join(gitDir, "logs", "refs", "stash"), `${lines.join("\n")}\n`, "utf-8");
+}
+const MOCK_FILE_HASHES = {
+    files: {
+        "src/test.ts": {
+            contentSha: "sha256abc",
+            headSha: "head123",
+            processedAt: new Date().toISOString(),
+        },
+    },
+};
+describe("StashManager", () => {
+    it("detects no change when stash ref unchanged", () => {
+        const { projectRoot, unerrDir, gitDir } = setupProjectWithGit();
+        writeStashRef(gitDir, "abc123def456");
+        writeStashLog(gitDir, 1);
+        const manager = new StashManager(unerrDir, projectRoot);
+        expect(manager.detectStashChange()).toBeNull();
+    });
+    it("detects stash push when count increases", () => {
+        const { projectRoot, unerrDir, gitDir } = setupProjectWithGit();
+        writeStashRef(gitDir, "ref1");
+        writeStashLog(gitDir, 1);
+        const manager = new StashManager(unerrDir, projectRoot);
+        // Simulate stash push
+        writeStashRef(gitDir, "ref2");
+        writeStashLog(gitDir, 2);
+        expect(manager.detectStashChange()).toBe("push");
+    });
+    it("detects stash pop when count decreases", () => {
+        const { projectRoot, unerrDir, gitDir } = setupProjectWithGit();
+        writeStashRef(gitDir, "ref1");
+        writeStashLog(gitDir, 2);
+        const manager = new StashManager(unerrDir, projectRoot);
+        // Simulate stash pop
+        writeStashRef(gitDir, "ref0");
+        writeStashLog(gitDir, 1);
+        expect(manager.detectStashChange()).toBe("pop");
+    });
+    it("saves and restores a stash snapshot", async () => {
+        const { projectRoot, unerrDir, gitDir } = setupProjectWithGit();
+        writeStashRef(gitDir, "abc123def456abc123def456abc123def456abc1");
+        writeStashLog(gitDir, 1);
+        const entities = [
+            makeDrift({ key: "k1", name: "fn1", drift_status: "modified" }),
+            makeDrift({ key: "k2", name: "fn2", drift_status: "added" }),
+        ];
+        const graph = createMockGraph(entities);
+        const manager = new StashManager(unerrDir, projectRoot);
+        // Save snapshot
+        const snapshotId = await manager.saveSnapshot(graph, MOCK_FILE_HASHES);
+        expect(snapshotId).toBe("abc123def456");
+        // Clear overlay to simulate stash applying
+        graph.entities.clear();
+        expect(graph.getAllDriftEntities()).toHaveLength(0);
+        // Restore snapshot
+        const restored = await manager.restoreSnapshot(graph);
+        expect(restored).toBe(2);
+        expect(graph.entities.size).toBe(2);
+        expect(graph.entities.get("k1")?.name).toBe("fn1");
+        expect(graph.entities.get("k2")?.name).toBe("fn2");
+    });
+    it("returns null when saving with no drift entities", async () => {
+        const { projectRoot, unerrDir, gitDir } = setupProjectWithGit();
+        writeStashRef(gitDir, "abc123def456");
+        const graph = createMockGraph([]);
+        const manager = new StashManager(unerrDir, projectRoot);
+        const snapshotId = await manager.saveSnapshot(graph, MOCK_FILE_HASHES);
+        expect(snapshotId).toBeNull();
+    });
+    it("returns null when saving with no stash ref", async () => {
+        const { projectRoot, unerrDir } = setupProjectWithGit();
+        const graph = createMockGraph([makeDrift({ key: "k1", name: "fn1" })]);
+        const manager = new StashManager(unerrDir, projectRoot);
+        const snapshotId = await manager.saveSnapshot(graph, MOCK_FILE_HASHES);
+        expect(snapshotId).toBeNull();
+    });
+    it("restores 0 when no snapshots exist", async () => {
+        const { projectRoot, unerrDir } = setupProjectWithGit();
+        const graph = createMockGraph([]);
+        const manager = new StashManager(unerrDir, projectRoot);
+        expect(await manager.restoreSnapshot(graph)).toBe(0);
+    });
+    it("drops a specific snapshot", async () => {
+        const { projectRoot, unerrDir, gitDir } = setupProjectWithGit();
+        const fullRef = "abc123def456abc123def456abc123def456abc1";
+        writeStashRef(gitDir, fullRef);
+        const graph = createMockGraph([makeDrift({ key: "k1", name: "fn1" })]);
+        const manager = new StashManager(unerrDir, projectRoot);
+        await manager.saveSnapshot(graph, MOCK_FILE_HASHES);
+        expect(manager.listSnapshots()).toHaveLength(1);
+        expect(manager.dropSnapshot(fullRef)).toBe(true);
+        expect(manager.listSnapshots()).toHaveLength(0);
+    });
+    it("enforces LRU cap of 10 snapshots", async () => {
+        const { projectRoot, unerrDir, gitDir } = setupProjectWithGit();
+        const graph = createMockGraph([makeDrift({ key: "k1", name: "fn1" })]);
+        const manager = new StashManager(unerrDir, projectRoot);
+        // Create 12 snapshots
+        for (let i = 0; i < 12; i++) {
+            const ref = `ref${String(i).padStart(12, "0")}aaaaaaaaaaaaaaaa`;
+            writeStashRef(gitDir, ref);
+            await manager.saveSnapshot(graph, MOCK_FILE_HASHES);
+        }
+        // Should be capped at 10
+        expect(manager.listSnapshots().length).toBeLessThanOrEqual(10);
+    });
+    it("retrieves file hash state from snapshot", async () => {
+        const { projectRoot, unerrDir, gitDir } = setupProjectWithGit();
+        writeStashRef(gitDir, "abc123def456abc1");
+        const graph = createMockGraph([makeDrift({ key: "k1", name: "fn1" })]);
+        const manager = new StashManager(unerrDir, projectRoot);
+        await manager.saveSnapshot(graph, MOCK_FILE_HASHES);
+        const hashes = manager.getSnapshotFileHashes();
+        expect(hashes).not.toBeNull();
+        expect(hashes?.files["src/test.ts"]?.contentSha).toBe("sha256abc");
+    });
+    it("cleans up snapshot after restore", async () => {
+        const { projectRoot, unerrDir, gitDir } = setupProjectWithGit();
+        writeStashRef(gitDir, "abc123def456abc1");
+        const graph = createMockGraph([makeDrift({ key: "k1", name: "fn1" })]);
+        const manager = new StashManager(unerrDir, projectRoot);
+        await manager.saveSnapshot(graph, MOCK_FILE_HASHES);
+        expect(manager.listSnapshots()).toHaveLength(1);
+        graph.entities.clear();
+        await manager.restoreSnapshot(graph);
+        // Snapshot should be cleaned up after restore
+        expect(manager.listSnapshots()).toHaveLength(0);
+    });
+    it("handles stash push → pop cycle preserving overlay", async () => {
+        const { projectRoot, unerrDir, gitDir } = setupProjectWithGit();
+        const originalEntities = [
+            makeDrift({
+                key: "k1",
+                name: "handler",
+                drift_status: "modified",
+                body: "function handler() { return 42; }",
+                previous_body: "function handler() { return 0; }",
+            }),
+        ];
+        const graph = createMockGraph(originalEntities);
+        // Initial state: 1 stash
+        writeStashRef(gitDir, "stashref1aaa");
+        writeStashLog(gitDir, 0);
+        const manager = new StashManager(unerrDir, projectRoot);
+        // Simulate stash push
+        writeStashRef(gitDir, "stashref2bbb");
+        writeStashLog(gitDir, 1);
+        expect(manager.detectStashChange()).toBe("push");
+        await manager.saveSnapshot(graph, MOCK_FILE_HASHES);
+        // Clear overlay (simulating git stash restoring working tree)
+        graph.entities.clear();
+        expect(graph.getAllDriftEntities()).toHaveLength(0);
+        // Simulate stash pop
+        writeStashRef(gitDir, "stashref1aaa");
+        writeStashLog(gitDir, 0);
+        expect(manager.detectStashChange()).toBe("pop");
+        const restored = await manager.restoreSnapshot(graph);
+        expect(restored).toBe(1);
+        const entity = graph.entities.get("k1");
+        expect(entity).toBeDefined();
+        expect(entity?.name).toBe("handler");
+        expect(entity?.drift_status).toBe("modified");
+        expect(entity?.body).toBe("function handler() { return 42; }");
+        expect(entity?.previous_body).toBe("function handler() { return 0; }");
+    });
+});