@unerr-ai/unerr 0.1.6 → 0.1.7

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

@@ -1,149 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-/**
- * 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

@@ -1,131 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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();
-        });
-    });
-});