@unerr-ai/unerr 0.1.0 → 0.1.2

package/dist/__tests__/sprint-s1-wiring.test.js

@@ -0,0 +1,215 @@
+/**
+ * Sprint S1: Output Compression & Quality Loop — Integration Tests.
+ *
+ * Verifies:
+ *   - Large text output (>2K tokens) is automatically compressed
+ *   - Session dedup filters repeated _context keys for same entity
+ *   - Quality monitor adapts retention on retry spikes
+ *   - Budget enforcer caps total response size
+ *   - Retry detection feeds into quality monitor
+ */
+import { describe, expect, it, vi } from "vitest";
+import { QueryRouter } from "../intelligence/query-router.js";
+import { createCompressionQualityMonitor } from "../proxy/compression-quality-monitor.js";
+import { createSessionDedup } from "../proxy/session-dedup.js";
+function createMockGraph(overrides = {}) {
+    return {
+        getEntity: vi.fn().mockReturnValue({
+            key: "fn1",
+            name: "fn1",
+            kind: "function",
+            file_path: "src/main.ts",
+            risk_level: "normal",
+        }),
+        getBlastRadius: vi.fn().mockReturnValue({
+            direct_callers: 5,
+            direct_callees: 2,
+            transitive_count: 10,
+            is_chokepoint: false,
+            summary: "5 callers, 10 transitive dependents",
+        }),
+        getBlastRadiusEntities: vi.fn().mockReturnValue(["caller1", "caller2"]),
+        getConventionsForEntity: vi.fn().mockReturnValue([]),
+        getCorrections: vi.fn().mockReturnValue([]),
+        getCommunityForEntity: vi.fn().mockReturnValue(null),
+        getCrossCommunityEdges: vi.fn().mockReturnValue([]),
+        getEntitiesByFile: vi.fn().mockReturnValue([]),
+        queryEntities: vi.fn().mockReturnValue([]),
+        searchEntities: vi.fn().mockReturnValue([]),
+        getDriftOverlayEntity: vi.fn().mockReturnValue(null),
+        getDriftSummary: vi
+            .fn()
+            .mockReturnValue({ added: 0, modified: 0, removed: 0, total: 0 }),
+        getCriticalNodes: vi.fn().mockReturnValue([]),
+        getCrossBoundaryLinks: vi.fn().mockReturnValue([]),
+        getCallers: vi.fn().mockReturnValue([]),
+        getCallersOf: vi.fn().mockReturnValue([]),
+        getCalleesOf: vi.fn().mockReturnValue([]),
+        getCallees: vi.fn().mockReturnValue([]),
+        getImports: vi.fn().mockReturnValue([]),
+        getRules: vi.fn().mockReturnValue([]),
+        getJustificationsForEntity: vi.fn().mockReturnValue([]),
+        getDriftEntitiesForFile: vi.fn().mockReturnValue([]),
+        close: vi.fn(),
+        ...overrides,
+    };
+}
+describe("Sprint S1: Output Compression Wiring", () => {
+    describe("S1.5: Compression triggered on large text output", () => {
+        it("compresses large string results exceeding 2K tokens", async () => {
+            // search_code returning a large string simulates a tool that returns raw text
+            const largeText = "line of code here\n".repeat(2000); // ~8K tokens
+            const graph = createMockGraph({
+                searchEntities: vi.fn().mockReturnValue(largeText),
+            });
+            const router = new QueryRouter(graph);
+            const monitor = createCompressionQualityMonitor();
+            router.setCompressionMonitor(monitor);
+            const result = await router.execute("search_code", { query: "test" });
+            // The content should be compressed (shorter than original)
+            const contentStr = typeof result.content === "string"
+                ? result.content
+                : JSON.stringify(result.content);
+            expect(contentStr.length).toBeLessThan(largeText.length);
+        });
+        it("does not compress output under 2K tokens", async () => {
+            const shortText = "function foo() { return 42; }";
+            const graph = createMockGraph({
+                searchEntities: vi.fn().mockReturnValue(shortText),
+            });
+            const router = new QueryRouter(graph);
+            const result = await router.execute("search_code", { query: "foo" });
+            // Short output passes through unchanged
+            expect(result.content).toBe(shortText);
+        });
+        it("does not compress structured object results", async () => {
+            const graph = createMockGraph();
+            // get_function returns an entity object via resolveEntityWithOverlay
+            const router = new QueryRouter(graph);
+            const result = await router.execute("get_function", { key: "fn1" });
+            // Structured objects pass through — no string compression
+            expect(typeof result.content).toBe("object");
+        });
+    });
+    // S1.4 checked `_context.blast_radius` as a direct field. After the
+    // Three-Layer Experience System rollout (Sprint 8/9), that field was
+    // replaced by `_context.signals[]`. Session dedup still works — it now
+    // dedups individual signals — but the wire shape changed. Coverage
+    // continues in signal-scorer.test.ts (dedup branch).
+    describe.skip("S1.4: Session dedup filters repeated _context (deprecated — see signal-scorer.test.ts)", () => {
+        it("first call for entity delivers blast_radius in _context", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const dedup = createSessionDedup();
+            router.setSessionDedup(dedup);
+            const r1 = await router.execute("get_function", { key: "fn1" });
+            // First call should have blast_radius in _context
+            expect(r1._context?.blast_radius).toBeDefined();
+        });
+        it("second call for same entity does not repeat blast_radius", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const dedup = createSessionDedup();
+            router.setSessionDedup(dedup);
+            // First call delivers blast_radius
+            await router.execute("get_function", { key: "fn1" });
+            // Second call — SessionContext already deduplicates via shouldInjectBlastRadius
+            // AND session dedup filters any remaining repeated keys
+            const r2 = await router.execute("get_function", { key: "fn1" });
+            if (r2._context) {
+                expect(r2._context.blast_radius).toBeUndefined();
+            }
+        });
+        it("different entities get independent context delivery", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const dedup = createSessionDedup();
+            router.setSessionDedup(dedup);
+            await router.execute("get_function", { key: "fn1" });
+            const r2 = await router.execute("get_function", { key: "fn2" });
+            // fn2 is a fresh entity — should get blast_radius
+            expect(r2._context?.blast_radius).toBeDefined();
+        });
+    });
+    describe("S1.7-S1.9: Quality monitor integration", () => {
+        it("feeds compression events into quality monitor on large output", async () => {
+            const largeText = "error: test failure\n".repeat(2000);
+            const graph = createMockGraph({
+                searchEntities: vi.fn().mockReturnValue(largeText),
+            });
+            const router = new QueryRouter(graph);
+            const monitor = createCompressionQualityMonitor();
+            router.setCompressionMonitor(monitor);
+            await router.execute("search_code", { query: "test" });
+            // Adaptive config reflects the compression event was recorded
+            const config = monitor.getAdaptiveConfig();
+            expect(config).toBeDefined();
+            expect(config.confidence).toBeGreaterThanOrEqual(0);
+        });
+        it("increases retention after repeated over-compression signals", () => {
+            const monitor = createCompressionQualityMonitor();
+            const initialRetention = monitor.getRetention("generic");
+            // Simulate 3 compression + retry cycles (over-compression)
+            for (let i = 0; i < 3; i++) {
+                monitor.recordCompression(`c${i}`, "generic", 0.5);
+                monitor.recordAgentAction(`entity-${i}`, true, false);
+            }
+            const adaptedRetention = monitor.getRetention("generic");
+            expect(adaptedRetention).toBeGreaterThan(initialRetention);
+        });
+        it("reduces retention cautiously after 10+ successful compressions", () => {
+            const monitor = createCompressionQualityMonitor();
+            // First force retention up
+            for (let i = 0; i < 3; i++) {
+                monitor.recordCompression(`up${i}`, "generic", 0.5);
+                monitor.recordAgentAction(`e${i}`, true, false);
+            }
+            const highRetention = monitor.getRetention("generic");
+            // Then 10 good compressions
+            for (let i = 0; i < 10; i++) {
+                monitor.recordCompression(`good${i}`, "generic", 0.7);
+                monitor.recordAgentAction(`g${i}`, false, false);
+            }
+            const loweredRetention = monitor.getRetention("generic");
+            expect(loweredRetention).toBeLessThanOrEqual(highRetention);
+        });
+    });
+    describe("S1.8: Retry detection in enrichResult", () => {
+        it("detects retry when same entity queried within 60s", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const monitor = createCompressionQualityMonitor();
+            router.setCompressionMonitor(monitor);
+            // We need a compression event first for the monitor to register retries
+            // Simulate by querying a tool that returns large text (triggers compression)
+            const largeText = "content\n".repeat(2000);
+            graph.searchEntities = vi.fn().mockReturnValue(largeText);
+            await router.execute("search_code", { query: "a" });
+            // Now query an enrichable tool twice within 60s
+            await router.execute("get_function", { key: "fn1" });
+            await router.execute("get_function", { key: "fn1" });
+            // The second query should trigger retry detection
+            // which feeds into the monitor (if there was a recent compression)
+            expect(monitor.getSignalCount()).toBeGreaterThan(0);
+        });
+    });
+    describe("S1.10: Budget enforcer as final cap", () => {
+        it("caps extremely large multi-line output to within budget", async () => {
+            // Real-world content has newlines — budget enforcer splits by line
+            const hugeText = Array.from({ length: 5000 }, (_, i) => `line ${i}: some content that takes up space in the output buffer`).join("\n"); // ~5000 lines, ~300K chars, ~75K tokens
+            const graph = createMockGraph({
+                searchEntities: vi.fn().mockReturnValue(hugeText),
+            });
+            const router = new QueryRouter(graph);
+            const monitor = createCompressionQualityMonitor();
+            router.setCompressionMonitor(monitor);
+            const result = await router.execute("search_code", { query: "line" });
+            const contentStr = typeof result.content === "string"
+                ? result.content
+                : JSON.stringify(result.content);
+            // Budget enforcer ensures content stays well under original size
+            // 4K tokens ≈ 16K chars — allow some overhead from markers
+            expect(contentStr.length).toBeLessThan(hugeText.length * 0.3);
+        });
+    });
+});

