@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/session-events.test.js

@@ -0,0 +1,149 @@
+/**
+ * Tests for SessionEvents tracking and cumulative stats persistence (Task 1.4).
+ *
+ * Tests validate:
+ *   - SessionEvents creation and counting
+ *   - Event recording functions increment correct counters
+ *   - totalCaughtEvents aggregation
+ *   - Cumulative stats persistence and weekly reset
+ *   - Cumulative stats accumulation across sessions
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createSessionEvents, createSessionStats, loadCumulativeStats, persistCumulativeStats, recordChokepointWarning, recordCircularDep, recordDeadCodeReference, recordSignaturePreservation, recordViolation, totalCaughtEvents, } from "../proxy/session-stats.js";
+// ── SessionEvents ─────────────────────────────────────────────────
+describe("SessionEvents", () => {
+    it("creates zeroed events", () => {
+        const events = createSessionEvents();
+        expect(events.conventionViolationsCaught).toBe(0);
+        expect(events.chokepointWarningsIssued).toBe(0);
+        expect(events.circularDepsDetected).toBe(0);
+        expect(events.signaturePreservations).toBe(0);
+        expect(events.deadCodeReferences).toBe(0);
+    });
+    it("totalCaughtEvents sums all event types", () => {
+        const events = createSessionEvents();
+        events.conventionViolationsCaught = 3;
+        events.chokepointWarningsIssued = 2;
+        events.circularDepsDetected = 1;
+        events.signaturePreservations = 4;
+        events.deadCodeReferences = 5;
+        expect(totalCaughtEvents(events)).toBe(15);
+    });
+    it("totalCaughtEvents returns 0 for empty events", () => {
+        expect(totalCaughtEvents(createSessionEvents())).toBe(0);
+    });
+});
+// ── Event Recording ───────────────────────────────────────────────
+describe("Event recording functions", () => {
+    it("recordViolation increments both violationsCaught and conventionViolationsCaught", () => {
+        const stats = createSessionStats();
+        recordViolation(stats);
+        recordViolation(stats);
+        expect(stats.violationsCaught).toBe(2);
+        expect(stats.events.conventionViolationsCaught).toBe(2);
+    });
+    it("recordChokepointWarning increments chokepointWarningsIssued", () => {
+        const stats = createSessionStats();
+        recordChokepointWarning(stats);
+        expect(stats.events.chokepointWarningsIssued).toBe(1);
+    });
+    it("recordCircularDep increments circularDepsDetected", () => {
+        const stats = createSessionStats();
+        recordCircularDep(stats);
+        recordCircularDep(stats);
+        recordCircularDep(stats);
+        expect(stats.events.circularDepsDetected).toBe(3);
+    });
+    it("recordSignaturePreservation increments signaturePreservations", () => {
+        const stats = createSessionStats();
+        recordSignaturePreservation(stats);
+        expect(stats.events.signaturePreservations).toBe(1);
+    });
+    it("recordDeadCodeReference increments deadCodeReferences", () => {
+        const stats = createSessionStats();
+        recordDeadCodeReference(stats);
+        recordDeadCodeReference(stats);
+        expect(stats.events.deadCodeReferences).toBe(2);
+    });
+    it("events are embedded in SessionStats", () => {
+        const stats = createSessionStats();
+        recordViolation(stats);
+        recordChokepointWarning(stats);
+        recordCircularDep(stats);
+        expect(totalCaughtEvents(stats.events)).toBe(3);
+    });
+});
+// ── Cumulative Stats ──────────────────────────────────────────────
+describe("Cumulative stats persistence", () => {
+    let origHome;
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = path.join(os.tmpdir(), `unerr-cumulative-test-${Date.now()}`);
+        fs.mkdirSync(path.join(tmpDir, ".unerr"), { recursive: true });
+        origHome = process.env.HOME;
+        process.env.HOME = tmpDir;
+    });
+    afterEach(() => {
+        process.env.HOME = origHome;
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("returns zeroed cumulative stats on first load", () => {
+        const cumulative = loadCumulativeStats();
+        expect(cumulative.totalTokensSaved).toBe(0);
+        expect(cumulative.totalDollarsSaved).toBe(0);
+        expect(cumulative.totalSessions).toBe(0);
+        expect(cumulative.violationsCaughtAllTime).toBe(0);
+        expect(cumulative.chokepointWarningsAllTime).toBe(0);
+        expect(cumulative.weekStart).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+    });
+    it("persists and accumulates session stats", () => {
+        const stats1 = createSessionStats();
+        stats1.toolCallsLocal = 50;
+        stats1.estimatedTokensSaved = 160000;
+        stats1.events.conventionViolationsCaught = 3;
+        stats1.events.chokepointWarningsIssued = 1;
+        const c1 = persistCumulativeStats(stats1);
+        expect(c1.totalSessions).toBe(1);
+        expect(c1.totalTokensSaved).toBe(160000);
+        expect(c1.violationsCaughtAllTime).toBe(4); // 3 + 1
+        // Second session
+        const stats2 = createSessionStats();
+        stats2.toolCallsLocal = 30;
+        stats2.estimatedTokensSaved = 96000;
+        stats2.events.conventionViolationsCaught = 2;
+        const c2 = persistCumulativeStats(stats2);
+        expect(c2.totalSessions).toBe(2);
+        expect(c2.totalTokensSaved).toBe(256000);
+        expect(c2.violationsCaughtAllTime).toBe(6);
+    });
+    it("resets on new week", () => {
+        // Write stats with a different week
+        const filePath = path.join(tmpDir, ".unerr", "cumulative-stats.json");
+        fs.writeFileSync(filePath, JSON.stringify({
+            totalTokensSaved: 500000,
+            totalDollarsSaved: 30.0,
+            totalSessions: 10,
+            weekStart: "2025-01-06", // Old week
+            violationsCaughtAllTime: 50,
+            chokepointWarningsAllTime: 20,
+        }));
+        const cumulative = loadCumulativeStats();
+        // Should be reset since weekStart doesn't match current
+        expect(cumulative.totalSessions).toBe(0);
+        expect(cumulative.totalTokensSaved).toBe(0);
+    });
+    it("writes cumulative file to ~/.unerr/", () => {
+        const stats = createSessionStats();
+        stats.toolCallsLocal = 10;
+        stats.estimatedTokensSaved = 32000;
+        persistCumulativeStats(stats);
+        const filePath = path.join(tmpDir, ".unerr", "cumulative-stats.json");
+        expect(fs.existsSync(filePath)).toBe(true);
+        const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        expect(data.totalSessions).toBe(1);
+        expect(data.totalTokensSaved).toBe(32000);
+    });
+});

package/dist/__tests__/session-legend.test.js

@@ -0,0 +1,20 @@
+/**
+ * Layer 6 Sprint FE-E — session legend tracker.
+ */
+import { describe, expect, it } from "vitest";
+import { createSessionLegendTracker } from "../proxy/session-legend.js";
+describe("SessionLegendTracker", () => {
+    it("consumes columnar legend only once until invalidated", () => {
+        const L = createSessionLegendTracker();
+        expect(L.consumeColumnarLegend()).toBe(true);
+        expect(L.consumeColumnarLegend()).toBe(false);
+        L.invalidateAll();
+        expect(L.consumeColumnarLegend()).toBe(true);
+    });
+    it("invalidateAll resets columnar channel", () => {
+        const L = createSessionLegendTracker();
+        expect(L.consumeColumnarLegend()).toBe(true);
+        L.invalidateAll();
+        expect(L.consumeColumnarLegend()).toBe(true);
+    });
+});

