@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/tool-clusters.test.js

@@ -1,177 +0,0 @@
-/**
- * S7: Semantic Tool Clustering tests.
- *
- * Tests: cluster definitions, usage tracking, tool reordering.
- */
-import { describe, expect, it } from "vitest";
-import { TOOL_CLUSTERS, ToolUsageTracker, getToolCluster, reorderToolsByCluster, } from "../proxy/tool-clusters.js";
-// ── Cluster Definitions ──────────────────────────────────────────────
-describe("TOOL_CLUSTERS", () => {
-    it("has 6 semantic clusters", () => {
-        // ST-2: session-narrative cluster added (mark_* tools)
-        expect(TOOL_CLUSTERS).toHaveLength(6);
-    });
-    it("clusters have unique IDs", () => {
-        const ids = TOOL_CLUSTERS.map((c) => c.id);
-        expect(new Set(ids).size).toBe(ids.length);
-    });
-    it("all tools appear in exactly one cluster", () => {
-        const toolCounts = new Map();
-        for (const cluster of TOOL_CLUSTERS) {
-            for (const tool of cluster.tools) {
-                toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + 1);
-            }
-        }
-        for (const [tool, count] of toolCounts) {
-            expect(count, `${tool} appears in ${count} clusters`).toBe(1);
-        }
-    });
-    it("navigation cluster has the most tools", () => {
-        const nav = TOOL_CLUSTERS.find((c) => c.id === "navigation");
-        expect(nav).toBeDefined();
-        for (const cluster of TOOL_CLUSTERS) {
-            if (cluster.id !== "navigation") {
-                expect(nav.tools.length).toBeGreaterThanOrEqual(cluster.tools.length);
-            }
-        }
-    });
-    it("each cluster has trigger keywords", () => {
-        for (const cluster of TOOL_CLUSTERS) {
-            expect(cluster.triggerKeywords.length).toBeGreaterThan(0);
-        }
-    });
-});
-// ── getToolCluster ───────────────────────────────────────────────────
-describe("getToolCluster", () => {
-    it("maps search_code to navigation", () => {
-        expect(getToolCluster("search_code")).toBe("navigation");
-    });
-    it("maps file_outline to file-access", () => {
-        expect(getToolCluster("file_outline")).toBe("file-access");
-    });
-    // Disabled: get_rules tool is disabled (no rules detected yet)
-    // it("maps get_rules to quality", () => {
-    //   expect(getToolCluster("get_rules")).toBe("quality");
-    // });
-    it("maps record_fact to persistence", () => {
-        expect(getToolCluster("record_fact")).toBe("persistence");
-    });
-    // Disabled: safety cluster removed (shadow ledger tools not exposed)
-    // it("maps unerr_mark_working to safety", () => {
-    //   expect(getToolCluster("unerr_mark_working")).toBe("safety");
-    // });
-    it("returns undefined for unknown tool", () => {
-        expect(getToolCluster("unknown_tool")).toBeUndefined();
-    });
-});
-// ── ToolUsageTracker ─────────────────────────────────────────────────
-describe("ToolUsageTracker", () => {
-    it("starts with zero call count", () => {
-        const tracker = new ToolUsageTracker();
-        expect(tracker.getCallCount()).toBe(0);
-    });
-    it("records tool calls", () => {
-        const tracker = new ToolUsageTracker();
-        tracker.record("search_code");
-        tracker.record("get_entity");
-        expect(tracker.getCallCount()).toBe(2);
-    });
-    it("tracks most recent cluster", () => {
-        const tracker = new ToolUsageTracker();
-        tracker.record("search_code");
-        expect(tracker.getMostRecentCluster()).toBe("navigation");
-        tracker.record("file_outline");
-        expect(tracker.getMostRecentCluster()).toBe("file-access");
-    });
-    it("returns null for most recent cluster with no history", () => {
-        const tracker = new ToolUsageTracker();
-        expect(tracker.getMostRecentCluster()).toBeNull();
-    });
-    it("returns null for unknown tools in most recent cluster", () => {
-        const tracker = new ToolUsageTracker();
-        tracker.record("unknown_tool");
-        expect(tracker.getMostRecentCluster()).toBeNull();
-    });
-    it("produces cluster scores with recency weighting", () => {
-        const tracker = new ToolUsageTracker();
-        tracker.record("search_code");
-        tracker.record("file_outline");
-        tracker.record("search_code");
-        const scores = tracker.getClusterScores();
-        // navigation should score higher (2 calls, more recent)
-        expect(scores.get("navigation")).toBeGreaterThan(0);
-        expect(scores.get("file-access")).toBeGreaterThan(0);
-        expect(scores.get("navigation")).toBeGreaterThan(scores.get("file-access"));
-    });
-    it("respects maxHistory limit", () => {
-        const tracker = new ToolUsageTracker(3);
-        tracker.record("search_code");
-        tracker.record("file_outline");
-        tracker.record("get_rules");
-        tracker.record("record_fact");
-        expect(tracker.getCallCount()).toBe(3); // oldest dropped
-    });
-});
-// ── reorderToolsByCluster ────────────────────────────────────────────
-describe("reorderToolsByCluster", () => {
-    const mockTools = [
-        { name: "get_entity" },
-        { name: "file_outline" },
-        { name: "get_rules" },
-        { name: "record_fact" },
-        { name: "unerr_mark_working" },
-        { name: "search_code" },
-        { name: "file_read" },
-    ];
-    it("returns all tools (never filters)", () => {
-        const tracker = new ToolUsageTracker();
-        const result = reorderToolsByCluster(mockTools, tracker);
-        expect(result).toHaveLength(mockTools.length);
-    });
-    it("returns same tools with null tracker", () => {
-        const result = reorderToolsByCluster(mockTools, null);
-        expect(result).toHaveLength(mockTools.length);
-        // All original tools present
-        const names = result.map((t) => t.name);
-        for (const tool of mockTools) {
-            expect(names).toContain(tool.name);
-        }
-    });
-    it("uses default cluster order with no usage data", () => {
-        const tracker = new ToolUsageTracker();
-        const result = reorderToolsByCluster(mockTools, tracker);
-        const names = result.map((t) => t.name);
-        // Navigation cluster tools should come first (default order)
-        expect(names.indexOf("search_code")).toBeLessThan(names.indexOf("file_outline"));
-        expect(names.indexOf("search_code")).toBeLessThan(names.indexOf("get_rules"));
-    });
-    it("prioritizes recently-used cluster", () => {
-        const tracker = new ToolUsageTracker();
-        // Use file-access tools heavily
-        tracker.record("file_outline");
-        tracker.record("file_read");
-        tracker.record("file_outline");
-        const result = reorderToolsByCluster(mockTools, tracker);
-        const names = result.map((t) => t.name);
-        // file-access tools should now come before navigation
-        expect(names.indexOf("file_outline")).toBeLessThan(names.indexOf("search_code"));
-    });
-    it("includes unclustered tools at the end", () => {
-        const toolsWithExtra = [
-            ...mockTools,
-            { name: "custom_tool_not_in_cluster" },
-        ];
-        const result = reorderToolsByCluster(toolsWithExtra, null);
-        const names = result.map((t) => t.name);
-        expect(names[names.length - 1]).toBe("custom_tool_not_in_cluster");
-    });
-    it("preserves tool object references", () => {
-        const tools = [
-            { name: "search_code", description: "search desc" },
-            { name: "file_outline", description: "outline desc" },
-        ];
-        const result = reorderToolsByCluster(tools, null);
-        const searchTool = result.find((t) => t.name === "search_code");
-        expect(searchTool).toBe(tools[0]); // Same reference, not copy
-    });
-});

