@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/timeline-filters.test.js

@@ -1,193 +0,0 @@
-/**
- * TR-1 / TR-2: filter + pagination + listSessions + getActivityBuckets store
- * methods, plus the route surface that exposes them.
- */
-import { mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createTimelineRoutes } from "../server/routes/timeline.js";
-import { CozoTimelineStore } from "../timeline/timeline-store.js";
-let tempDir;
-let store;
-beforeEach(async () => {
-    tempDir = join(tmpdir(), `unerr-tf-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(join(tempDir, ".unerr"), { recursive: true });
-    store = await CozoTimelineStore.create(tempDir);
-});
-afterEach(() => {
-    try {
-        store.close();
-    }
-    catch {
-        /* ignore */
-    }
-    try {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        /* ignore */
-    }
-});
-function turn(overrides) {
-    return {
-        session_id: overrides.session_id ?? "s1",
-        started_at: overrides.started_at ?? 1_000,
-        ended_at: overrides.ended_at ?? 2_000,
-        opened_by: overrides.opened_by ?? "first_call",
-        closed_reason: overrides.closed_reason ?? "session_end",
-        tool_count: overrides.tool_count ?? 3,
-        file_count: overrides.file_count ?? 2,
-        edit_count: overrides.edit_count ?? 1,
-        title: overrides.title ?? "",
-        outcome: overrides.outcome ?? "unknown",
-        ...overrides,
-    };
-}
-describe("listTurns — filters + pagination", () => {
-    it("paginates via offset + limit", async () => {
-        for (let i = 0; i < 7; i++) {
-            await store.upsertTurn(turn({ turn_id: `t${i}`, started_at: 1000 + i * 1000 }));
-        }
-        const page1 = await store.listTurns({ limit: 3, offset: 0 });
-        const page2 = await store.listTurns({ limit: 3, offset: 3 });
-        const page3 = await store.listTurns({ limit: 3, offset: 6 });
-        expect(page1.map((t) => t.turn_id)).toEqual(["t6", "t5", "t4"]);
-        expect(page2.map((t) => t.turn_id)).toEqual(["t3", "t2", "t1"]);
-        expect(page3.map((t) => t.turn_id)).toEqual(["t0"]);
-    });
-    it("filters by fromTs / toTs (inclusive)", async () => {
-        await store.upsertTurn(turn({ turn_id: "a", started_at: 100 }));
-        await store.upsertTurn(turn({ turn_id: "b", started_at: 500 }));
-        await store.upsertTurn(turn({ turn_id: "c", started_at: 900 }));
-        const within = await store.listTurns({ fromTs: 200, toTs: 800 });
-        expect(within.map((t) => t.turn_id)).toEqual(["b"]);
-    });
-    it("filters by query — case-insensitive substring on title", async () => {
-        await store.upsertTurn(turn({ turn_id: "a", title: "Refactor Auth Middleware" }));
-        await store.upsertTurn(turn({ turn_id: "b", title: "Payments cleanup" }));
-        await store.upsertTurn(turn({ turn_id: "c", title: "auth follow-up" }));
-        const hits = await store.listTurns({ query: "auth" });
-        expect(hits.map((t) => t.turn_id).sort()).toEqual(["a", "c"]);
-    });
-    it("query escapes regex metacharacters in the user input", async () => {
-        await store.upsertTurn(turn({ turn_id: "a", title: "fix [bug] in handler" }));
-        await store.upsertTurn(turn({ turn_id: "b", title: "fix bug" }));
-        const hits = await store.listTurns({ query: "[bug]" });
-        expect(hits.map((t) => t.turn_id)).toEqual(["a"]);
-    });
-    it("countTurns mirrors the same filter semantics", async () => {
-        await store.upsertTurn(turn({ turn_id: "a", session_id: "s1", started_at: 100 }));
-        await store.upsertTurn(turn({ turn_id: "b", session_id: "s1", started_at: 200 }));
-        await store.upsertTurn(turn({ turn_id: "c", session_id: "s2", started_at: 150 }));
-        expect(await store.countTurns({})).toBe(3);
-        expect(await store.countTurns({ sessionId: "s1" })).toBe(2);
-        expect(await store.countTurns({ fromTs: 110, toTs: 250 })).toBe(2);
-    });
-});
-describe("listSessions", () => {
-    it("aggregates per-session stats and orders by last_seen desc", async () => {
-        await store.upsertTurn(turn({
-            turn_id: "x1",
-            session_id: "sa",
-            started_at: 100,
-            ended_at: 200,
-            edit_count: 1,
-            file_count: 2,
-        }));
-        await store.upsertTurn(turn({
-            turn_id: "x2",
-            session_id: "sa",
-            started_at: 300,
-            ended_at: 400,
-            edit_count: 2,
-            file_count: 3,
-        }));
-        await store.upsertTurn(turn({
-            turn_id: "x3",
-            session_id: "sb",
-            started_at: 500,
-            ended_at: 600,
-            edit_count: 1,
-            file_count: 1,
-        }));
-        const list = await store.listSessions();
-        expect(list.map((s) => s.session_id)).toEqual(["sb", "sa"]);
-        const sa = list.find((s) => s.session_id === "sa");
-        expect(sa.turn_count).toBe(2);
-        expect(sa.edit_count).toBe(3);
-        expect(sa.first_seen).toBe(100);
-        expect(sa.last_seen).toBe(400);
-    });
-});
-describe("getActivityBuckets", () => {
-    it("fills the requested range with zero days and counts turns per bucket", async () => {
-        const day = 24 * 60 * 60_000;
-        const t0 = day; // bucket-aligned for predictability
-        await store.upsertTurn(turn({
-            turn_id: "a",
-            started_at: t0,
-            ended_at: t0 + 5_000,
-            edit_count: 1,
-            tool_count: 4,
-        }));
-        await store.upsertTurn(turn({
-            turn_id: "b",
-            started_at: t0 + day + 1_000,
-            ended_at: t0 + day + 5_000,
-            edit_count: 3,
-            tool_count: 7,
-        }));
-        const buckets = await store.getActivityBuckets({
-            fromTs: t0,
-            toTs: t0 + 3 * day,
-            bucketMs: day,
-        });
-        expect(buckets).toHaveLength(4);
-        expect(buckets[0]?.turns).toBe(1);
-        expect(buckets[1]?.turns).toBe(1);
-        expect(buckets[1]?.edits).toBe(3);
-        expect(buckets[1]?.tools).toBe(7);
-        expect(buckets[2]?.turns).toBe(0);
-        expect(buckets[3]?.turns).toBe(0);
-    });
-});
-describe("HTTP routes — pagination + sessions + heatmap", () => {
-    it("GET /turns returns paginated envelope (total, returned, offset, limit)", async () => {
-        for (let i = 0; i < 5; i++) {
-            await store.upsertTurn(turn({ turn_id: `r${i}`, started_at: 1000 + i * 1000 }));
-        }
-        const app = createTimelineRoutes({ store });
-        const res = await app.request("/turns?limit=2&offset=2");
-        const body = (await res.json());
-        expect(body.total).toBe(5);
-        expect(body.returned).toBe(2);
-        expect(body.offset).toBe(2);
-        expect(body.limit).toBe(2);
-        expect(body.data.map((t) => t.turn_id)).toEqual(["r2", "r1"]);
-    });
-    it("GET /turns?q= performs a substring search", async () => {
-        await store.upsertTurn(turn({ turn_id: "a", title: "Auth refactor" }));
-        await store.upsertTurn(turn({ turn_id: "b", title: "Payments" }));
-        const app = createTimelineRoutes({ store });
-        const res = await app.request("/turns?q=auth");
-        const body = (await res.json());
-        expect(body.total).toBe(1);
-        expect(body.data[0]?.turn_id).toBe("a");
-    });
-    it("GET /sessions returns the aggregated session list", async () => {
-        await store.upsertTurn(turn({ turn_id: "x", session_id: "sa", started_at: 100, ended_at: 200 }));
-        const app = createTimelineRoutes({ store });
-        const res = await app.request("/sessions");
-        const body = (await res.json());
-        expect(body.data).toHaveLength(1);
-        expect(body.data[0]?.session_id).toBe("sa");
-        expect(body.data[0]?.turn_count).toBe(1);
-    });
-    it("GET /heatmap returns the requested number of buckets", async () => {
-        const app = createTimelineRoutes({ store });
-        const res = await app.request("/heatmap?days=7");
-        const body = (await res.json());
-        expect(body.data.length).toBe(7);
-    });
-});

package/dist/__tests__/timeline-markers.test.js

@@ -1,151 +0,0 @@
-/**
- * ST-2a: timeline marker tool handlers.
- * Verifies dual-write (ledger + timeline.db.markers), validation, and turn
- * stamping inheritance from the segmenter.
- */
-import { mkdirSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { CozoTimelineStore } from "../timeline/timeline-store.js";
-import { MARKER_TOOLS, handleMarkerCall, isMarkerTool, } from "../tools/intelligence/timeline-markers.js";
-import { ShadowLedger } from "../tracking/shadow-ledger.js";
-let tempDir;
-let unerrDir;
-let ledger;
-let store;
-beforeEach(async () => {
-    tempDir = join(tmpdir(), `unerr-mk-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    unerrDir = join(tempDir, ".unerr");
-    mkdirSync(unerrDir, { recursive: true });
-    ledger = new ShadowLedger(unerrDir);
-    store = await CozoTimelineStore.create(tempDir);
-});
-afterEach(() => {
-    try {
-        store.close();
-    }
-    catch {
-        /* ignore */
-    }
-    try {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        /* ignore */
-    }
-});
-describe("isMarkerTool / MARKER_TOOLS", () => {
-    it("recognises all four marker names", () => {
-        expect(MARKER_TOOLS).toEqual([
-            "mark_intent",
-            "mark_decision",
-            "mark_blocker",
-            "mark_resolution",
-        ]);
-        for (const t of MARKER_TOOLS) {
-            expect(isMarkerTool(t)).toBe(true);
-        }
-        expect(isMarkerTool("file_read")).toBe(false);
-        expect(isMarkerTool("mark_anything_else")).toBe(false);
-    });
-});
-describe("handleMarkerCall — happy paths", () => {
-    it("mark_intent writes a ledger row AND a markers row", async () => {
-        const res = await handleMarkerCall("mark_intent", { text: "refactor auth" }, { ledger, store, branch: "main", headSha: "deadbeef" });
-        const body = JSON.parse(res.content[0].text);
-        expect(body.ok).toBe(true);
-        expect(body.type).toBe("mark_intent");
-        expect(body.marker_id).toMatch(/^[a-f0-9]{12}$/);
-        expect(body.turn_id).toMatch(/^[a-f0-9]{12}$/);
-        // Ledger row
-        const ledgerLines = readFileSync(join(unerrDir, "ledger", "shadow.jsonl"), "utf-8")
-            .trim()
-            .split("\n")
-            .map((l) => JSON.parse(l));
-        expect(ledgerLines).toHaveLength(1);
-        expect(ledgerLines[0].tool).toBe("mark_intent");
-        expect(ledgerLines[0].args_summary.text).toBe("refactor auth");
-        expect(ledgerLines[0].turn_id).toBe(body.turn_id);
-        // Timeline.db row
-        const markers = await store.listMarkers();
-        expect(markers).toHaveLength(1);
-        expect(markers[0].marker_id).toBe(body.marker_id);
-        expect(markers[0].type).toBe("mark_intent");
-        expect(markers[0].text).toBe("refactor auth");
-        expect(markers[0].turn_id).toBe(body.turn_id);
-    });
-    it("mark_decision persists alternatives (capped)", async () => {
-        await handleMarkerCall("mark_decision", {
-            text: "JWT over session cookies",
-            alternatives: ["session cookies", "OAuth proxy", "API tokens"],
-        }, { ledger, store, branch: "main", headSha: "x" });
-        const lines = readFileSync(join(unerrDir, "ledger", "shadow.jsonl"), "utf-8")
-            .trim()
-            .split("\n")
-            .map((l) => JSON.parse(l));
-        expect(lines[0].args_summary.alternatives).toEqual([
-            "session cookies",
-            "OAuth proxy",
-            "API tokens",
-        ]);
-    });
-    it("mark_blocker carries file_path through to timeline.db", async () => {
-        const res = await handleMarkerCall("mark_blocker", { text: "type error in verify", file_path: "src/auth/token.ts" }, { ledger, store, branch: "main", headSha: "x" });
-        const body = JSON.parse(res.content[0].text);
-        const markers = await store.listMarkers({ type: "mark_blocker" });
-        expect(markers).toHaveLength(1);
-        expect(markers[0].marker_id).toBe(body.marker_id);
-        expect(markers[0].file_path).toBe("src/auth/token.ts");
-    });
-    it("redacts secrets in BOTH the ledger row AND the timeline.db markers row", async () => {
-        // Regression — live test on 2026-05-12 found the redactor only ran on
-        // shadow.jsonl; raw tokens leaked into timeline.db.markers.text.
-        const tokenish = "GITHUB_TOKEN=ghp_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
-        const res = await handleMarkerCall("mark_blocker", { text: `auth fails when ${tokenish} is set`, file_path: "src/auth.ts" }, { ledger, store, branch: "main", headSha: "x" });
-        const body = JSON.parse(res.content[0].text);
-        expect(body.ok).toBe(true);
-        // Ledger redacted
-        const ledgerLines = readFileSync(join(unerrDir, "ledger", "shadow.jsonl"), "utf-8")
-            .trim()
-            .split("\n")
-            .map((l) => JSON.parse(l));
-        const ledgerRow = ledgerLines.find((r) => r.id === body.marker_id);
-        expect(ledgerRow.args_summary.text).not.toContain("ghp_");
-        expect(ledgerRow.args_summary.text).toContain("<redacted>");
-        // Timeline.db markers row also redacted (the bug)
-        const markers = await store.listMarkers({ type: "mark_blocker" });
-        const row = markers.find((m) => m.marker_id === body.marker_id);
-        expect(row).toBeDefined();
-        expect(row.text).not.toContain("ghp_");
-        expect(row.text).toContain("<redacted>");
-    });
-    it("mark_resolution links to blocker via blocker_ref", async () => {
-        const blocker = await handleMarkerCall("mark_blocker", { text: "type error" }, { ledger, store, branch: "main", headSha: "x" });
-        const blockerId = JSON.parse(blocker.content[0].text).marker_id;
-        const res = await handleMarkerCall("mark_resolution", { blocker_ref: blockerId, text: "fixed by import bump" }, { ledger, store, branch: "main", headSha: "x" });
-        const body = JSON.parse(res.content[0].text);
-        expect(body.ok).toBe(true);
-        const resolutions = await store.listMarkers({ type: "mark_resolution" });
-        expect(resolutions).toHaveLength(1);
-        expect(resolutions[0].blocker_ref).toBe(blockerId);
-    });
-});
-describe("handleMarkerCall — validation", () => {
-    it("rejects empty text", async () => {
-        const res = await handleMarkerCall("mark_intent", { text: "   " }, { ledger, store, branch: "main", headSha: "x" });
-        const body = JSON.parse(res.content[0].text);
-        expect(body.error).toMatch(/required/);
-    });
-    it("rejects over-cap text per tool", async () => {
-        const long = "x".repeat(200);
-        const res = await handleMarkerCall("mark_intent", { text: long }, { ledger, store, branch: "main", headSha: "x" });
-        const body = JSON.parse(res.content[0].text);
-        expect(body.error).toMatch(/80/);
-    });
-    it("mark_resolution requires blocker_ref", async () => {
-        const res = await handleMarkerCall("mark_resolution", { text: "fixed" }, { ledger, store, branch: "main", headSha: "x" });
-        const body = JSON.parse(res.content[0].text);
-        expect(body.error).toMatch(/blocker_ref required/);
-    });
-});

package/dist/__tests__/timeline-routes.test.js

@@ -1,156 +0,0 @@
-/**
- * ST-3b: Timeline HTTP routes — smoke test against the Hono app.
- */
-import { mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createTimelineRoutes } from "../server/routes/timeline.js";
-import { CozoTimelineStore } from "../timeline/timeline-store.js";
-let tempDir;
-let store;
-beforeEach(async () => {
-    tempDir = join(tmpdir(), `unerr-rt-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(join(tempDir, ".unerr"), { recursive: true });
-    store = await CozoTimelineStore.create(tempDir);
-});
-afterEach(() => {
-    try {
-        store.close();
-    }
-    catch {
-        /* ignore */
-    }
-    try {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        /* ignore */
-    }
-});
-async function jsonOf(res) {
-    return await res.json();
-}
-describe("Timeline routes", () => {
-    it("GET /health reports the db path", async () => {
-        const app = createTimelineRoutes({ store });
-        const res = await app.request("/health");
-        expect(res.status).toBe(200);
-        const body = (await jsonOf(res));
-        expect(body.data.ok).toBe(true);
-        expect(body.data.db_path).toBe(store.dbPath);
-    });
-    it("GET /turns returns turns in newest-first order", async () => {
-        await store.upsertTurn({
-            turn_id: "t1",
-            session_id: "s1",
-            started_at: 100,
-            ended_at: 200,
-            opened_by: "first_call",
-            closed_reason: "session_end",
-            tool_count: 2,
-            file_count: 1,
-            edit_count: 0,
-            title: "early",
-            outcome: "unknown",
-        });
-        await store.upsertTurn({
-            turn_id: "t2",
-            session_id: "s1",
-            started_at: 300,
-            ended_at: 400,
-            opened_by: "idle_gap",
-            closed_reason: "idle_gap",
-            tool_count: 5,
-            file_count: 2,
-            edit_count: 1,
-            title: "late",
-            outcome: "unknown",
-        });
-        const app = createTimelineRoutes({ store });
-        const res = await app.request("/turns");
-        const body = (await jsonOf(res));
-        expect(body.data.map((t) => t.turn_id)).toEqual(["t2", "t1"]);
-    });
-    it("GET /loops uses the ledger getter for live detection", async () => {
-        const t = (offsetSec) => new Date(Date.parse("2026-05-12T10:00:00Z") + offsetSec * 1000).toISOString();
-        let id = 0;
-        const make = (tool, file, ts) => {
-            id += 1;
-            return {
-                id: `e${id}`,
-                ts,
-                tool,
-                args_summary: { file_path: file },
-                result_summary: {},
-                branch: "main",
-                head_sha: "x",
-                session_id: "s1",
-                correlation_id: null,
-            };
-        };
-        const entries = [
-            make("file_read", "a.ts", t(0)),
-            make("file_read", "a.ts", t(10)),
-            make("file_read", "a.ts", t(20)),
-            make("file_read", "a.ts", t(30)),
-            make("file_read", "a.ts", t(40)),
-        ];
-        const app = createTimelineRoutes({
-            store,
-            getRecentLedgerEntries: () => entries,
-        });
-        const res = await app.request("/loops");
-        const body = (await jsonOf(res));
-        expect(body.data).toHaveLength(1);
-        expect(body.data[0]?.kind).toBe("file_reread");
-    });
-    it("GET /resume returns null when no recent turn exists", async () => {
-        const app = createTimelineRoutes({ store });
-        const res = await app.request("/resume");
-        const body = (await jsonOf(res));
-        expect(body.data).toBeNull();
-    });
-    it("GET /resume surfaces dominant intent + open blockers for the latest fresh turn", async () => {
-        const now = Date.now();
-        await store.upsertTurn({
-            turn_id: "tx",
-            session_id: "sx",
-            started_at: now - 60_000,
-            ended_at: now - 30_000,
-            opened_by: "first_call",
-            closed_reason: "session_end",
-            tool_count: 3,
-            file_count: 1,
-            edit_count: 0,
-            title: "auth refactor",
-            outcome: "unknown",
-        });
-        await store.insertMarker({
-            marker_id: "i1",
-            type: "mark_intent",
-            text: "harden auth flow",
-            session_id: "sx",
-            turn_id: "tx",
-            ts: now - 50_000,
-            blocker_ref: "",
-            file_path: "",
-        });
-        await store.insertMarker({
-            marker_id: "b1",
-            type: "mark_blocker",
-            text: "type error in verify",
-            session_id: "sx",
-            turn_id: "tx",
-            ts: now - 40_000,
-            blocker_ref: "",
-            file_path: "src/auth.ts",
-        });
-        const app = createTimelineRoutes({ store });
-        const res = await app.request("/resume");
-        const body = (await jsonOf(res));
-        expect(body.data.intent).toBe("harden auth flow");
-        expect(body.data.session_id).toBe("sx");
-        expect(body.data.open_threads.map((t) => t.text)).toContain("type error in verify");
-    });
-});

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

@@ -1,171 +0,0 @@
-/**
- * ST-1b: CozoTimelineStore — third CozoDB instance at `.unerr/timeline.db`.
- * Tests cover open/init, idempotence, and round-trip CRUD on turns + markers.
- */
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { CozoTimelineStore, } from "../timeline/timeline-store.js";
-let tempDir;
-beforeEach(() => {
-    tempDir = join(tmpdir(), `unerr-tl-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(tempDir, { recursive: true });
-});
-afterEach(() => {
-    try {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        /* ignore */
-    }
-});
-function makeTurn(overrides = {}) {
-    return {
-        turn_id: overrides.turn_id ?? "t1",
-        session_id: overrides.session_id ?? "s1",
-        started_at: overrides.started_at ?? 1000,
-        ended_at: overrides.ended_at ?? 2000,
-        opened_by: overrides.opened_by ?? "first_call",
-        closed_reason: overrides.closed_reason ?? "session_end",
-        tool_count: overrides.tool_count ?? 3,
-        file_count: overrides.file_count ?? 2,
-        edit_count: overrides.edit_count ?? 1,
-        title: overrides.title ?? "",
-        outcome: overrides.outcome ?? "unknown",
-    };
-}
-function makeMarker(overrides = {}) {
-    return {
-        marker_id: overrides.marker_id ?? "m1",
-        type: overrides.type ?? "mark_intent",
-        text: overrides.text ?? "refactor auth",
-        session_id: overrides.session_id ?? "s1",
-        turn_id: overrides.turn_id ?? "t1",
-        ts: overrides.ts ?? 1500,
-        blocker_ref: overrides.blocker_ref ?? "",
-        file_path: overrides.file_path ?? "",
-    };
-}
-describe("CozoTimelineStore", () => {
-    it("creates .unerr/timeline.db on first call and reports isNew=true", async () => {
-        const store = await CozoTimelineStore.create(tempDir);
-        try {
-            expect(store.isNew).toBe(true);
-            expect(store.dbPath).toBe(join(tempDir, ".unerr", "timeline.db"));
-            expect(existsSync(store.dbPath)).toBe(true);
-        }
-        finally {
-            store.close();
-        }
-    });
-    it("second create on the same path reports isNew=false and schema-init is idempotent", async () => {
-        const a = await CozoTimelineStore.create(tempDir);
-        a.close();
-        const b = await CozoTimelineStore.create(tempDir);
-        try {
-            expect(b.isNew).toBe(false);
-        }
-        finally {
-            b.close();
-        }
-    });
-    it("initialises all six expected relations", async () => {
-        const store = await CozoTimelineStore.create(tempDir);
-        try {
-            const rels = await store.getDb().run("::relations");
-            const names = new Set(rels.rows.map((r) => r[0]));
-            for (const expected of [
-                "turns",
-                "intents",
-                "intent_sessions",
-                "markers",
-                "derived_signals",
-                "signal_reinforcement",
-            ]) {
-                expect(names.has(expected)).toBe(true);
-            }
-        }
-        finally {
-            store.close();
-        }
-    });
-    it("round-trips a turn through upsertTurn → listTurns", async () => {
-        const store = await CozoTimelineStore.create(tempDir);
-        try {
-            const turn = makeTurn({ title: "auth refactor" });
-            await store.upsertTurn(turn);
-            const list = await store.listTurns();
-            expect(list).toHaveLength(1);
-            expect(list[0]?.turn_id).toBe(turn.turn_id);
-            expect(list[0]?.title).toBe("auth refactor");
-            expect(list[0]?.opened_by).toBe("first_call");
-        }
-        finally {
-            store.close();
-        }
-    });
-    it("upsertTurn replaces an existing turn with the same id", async () => {
-        const store = await CozoTimelineStore.create(tempDir);
-        try {
-            await store.upsertTurn(makeTurn({ title: "v1", tool_count: 1 }));
-            await store.upsertTurn(makeTurn({ title: "v2", tool_count: 5 }));
-            const list = await store.listTurns();
-            expect(list).toHaveLength(1);
-            expect(list[0]?.title).toBe("v2");
-            expect(list[0]?.tool_count).toBe(5);
-        }
-        finally {
-            store.close();
-        }
-    });
-    it("listTurns filters by session and orders newest-first", async () => {
-        const store = await CozoTimelineStore.create(tempDir);
-        try {
-            await store.upsertTurn(makeTurn({ turn_id: "t1", session_id: "a", started_at: 100 }));
-            await store.upsertTurn(makeTurn({ turn_id: "t2", session_id: "a", started_at: 200 }));
-            await store.upsertTurn(makeTurn({ turn_id: "t3", session_id: "b", started_at: 150 }));
-            const inA = await store.listTurns({ sessionId: "a" });
-            expect(inA.map((t) => t.turn_id)).toEqual(["t2", "t1"]);
-            const all = await store.listTurns();
-            expect(all.map((t) => t.turn_id)).toEqual(["t2", "t3", "t1"]);
-        }
-        finally {
-            store.close();
-        }
-    });
-    it("round-trips markers through insertMarker → listMarkers with type filter", async () => {
-        const store = await CozoTimelineStore.create(tempDir);
-        try {
-            await store.insertMarker(makeMarker({
-                marker_id: "m1",
-                type: "mark_intent",
-                text: "auth",
-                ts: 100,
-            }));
-            await store.insertMarker(makeMarker({
-                marker_id: "m2",
-                type: "mark_blocker",
-                text: "type error",
-                ts: 200,
-            }));
-            await store.insertMarker(makeMarker({
-                marker_id: "m3",
-                type: "mark_resolution",
-                text: "fixed",
-                ts: 300,
-                blocker_ref: "m2",
-            }));
-            const all = await store.listMarkers();
-            expect(all.map((m) => m.marker_id)).toEqual(["m3", "m2", "m1"]);
-            const blockers = await store.listMarkers({ type: "mark_blocker" });
-            expect(blockers).toHaveLength(1);
-            expect(blockers[0]?.text).toBe("type error");
-            const resolutions = await store.listMarkers({ type: "mark_resolution" });
-            expect(resolutions[0]?.blocker_ref).toBe("m2");
-        }
-        finally {
-            store.close();
-        }
-    });
-});