@unerr-ai/unerr 0.1.0 → 0.1.2

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

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

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

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

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