package/dist/__tests__/transport-mux.test.js

@@ -1,283 +0,0 @@
-/**
- * Sprint 7.2: Transport Multiplexer tests (Unix domain socket multi-client).
- */
-import { existsSync, mkdtempSync } from "node:fs";
-import { createConnection } from "node:net";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { TransportMux, } from "../proxy/transport-mux.js";
-function createTempDir() {
-    return mkdtempSync(join(tmpdir(), "mux-"));
-}
-/** Send a JSON-RPC message over a socket and wait for response. */
-function sendMessage(sockPath, message) {
-    return new Promise((resolve, reject) => {
-        const socket = createConnection(sockPath);
-        let buffer = "";
-        socket.on("connect", () => {
-            socket.write(`${JSON.stringify(message)}\n`);
-        });
-        socket.on("data", (data) => {
-            buffer += data.toString();
-            const newlineIdx = buffer.indexOf("\n");
-            if (newlineIdx !== -1) {
-                const line = buffer.slice(0, newlineIdx).trim();
-                try {
-                    const response = JSON.parse(line);
-                    socket.destroy();
-                    resolve(response);
-                }
-                catch (err) {
-                    socket.destroy();
-                    reject(err);
-                }
-            }
-        });
-        socket.on("error", reject);
-        // Timeout after 2s
-        setTimeout(() => {
-            socket.destroy();
-            reject(new Error("Timeout waiting for response"));
-        }, 2000);
-    });
-}
-/** Wait for socket to become available. */
-function waitForSocket(sockPath, timeoutMs = 2000) {
-    return new Promise((resolve, reject) => {
-        const start = Date.now();
-        const check = () => {
-            if (existsSync(sockPath)) {
-                resolve();
-                return;
-            }
-            if (Date.now() - start > timeoutMs) {
-                reject(new Error("Timeout waiting for socket"));
-                return;
-            }
-            setTimeout(check, 50);
-        };
-        check();
-    });
-}
-describe("TransportMux", () => {
-    const muxInstances = [];
-    afterEach(() => {
-        for (const mux of muxInstances) {
-            mux.stop();
-        }
-        muxInstances.length = 0;
-    });
-    it("starts and stops cleanly", async () => {
-        const dir = createTempDir();
-        const sockPath = join(dir, "proxy.sock");
-        const mux = new TransportMux(sockPath);
-        muxInstances.push(mux);
-        mux.start();
-        await waitForSocket(sockPath);
-        expect(existsSync(sockPath)).toBe(true);
-        mux.stop();
-        expect(existsSync(sockPath)).toBe(false);
-    });
-    it("accepts a UDS client and routes messages", async () => {
-        const dir = createTempDir();
-        const sockPath = join(dir, "proxy.sock");
-        const mux = new TransportMux(sockPath);
-        muxInstances.push(mux);
-        const receivedMessages = [];
-        const handler = async (clientId, message) => {
-            receivedMessages.push({ clientId, method: message.method });
-            return {
-                jsonrpc: "2.0",
-                result: { tools: ["get_function"] },
-            };
-        };
-        mux.setHandler(handler);
-        mux.start();
-        await waitForSocket(sockPath);
-        const response = await sendMessage(sockPath, {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/list",
-        });
-        expect(response.jsonrpc).toBe("2.0");
-        expect(response.id).toBe(1);
-        expect(response.result).toBeDefined();
-        expect(receivedMessages).toHaveLength(1);
-        expect(receivedMessages[0]?.method).toBe("tools/list");
-        expect(receivedMessages[0]?.clientId).toMatch(/^uds-/);
-    });
-    it("handles tools/call with arguments", async () => {
-        const dir = createTempDir();
-        const sockPath = join(dir, "proxy.sock");
-        const mux = new TransportMux(sockPath);
-        muxInstances.push(mux);
-        const handler = async (_clientId, message) => {
-            const params = message.params;
-            return {
-                jsonrpc: "2.0",
-                result: {
-                    content: [{ type: "text", text: `Called ${params.name}` }],
-                },
-            };
-        };
-        mux.setHandler(handler);
-        mux.start();
-        await waitForSocket(sockPath);
-        const response = await sendMessage(sockPath, {
-            jsonrpc: "2.0",
-            id: 2,
-            method: "tools/call",
-            params: { name: "get_function", arguments: { key: "k1" } },
-        });
-        expect(response.id).toBe(2);
-        const result = response.result;
-        expect(result.content[0]?.text).toBe("Called get_function");
-    });
-    it("returns error for unknown methods", async () => {
-        const dir = createTempDir();
-        const sockPath = join(dir, "proxy.sock");
-        const mux = new TransportMux(sockPath);
-        muxInstances.push(mux);
-        const handler = async () => {
-            return {
-                jsonrpc: "2.0",
-                error: { code: -32601, message: "Method not found" },
-            };
-        };
-        mux.setHandler(handler);
-        mux.start();
-        await waitForSocket(sockPath);
-        const response = await sendMessage(sockPath, {
-            jsonrpc: "2.0",
-            id: 3,
-            method: "unknown/method",
-        });
-        expect(response.error).toBeDefined();
-        expect(response.error?.code).toBe(-32601);
-    });
-    it("returns parse error for invalid JSON", async () => {
-        const dir = createTempDir();
-        const sockPath = join(dir, "proxy.sock");
-        const mux = new TransportMux(sockPath);
-        muxInstances.push(mux);
-        mux.setHandler(async () => ({
-            jsonrpc: "2.0",
-            result: {},
-        }));
-        mux.start();
-        await waitForSocket(sockPath);
-        // Send raw invalid JSON
-        const response = await new Promise((resolve, reject) => {
-            const socket = createConnection(sockPath);
-            let buffer = "";
-            socket.on("connect", () => {
-                socket.write("not valid json\n");
-            });
-            socket.on("data", (data) => {
-                buffer += data.toString();
-                const idx = buffer.indexOf("\n");
-                if (idx !== -1) {
-                    socket.destroy();
-                    resolve(JSON.parse(buffer.slice(0, idx)));
-                }
-            });
-            socket.on("error", reject);
-            setTimeout(() => {
-                socket.destroy();
-                reject(new Error("Timeout"));
-            }, 2000);
-        });
-        expect(response.error).toBeDefined();
-        expect(response.error?.code).toBe(-32700);
-    });
-    it("supports multiple concurrent clients", async () => {
-        const dir = createTempDir();
-        const sockPath = join(dir, "proxy.sock");
-        const mux = new TransportMux(sockPath);
-        muxInstances.push(mux);
-        const clientIds = new Set();
-        const handler = async (clientId) => {
-            clientIds.add(clientId);
-            return {
-                jsonrpc: "2.0",
-                result: { clientId },
-            };
-        };
-        mux.setHandler(handler);
-        mux.start();
-        await waitForSocket(sockPath);
-        // Send two messages concurrently from separate connections
-        const [r1, r2] = await Promise.all([
-            sendMessage(sockPath, { jsonrpc: "2.0", id: 1, method: "tools/list" }),
-            sendMessage(sockPath, { jsonrpc: "2.0", id: 2, method: "tools/list" }),
-        ]);
-        expect(r1.result).toBeDefined();
-        expect(r2.result).toBeDefined();
-        // Each connection gets a unique client ID
-        expect(clientIds.size).toBe(2);
-    });
-    it("tracks client count", async () => {
-        const dir = createTempDir();
-        const sockPath = join(dir, "proxy.sock");
-        const mux = new TransportMux(sockPath);
-        muxInstances.push(mux);
-        mux.setHandler(async () => ({ jsonrpc: "2.0", result: {} }));
-        mux.start();
-        await waitForSocket(sockPath);
-        expect(mux.clientCount).toBe(0);
-        // Connect a client (it connects then disconnects after response)
-        await sendMessage(sockPath, {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/list",
-        });
-        // After sendMessage destroys socket, client should be cleaned up
-        // Give event loop time to process the close
-        await new Promise((r) => setTimeout(r, 100));
-        expect(mux.clientCount).toBe(0);
-    });
-    it("cleans up stale socket file on start", async () => {
-        const dir = createTempDir();
-        const sockPath = join(dir, "proxy.sock");
-        // Create a stale socket file
-        const { writeFileSync } = await import("node:fs");
-        writeFileSync(sockPath, "stale", "utf-8");
-        expect(existsSync(sockPath)).toBe(true);
-        const mux = new TransportMux(sockPath);
-        muxInstances.push(mux);
-        // Start should remove stale file and recreate
-        mux.start();
-        await waitForSocket(sockPath);
-        // Should still work
-        mux.setHandler(async () => ({
-            jsonrpc: "2.0",
-            result: { ok: true },
-        }));
-        const response = await sendMessage(sockPath, {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/list",
-        });
-        expect(response.result).toBeDefined();
-    });
-    it("handles handler errors gracefully", async () => {
-        const dir = createTempDir();
-        const sockPath = join(dir, "proxy.sock");
-        const mux = new TransportMux(sockPath);
-        muxInstances.push(mux);
-        mux.setHandler(async () => {
-            throw new Error("Handler crashed");
-        });
-        mux.start();
-        await waitForSocket(sockPath);
-        const response = await sendMessage(sockPath, {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/list",
-        });
-        expect(response.error).toBeDefined();
-        expect(response.error?.code).toBe(-32603);
-        expect(response.error?.message).toBe("Handler crashed");
-    });
-});