package/dist/__tests__/sprint-s2-wiring.test.js

@@ -0,0 +1,256 @@
+/**
+ * Sprint S2: Session Health & Exploration Cost — Integration Tests.
+ *
+ * Verifies:
+ *   - Every graph tool response includes _meta.tokens_saved (number > 0)
+ *   - After 3+ queries to same entity → health drops below 0.8
+ *   - After 10+ tool calls/min → tool_call_acceleration signal fires
+ *   - Session health warning injected when health < 0.6
+ *   - Exploration cost accumulator tracks cumulative savings
+ *   - Health monitor feeds from blast radius and convention violations
+ */
+import { describe, expect, it, vi } from "vitest";
+import { createExplorationAccumulator } from "../intelligence/exploration-cost.js";
+import { QueryRouter } from "../intelligence/query-router.js";
+import { createSessionHealthMonitor } from "../intelligence/session-health-monitor.js";
+function createMockGraph(overrides = {}) {
+    return {
+        getEntity: vi.fn().mockReturnValue({
+            key: "fn1",
+            name: "fn1",
+            kind: "function",
+            file_path: "src/main.ts",
+            risk_level: "normal",
+        }),
+        getBlastRadius: vi.fn().mockReturnValue({
+            direct_callers: 5,
+            direct_callees: 2,
+            transitive_count: 10,
+            is_chokepoint: false,
+            summary: "5 callers, 10 transitive dependents",
+        }),
+        getBlastRadiusEntities: vi.fn().mockReturnValue(["caller1", "caller2"]),
+        getConventionsForEntity: vi.fn().mockReturnValue([]),
+        getCorrections: vi.fn().mockReturnValue([]),
+        getCommunityForEntity: vi.fn().mockReturnValue(null),
+        getCrossCommunityEdges: vi.fn().mockReturnValue([]),
+        getEntitiesByFile: vi.fn().mockReturnValue([]),
+        queryEntities: vi.fn().mockReturnValue([]),
+        searchEntities: vi.fn().mockReturnValue([]),
+        getDriftOverlayEntity: vi.fn().mockReturnValue(null),
+        getDriftSummary: vi
+            .fn()
+            .mockReturnValue({ added: 0, modified: 0, removed: 0, total: 0 }),
+        getCriticalNodes: vi.fn().mockReturnValue([]),
+        getCrossBoundaryLinks: vi.fn().mockReturnValue([]),
+        getCallers: vi.fn().mockReturnValue([]),
+        getCallersOf: vi.fn().mockReturnValue([]),
+        getCalleesOf: vi.fn().mockReturnValue([]),
+        getCallees: vi.fn().mockReturnValue([]),
+        getImports: vi.fn().mockReturnValue([]),
+        getRules: vi.fn().mockReturnValue([]),
+        getJustificationsForEntity: vi.fn().mockReturnValue([]),
+        getDriftEntitiesForFile: vi.fn().mockReturnValue([]),
+        close: vi.fn(),
+        ...overrides,
+    };
+}
+describe("Sprint S2: Session Health & Exploration Cost Wiring", () => {
+    describe("S2.7-S2.8: Exploration cost on every graph response", () => {
+        it("tracks tokens saved internally for graph tool responses", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const accumulator = createExplorationAccumulator();
+            router.setExplorationAccumulator(accumulator);
+            await router.execute("get_function", { key: "fn1" });
+            // Vanity fields stripped from wire; verify via internal accumulator instead.
+            const savings = router.getExplorationSavings();
+            expect(savings).not.toBeNull();
+            expect(savings.saved).toBeGreaterThan(0);
+        });
+        it("accumulates savings across multiple tool calls", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const accumulator = createExplorationAccumulator();
+            router.setExplorationAccumulator(accumulator);
+            await router.execute("get_function", { key: "fn1" });
+            await router.execute("get_function", { key: "fn2" });
+            await router.execute("search_code", { query: "test" });
+            const savings = router.getExplorationSavings();
+            expect(savings).not.toBeNull();
+            expect(savings.saved).toBeGreaterThan(0);
+            expect(savings.without).toBeGreaterThan(savings.saved);
+        });
+        it("different tool types produce different cost estimates", async () => {
+            const graph = createMockGraph({
+                getBlastRadius: vi.fn().mockReturnValue({
+                    direct_callers: 15,
+                    direct_callees: 3,
+                    transitive_count: 30,
+                    is_chokepoint: true,
+                    summary: "15 callers, 30 transitive",
+                }),
+                getBlastRadiusEntities: vi
+                    .fn()
+                    .mockReturnValue(Array.from({ length: 15 }, (_, i) => `caller${i}`)),
+            });
+            const router = new QueryRouter(graph);
+            const accumulator = createExplorationAccumulator();
+            router.setExplorationAccumulator(accumulator);
+            await router.execute("get_function", { key: "fn1" });
+            const beforeSecond = router.getExplorationSavings().saved;
+            await router.execute("search_code", { query: "test" });
+            const afterSecond = router.getExplorationSavings().saved;
+            // Both calls should add to the internal savings accumulator.
+            expect(beforeSecond).toBeGreaterThan(0);
+            expect(afterSecond).toBeGreaterThan(beforeSecond);
+        });
+    });
+    describe("S2.4-S2.5: Health monitor feeds from tool calls and blast radius", () => {
+        it("records tool calls into health monitor", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const monitor = createSessionHealthMonitor();
+            router.setHealthMonitor(monitor);
+            await router.execute("get_function", { key: "fn1" });
+            await router.execute("get_function", { key: "fn1" });
+            await router.execute("get_function", { key: "fn1" });
+            const health = monitor.getHealth();
+            // After 3 queries to same entity, repeated_query signal should fire
+            expect(health.signals.some((s) => s.type === "repeated_query")).toBe(true);
+        });
+        it("health drops below 0.8 after 3+ queries to same entity", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const monitor = createSessionHealthMonitor();
+            router.setHealthMonitor(monitor);
+            await router.execute("get_function", { key: "fn1" });
+            await router.execute("get_function", { key: "fn1" });
+            await router.execute("get_function", { key: "fn1" });
+            const health = monitor.getHealth();
+            expect(health.health).toBeLessThan(1.0);
+        });
+        it("feeds blast radius results into health monitor", async () => {
+            const graph = createMockGraph({
+                getBlastRadius: vi.fn().mockReturnValue({
+                    direct_callers: 20,
+                    direct_callees: 5,
+                    transitive_count: 50,
+                    is_chokepoint: true,
+                    summary: "20 callers, 50 transitive",
+                }),
+                getBlastRadiusEntities: vi
+                    .fn()
+                    .mockReturnValue(Array.from({ length: 20 }, (_, i) => `caller${i}`)),
+            });
+            const router = new QueryRouter(graph);
+            const monitor = createSessionHealthMonitor();
+            router.setHealthMonitor(monitor);
+            // First call injects blast radius
+            await router.execute("get_function", { key: "fn1" });
+            const health = monitor.getHealth();
+            // Health monitor should have recorded the blast radius
+            expect(health).toBeDefined();
+        });
+    });
+    describe("S2.6: Convention violations feed into health monitor", () => {
+        it("low-adherence conventions feed as violations", async () => {
+            const graph = createMockGraph({
+                getConventionsForEntity: vi.fn().mockReturnValue([
+                    {
+                        id: "conv1",
+                        name: "camelCase",
+                        adherence_pct: 45,
+                        rule: "Use camelCase",
+                    },
+                    {
+                        id: "conv2",
+                        name: "noAny",
+                        adherence_pct: 30,
+                        rule: "Avoid any type",
+                    },
+                    {
+                        id: "conv3",
+                        name: "imports",
+                        adherence_pct: 90,
+                        rule: "Use named imports",
+                    },
+                ]),
+            });
+            const router = new QueryRouter(graph);
+            const monitor = createSessionHealthMonitor();
+            router.setHealthMonitor(monitor);
+            await router.execute("get_function", { key: "fn1" });
+            // Should have recorded 2 violations (adherence < 70%)
+            const health = monitor.getHealth();
+            expect(health).toBeDefined();
+        });
+    });
+    describe("S2.9: Session health warning in _meta", () => {
+        it("no session_health warning when health is good", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const monitor = createSessionHealthMonitor();
+            router.setHealthMonitor(monitor);
+            const result = await router.execute("get_function", { key: "fn1" });
+            // Single query — health should be fine (no warning)
+            expect(result._meta.session_health).toBeUndefined();
+        });
+        it("injects session_health when health drops below 0.6", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const monitor = createSessionHealthMonitor();
+            router.setHealthMonitor(monitor);
+            // Hammer the same entity many times to degrade health
+            for (let i = 0; i < 12; i++) {
+                await router.execute("get_function", { key: "fn1" });
+            }
+            // Get the last result
+            const result = await router.execute("get_function", { key: "fn1" });
+            // After 13 queries to same entity, health should be degraded
+            const health = monitor.getHealth();
+            if (health.health < 0.6) {
+                expect(result._meta.session_health).toBeDefined();
+                expect(result._meta.session_health.health).toBeLessThan(0.6);
+                expect(result._meta.session_health.recommendation).toBeDefined();
+                expect(result._meta.session_health.signals.length).toBeGreaterThan(0);
+            }
+        });
+    });
+    describe("S2.10: Cumulative savings accessible for session summary", () => {
+        it("getExplorationSavings returns null when no accumulator set", () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            expect(router.getExplorationSavings()).toBeNull();
+        });
+        it("getExplorationSavings returns cumulative data after queries", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const accumulator = createExplorationAccumulator();
+            router.setExplorationAccumulator(accumulator);
+            await router.execute("get_function", { key: "fn1" });
+            await router.execute("get_function", { key: "fn2" });
+            const savings = router.getExplorationSavings();
+            expect(savings).not.toBeNull();
+            expect(savings.saved).toBeGreaterThan(0);
+            expect(savings.ratio).toBeGreaterThan(0);
+            expect(savings.ratio).toBeLessThan(1);
+        });
+    });
+    describe("Tool call acceleration detection", () => {
+        it("rapid tool calls trigger acceleration signal in health monitor", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const monitor = createSessionHealthMonitor();
+            router.setHealthMonitor(monitor);
+            // Fire 12 tool calls rapidly (simulates acceleration > 10/min)
+            for (let i = 0; i < 12; i++) {
+                await router.execute("get_function", { key: `fn${i}` });
+            }
+            const health = monitor.getHealth();
+            // With 12 rapid calls, tool_call_acceleration should fire
+            const hasAcceleration = health.signals.some((s) => s.type === "tool_call_acceleration");
+            expect(hasAcceleration).toBe(true);
+        });
+    });
+});

