@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/metrics-store.test.js

@@ -1,223 +0,0 @@
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import os from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { closeMetricsStore, openMetricsStore, } from "../tracking/metrics-store.js";
-describe("MetricsStore", () => {
-    let dir;
-    beforeEach(() => {
-        dir = join(os.tmpdir(), `unerr-metrics-${Date.now()}-${Math.random()}`);
-        mkdirSync(dir, { recursive: true });
-    });
-    afterEach(() => {
-        closeMetricsStore(dir);
-        rmSync(dir, { recursive: true, force: true });
-    });
-    it("creates metrics.db on first open and is idempotent", () => {
-        openMetricsStore(dir);
-        expect(existsSync(join(dir, "metrics.db"))).toBe(true);
-        // Re-opening returns the same instance (no error)
-        expect(openMetricsStore(dir)).toBe(openMetricsStore(dir));
-    });
-    it("inserts + reads compression events with monotonic id", () => {
-        const s = openMetricsStore(dir);
-        const id1 = s.insertCompression({
-            ts: Date.now(),
-            ts_iso: new Date().toISOString(),
-            command: "ls",
-            category: "log_text",
-            confidence: 0.9,
-            raw_bytes: 1024,
-            compressed_bytes: 512,
-            saved_pct: 50,
-            omni_fallback: 0,
-            tee_file: null,
-        });
-        const id2 = s.insertCompression({
-            ts: Date.now() + 1,
-            ts_iso: new Date().toISOString(),
-            command: "ps",
-            category: "tabular",
-            confidence: 0.95,
-            raw_bytes: 2048,
-            compressed_bytes: 256,
-            saved_pct: 87.5,
-            omni_fallback: 0,
-            tee_file: ".unerr/tee/foo.txt",
-        });
-        expect(id2).toBeGreaterThan(id1);
-        const recent = s.recentCompression(10);
-        expect(recent).toHaveLength(2);
-        // ORDER BY id DESC — newest first
-        expect(recent[0]?.command).toBe("ps");
-        expect(recent[1]?.command).toBe("ls");
-    });
-    it("supports id > lastSeen polling for compression", () => {
-        const s = openMetricsStore(dir);
-        for (let i = 0; i < 3; i++) {
-            s.insertCompression({
-                ts: Date.now() + i,
-                ts_iso: new Date().toISOString(),
-                command: `cmd-${i}`,
-                category: "log_text",
-                confidence: 0.9,
-                raw_bytes: 100,
-                compressed_bytes: 50,
-                saved_pct: 50,
-                omni_fallback: 0,
-                tee_file: null,
-            });
-        }
-        const all = s.compressionSince(0);
-        expect(all).toHaveLength(3);
-        expect(all.map((r) => r.command)).toEqual(["cmd-0", "cmd-1", "cmd-2"]);
-        const afterFirst = s.compressionSince(all[0].id);
-        expect(afterFirst).toHaveLength(2);
-        expect(afterFirst[0]?.command).toBe("cmd-1");
-    });
-    it("inserts + reads file_read events", () => {
-        const s = openMetricsStore(dir);
-        s.insertFileRead({
-            ts: Date.now(),
-            ts_iso: new Date().toISOString(),
-            file: "src/foo.ts",
-            mode: "outline",
-            total_lines: 500,
-            returned_lines: 30,
-            saved_pct: 94,
-            entity: null,
-            token_estimate: 200,
-        });
-        const all = s.fileReadsSince(0);
-        expect(all).toHaveLength(1);
-        expect(all[0]?.file).toBe("src/foo.ts");
-        expect(all[0]?.mode).toBe("outline");
-    });
-    it("inserts + reads token_flow events; filters by session", () => {
-        const s = openMetricsStore(dir);
-        s.insertTokenFlow({
-            ts: Date.now(),
-            ts_iso: new Date().toISOString(),
-            session_id: "s-1",
-            pid: 1234,
-            turn: 1,
-            mechanism: "graph_query",
-            tool: "search_code",
-            tokens_without: 1000,
-            tokens_with: 200,
-            tokens_saved: 800,
-            detail: JSON.stringify({ query: "foo" }),
-        });
-        s.insertTokenFlow({
-            ts: Date.now() + 1,
-            ts_iso: new Date().toISOString(),
-            session_id: "s-2",
-            pid: 1234,
-            turn: 1,
-            mechanism: "shell_compression",
-            tool: null,
-            tokens_without: 5000,
-            tokens_with: 500,
-            tokens_saved: 4500,
-            detail: null,
-        });
-        expect(s.allTokenFlow()).toHaveLength(2);
-        expect(s.tokenFlowBySession("s-1")).toHaveLength(1);
-        expect(s.tokenFlowBySession("s-2")[0]?.mechanism).toBe("shell_compression");
-    });
-    it("upserts session_history (one row per session_id)", () => {
-        const s = openMetricsStore(dir);
-        s.upsertSessionHistory({
-            session_id: "s-1",
-            started_at: "2026-05-12T10:00:00Z",
-            ended_at: "2026-05-12T10:30:00Z",
-            duration_ms: 1_800_000,
-            tool_calls: 50,
-            tokens_saved: 12000,
-            tokens_processed: 50000,
-            efficiency: 24,
-            dollars_saved: 0.15,
-            model_id: "claude-opus-4-7",
-            entity_count: 30,
-            agent_name: "claude-code",
-            token_flow_summary: null,
-        });
-        // Second upsert for the same session_id should update, not append.
-        s.upsertSessionHistory({
-            session_id: "s-1",
-            started_at: "2026-05-12T10:00:00Z",
-            ended_at: "2026-05-12T11:00:00Z",
-            duration_ms: 3_600_000,
-            tool_calls: 80,
-            tokens_saved: 20000,
-            tokens_processed: 80000,
-            efficiency: 25,
-            dollars_saved: 0.25,
-            model_id: "claude-opus-4-7",
-            entity_count: 45,
-            agent_name: "claude-code",
-            token_flow_summary: JSON.stringify({ top_mechanism: "graph_query" }),
-        });
-        const all = s.allSessionHistory();
-        expect(all).toHaveLength(1);
-        expect(all[0]?.tool_calls).toBe(80);
-        expect(all[0]?.duration_ms).toBe(3_600_000);
-    });
-    it("upserts session_summary and reads by id", () => {
-        const s = openMetricsStore(dir);
-        s.upsertSessionSummary({
-            session_id: "sum-1",
-            written_at: "2026-05-12T10:30:00Z",
-            started_at: "2026-05-12T10:00:00Z",
-            ended_at: "2026-05-12T10:30:00Z",
-            duration_ms: 1_800_000,
-            tool_calls: 50,
-            chains: 5,
-            files_modified: JSON.stringify(["a.ts", "b.ts"]),
-            entities_touched: JSON.stringify(["fooFn", "barClass"]),
-            tools_used: JSON.stringify({ search_code: 10, file_read: 20 }),
-            feature_areas: JSON.stringify(["intelligence"]),
-            facts_recorded: 2,
-            facts_surfaced: JSON.stringify(["f-1"]),
-            revert_count: 0,
-            rot_score: 0.1,
-            token_estimate: 50000,
-            branch: "main",
-        });
-        const r = s.sessionSummary("sum-1");
-        expect(r?.session_id).toBe("sum-1");
-        expect(r?.chains).toBe(5);
-        expect(JSON.parse(r.files_modified)).toEqual(["a.ts", "b.ts"]);
-        expect(s.sessionSummary("never-existed")).toBeNull();
-    });
-    it("reset() empties tables and resets autoincrement", () => {
-        const s = openMetricsStore(dir);
-        s.insertCompression({
-            ts: Date.now(),
-            ts_iso: new Date().toISOString(),
-            command: "x",
-            category: "log_text",
-            confidence: 1,
-            raw_bytes: 1,
-            compressed_bytes: 1,
-            saved_pct: 0,
-            omni_fallback: 0,
-            tee_file: null,
-        });
-        s.reset();
-        expect(s.recentCompression(10)).toEqual([]);
-        const firstAfterReset = s.insertCompression({
-            ts: Date.now(),
-            ts_iso: new Date().toISOString(),
-            command: "y",
-            category: "log_text",
-            confidence: 1,
-            raw_bytes: 1,
-            compressed_bytes: 1,
-            saved_pct: 0,
-            omni_fallback: 0,
-            tee_file: null,
-        });
-        expect(firstAfterReset).toBe(1);
-    });
-});