package/dist/__tests__/turn-segmenter.test.js

@@ -1,166 +0,0 @@
-/**
- * ST-1: TurnSegmenter — pure, no I/O. Tests cover boundary detection
- * (first_call, idle_gap, stop_hook) and session isolation.
- */
-import { describe, expect, it, vi } from "vitest";
-import { TurnSegmenter, } from "../tracking/turn-segmenter.js";
-function makeEntry(sessionId, ts) {
-    return { session_id: sessionId, ts };
-}
-describe("TurnSegmenter", () => {
-    it("stamps the first entry as a new turn with confidence 'first_call'", () => {
-        const seg = new TurnSegmenter();
-        const e = makeEntry("s1", new Date("2026-05-12T10:00:00Z").toISOString());
-        seg.observe(e);
-        expect(e.turn_id).toMatch(/^[a-f0-9]{12}$/);
-        expect(e.turn_confidence).toBe("first_call");
-    });
-    it("keeps subsequent entries within idle window in the same turn", () => {
-        const seg = new TurnSegmenter({ idleGapMs: 20_000 });
-        const e1 = makeEntry("s1", new Date("2026-05-12T10:00:00Z").toISOString());
-        const e2 = makeEntry("s1", new Date("2026-05-12T10:00:15Z").toISOString());
-        seg.observe(e1);
-        seg.observe(e2);
-        expect(e2.turn_id).toBe(e1.turn_id);
-        expect(e2.turn_confidence).toBe("first_call");
-    });
-    it("opens a new turn after an idle gap and emits a close event", () => {
-        const seg = new TurnSegmenter({ idleGapMs: 20_000 });
-        const closes = [];
-        seg.onTurnClose((e) => closes.push(e));
-        const e1 = makeEntry("s1", new Date("2026-05-12T10:00:00Z").toISOString());
-        const e2 = makeEntry("s1", new Date("2026-05-12T10:00:25Z").toISOString());
-        seg.observe(e1);
-        seg.observe(e2);
-        expect(e2.turn_id).not.toBe(e1.turn_id);
-        expect(e2.turn_confidence).toBe("idle_gap");
-        expect(closes).toHaveLength(1);
-        expect(closes[0]?.turn_id).toBe(e1.turn_id);
-        expect(closes[0]?.reason).toBe("idle_gap");
-        expect(closes[0]?.session_id).toBe("s1");
-    });
-    it("isolates turn ids across sessions", () => {
-        const seg = new TurnSegmenter();
-        const a = makeEntry("sa", new Date("2026-05-12T10:00:00Z").toISOString());
-        const b = makeEntry("sb", new Date("2026-05-12T10:00:00Z").toISOString());
-        seg.observe(a);
-        seg.observe(b);
-        expect(a.turn_id).toBeTypeOf("string");
-        expect(b.turn_id).toBeTypeOf("string");
-        expect(a.turn_id).not.toBe(b.turn_id);
-    });
-    it("closeTurn anchors an exact boundary; next entry is 'first_call'", () => {
-        const seg = new TurnSegmenter();
-        const closes = [];
-        seg.onTurnClose((e) => closes.push(e));
-        const e1 = makeEntry("s1", new Date("2026-05-12T10:00:00Z").toISOString());
-        seg.observe(e1);
-        seg.closeTurn("s1", "stop_hook");
-        const e2 = makeEntry("s1", new Date("2026-05-12T10:00:05Z").toISOString());
-        seg.observe(e2);
-        expect(e2.turn_id).not.toBe(e1.turn_id);
-        expect(e2.turn_confidence).toBe("first_call");
-        expect(closes).toHaveLength(1);
-        expect(closes[0]?.reason).toBe("stop_hook");
-    });
-    it("closeTurn with no open turn is a no-op", () => {
-        const seg = new TurnSegmenter();
-        const closes = [];
-        seg.onTurnClose((e) => closes.push(e));
-        seg.closeTurn("never-seen");
-        expect(closes).toHaveLength(0);
-    });
-    it("getCurrentTurnId returns the active turn for the session", () => {
-        const seg = new TurnSegmenter();
-        expect(seg.getCurrentTurnId("s1")).toBeNull();
-        const e = makeEntry("s1", new Date("2026-05-12T10:00:00Z").toISOString());
-        seg.observe(e);
-        expect(seg.getCurrentTurnId("s1")).toBe(e.turn_id);
-        seg.closeTurn("s1");
-        expect(seg.getCurrentTurnId("s1")).toBeNull();
-    });
-    it("onTurnClose returns an unsubscribe function", () => {
-        const seg = new TurnSegmenter({ idleGapMs: 10_000 });
-        const listener = vi.fn();
-        const unsubscribe = seg.onTurnClose(listener);
-        const e1 = makeEntry("s1", new Date("2026-05-12T10:00:00Z").toISOString());
-        const e2 = makeEntry("s1", new Date("2026-05-12T10:00:20Z").toISOString());
-        seg.observe(e1);
-        seg.observe(e2);
-        expect(listener).toHaveBeenCalledTimes(1);
-        unsubscribe();
-        const e3 = makeEntry("s1", new Date("2026-05-12T10:00:50Z").toISOString());
-        seg.observe(e3);
-        expect(listener).toHaveBeenCalledTimes(1);
-    });
-    it("survives a throwing listener without breaking other listeners", () => {
-        const seg = new TurnSegmenter({ idleGapMs: 10_000 });
-        const good = vi.fn();
-        seg.onTurnClose(() => {
-            throw new Error("boom");
-        });
-        seg.onTurnClose(good);
-        const e1 = makeEntry("s1", new Date("2026-05-12T10:00:00Z").toISOString());
-        const e2 = makeEntry("s1", new Date("2026-05-12T10:00:30Z").toISOString());
-        seg.observe(e1);
-        seg.observe(e2);
-        expect(good).toHaveBeenCalledTimes(1);
-    });
-    it("reset clears all session state", () => {
-        const seg = new TurnSegmenter();
-        const e = makeEntry("s1", new Date("2026-05-12T10:00:00Z").toISOString());
-        seg.observe(e);
-        expect(seg.getCurrentTurnId("s1")).not.toBeNull();
-        seg.reset();
-        expect(seg.getCurrentTurnId("s1")).toBeNull();
-    });
-});
-describe("ShadowLedger ↔ TurnSegmenter integration", () => {
-    it("stamps recorded entries with turn_id and turn_confidence", async () => {
-        const { mkdirSync, rmSync, readFileSync } = await import("node:fs");
-        const { tmpdir } = await import("node:os");
-        const { join } = await import("node:path");
-        const { ShadowLedger } = await import("../tracking/shadow-ledger.js");
-        const tempDir = join(tmpdir(), `unerr-ts-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-        const unerrDir = join(tempDir, ".unerr");
-        mkdirSync(unerrDir, { recursive: true });
-        try {
-            const ledger = new ShadowLedger(unerrDir);
-            const e1 = ledger.record("search_code", { query: "foo" }, { count: 3 }, "main", "deadbeef");
-            const e2 = ledger.record("file_read", { file_path: "src/a.ts" }, { lines: 100 }, "main", "deadbeef");
-            expect(e1.turn_id).toMatch(/^[a-f0-9]{12}$/);
-            expect(e1.turn_confidence).toBe("first_call");
-            expect(e2.turn_id).toBe(e1.turn_id);
-            const filePath = join(unerrDir, "ledger", "shadow.jsonl");
-            const lines = readFileSync(filePath, "utf-8")
-                .trim()
-                .split("\n")
-                .map((l) => JSON.parse(l));
-            expect(lines[0].turn_id).toBe(e1.turn_id);
-            expect(lines[0].turn_confidence).toBe("first_call");
-        }
-        finally {
-            rmSync(tempDir, { recursive: true, force: true });
-        }
-    });
-    it("ledger.closeTurn() anchors a fresh first_call boundary on next record", async () => {
-        const { mkdirSync, rmSync } = await import("node:fs");
-        const { tmpdir } = await import("node:os");
-        const { join } = await import("node:path");
-        const { ShadowLedger } = await import("../tracking/shadow-ledger.js");
-        const tempDir = join(tmpdir(), `unerr-ts-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-        const unerrDir = join(tempDir, ".unerr");
-        mkdirSync(unerrDir, { recursive: true });
-        try {
-            const ledger = new ShadowLedger(unerrDir);
-            const a = ledger.record("search_code", {}, {}, "main", "x");
-            ledger.closeTurn("stop_hook");
-            const b = ledger.record("file_read", {}, {}, "main", "x");
-            expect(b.turn_id).not.toBe(a.turn_id);
-            expect(b.turn_confidence).toBe("first_call");
-        }
-        finally {
-            rmSync(tempDir, { recursive: true, force: true });
-        }
-    });
-});