package/dist/__tests__/sprint-s3-wiring.test.js

@@ -0,0 +1,195 @@
+/**
+ * Sprint S3: Context Rot Detector — Integration Tests.
+ *
+ * Verifies:
+ *   - After 200K+ estimated tokens → depth_threshold signal fires
+ *   - After 3+ queries to same entity → repeated_exploration signal
+ *   - inject_refresh action → _context.session_warning with actionable summary
+ *   - suggest_new_session → _meta.session_health includes recommendation
+ *   - Errors feed into context rot detector
+ */
+import { describe, expect, it, vi } from "vitest";
+import { QueryRouter } from "../intelligence/query-router.js";
+import { createContextRotDetector } from "../proxy/context-rot-detector.js";
+function createMockGraph(overrides = {}) {
+    return {
+        getEntity: vi.fn().mockReturnValue({
+            key: "fn1",
+            name: "fn1",
+            kind: "function",
+            file_path: "src/main.ts",
+            risk_level: "normal",
+        }),
+        getBlastRadius: vi.fn().mockReturnValue({
+            direct_callers: 5,
+            direct_callees: 2,
+            transitive_count: 10,
+            is_chokepoint: false,
+            summary: "5 callers, 10 transitive dependents",
+        }),
+        getBlastRadiusEntities: vi.fn().mockReturnValue(["caller1", "caller2"]),
+        getConventionsForEntity: vi.fn().mockReturnValue([]),
+        getCorrections: vi.fn().mockReturnValue([]),
+        getCommunityForEntity: vi.fn().mockReturnValue(null),
+        getCrossCommunityEdges: vi.fn().mockReturnValue([]),
+        getEntitiesByFile: vi.fn().mockReturnValue([]),
+        queryEntities: vi.fn().mockReturnValue([]),
+        searchEntities: vi.fn().mockReturnValue([]),
+        getDriftOverlayEntity: vi.fn().mockReturnValue(null),
+        getDriftSummary: vi
+            .fn()
+            .mockReturnValue({ added: 0, modified: 0, removed: 0, total: 0 }),
+        getCriticalNodes: vi.fn().mockReturnValue([]),
+        getCrossBoundaryLinks: vi.fn().mockReturnValue([]),
+        getCallers: vi.fn().mockReturnValue([]),
+        getCallersOf: vi.fn().mockReturnValue([]),
+        getCalleesOf: vi.fn().mockReturnValue([]),
+        getCallees: vi.fn().mockReturnValue([]),
+        getImports: vi.fn().mockReturnValue([]),
+        getRules: vi.fn().mockReturnValue([]),
+        getJustificationsForEntity: vi.fn().mockReturnValue([]),
+        getDriftEntitiesForFile: vi.fn().mockReturnValue([]),
+        close: vi.fn(),
+        ...overrides,
+    };
+}
+describe("Sprint S3: Context Rot Detector Wiring", () => {
+    describe("S3.3: Token depth tracking", () => {
+        it("accumulates token depth from tool call responses", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const detector = createContextRotDetector();
+            router.setContextRotDetector(detector);
+            // Make several calls to accumulate token depth
+            for (let i = 0; i < 5; i++) {
+                await router.execute("get_function", { key: `fn${i}` });
+            }
+            // Evaluate — should have accumulated some tokens (small, but non-zero)
+            const signal = detector.evaluate();
+            expect(signal.estimatedDepth).toBeGreaterThan(0);
+        });
+        it("fires depth_threshold after 200K+ tokens", () => {
+            const detector = createContextRotDetector();
+            // Simulate large token accumulation
+            detector.recordToolCallTokens(210_000);
+            const signal = detector.evaluate();
+            expect(signal.signals.some((s) => s.type === "depth_threshold")).toBe(true);
+            expect(signal.rotConfidence).toBeGreaterThan(0);
+        });
+    });
+    describe("S3.4: Repeated query detection via sessionContext", () => {
+        it("detects repeated queries to same entity", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const detector = createContextRotDetector();
+            router.setContextRotDetector(detector);
+            // First call establishes history
+            await router.execute("get_function", { key: "fn1" });
+            // Subsequent calls should trigger repeated query detection
+            await router.execute("get_function", { key: "fn1" });
+            await router.execute("get_function", { key: "fn1" });
+            await router.execute("get_function", { key: "fn1" });
+            const signal = detector.evaluate();
+            // After 3+ re-queries to an entity already in history, repeated_exploration fires
+            expect(signal.signals.some((s) => s.type === "repeated_exploration")).toBe(true);
+        });
+    });
+    describe("S3.5: Error feeding", () => {
+        it("feeds errors into context rot detector on tool failure", async () => {
+            const graph = createMockGraph({
+                searchEntities: vi.fn().mockImplementation(() => {
+                    throw new Error("simulated failure");
+                }),
+            });
+            const router = new QueryRouter(graph);
+            const detector = createContextRotDetector();
+            router.setContextRotDetector(detector);
+            // Trigger multiple failures
+            for (let i = 0; i < 6; i++) {
+                await router.execute("search_code", { query: "test" });
+            }
+            const signal = detector.evaluate();
+            // After 5+ errors, declining_precision should fire
+            expect(signal.signals.some((s) => s.type === "declining_precision")).toBe(true);
+        });
+    });
+    describe("S3.6-S3.7: Rot evaluation and inject_refresh", () => {
+        it("injects session_warning in _context when rot triggers inject_refresh", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const detector = createContextRotDetector();
+            router.setContextRotDetector(detector);
+            // Push token depth past warning threshold (200K)
+            detector.recordToolCallTokens(220_000);
+            // Add repeated queries to push rot confidence into inject_refresh range (0.4-0.7)
+            detector.recordRepeatedQuery("fn1");
+            detector.recordRepeatedQuery("fn1");
+            detector.recordRepeatedQuery("fn1");
+            // Now execute enough calls to hit the 10th-call evaluation boundary
+            // We need toolCallCount to be divisible by 10
+            for (let i = 0; i < 9; i++) {
+                await router.execute("get_function", { key: `entity${i}` });
+            }
+            // 10th call triggers evaluation
+            const result = await router.execute("get_function", { key: "entity9" });
+            // Should have session_warning in _context
+            const ctx = result._context;
+            if (ctx?.session_warning) {
+                const warning = ctx.session_warning;
+                expect(warning.reason).toBeDefined();
+                expect(warning.rot_confidence).toBeGreaterThan(0);
+            }
+        });
+    });
+    describe("S3.8: Severe rot triggers suggest_new_session in _meta", () => {
+        it("injects _meta.session_health with suggest_new_session on critical rot", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const detector = createContextRotDetector();
+            router.setContextRotDetector(detector);
+            // Push past critical threshold (300K tokens → 0.4 rot)
+            detector.recordToolCallTokens(310_000);
+            // Add repeated queries (0.15 each for 3+ queries per entity)
+            detector.recordRepeatedQuery("fn1");
+            detector.recordRepeatedQuery("fn1");
+            detector.recordRepeatedQuery("fn1");
+            detector.recordRepeatedQuery("fn2");
+            detector.recordRepeatedQuery("fn2");
+            detector.recordRepeatedQuery("fn2");
+            // Add errors (0.2 for 5+ errors)
+            for (let i = 0; i < 6; i++) {
+                detector.recordError();
+            }
+            // Total rot: 0.4 (depth) + 0.15 (fn1) + 0.15 (fn2) + 0.2 (errors) = 0.9 → suggest_new_session
+            // Execute 10 calls to trigger evaluation
+            for (let i = 0; i < 9; i++) {
+                await router.execute("get_function", { key: `x${i}` });
+            }
+            const result = await router.execute("get_function", { key: "x9" });
+            expect(result._meta.session_health).toBeDefined();
+            expect(result._meta.session_health?.recommendation).toBe("suggest_new_session");
+            expect(result._meta.session_health?.signals.length).toBeGreaterThan(0);
+        });
+    });
+    describe("S3.9: getRefreshContext provides recovery data", () => {
+        it("builds refresh context when rot action is triggered", () => {
+            const detector = createContextRotDetector();
+            // Push into inject_refresh range (0.2 depth + 0.15 fn1 + 0.15 fn2 = 0.5)
+            detector.recordToolCallTokens(220_000);
+            detector.recordRepeatedQuery("fn1");
+            detector.recordRepeatedQuery("fn1");
+            detector.recordRepeatedQuery("fn1");
+            detector.recordRepeatedQuery("fn2");
+            detector.recordRepeatedQuery("fn2");
+            detector.recordRepeatedQuery("fn2");
+            const signal = detector.evaluate();
+            expect(signal.action).toBe("inject_refresh");
+            const refresh = detector.getRefreshContext();
+            expect(refresh).not.toBeNull();
+            expect(refresh?.reason).toBe("context_degradation");
+            expect(refresh?.estimated_depth).toBe(220_000);
+            expect(refresh?.repeated_entities).toContain("fn1");
+            expect(refresh?.repeated_entities).toContain("fn2");
+        });
+    });
+});