package/dist/__tests__/session-persistence.test.js

@@ -0,0 +1,131 @@
+import { 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 { generateSessionResumePayload } from "../proxy/session-persistence.js";
+function writeLastSession(unerrDir, record) {
+    const stateDir = join(unerrDir, "state");
+    mkdirSync(stateDir, { recursive: true });
+    writeFileSync(join(stateDir, "last_session.json"), JSON.stringify(record), "utf-8");
+}
+function makeSessionRecord(overrides = {}) {
+    return {
+        session_id: "test-session",
+        written_at: new Date().toISOString(),
+        started_at: new Date(Date.now() - 3600000).toISOString(),
+        ended_at: new Date(Date.now() - 60000).toISOString(), // 1 min ago
+        duration_ms: 3540000,
+        tool_calls: 25,
+        chains: 8,
+        files_modified: ["src/auth.ts", "src/proxy.ts", "src/config.ts"],
+        entities_touched: ["src/auth.ts::login", "src/proxy.ts::startProxy"],
+        tools_used: { get_function: 10, get_callers: 5, file_read: 10 },
+        feature_areas: ["src/auth"],
+        facts_recorded: 2,
+        facts_surfaced: ["fact-1", "fact-2"],
+        revert_count: 1,
+        rot_score: 0.2,
+        token_estimate: 15000,
+        branch: "main",
+        ...overrides,
+    };
+}
+describe("session-persistence", () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = join(tmpdir(), `unerr-persist-${Date.now()}`);
+        mkdirSync(testDir, { recursive: true });
+    });
+    afterEach(() => {
+        try {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+        catch {
+            // best-effort cleanup
+        }
+    });
+    describe("generateSessionResumePayload", () => {
+        it("returns payload for recent session", async () => {
+            const record = makeSessionRecord();
+            writeLastSession(testDir, record);
+            const payload = await generateSessionResumePayload(testDir);
+            expect(payload).not.toBeNull();
+            expect(payload.session_resumed).toBe(true);
+            expect(payload.previous_session.session_id).toBe("test-session");
+            expect(payload.previous_session.tool_calls).toBe(25);
+            expect(payload.continuity.staleness).toBe("fresh");
+            expect(payload.continuity.hot_files.length).toBeGreaterThan(0);
+        });
+        it("returns null when no prior session", async () => {
+            const payload = await generateSessionResumePayload(testDir);
+            expect(payload).toBeNull();
+        });
+        it("returns null for sessions older than 24h", async () => {
+            const record = makeSessionRecord({
+                ended_at: new Date(Date.now() - 25 * 3600000).toISOString(),
+            });
+            writeLastSession(testDir, record);
+            const payload = await generateSessionResumePayload(testDir);
+            expect(payload).toBeNull();
+        });
+        it("marks staleness as 'warm' for sessions 4-24h old", async () => {
+            const record = makeSessionRecord({
+                ended_at: new Date(Date.now() - 8 * 3600000).toISOString(),
+            });
+            writeLastSession(testDir, record);
+            const payload = await generateSessionResumePayload(testDir);
+            expect(payload).not.toBeNull();
+            expect(payload.continuity.staleness).toBe("warm");
+        });
+        it("includes revert warning in incomplete hint", async () => {
+            const record = makeSessionRecord({ revert_count: 3 });
+            writeLastSession(testDir, record);
+            const payload = await generateSessionResumePayload(testDir);
+            expect(payload.continuity.incomplete_hint).toContain("revert");
+        });
+        it("includes hot files from previous session", async () => {
+            const record = makeSessionRecord({
+                files_modified: ["src/a.ts", "src/b.ts", "src/c.ts"],
+            });
+            writeLastSession(testDir, record);
+            const payload = await generateSessionResumePayload(testDir);
+            expect(payload.continuity.hot_files).toContain("src/a.ts");
+        });
+        it("recalls facts when factStore is provided", async () => {
+            const record = makeSessionRecord();
+            writeLastSession(testDir, record);
+            const mockFactStore = {
+                async recallByScope(scope) {
+                    if (scope === "src/auth.ts") {
+                        return [
+                            {
+                                fact_id: "f1",
+                                fact_type: "semantic",
+                                scope: "src/auth.ts",
+                                subject: "auth",
+                                content: "Auth uses JWT",
+                                base_confidence: 0.9,
+                                effective_confidence: 0.85,
+                                reinforcement_count: 3,
+                                created_at: Date.now(),
+                                last_reinforced_at: Date.now(),
+                                last_contradicted_at: 0,
+                                source: "agent_explicit",
+                            },
+                        ];
+                    }
+                    return [];
+                },
+            };
+            const payload = await generateSessionResumePayload(testDir, mockFactStore);
+            expect(payload.recalled_facts.length).toBeGreaterThan(0);
+            expect(payload.recalled_facts[0].content).toBe("Auth uses JWT");
+        });
+        it("returns empty recalled_facts when factStore is null", async () => {
+            const record = makeSessionRecord();
+            writeLastSession(testDir, record);
+            const payload = await generateSessionResumePayload(testDir, null);
+            expect(payload.recalled_facts).toEqual([]);
+        });
+    });
+});

