@unerr-ai/unerr 0.1.6 → 0.1.7

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

@@ -1,221 +0,0 @@
-/**
- * Sprint 2 — SessionContext unit tests.
- *
- * Tests dedup logic for blast radius, conventions, risks, greeting,
- * and value counter threshold behavior.
- */
-import { describe, expect, it } from "vitest";
-import { SessionContext } from "../intelligence/session-context.js";
-function createEvents(overrides = {}) {
-    return {
-        conventionViolationsCaught: 0,
-        chokepointWarningsIssued: 0,
-        circularDepsDetected: 0,
-        signaturePreservations: 0,
-        deadCodeReferences: 0,
-        aiEntitiesModified: 0,
-        humanEntitiesModified: 0,
-        mixedEntitiesModified: 0,
-        ...overrides,
-    };
-}
-describe("SessionContext", () => {
-    // ── Blast radius dedup ──────────────────────────────────────────
-    describe("shouldInjectBlastRadius", () => {
-        it("returns true for first query of an entity", () => {
-            const ctx = new SessionContext();
-            expect(ctx.shouldInjectBlastRadius("fn1")).toBe(true);
-        });
-        it("returns false after entity has been queried", () => {
-            const ctx = new SessionContext();
-            ctx.recordQuery("fn1");
-            expect(ctx.shouldInjectBlastRadius("fn1")).toBe(false);
-        });
-        it("different entities are independent", () => {
-            const ctx = new SessionContext();
-            ctx.recordQuery("fn1");
-            expect(ctx.shouldInjectBlastRadius("fn2")).toBe(true);
-        });
-    });
-    // ── Convention dedup ────────────────────────────────────────────
-    describe("shouldInjectConvention", () => {
-        it("returns true for unseen convention", () => {
-            const ctx = new SessionContext();
-            expect(ctx.shouldInjectConvention("pattern:p1")).toBe(true);
-        });
-        it("returns false after convention has been surfaced", () => {
-            const ctx = new SessionContext();
-            ctx.recordConventions(["pattern:p1"]);
-            expect(ctx.shouldInjectConvention("pattern:p1")).toBe(false);
-        });
-        it("tracks multiple conventions independently", () => {
-            const ctx = new SessionContext();
-            ctx.recordConventions(["pattern:p1"]);
-            expect(ctx.shouldInjectConvention("pattern:p2")).toBe(true);
-        });
-    });
-    // ── Risk dedup ──────────────────────────────────────────────────
-    describe("shouldInjectRisk", () => {
-        it("returns true for unseen entity risk", () => {
-            const ctx = new SessionContext();
-            expect(ctx.shouldInjectRisk("fn1")).toBe(true);
-        });
-        it("returns false after risk has been surfaced", () => {
-            const ctx = new SessionContext();
-            ctx.recordRisk("fn1");
-            expect(ctx.shouldInjectRisk("fn1")).toBe(false);
-        });
-    });
-    // ── Session greeting ────────────────────────────────────────────
-    describe("isFirstCall / markGreeted", () => {
-        it("isFirstCall returns true initially", () => {
-            const ctx = new SessionContext();
-            expect(ctx.isFirstCall()).toBe(true);
-        });
-        it("isFirstCall returns false after markGreeted", () => {
-            const ctx = new SessionContext();
-            ctx.markGreeted();
-            expect(ctx.isFirstCall()).toBe(false);
-        });
-        it("markGreeted is idempotent", () => {
-            const ctx = new SessionContext();
-            ctx.markGreeted();
-            ctx.markGreeted();
-            expect(ctx.isFirstCall()).toBe(false);
-        });
-    });
-    // ── Tool call counter ───────────────────────────────────────────
-    describe("recordToolCall / getToolCallCount", () => {
-        it("starts at zero", () => {
-            const ctx = new SessionContext();
-            expect(ctx.getToolCallCount()).toBe(0);
-        });
-        it("increments on each call", () => {
-            const ctx = new SessionContext();
-            ctx.recordToolCall();
-            ctx.recordToolCall();
-            ctx.recordToolCall();
-            expect(ctx.getToolCallCount()).toBe(3);
-        });
-    });
-    // ── Value counter ───────────────────────────────────────────────
-    describe("getValueCounter", () => {
-        it("returns undefined when <=10 tool calls", () => {
-            const ctx = new SessionContext();
-            for (let i = 0; i < 10; i++)
-                ctx.recordToolCall();
-            const events = createEvents({ conventionViolationsCaught: 3 });
-            expect(ctx.getValueCounter(events)).toBeUndefined();
-        });
-        it("returns undefined when caught events is 0", () => {
-            const ctx = new SessionContext();
-            for (let i = 0; i < 15; i++)
-                ctx.recordToolCall();
-            expect(ctx.getValueCounter(createEvents())).toBeUndefined();
-        });
-        it("returns undefined when caught events not divisible by 3", () => {
-            const ctx = new SessionContext();
-            for (let i = 0; i < 15; i++)
-                ctx.recordToolCall();
-            const events = createEvents({ conventionViolationsCaught: 2 });
-            expect(ctx.getValueCounter(events)).toBeUndefined();
-        });
-        it("returns counter string when conditions are met", () => {
-            const ctx = new SessionContext();
-            for (let i = 0; i < 15; i++)
-                ctx.recordToolCall();
-            const events = createEvents({ conventionViolationsCaught: 3 });
-            const counter = ctx.getValueCounter(events);
-            expect(counter).toBe("(unerr has caught 3 issues this session)");
-        });
-        it("fires only once per threshold crossing", () => {
-            const ctx = new SessionContext();
-            for (let i = 0; i < 15; i++)
-                ctx.recordToolCall();
-            const events = createEvents({ conventionViolationsCaught: 3 });
-            const first = ctx.getValueCounter(events);
-            expect(first).toBeDefined();
-            // Same count — should not fire again
-            const second = ctx.getValueCounter(events);
-            expect(second).toBeUndefined();
-            // Advance to 6
-            events.conventionViolationsCaught = 6;
-            const third = ctx.getValueCounter(events);
-            expect(third).toBeDefined();
-            expect(third).toContain("6 issues");
-        });
-        it("counts across all event categories", () => {
-            const ctx = new SessionContext();
-            for (let i = 0; i < 15; i++)
-                ctx.recordToolCall();
-            // 1 + 1 + 1 = 3, divisible by 3
-            const events = createEvents({
-                conventionViolationsCaught: 1,
-                chokepointWarningsIssued: 1,
-                circularDepsDetected: 1,
-            });
-            const counter = ctx.getValueCounter(events);
-            expect(counter).toBe("(unerr has caught 3 issues this session)");
-        });
-    });
-    // ── Post-compaction recovery (Task 7.8) ─────────────────────────
-    describe("entity history (post-compaction)", () => {
-        it("records entity history on first call", () => {
-            const ctx = new SessionContext();
-            ctx.recordEntityHistory("fn1", 5, "high");
-            expect(ctx.hasHistory("fn1")).toBe(true);
-            const entry = ctx.getHistory("fn1");
-            expect(entry?.blast_radius).toBe(5);
-            expect(entry?.risk).toBe("high");
-            expect(entry?.queriedAt).toBeDefined();
-        });
-        it("does not overwrite on subsequent calls", () => {
-            const ctx = new SessionContext();
-            ctx.recordEntityHistory("fn1", 5, "high");
-            ctx.recordEntityHistory("fn1", 10, "low");
-            const entry = ctx.getHistory("fn1");
-            expect(entry?.blast_radius).toBe(5);
-            expect(entry?.risk).toBe("high");
-        });
-        it("returns undefined for unqueried entity", () => {
-            const ctx = new SessionContext();
-            expect(ctx.hasHistory("fn1")).toBe(false);
-            expect(ctx.getHistory("fn1")).toBeUndefined();
-        });
-        it("tracks multiple entities independently", () => {
-            const ctx = new SessionContext();
-            ctx.recordEntityHistory("fn1", 5, "high");
-            ctx.recordEntityHistory("fn2", 0, "normal");
-            expect(ctx.getHistory("fn1")?.blast_radius).toBe(5);
-            expect(ctx.getHistory("fn2")?.blast_radius).toBe(0);
-        });
-    });
-    // ── Diagnostics ─────────────────────────────────────────────────
-    describe("diagnostics", () => {
-        it("tracks entities queried count", () => {
-            const ctx = new SessionContext();
-            ctx.recordQuery("fn1");
-            ctx.recordQuery("fn2");
-            expect(ctx.entitiesQueried).toBe(2);
-        });
-        it("tracks conventions surfaced count", () => {
-            const ctx = new SessionContext();
-            ctx.recordConventions(["c1", "c2", "c3"]);
-            expect(ctx.conventionsSurfaced).toBe(3);
-        });
-        it("tracks risks surfaced count", () => {
-            const ctx = new SessionContext();
-            ctx.recordRisk("fn1");
-            ctx.recordRisk("fn2");
-            expect(ctx.risksSurfaced).toBe(2);
-        });
-        it("deduplicates entities and conventions", () => {
-            const ctx = new SessionContext();
-            ctx.recordQuery("fn1");
-            ctx.recordQuery("fn1");
-            expect(ctx.entitiesQueried).toBe(1);
-            ctx.recordConventions(["c1", "c1"]);
-            expect(ctx.conventionsSurfaced).toBe(1);
-        });
-    });
-});

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

