@unerr-ai/unerr 0.1.0 → 0.1.2

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

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

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

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

@@ -0,0 +1,171 @@
+/**
+ * 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();
+        }
+    });
+});