package/dist/__tests__/session-resume-block.test.js

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import { formatSessionResumeBlock, } from "../proxy/session-persistence.js";
+function makePayload(overrides) {
+    return {
+        session_resumed: true,
+        previous_session: {
+            session_id: "test-sess",
+            duration_ms: 300000,
+            tool_calls: 15,
+            chains: 3,
+            files_modified: ["src/auth.ts", "src/api.ts"],
+            entities_touched: ["login", "register"],
+            tools_used: { file_read: 8, get_function: 5 },
+            feature_areas: ["auth"],
+            revert_count: 0,
+            facts_recorded: 2,
+            branch: "main",
+            ended_at: new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString(),
+        },
+        continuity: {
+            hot_files: ["src/auth.ts", "src/api.ts"],
+            incomplete_hint: "Continuing work on src/auth.ts, src/api.ts",
+            staleness: "fresh",
+        },
+        recalled_facts: [
+            {
+                fact_id: "f1",
+                type: "negative",
+                content: "Never store passwords in plain text",
+                confidence: 0.95,
+                source: "negative_knowledge",
+            },
+            {
+                fact_id: "f2",
+                type: "semantic",
+                content: "Auth uses bcrypt for hashing",
+                confidence: 0.8,
+                source: "agent_explicit",
+            },
+        ],
+        decayed_since_last_session: [],
+        ...overrides,
+    };
+}
+describe("formatSessionResumeBlock", () => {
+    it("formats a complete resume block with elapsed time and facts", () => {
+        const block = formatSessionResumeBlock(makePayload());
+        expect(block).toContain("[unerr:session-resume]");
+        expect(block).toContain("2h ago");
+        expect(block).toContain("src/auth.ts");
+        expect(block).toContain("Never store passwords in plain text");
+        expect(block).toContain("95%");
+    });
+    it("returns empty string for null payload", () => {
+        expect(formatSessionResumeBlock(null)).toBe("");
+    });
+    it("filters out low-confidence facts", () => {
+        const payload = makePayload({
+            recalled_facts: [
+                {
+                    fact_id: "f1",
+                    type: "semantic",
+                    content: "Low confidence fact",
+                    confidence: 0.3,
+                    source: "session_analysis",
+                },
+            ],
+        });
+        const block = formatSessionResumeBlock(payload);
+        expect(block).not.toContain("Low confidence fact");
+    });
+    it("truncates to 500 chars max", () => {
+        const payload = makePayload({
+            recalled_facts: Array.from({ length: 20 }, (_, i) => ({
+                fact_id: `f${i}`,
+                type: "semantic",
+                content: `Very long fact number ${i} with lots of extra detail that pads the content significantly`,
+                confidence: 0.95,
+                source: "agent_explicit",
+            })),
+        });
+        const block = formatSessionResumeBlock(payload);
+        expect(block.length).toBeLessThanOrEqual(500);
+    });
+    it("includes incomplete hint when meaningful", () => {
+        const payload = makePayload({
+            continuity: {
+                hot_files: ["src/auth.ts"],
+                incomplete_hint: "2 revert(s) in last session — approach may need rethinking",
+                staleness: "fresh",
+            },
+        });
+        const block = formatSessionResumeBlock(payload);
+        expect(block).toContain("revert(s)");
+    });
+    it("skips generic incomplete hint", () => {
+        const payload = makePayload({
+            continuity: {
+                hot_files: ["src/auth.ts"],
+                incomplete_hint: "No specific continuity context",
+                staleness: "fresh",
+            },
+        });
+        const block = formatSessionResumeBlock(payload);
+        expect(block).not.toContain("No specific continuity context");
+    });
+});