package/dist/__tests__/native-watcher.test.js

@@ -1,191 +0,0 @@
-/**
- * Native watcher tests — @parcel/watcher integration with debounced events.
- */
-import { mkdirSync, realpathSync, rmSync, unlinkSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createNativeWatcher, } from "../tracking/native-watcher.js";
-let tempDir;
-let watcher = null;
-function makeTempDir() {
-    const raw = join(tmpdir(), `unerr-watcher-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(raw, { recursive: true });
-    return realpathSync(raw);
-}
-/**
- * Wait until the predicate matches at least one event, or timeout.
- * Returns all collected events at the time the predicate was satisfied.
- */
-function waitForMatch(collected, predicate, timeoutMs = 3000) {
-    return new Promise((resolve) => {
-        const start = Date.now();
-        const check = () => {
-            if (collected.some(predicate)) {
-                resolve([...collected]);
-                return;
-            }
-            if (Date.now() - start > timeoutMs) {
-                resolve([...collected]);
-                return;
-            }
-            setTimeout(check, 20);
-        };
-        check();
-    });
-}
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
- * Start watcher and drain the initial FSEvents directory-creation event
- * that fires when subscribing to a newly-created temp directory.
- */
-async function startAndDrain(w, events) {
-    await w.start();
-    await delay(500);
-    events.length = 0;
-}
-beforeEach(() => {
-    tempDir = makeTempDir();
-});
-afterEach(async () => {
-    if (watcher?.isRunning()) {
-        await watcher.stop();
-    }
-    watcher = null;
-    try {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        /* ignore */
-    }
-});
-describe("NativeWatcher", () => {
-    it("can be created and started without errors", async () => {
-        const events = [];
-        watcher = createNativeWatcher({
-            projectRoot: tempDir,
-            onEvents: (batch) => events.push(...batch),
-        });
-        await watcher.start();
-        expect(watcher.isRunning()).toBe(true);
-        await watcher.stop();
-        expect(watcher.isRunning()).toBe(false);
-    });
-    it("detects file creation", async () => {
-        const events = [];
-        watcher = createNativeWatcher({
-            projectRoot: tempDir,
-            debounceMs: 30,
-            onEvents: (batch) => events.push(...batch),
-        });
-        await startAndDrain(watcher, events);
-        writeFileSync(join(tempDir, "new-file.txt"), "hello");
-        const result = await waitForMatch(events, (e) => e.path.includes("new-file.txt"));
-        const createEvent = result.find((e) => e.path.includes("new-file.txt"));
-        expect(createEvent).toBeDefined();
-        expect(createEvent?.type).toBe("create");
-    });
-    it("detects file modification", async () => {
-        const filePath = join(tempDir, "existing.txt");
-        writeFileSync(filePath, "initial content");
-        const events = [];
-        watcher = createNativeWatcher({
-            projectRoot: tempDir,
-            debounceMs: 30,
-            onEvents: (batch) => events.push(...batch),
-        });
-        await startAndDrain(watcher, events);
-        writeFileSync(filePath, "updated content");
-        const result = await waitForMatch(events, (e) => e.path.includes("existing.txt"));
-        const updateEvent = result.find((e) => e.path.includes("existing.txt"));
-        expect(updateEvent).toBeDefined();
-        expect(["create", "update"]).toContain(updateEvent?.type);
-    });
-    it("detects file deletion", async () => {
-        const filePath = join(tempDir, "to-delete.txt");
-        writeFileSync(filePath, "will be deleted");
-        const events = [];
-        watcher = createNativeWatcher({
-            projectRoot: tempDir,
-            debounceMs: 30,
-            onEvents: (batch) => events.push(...batch),
-        });
-        await startAndDrain(watcher, events);
-        unlinkSync(filePath);
-        const result = await waitForMatch(events, (e) => e.path.includes("to-delete.txt"));
-        const deleteEvent = result.find((e) => e.path.includes("to-delete.txt"));
-        expect(deleteEvent).toBeDefined();
-        expect(deleteEvent?.type).toBe("delete");
-    });
-    it("debounces rapid writes into a single batch", async () => {
-        const batches = [];
-        watcher = createNativeWatcher({
-            projectRoot: tempDir,
-            debounceMs: 150,
-            onEvents: (batch) => batches.push([...batch]),
-        });
-        await watcher.start();
-        await delay(500);
-        batches.length = 0;
-        for (let i = 0; i < 5; i++) {
-            writeFileSync(join(tempDir, `rapid-${i}.txt`), `content-${i}`);
-        }
-        await delay(500);
-        expect(batches.length).toBeLessThanOrEqual(2);
-        const allEvents = batches.flat();
-        expect(allEvents.length).toBeGreaterThanOrEqual(1);
-    });
-    it("ignores .git directory changes", async () => {
-        const gitDir = join(tempDir, ".git");
-        mkdirSync(gitDir, { recursive: true });
-        const events = [];
-        watcher = createNativeWatcher({
-            projectRoot: tempDir,
-            debounceMs: 30,
-            onEvents: (batch) => events.push(...batch),
-        });
-        await startAndDrain(watcher, events);
-        writeFileSync(join(gitDir, "HEAD"), "ref: refs/heads/main");
-        writeFileSync(join(tempDir, "tracked.txt"), "should see this");
-        const result = await waitForMatch(events, (e) => e.path.includes("tracked.txt"));
-        const gitEvents = result.filter((e) => e.path.includes("/.git/") || e.path.endsWith("/.git"));
-        expect(gitEvents.length).toBe(0);
-        const trackedEvent = result.find((e) => e.path.includes("tracked.txt"));
-        expect(trackedEvent).toBeDefined();
-    });
-    it("ignores node_modules directory changes", async () => {
-        const nmDir = join(tempDir, "node_modules", "some-pkg");
-        mkdirSync(nmDir, { recursive: true });
-        const events = [];
-        watcher = createNativeWatcher({
-            projectRoot: tempDir,
-            debounceMs: 30,
-            onEvents: (batch) => events.push(...batch),
-        });
-        await startAndDrain(watcher, events);
-        writeFileSync(join(nmDir, "index.js"), "module.exports = {}");
-        writeFileSync(join(tempDir, "src-file.ts"), "export const x = 1;");
-        const result = await waitForMatch(events, (e) => e.path.includes("src-file.ts"));
-        const nmEvents = result.filter((e) => e.path.includes("node_modules"));
-        expect(nmEvents.length).toBe(0);
-        const srcEvent = result.find((e) => e.path.includes("src-file.ts"));
-        expect(srcEvent).toBeDefined();
-    });
-    it("stops cleanly and flushes pending events", async () => {
-        const events = [];
-        watcher = createNativeWatcher({
-            projectRoot: tempDir,
-            debounceMs: 5000,
-            onEvents: (batch) => events.push(...batch),
-        });
-        await startAndDrain(watcher, events);
-        writeFileSync(join(tempDir, "pending.txt"), "content");
-        await delay(300);
-        await watcher.stop();
-        expect(watcher.isRunning()).toBe(false);
-        const pendingEvent = events.find((e) => e.path.includes("pending.txt"));
-        expect(pendingEvent).toBeDefined();
-    });
-});

package/dist/__tests__/navigation-hooks-agent-aware.test.js

@@ -1,145 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { resetHookDedup } from "../hooks/hook-dedup.js";
-import { runPostReadHook, runPreEditHook, runPreReadHook, } from "../hooks/navigation-hooks.js";
-/**
- * Tests for agent-aware navigation hook behavior.
- *
- * Claude Code hooks detect via `hook_event_name` field.
- * Cursor hooks detect via `tool_name` + `cwd` fields (no hook_event_name).
- * Cline hooks detect via `tool` + `params` + `event` fields.
- *
- * The key behavioral difference: Read-before-Edit warnings are Claude Code only.
- */
-// ── Helpers ──────────────────────────────────────────────────────────
-function claudeCodePayload(toolInput) {
-    return JSON.stringify({
-        hook_event_name: "PreToolUse",
-        tool_input: toolInput,
-    });
-}
-function cursorPayload(toolInput) {
-    return JSON.stringify({
-        tool_name: "Read",
-        tool_input: toolInput,
-        cwd: "/project",
-    });
-}
-function clinePayload(path) {
-    return JSON.stringify({
-        tool: "read_file",
-        params: { path },
-        event: "pre_tool",
-    });
-}
-// ── preReadHook: Claude Code ─────────────────────────────────────────
-describe("preReadHook — Claude Code", () => {
-    it("passthrough for targeted Read (offset/limit)", () => {
-        const result = JSON.parse(runPreReadHook(claudeCodePayload({ file_path: "src/foo.ts", offset: 10, limit: 20 })));
-        // Empty object = passthrough (no nudge)
-        expect(result).toEqual({});
-    });
-    it("nudges for full-file Read (no offset/limit)", () => {
-        const result = JSON.parse(runPreReadHook(claudeCodePayload({ file_path: "src/foo.ts" })));
-        const msg = result.hookSpecificOutput?.systemMessage ?? "";
-        expect(msg).toContain("ONLY for the Edit workflow");
-        expect(msg).toContain("offset/limit");
-        expect(msg).toContain("file_read");
-    });
-    it("still nudges for non-code files (preRead has no isCodeFile gate)", () => {
-        const result = JSON.parse(runPreReadHook(claudeCodePayload({ file_path: "README.md" })));
-        const msg = result.hookSpecificOutput?.systemMessage ?? "";
-        expect(msg).toContain("file_read");
-    });
-});
-// ── preReadHook: Non-Claude Code (Cursor) ────────────────────────────
-describe("preReadHook — Cursor (non-Claude Code)", () => {
-    it("nudges toward file_read (no Edit workflow mention)", () => {
-        const result = JSON.parse(runPreReadHook(cursorPayload({ file_path: "src/foo.ts" })));
-        // Cursor adapter uses `agent_message` at root level for pre-tool-use nudges
-        const msg = result.agent_message ?? "";
-        // Should NOT mention Edit workflow or offset/limit requirement
-        expect(msg).not.toContain("ONLY for the Edit workflow");
-        // Should mention file_read as the preferred tool
-        expect(msg).toContain("file_read");
-    });
-    it("still nudges even with offset/limit (Cursor doesn't need targeted Read)", () => {
-        const result = JSON.parse(runPreReadHook(cursorPayload({ file_path: "src/foo.ts", offset: 10, limit: 20 })));
-        // Cursor adapter uses `agent_message` for pre-tool-use nudges
-        const msg = result.agent_message ?? "";
-        // Non-Claude Code: always nudge toward file_read, even with offset/limit
-        expect(msg).toContain("file_read");
-    });
-});
-// ── preEditHook: Claude Code ─────────────────────────────────────────
-describe("preEditHook — Claude Code", () => {
-    it("includes Read prerequisite warning", () => {
-        const result = JSON.parse(runPreEditHook(claudeCodePayload({
-            file_path: "src/foo.ts",
-            old_string: "const x = 1",
-            new_string: "const x = 2",
-        })));
-        const msg = result.hookSpecificOutput?.systemMessage ?? "";
-        expect(msg).toContain("CRITICAL: Edit REQUIRES built-in Read");
-        expect(msg).toContain("file_read (MCP) does NOT satisfy this");
-    });
-    it("includes blast radius warning for signature changes", () => {
-        const result = JSON.parse(runPreEditHook(claudeCodePayload({
-            file_path: "src/foo.ts",
-            old_string: "export function doSomething(x: number)",
-            new_string: "export function doSomething(x: string)",
-        })));
-        const msg = result.hookSpecificOutput?.systemMessage ?? "";
-        expect(msg).toContain("CRITICAL: Edit REQUIRES built-in Read");
-        expect(msg).toContain("function/class signature");
-        expect(msg).toContain("get_references");
-    });
-});
-// ── preEditHook: Non-Claude Code (Cursor) ────────────────────────────
-describe("preEditHook — Cursor (non-Claude Code)", () => {
-    it("does NOT include Read prerequisite warning", () => {
-        const stdin = JSON.stringify({
-            tool_name: "Edit",
-            tool_input: {
-                file_path: "src/foo.ts",
-                old_string: "const x = 1",
-                new_string: "const x = 2",
-            },
-            cwd: "/project",
-        });
-        const result = JSON.parse(runPreEditHook(stdin));
-        // Cursor adapter uses `agent_message` at root level for pre-tool-use nudges
-        const msg = result.agent_message ?? "";
-        // Should NOT mention Edit requires Read
-        expect(msg).not.toContain("CRITICAL: Edit REQUIRES built-in Read");
-        expect(msg).not.toContain("file_read (MCP) does NOT satisfy this");
-        // Should still mention get_references for blast radius
-        expect(msg).toContain("get_references");
-    });
-});
-// ── postReadHook: Claude Code vs Cursor ──────────────────────────────
-describe("postReadHook — agent-aware enrichment", () => {
-    beforeEach(() => {
-        resetHookDedup();
-    });
-    it("Claude Code: mentions Edit workflow", () => {
-        const result = JSON.parse(runPostReadHook(claudeCodePayload({ file_path: "src/post-read-cc.ts" })));
-        const msg = result.hookSpecificOutput?.additionalContext ?? "";
-        expect(msg).toContain("Edit needs built-in Read first");
-        expect(msg).toContain("file_read");
-    });
-    it("Cursor: generic file_read suggestion (no Edit mention)", () => {
-        // Cursor postToolUse payload includes tool_output to distinguish from preToolUse
-        // Use a unique file path to avoid dedup collision with the Claude Code test above
-        const stdin = JSON.stringify({
-            tool_name: "Read",
-            tool_input: { file_path: "src/post-read-cursor.ts" },
-            tool_output: "file contents here",
-            cwd: "/project",
-        });
-        const result = JSON.parse(runPostReadHook(stdin));
-        // Cursor adapter uses `additional_context` at root level for post-tool-use enrichment
-        const msg = result.additional_context ?? "";
-        expect(msg).not.toContain("Edit needs built-in Read first");
-        expect(msg).toContain("file_read");
-    });
-});

package/dist/__tests__/negative-knowledge.test.js

@@ -1,116 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { detectAntiPatterns, detectInstableEntities, } from "../intelligence/negative-knowledge.js";
-describe("detectAntiPatterns", () => {
-    it("detects modified-then-reverted pattern", () => {
-        const entries = [
-            {
-                id: "target",
-                ts: "2026-04-30T10:00:00Z",
-                tool: "sync_local_diff",
-                args_summary: { files: ["src/ok.ts"] },
-                result_summary: {},
-            },
-            {
-                id: "bad1",
-                ts: "2026-04-30T10:01:00Z",
-                tool: "sync_local_diff",
-                args_summary: { files: ["src/bad.ts"] },
-                result_summary: {},
-            },
-            {
-                id: "bad2",
-                ts: "2026-04-30T10:02:00Z",
-                tool: "sync_local_diff",
-                args_summary: { files: ["src/worse.ts"] },
-                result_summary: {},
-            },
-            {
-                id: "rewind",
-                ts: "2026-04-30T10:05:00Z",
-                tool: "revert_to_working_state",
-                args_summary: {},
-                result_summary: { rewind_target_id: "target" },
-            },
-        ];
-        const corrections = detectAntiPatterns(entries, "rewind");
-        expect(corrections.length).toBe(2);
-        expect(corrections[0]?.entityKey).toBe("src/bad.ts");
-        expect(corrections[0]?.pattern).toBe("modified-then-reverted");
-        expect(corrections[1]?.entityKey).toBe("src/worse.ts");
-    });
-    it("returns empty when rewind not found", () => {
-        const entries = [
-            {
-                id: "e1",
-                ts: "2026-04-30T10:00:00Z",
-                tool: "sync_local_diff",
-                args_summary: { files: ["a.ts"] },
-                result_summary: {},
-            },
-        ];
-        expect(detectAntiPatterns(entries, "nonexistent")).toEqual([]);
-    });
-    it("returns empty when no target entry found", () => {
-        const entries = [
-            {
-                id: "rewind",
-                ts: "2026-04-30T10:00:00Z",
-                tool: "revert_to_working_state",
-                args_summary: {},
-                result_summary: { rewind_target_id: "missing" },
-            },
-        ];
-        expect(detectAntiPatterns(entries, "rewind")).toEqual([]);
-    });
-});
-describe("detectInstableEntities", () => {
-    it("detects entities modified 3+ times rapidly", () => {
-        const now = Date.now();
-        const entries = [
-            {
-                id: "e1",
-                ts: new Date(now - 5 * 60000).toISOString(),
-                tool: "sync_local_diff",
-                args_summary: { files: ["src/flaky.ts"] },
-                result_summary: {},
-            },
-            {
-                id: "e2",
-                ts: new Date(now - 3 * 60000).toISOString(),
-                tool: "sync_local_diff",
-                args_summary: { files: ["src/flaky.ts"] },
-                result_summary: {},
-            },
-            {
-                id: "e3",
-                ts: new Date(now - 1 * 60000).toISOString(),
-                tool: "sync_local_diff",
-                args_summary: { files: ["src/flaky.ts"] },
-                result_summary: {},
-            },
-        ];
-        const corrections = detectInstableEntities(entries);
-        expect(corrections.length).toBe(1);
-        expect(corrections[0]?.entityKey).toBe("src/flaky.ts");
-        expect(corrections[0]?.pattern).toBe("rapid-modification");
-    });
-    it("ignores stable entities", () => {
-        const entries = [
-            {
-                id: "e1",
-                ts: "2026-04-01T10:00:00Z",
-                tool: "sync_local_diff",
-                args_summary: { files: ["src/stable.ts"] },
-                result_summary: {},
-            },
-            {
-                id: "e2",
-                ts: "2026-04-15T10:00:00Z",
-                tool: "sync_local_diff",
-                args_summary: { files: ["src/stable.ts"] },
-                result_summary: {},
-            },
-        ];
-        expect(detectInstableEntities(entries)).toEqual([]);
-    });
-});