@@ -1,144 +0,0 @@
-/**
- * BA-1.7: Session Continuity Protocol tests.
- *
- * Verifies:
- *   - Incomplete work from session N carried forward to session N+1
- *   - Resume context matches ledger state
- *   - Agent-as-LLM prompt generated for complex sessions (>50 entries)
- *   - Empty ledger returns null (no false resume)
- *   - Risk prioritization: high-risk items appear first
- */
-import { mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { beforeEach, describe, expect, it } from "vitest";
-import { SessionContinuityBehavior } from "../behaviors/session-continuity.js";
-import { ShadowLedger } from "../tracking/shadow-ledger.js";
-function makeTmpDir() {
-    const dir = join(tmpdir(), `unerr-test-continuity-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-function makeCtx(sessionId) {
-    return {
-        toolName: "get_entity",
-        args: {},
-        sessionId,
-    };
-}
-describe("Session Continuity Protocol (BA-1.2)", () => {
-    let tmpDir;
-    beforeEach(() => {
-        tmpDir = makeTmpDir();
-    });
-    describe("Resume Context", () => {
-        it("carries forward incomplete work from previous session", async () => {
-            const ledger = new ShadowLedger(tmpDir);
-            const prevSessionId = ledger.getSessionId();
-            ledger.record("edit_file", { key: "src/payment.ts::processPayment", path: "src/payment.ts" }, { source: "local" }, "main", "abc123");
-            ledger.record("edit_file", { key: "src/payment.ts::processPayment", path: "src/payment.ts" }, { source: "local" }, "main", "abc123");
-            ledger.record("get_entity", { key: "src/checkout.ts::handleOrder" }, { source: "local", found: true }, "main", "abc123");
-            const newLedger = new ShadowLedger(tmpDir);
-            const newSessionId = newLedger.getSessionId();
-            expect(newSessionId).not.toBe(prevSessionId);
-            const behavior = new SessionContinuityBehavior();
-            behavior.attachLedger(newLedger);
-            const output = await behavior.onSessionStart(makeCtx(newSessionId));
-            expect(output).not.toBeNull();
-            expect(output?._context?.session_resume).toBeDefined();
-            const resume = output?._context?.session_resume;
-            expect(resume.last_session.tool_calls).toBe(3);
-        });
-        it("returns null for empty ledger (no false resume)", async () => {
-            const ledger = new ShadowLedger(tmpDir);
-            const behavior = new SessionContinuityBehavior();
-            behavior.attachLedger(ledger);
-            const output = await behavior.onSessionStart(makeCtx(ledger.getSessionId()));
-            expect(output).toBeNull();
-        });
-        it("returns null when no ledger is attached", async () => {
-            const behavior = new SessionContinuityBehavior();
-            const output = await behavior.onSessionStart(makeCtx("test-session"));
-            expect(output).toBeNull();
-        });
-    });
-    describe("Agent-as-LLM Prompt", () => {
-        it("generates agent-as-LLM prompt for sessions with >50 entries", async () => {
-            const ledger = new ShadowLedger(tmpDir);
-            for (let i = 0; i < 55; i++) {
-                ledger.record("get_entity", { key: `src/file${i}.ts::func${i}` }, { source: "local", found: true }, "main", "abc123");
-            }
-            const newLedger = new ShadowLedger(tmpDir);
-            const behavior = new SessionContinuityBehavior();
-            behavior.attachLedger(newLedger);
-            const output = await behavior.onSessionStart(makeCtx(newLedger.getSessionId()));
-            expect(output).not.toBeNull();
-            const resume = output?._context?.session_resume;
-            expect(resume.use_agent_llm).toBe(true);
-            expect(resume.agent_llm_prompt).toContain("Summarize");
-        });
-        it("does NOT generate agent-as-LLM prompt for simple sessions", async () => {
-            const ledger = new ShadowLedger(tmpDir);
-            for (let i = 0; i < 5; i++) {
-                ledger.record("get_entity", { key: `src/file${i}.ts::func${i}` }, { source: "local", found: true }, "main", "abc123");
-            }
-            const newLedger = new ShadowLedger(tmpDir);
-            const behavior = new SessionContinuityBehavior();
-            behavior.attachLedger(newLedger);
-            const output = await behavior.onSessionStart(makeCtx(newLedger.getSessionId()));
-            expect(output).not.toBeNull();
-            const resume = output?._context?.session_resume;
-            expect(resume.use_agent_llm).toBeUndefined();
-        });
-    });
-    describe("Working State", () => {
-        it("includes branch and file count in resume", async () => {
-            const ledger = new ShadowLedger(tmpDir);
-            ledger.record("edit_file", { key: "src/a.ts::funcA", path: "src/a.ts" }, { source: "local" }, "feature/payments", "abc123");
-            ledger.record("edit_file", { key: "src/b.ts::funcB", path: "src/b.ts" }, { source: "local" }, "feature/payments", "def456");
-            const newLedger = new ShadowLedger(tmpDir);
-            const behavior = new SessionContinuityBehavior();
-            behavior.attachLedger(newLedger);
-            const output = await behavior.onSessionStart(makeCtx(newLedger.getSessionId()));
-            expect(output).not.toBeNull();
-            const resume = output?._context?.session_resume;
-            expect(resume.working_state.last_branch).toBe("feature/payments");
-            expect(resume.working_state.files_modified).toBeGreaterThanOrEqual(2);
-        });
-    });
-    describe("Risk Prioritization", () => {
-        it("orders incomplete work by modification count (proxy for risk)", async () => {
-            const ledger = new ShadowLedger(tmpDir);
-            ledger.record("edit_file", { key: "src/low.ts::low" }, { source: "local" }, "main", "abc123");
-            for (let i = 0; i < 5; i++) {
-                ledger.record("edit_file", { key: "src/high.ts::high" }, { source: "local" }, "main", "abc123");
-            }
-            const newLedger = new ShadowLedger(tmpDir);
-            const behavior = new SessionContinuityBehavior();
-            behavior.attachLedger(newLedger);
-            const output = await behavior.onSessionStart(makeCtx(newLedger.getSessionId()));
-            expect(output).not.toBeNull();
-            const resume = output?._context?.session_resume;
-            if (resume.incomplete_work.length >= 2) {
-                expect(resume.incomplete_work[0]?.entity).toBe("src/high.ts::high");
-                expect(resume.incomplete_work[0]?.risk).toBe("high");
-            }
-        });
-    });
-    describe("Behavior Framework Integration", () => {
-        it("has correct id and hooks", () => {
-            const behavior = new SessionContinuityBehavior();
-            expect(behavior.id).toBe("session_continuity");
-            expect(behavior.hooks).toContain("session_start");
-            expect(behavior.defaultLevel).toBe("suggestion");
-        });
-        it("reports confidence correctly", () => {
-            const behavior = new SessionContinuityBehavior();
-            expect(behavior.getConfidence()).toBe(1.0);
-            behavior.recordFeedback("accepted");
-            behavior.recordFeedback("accepted");
-            behavior.recordFeedback("dismissed");
-            expect(behavior.getConfidence()).toBeCloseTo(2 / 3, 2);
-        });
-    });
-});

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

@@ -1,74 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createSessionDedup } from "../proxy/session-dedup.js";
-describe("createSessionDedup", () => {
-    it("passes all context on first call for an entity", () => {
-        const dedup = createSessionDedup();
-        const context = {
-            "dev.unerr/blast_radius": { entities: [] },
-            "dev.unerr/conventions": [{ name: "test" }],
-        };
-        const filtered = dedup.filter("entity-a", context);
-        expect(Object.keys(filtered)).toHaveLength(2);
-        expect(filtered["dev.unerr/blast_radius"]).toBeDefined();
-        expect(filtered["dev.unerr/conventions"]).toBeDefined();
-    });
-    it("removes already-delivered context keys on second call", () => {
-        const dedup = createSessionDedup();
-        const context = {
-            "dev.unerr/blast_radius": { entities: [] },
-            "dev.unerr/conventions": [{ name: "test" }],
-        };
-        dedup.filter("entity-a", context);
-        const second = dedup.filter("entity-a", context);
-        expect(Object.keys(second)).toHaveLength(0);
-    });
-    it("delivers context for different entities independently", () => {
-        const dedup = createSessionDedup();
-        const context = { "dev.unerr/blast_radius": { entities: [] } };
-        dedup.filter("entity-a", context);
-        const resultB = dedup.filter("entity-b", context);
-        expect(Object.keys(resultB)).toHaveLength(1);
-    });
-    it("delivers new context keys even if entity was seen before", () => {
-        const dedup = createSessionDedup();
-        dedup.filter("entity-a", { "dev.unerr/blast_radius": {} });
-        const result = dedup.filter("entity-a", {
-            "dev.unerr/blast_radius": {},
-            "dev.unerr/conventions": [],
-        });
-        expect(Object.keys(result)).toHaveLength(1);
-        expect(result["dev.unerr/conventions"]).toBeDefined();
-        expect(result["dev.unerr/blast_radius"]).toBeUndefined();
-    });
-    it("tracks delivered count", () => {
-        const dedup = createSessionDedup();
-        expect(dedup.getDeliveredCount()).toBe(0);
-        dedup.filter("e1", { a: 1, b: 2 });
-        expect(dedup.getDeliveredCount()).toBe(2);
-        dedup.filter("e2", { c: 3 });
-        expect(dedup.getDeliveredCount()).toBe(3);
-    });
-    it("hasDelivered returns correct state", () => {
-        const dedup = createSessionDedup();
-        expect(dedup.hasDelivered("e1", "a")).toBe(false);
-        dedup.filter("e1", { a: 1 });
-        expect(dedup.hasDelivered("e1", "a")).toBe(true);
-        expect(dedup.hasDelivered("e1", "b")).toBe(false);
-    });
-    it("reset clears all state", () => {
-        const dedup = createSessionDedup();
-        dedup.filter("e1", { a: 1 });
-        expect(dedup.getDeliveredCount()).toBe(1);
-        dedup.reset();
-        expect(dedup.getDeliveredCount()).toBe(0);
-        expect(dedup.hasDelivered("e1", "a")).toBe(false);
-    });
-    it("evicts oldest entries when exceeding max tracked keys", () => {
-        const dedup = createSessionDedup();
-        for (let i = 0; i < 11_000; i++) {
-            dedup.markDelivered(`entity-${i}`, [`key-${i}`]);
-        }
-        expect(dedup.getDeliveredCount()).toBeLessThanOrEqual(10_000);
-        expect(dedup.hasDelivered("entity-0", "key-0")).toBe(false);
-    });
-});

package/dist/__tests__/session-event-wiring.test.js

@@ -1,206 +0,0 @@
-/**
- * Sprint 4, Task 4.3: Session event wiring tests.
- *
- * Tests that the proxy-level event detection logic correctly identifies
- * when to record violations, circular deps, signature preservations,
- * chokepoint warnings, and dead code references from tool results.
- */
-import { describe, expect, it } from "vitest";
-import { createSessionStats, recordChokepointWarning, recordCircularDep, recordDeadCodeReference, recordSignaturePreservation, recordViolation, totalCaughtEvents, } from "../proxy/session-stats.js";
-// ── Convention Violation Wiring ──────────────────────────────────────
-describe("Convention violation wiring (check_rules)", () => {
-    it("records one violation per check_rules violation entry", () => {
-        const stats = createSessionStats();
-        // Simulate check_rules result with 3 violations
-        const checkResult = {
-            violations: [
-                { ruleKey: "naming-1", message: "bad name" },
-                { ruleKey: "naming-2", message: "wrong case" },
-                { ruleKey: "struct-1", message: "missing type" },
-            ],
-        };
-        if (checkResult.violations && checkResult.violations.length > 0) {
-            for (let i = 0; i < checkResult.violations.length; i++) {
-                recordViolation(stats);
-            }
-        }
-        expect(stats.violationsCaught).toBe(3);
-        expect(stats.events.conventionViolationsCaught).toBe(3);
-    });
-    it("does not record violations when check_rules has empty violations", () => {
-        const stats = createSessionStats();
-        const checkResult = { violations: [] };
-        if (checkResult.violations && checkResult.violations.length > 0) {
-            for (let i = 0; i < checkResult.violations.length; i++) {
-                recordViolation(stats);
-            }
-        }
-        expect(stats.violationsCaught).toBe(0);
-    });
-    it("does not record violations when check_rules has no violations field", () => {
-        const stats = createSessionStats();
-        const checkResult = { _meta: { source: "local" } };
-        if (checkResult.violations && checkResult.violations.length > 0) {
-            for (let i = 0; i < checkResult.violations.length; i++) {
-                recordViolation(stats);
-            }
-        }
-        expect(stats.violationsCaught).toBe(0);
-    });
-});
-// ── Circular Dependency Detection ────────────────────────────────────
-describe("Circular dependency detection (get_imports)", () => {
-    it("detects circular import when file appears in its own imports", () => {
-        const stats = createSessionStats();
-        // File A imports B, and its own file path — circular
-        const imports = [
-            { imported_file: "src/b.ts" },
-            { imported_file: "src/a.ts" },
-        ];
-        const filePath = "src/a.ts";
-        const importedFiles = new Set(imports.map((e) => e.imported_file));
-        for (const target of importedFiles) {
-            if (target === filePath) {
-                recordCircularDep(stats);
-                break;
-            }
-        }
-        expect(stats.events.circularDepsDetected).toBe(1);
-    });
-    it("does not detect circular when file is not in its own imports", () => {
-        const stats = createSessionStats();
-        // A imports B and C — no circular
-        const imports = [
-            { imported_file: "src/b.ts" },
-            { imported_file: "src/c.ts" },
-        ];
-        const filePath = "src/a.ts";
-        const importedFiles = new Set(imports.map((e) => e.imported_file));
-        for (const target of importedFiles) {
-            if (target === filePath) {
-                recordCircularDep(stats);
-                break;
-            }
-        }
-        expect(stats.events.circularDepsDetected).toBe(0);
-    });
-    it("counts only once per call", () => {
-        const stats = createSessionStats();
-        const imports = [
-            { imported_file: "src/a.ts" },
-            { imported_file: "src/b.ts" },
-        ];
-        const filePath = "src/a.ts";
-        const importedFiles = new Set(imports.map((e) => e.imported_file));
-        for (const target of importedFiles) {
-            if (target === filePath) {
-                recordCircularDep(stats);
-                break;
-            }
-        }
-        expect(stats.events.circularDepsDetected).toBe(1);
-    });
-    it("handles empty imports array", () => {
-        const stats = createSessionStats();
-        const imports = [];
-        const importedFiles = new Set(imports.map((e) => e.imported_file));
-        for (const target of importedFiles) {
-            if (target === "src/a.ts") {
-                recordCircularDep(stats);
-                break;
-            }
-        }
-        expect(stats.events.circularDepsDetected).toBe(0);
-    });
-});
-// ── Signature Preservation ───────────────────────────────────────────
-describe("Signature preservation detection (drift)", () => {
-    it("records preservation when drift status is 'modified'", () => {
-        const stats = createSessionStats();
-        const drift = { entityStatus: "modified" };
-        if (drift.entityStatus === "modified") {
-            recordSignaturePreservation(stats);
-        }
-        expect(stats.events.signaturePreservations).toBe(1);
-    });
-    it("does not record for 'added' drift status", () => {
-        const stats = createSessionStats();
-        const drift = { entityStatus: "added" };
-        if (drift.entityStatus === "modified") {
-            recordSignaturePreservation(stats);
-        }
-        expect(stats.events.signaturePreservations).toBe(0);
-    });
-    it("does not record when drift is null", () => {
-        const stats = createSessionStats();
-        const drift = null;
-        if (drift?.entityStatus === "modified") {
-            recordSignaturePreservation(stats);
-        }
-        expect(stats.events.signaturePreservations).toBe(0);
-    });
-});
-// ── Chokepoint Warning ───────────────────────────────────────────────
-describe("Chokepoint warning detection", () => {
-    it("records warning when fan_in > 10 and risk is high", () => {
-        const stats = createSessionStats();
-        const entityRisk = { fan_in: 15, fan_out: 3, risk_level: "high" };
-        if (entityRisk.risk_level === "high" && entityRisk.fan_in > 10) {
-            recordChokepointWarning(stats);
-        }
-        expect(stats.events.chokepointWarningsIssued).toBe(1);
-    });
-    it("does not record when fan_in <= 10 even with high risk", () => {
-        const stats = createSessionStats();
-        const entityRisk = { fan_in: 8, fan_out: 3, risk_level: "high" };
-        if (entityRisk.risk_level === "high" && entityRisk.fan_in > 10) {
-            recordChokepointWarning(stats);
-        }
-        expect(stats.events.chokepointWarningsIssued).toBe(0);
-    });
-});
-// ── Dead Code Reference ──────────────────────────────────────────────
-describe("Dead code reference detection", () => {
-    it("records when fan_in is exactly 0", () => {
-        const stats = createSessionStats();
-        const entityRisk = { fan_in: 0, fan_out: 3, risk_level: "normal" };
-        if (entityRisk.fan_in === 0) {
-            recordDeadCodeReference(stats);
-        }
-        expect(stats.events.deadCodeReferences).toBe(1);
-    });
-    it("does not record when fan_in > 0", () => {
-        const stats = createSessionStats();
-        const entityRisk = { fan_in: 2, fan_out: 3, risk_level: "normal" };
-        if (entityRisk.fan_in === 0) {
-            recordDeadCodeReference(stats);
-        }
-        expect(stats.events.deadCodeReferences).toBe(0);
-    });
-});
-// ── Combined Event Tracking ──────────────────────────────────────────
-describe("Combined event tracking across tool calls", () => {
-    it("totalCaughtEvents reflects all event types from a session", () => {
-        const stats = createSessionStats();
-        // Simulate a session with multiple events
-        recordViolation(stats); // check_rules found violation
-        recordViolation(stats); // check_rules found another
-        recordChokepointWarning(stats); // high-risk entity queried
-        recordCircularDep(stats); // circular import detected
-        recordSignaturePreservation(stats); // modified entity accessed
-        recordDeadCodeReference(stats); // dead code flagged
-        expect(totalCaughtEvents(stats.events)).toBe(6);
-        expect(stats.events.conventionViolationsCaught).toBe(2);
-        expect(stats.events.chokepointWarningsIssued).toBe(1);
-        expect(stats.events.circularDepsDetected).toBe(1);
-        expect(stats.events.signaturePreservations).toBe(1);
-        expect(stats.events.deadCodeReferences).toBe(1);
-    });
-    it("violationsCaught is separate from events.conventionViolationsCaught", () => {
-        const stats = createSessionStats();
-        recordViolation(stats);
-        // Both should track (violationsCaught is the legacy counter)
-        expect(stats.violationsCaught).toBe(1);
-        expect(stats.events.conventionViolationsCaught).toBe(1);
-    });
-});