package/dist/__tests__/session-resume.test.js

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import { generateSessionResume } from "../proxy/session-resume.js";
+const MOCK_ENTRIES = [
+    {
+        id: "e1",
+        ts: "2026-04-30T10:00:00Z",
+        tool: "get_function",
+        args_summary: { key: "src/auth.ts::login" },
+        result_summary: {},
+        session_id: "s1",
+        branch: "main",
+        head_sha: "aaa",
+    },
+    {
+        id: "e2",
+        ts: "2026-04-30T10:01:00Z",
+        tool: "sync_local_diff",
+        args_summary: { files: ["src/auth.ts", "src/utils/token.ts"] },
+        result_summary: {},
+        session_id: "s1",
+        branch: "main",
+        head_sha: "bbb",
+    },
+    {
+        id: "e3",
+        ts: "2026-04-30T10:05:00Z",
+        tool: "check_rules",
+        args_summary: { key: "src/auth.ts" },
+        result_summary: {},
+        session_id: "s1",
+        branch: "main",
+        head_sha: "ccc",
+    },
+    {
+        id: "e4",
+        ts: "2026-04-30T10:10:00Z",
+        tool: "get_callers",
+        args_summary: { key: "src/auth.ts::login" },
+        result_summary: {},
+        session_id: "s1",
+        branch: "main",
+        head_sha: "ddd",
+    },
+    {
+        id: "e5",
+        ts: "2026-04-30T10:15:00Z",
+        tool: "sync_local_diff",
+        args_summary: { files: ["src/auth.ts"] },
+        result_summary: { commit_sha: "fff" },
+        session_id: "s1",
+        branch: "feature/auth",
+        head_sha: "eee",
+    },
+];
+describe("generateSessionResume", () => {
+    it("generates resume from shadow ledger entries", () => {
+        const result = generateSessionResume(MOCK_ENTRIES);
+        expect(result).not.toBeNull();
+        expect(result?.summary).toContain("tool calls");
+        expect(result?.filesModified).toContain("src/auth.ts");
+        expect(result?.toolsUsed.sync_local_diff).toBe(2);
+        expect(result?.toolsUsed.get_function).toBe(1);
+    });
+    it("detects last branch", () => {
+        const result = generateSessionResume(MOCK_ENTRIES);
+        expect(result?.lastBranch).toBe("feature/auth");
+    });
+    it("calculates session duration", () => {
+        const result = generateSessionResume(MOCK_ENTRIES);
+        expect(result?.sessionDurationMs).toBe(15 * 60 * 1000);
+    });
+    it("tracks incomplete entities (modified but not committed)", () => {
+        const noCommitEntries = MOCK_ENTRIES.slice(0, 4);
+        const result = generateSessionResume(noCommitEntries);
+        expect(result?.incompleteEntities.length).toBeGreaterThan(0);
+        expect(result?.incompleteEntities).toContain("src/auth.ts");
+    });
+    it("returns null for empty entries", () => {
+        expect(generateSessionResume([])).toBeNull();
+    });
+    it("limits file list in summary", () => {
+        const manyFiles = Array.from({ length: 20 }, (_, i) => `src/file${i}.ts`);
+        const entries = [
+            {
+                id: "e1",
+                ts: "2026-04-30T10:00:00Z",
+                tool: "sync_local_diff",
+                args_summary: { files: manyFiles },
+                result_summary: {},
+                session_id: "s1",
+            },
+        ];
+        const result = generateSessionResume(entries);
+        expect(result?.summary).toContain("+");
+        expect(result?.filesModified.length).toBe(20);
+    });
+});

package/dist/__tests__/session-summary-writer.test.js

@@ -0,0 +1,134 @@
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { closeMetricsStore, openMetricsStore, } from "../tracking/metrics-store.js";
+import { readLastSession, writeSessionSummary, } from "../tracking/session-summary-writer.js";
+function makeEntry(overrides = {}) {
+    return {
+        id: `entry-${Math.random().toString(36).slice(2, 8)}`,
+        ts: new Date().toISOString(),
+        tool: "get_function",
+        args_summary: {},
+        result_summary: {},
+        branch: "main",
+        head_sha: "abc123",
+        session_id: "test-session",
+        correlation_id: null,
+        ...overrides,
+    };
+}
+describe("session-summary-writer", () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = join(tmpdir(), `unerr-test-${Date.now()}`);
+        mkdirSync(testDir, { recursive: true });
+    });
+    afterEach(() => {
+        try {
+            closeMetricsStore(testDir);
+            rmSync(testDir, { recursive: true, force: true });
+        }
+        catch {
+            // cleanup best-effort
+        }
+    });
+    describe("writeSessionSummary", () => {
+        it("upserts session summary row into metrics.db", () => {
+            const ctx = {
+                sessionId: "test-session-001",
+                entries: [
+                    makeEntry({
+                        tool: "get_function",
+                        args_summary: { key: "src/a.ts::fn" },
+                    }),
+                    makeEntry({
+                        tool: "get_callers",
+                        args_summary: { key: "src/a.ts::fn" },
+                    }),
+                    makeEntry({ tool: "record_fact" }),
+                ],
+                factsRecordedIds: ["fact-abc"],
+                factsSurfacedIds: ["fact-xyz"],
+                rotScore: 0.15,
+                tokenEstimate: 8000,
+            };
+            const record = writeSessionSummary(testDir, ctx);
+            expect(record).not.toBeNull();
+            expect(record.session_id).toBe("test-session-001");
+            expect(record.tool_calls).toBe(3);
+            expect(record.facts_recorded).toBe(1);
+            expect(record.rot_score).toBe(0.15);
+            expect(record.token_estimate).toBe(8000);
+            const row = openMetricsStore(testDir).sessionSummary("test-session-001");
+            expect(row).not.toBeNull();
+            expect(row.session_id).toBe("test-session-001");
+            expect(row.tool_calls).toBe(3);
+            expect(JSON.parse(row.files_modified)).toEqual(expect.arrayContaining([]));
+        });
+        it("writes last_session.json pointer", () => {
+            const ctx = {
+                sessionId: "sess-pointer-test",
+                entries: [makeEntry()],
+                factsRecordedIds: [],
+                factsSurfacedIds: [],
+                rotScore: 0,
+                tokenEstimate: 1000,
+            };
+            writeSessionSummary(testDir, ctx);
+            const pointerPath = join(testDir, "state", "last_session.json");
+            expect(existsSync(pointerPath)).toBe(true);
+            const pointer = JSON.parse(readFileSync(pointerPath, "utf-8"));
+            expect(pointer.session_id).toBe("sess-pointer-test");
+        });
+        it("returns null for empty entries", () => {
+            const ctx = {
+                sessionId: "empty",
+                entries: [],
+                factsRecordedIds: [],
+                factsSurfacedIds: [],
+                rotScore: 0,
+                tokenEstimate: 0,
+            };
+            const record = writeSessionSummary(testDir, ctx);
+            expect(record).toBeNull();
+        });
+        it("extracts files and entities from entries", () => {
+            const ctx = {
+                sessionId: "extraction-test",
+                entries: [
+                    makeEntry({ args_summary: { file_path: "src/auth.ts" } }),
+                    makeEntry({ args_summary: { key: "src/proxy.ts::startProxy" } }),
+                ],
+                factsRecordedIds: [],
+                factsSurfacedIds: [],
+                rotScore: 0,
+                tokenEstimate: 2000,
+            };
+            const record = writeSessionSummary(testDir, ctx);
+            expect(record.files_modified).toContain("src/auth.ts");
+            expect(record.entities_touched).toContain("src/proxy.ts::startProxy");
+        });
+    });
+    describe("readLastSession", () => {
+        it("reads written last_session.json", () => {
+            const ctx = {
+                sessionId: "read-test",
+                entries: [makeEntry(), makeEntry()],
+                factsRecordedIds: ["f1"],
+                factsSurfacedIds: [],
+                rotScore: 0.5,
+                tokenEstimate: 5000,
+            };
+            writeSessionSummary(testDir, ctx);
+            const last = readLastSession(testDir);
+            expect(last).not.toBeNull();
+            expect(last.session_id).toBe("read-test");
+            expect(last.tool_calls).toBe(2);
+        });
+        it("returns null when no prior session", () => {
+            const last = readLastSession(testDir);
+            expect(last).toBeNull();
+        });
+    });
+});