pi-mega-compact 0.11.3 → 0.11.5

package/dist/src/store/sqlite/global-index.test.js

@@ -1,136 +0,0 @@
-/**
- * global-index.test.ts — S39 session heartbeats + token_samples round-trip.
- *
- * Verifies recordSessionHeartbeat + appendTokenSample + readActiveSessions +
- * readSessionTimeseries + pruneStaleSessions + pruneTokenSamples +
- * clearSessionHeartbeat, with particular focus on the Step 5 events.log
- * session_sample JSONL line shape (the SSE real-time push wire format).
- *
- * Pi-agnostic. Uses an isolated mock index dir (never the real user
- * `~/.mega-compact-index/` — guardrail G7). PREVENT-PI-004 (zero network):
- * every operation is local SQLite + local FS append.
- */
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert/strict";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { mkdtempSync, rmSync, readFileSync, existsSync } from "node:fs";
-import { recordSessionHeartbeat, appendTokenSample, readActiveSessions, readSessionTimeseries, pruneStaleSessions, pruneTokenSamples, clearSessionHeartbeat, closeIndexStore, } from "./global-index.js";
-describe("global-index session time-series (S39)", () => {
-    let indexDir;
-    let eventsLogPath;
-    before(() => {
-        indexDir = mkdtempSync(join(tmpdir(), "mc-global-idx-"));
-        eventsLogPath = join(indexDir, "events.log");
-    });
-    after(() => {
-        closeIndexStore();
-        rmSync(indexDir, { recursive: true, force: true });
-    });
-    it("recordSessionHeartbeat + readActiveSessions: heartbeat row appears", () => {
-        recordSessionHeartbeat(12_345, "sess-abc-1", "/home/u/repos/proj-a", "/home/u/.pi/state-a", 200_000, indexDir);
-        const sessions = readActiveSessions(indexDir);
-        assert.equal(sessions.length, 1);
-        const s = sessions[0];
-        assert.equal(s.pid, 12_345);
-        assert.equal(s.sessionId, "sess-abc-1");
-        assert.equal(s.repoRoot, "/home/u/repos/proj-a");
-        assert.equal(s.stateDir, "/home/u/.pi/state-a");
-        assert.equal(s.ctxWindow, 200_000);
-        assert.ok(s.lastSeen > 0);
-        // No token sample yet → tokens/percent are null.
-        assert.equal(s.tokens, null);
-        assert.equal(s.percent, null);
-    });
-    it("appendTokenSample writes a token_samples row + a session_sample JSONL line", () => {
-        appendTokenSample("sess-abc-1", "/home/u/repos/proj-a", 42_000, 21.5, 200_000, eventsLogPath, indexDir);
-        // The token_samples row should now be the latest sample for this session.
-        const sessions = readActiveSessions(indexDir);
-        const s = sessions.find((x) => x.sessionId === "sess-abc-1");
-        assert.ok(s, "session must still appear in readActiveSessions");
-        assert.equal(s.tokens, 42_000);
-        assert.equal(s.percent, 21.5);
-        // The events.log JSONL line should exist and match the wire format
-        // described by the SseSessionSample contract: an object with `ts`
-        // (ISO 8601 string), `type: 'session_sample'`, and the payload fields.
-        assert.ok(existsSync(eventsLogPath), "events.log should exist");
-        const lines = readFileSync(eventsLogPath, "utf-8")
-            .trim()
-            .split("\n")
-            .filter(Boolean);
-        assert.equal(lines.length, 1, "exactly one JSONL line expected");
-        const parsed = JSON.parse(lines[0]);
-        assert.equal(parsed["type"], "session_sample");
-        assert.equal(parsed["sessionId"], "sess-abc-1");
-        assert.equal(parsed["tokens"], 42_000);
-        assert.equal(parsed["percent"], 21.5);
-        // Step 5 contract mirroring: `ts` is an ISO 8601 string (matches every
-        // other SseEvent variant's `ts: string` and the DashboardEmitter
-        // events.log pattern), NOT a numeric ms value.
-        assert.equal(typeof parsed["ts"], "string", "ts must be an ISO 8601 string (matches other SseEvent variants)");
-        // Must be ISO-parseable (NaN if invalid → typeof won't be number).
-        const tsMs = Date.parse(parsed["ts"]);
-        assert.ok(Number.isFinite(tsMs), "ts must be a valid ISO 8601 timestamp");
-        // And recent (within the last 5s).
-        assert.ok(Math.abs(Date.now() - tsMs) < 5_000, "ts must be within ~5s of now");
-    });
-    it("readSessionTimeseries returns per-session series + totals in chronological order", () => {
-        // Two sessions, two samples each — fully within the rolling window.
-        // sess-xyz-9 needs its own heartbeat row so readActiveSessions can later
-        // surface it (heartbeats are the primary key, not the samples).
-        recordSessionHeartbeat(67_890, "sess-xyz-9", "/home/u/repos/proj-b", "/home/u/.pi/state-b", 200_000, indexDir);
-        appendTokenSample("sess-abc-1", "/home/u/repos/proj-a", 50_000, 25, 200_000, null, // no events.log line for this assertion
-        indexDir);
-        appendTokenSample("sess-xyz-9", "/home/u/repos/proj-b", 10_000, 5, 200_000, null, indexDir);
-        appendTokenSample("sess-xyz-9", "/home/u/repos/proj-b", 30_000, 15, 200_000, null, indexDir);
-        const since = Date.now() - 60_000;
-        const result = readSessionTimeseries(since, indexDir);
-        const seriesIds = result.series.map((s) => s.sessionId).sort();
-        assert.deepEqual(seriesIds, ["sess-abc-1", "sess-xyz-9"]);
-        const xyz = result.series.find((s) => s.sessionId === "sess-xyz-9");
-        assert.ok(xyz, "sess-xyz-9 series must exist");
-        assert.equal(xyz.data.length, 2);
-        assert.equal(xyz.data[0].tokens, 10_000);
-        assert.equal(xyz.data[1].tokens, 30_000);
-        // Stable hash-based color from the SESSION_COLORS palette.
-        assert.match(xyz.color, /^#[0-9a-f]{6}$/i);
-        // Totals: each timestamp summed across sessions.
-        assert.ok(result.totals.length >= 2);
-        for (const t of result.totals) {
-            assert.ok(typeof t.ts === "number" && t.ts > 0);
-            assert.ok(typeof t.tokens === "number" && t.tokens >= 0);
-        }
-        // Totals are sorted ascending by ts.
-        for (let i = 1; i < result.totals.length; i++) {
-            assert.ok(result.totals[i].ts >= result.totals[i - 1].ts, "totals must be chronologically ascending");
-        }
-    });
-    it("pruneStaleSessions clears heartbeats older than the cutoff (and only those)", () => {
-        // At this point we have 2 sessions; both are fresh (lastSeen ≈ now).
-        const beforeCount = readActiveSessions(indexDir).length;
-        assert.equal(beforeCount, 2);
-        // With a 0 ms cutoff, both are stale → pruned.
-        const pruned = pruneStaleSessions(0, indexDir);
-        assert.equal(pruned, 2, "both heartbeats should be pruned");
-        assert.equal(readActiveSessions(indexDir).length, 0);
-    });
-    it("pruneTokenSamples clears token_samples older than the cutoff", () => {
-        // Re-seed two samples; the previously-written ones were for two
-        // sessions (sess-abc-1 + sess-xyz-9). The prunedStaleSessions call
-        // above left token_samples untouched (separate table).
-        const sinceBefore = Date.now() - 60_000;
-        const before = readSessionTimeseries(sinceBefore, indexDir);
-        const beforeCount = before.series.reduce((n, s) => n + s.data.length, 0);
-        assert.ok(beforeCount >= 3, "expected to find the seeded samples");
-        const npurged = pruneTokenSamples(0, indexDir);
-        assert.ok(npurged >= 3, "should have pruned the seeded samples");
-        const after = readSessionTimeseries(sinceBefore, indexDir);
-        const afterCount = after.series.reduce((n, s) => n + s.data.length, 0);
-        assert.equal(afterCount, 0, "no samples should remain after pruning");
-    });
-    it("clearSessionHeartbeat is a no-op on missing rows (never throws)", () => {
-        const before = readActiveSessions(indexDir).length;
-        assert.doesNotThrow(() => clearSessionHeartbeat(99_999, "nonexistent-session", indexDir));
-        assert.equal(readActiveSessions(indexDir).length, before);
-    });
-});

package/dist/src/store/sqlite/mechanical-fix.test.js

@@ -1,146 +0,0 @@
-/**
- * mechanical-fix.test.ts — focused unit tests for the SQLite-side mechanical-fix
- * batch: safeJson (utils.ts), storeStats numeric MAX + dedup_status filter
- * (stats.ts), addTokensSaved CAST AS REAL (meta.ts), evictMemoryLru named
- * @param bindings (memories.ts). Pi-agnostic; uses isolated state dirs (G7).
- */
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert/strict";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { mkdtempSync, rmSync } from "node:fs";
-import { safeJson, closeStore } from "./utils.js";
-import { storeStats } from "./stats.js";
-import { upsertCheckpoint, setDedupStatus } from "./checkpoints.js";
-import { addTokensSaved, getTokensSaved } from "./meta.js";
-import { addMemory, listMemories } from "./memories.js";
-function makeCp(id, sessionId) {
-    return {
-        checkpointId: id,
-        sessionId,
-        summary: `summary-${id}`,
-        keyDecisions: [],
-        nextSteps: [],
-        filesModified: [],
-        tokenEstimate: 100,
-        regionHash: `hash-${id}`,
-        embedding: [],
-        timestamp: Date.now(),
-    };
-}
-// ---------------------------------------------------------------------------
-// safeJson (utils.ts)
-// ---------------------------------------------------------------------------
-describe("mechanical-fix: safeJson (utils.ts)", () => {
-    it("returns fallback on null, undefined, empty, and corrupt JSON", () => {
-        assert.deepEqual(safeJson(null, []), []);
-        assert.deepEqual(safeJson(undefined, []), []);
-        assert.deepEqual(safeJson("", []), []);
-        assert.deepEqual(safeJson("not json", ["fb"]), ["fb"]);
-        assert.deepEqual(safeJson('["a","b"]', []), ["a", "b"]);
-        assert.equal(safeJson(null, 42), 42);
-        assert.deepEqual(safeJson('{"k":1}', {}), { k: 1 });
-    });
-});
-// ---------------------------------------------------------------------------
-// storeStats (stats.ts) — numeric MAX(id) + dedup_status filter
-// ---------------------------------------------------------------------------
-describe("mechanical-fix: storeStats (stats.ts)", () => {
-    let dir;
-    before(() => {
-        dir = mkdtempSync(join(tmpdir(), "mc-mech-stats-"));
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-    });
-    after(() => {
-        closeStore(dir);
-        delete process.env.MEGACOMPACT_STATE_DIR;
-        rmSync(dir, { recursive: true, force: true });
-    });
-    it("returns numerically-max checkpoint id (not lexicographic) for 100+ checkpoints", () => {
-        const sid = "sess_stats";
-        // Insert chkpt_001..chkpt_100 (100 checkpoints) + chkpt_999 + chkpt_1000.
-        // Numeric max = 1000 → "chkpt_1000"; lexicographic max would be "chkpt_999"
-        // (because '9' > '1' at position 6 when comparing 8 vs 9-char strings).
-        for (let i = 1; i <= 100; i++) {
-            upsertCheckpoint(makeCp(`chkpt_${String(i).padStart(3, "0")}`, sid), dir);
-        }
-        upsertCheckpoint(makeCp("chkpt_999", sid), dir);
-        upsertCheckpoint(makeCp("chkpt_1000", sid), dir);
-        const s = storeStats(sid, dir);
-        assert.equal(s.checkpointCount, 102);
-        assert.equal(s.lastCheckpointId, "chkpt_1000");
-        assert.equal(s.lastSummary, "summary-chkpt_1000");
-    });
-    it("excludes dedup_status='removed' rows from counts", () => {
-        const sid = "sess_dedup";
-        upsertCheckpoint(makeCp("chkpt_001", sid), dir);
-        upsertCheckpoint(makeCp("chkpt_002", sid), dir);
-        setDedupStatus("chkpt_001", sid, "removed", dir);
-        const s = storeStats(sid, dir);
-        assert.equal(s.checkpointCount, 1);
-        assert.equal(s.lastCheckpointId, "chkpt_002");
-    });
-});
-// ---------------------------------------------------------------------------
-// addTokensSaved (meta.ts) — CAST AS REAL preserves fractional values
-// ---------------------------------------------------------------------------
-describe("mechanical-fix: addTokensSaved (meta.ts)", () => {
-    let dir;
-    before(() => {
-        dir = mkdtempSync(join(tmpdir(), "mc-mech-meta-"));
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-    });
-    after(() => {
-        closeStore(dir);
-        delete process.env.MEGACOMPACT_STATE_DIR;
-        rmSync(dir, { recursive: true, force: true });
-    });
-    it("preserves fractional values (CAST AS REAL, not INTEGER)", () => {
-        addTokensSaved(10.5, dir);
-        assert.equal(getTokensSaved(dir), 10.5);
-        addTokensSaved(10.5, dir);
-        // With INTEGER: CAST("10.5" AS INTEGER)=10, 10+10.5=20.5.
-        // With REAL: CAST("10.5" AS REAL)=10.5, 10.5+10.5=21.
-        assert.equal(getTokensSaved(dir), 21);
-    });
-});
-// ---------------------------------------------------------------------------
-// evictMemoryLru (memories.ts) — named @param bindings
-// ---------------------------------------------------------------------------
-describe("mechanical-fix: evictMemoryLru (memories.ts)", () => {
-    let dir;
-    before(() => {
-        dir = mkdtempSync(join(tmpdir(), "mc-mech-mem-"));
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-        process.env.MEGACOMPACT_MEMORY_MAX_ROWS = "3";
-    });
-    after(() => {
-        closeStore(dir);
-        delete process.env.MEGACOMPACT_STATE_DIR;
-        delete process.env.MEGACOMPACT_MEMORY_MAX_ROWS;
-        rmSync(dir, { recursive: true, force: true });
-    });
-    it("evicts oldest rows past cap (repo-scoped, @repo named binding)", () => {
-        const repo = "test-repo";
-        for (let i = 0; i < 5; i++) {
-            addMemory({ content: `memory-${i}` }, repo, dir);
-        }
-        const memories = listMemories(repo, 100, dir);
-        assert.equal(memories.length, 3);
-        // Oldest two (memory-0, memory-1) evicted; memory-2, 3, 4 survive.
-        const contents = memories.map((m) => m.content).sort();
-        assert.deepEqual(contents, ["memory-2", "memory-3", "memory-4"]);
-    });
-    it("handles null-repo scope (repo IS NULL branch, @over only)", () => {
-        for (let i = 0; i < 4; i++) {
-            addMemory({ content: `nullmem-${i}` }, null, dir);
-        }
-        // listMemories(null, ...) returns ALL rows (no repo filter); narrow to
-        // null-repo rows to verify the IS NULL eviction branch in isolation.
-        const nullMemories = listMemories(null, 100, dir).filter((m) => m.repo === null);
-        assert.equal(nullMemories.length, 3);
-        // Oldest (nullmem-0) evicted.
-        const contents = nullMemories.map((m) => m.content).sort();
-        assert.deepEqual(contents, ["nullmem-1", "nullmem-2", "nullmem-3"]);
-    });
-});

package/dist/src/store/sqlite/perf-samples.test.js

@@ -1,146 +0,0 @@
-/**
- * perf-samples.test.ts — v0.8.8 perf_samples table round-trip + filtering.
- * Pi-agnostic. Uses an isolated state dir (never the real user dir — G7).
- */
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert/strict";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { mkdtempSync, rmSync } from "node:fs";
-import { closeStore } from "./utils.js";
-import { recordPerfSample, readPerfSamples, PERF_KINDS, readProviderCacheLifetime, readLatestCacheHitPct, } from "./perf-samples.js";
-describe("perf-samples (v0.8.8)", () => {
-    let dir;
-    before(() => {
-        dir = mkdtempSync(join(tmpdir(), "mc-perfsamples-"));
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-    });
-    after(() => {
-        closeStore(dir);
-        delete process.env.MEGACOMPACT_STATE_DIR;
-        rmSync(dir, { recursive: true, force: true });
-    });
-    it("records + reads back a turn_latency_ms sample with parsed meta", () => {
-        recordPerfSample(dir, "turn_latency_ms", 123.4, { turnIndex: 2 });
-        const rows = readPerfSamples(dir, 0);
-        assert.equal(rows.length, 1);
-        assert.equal(rows[0].kind, "turn_latency_ms");
-        assert.equal(rows[0].value, 123.4);
-        assert.deepEqual(rows[0].meta, { turnIndex: 2 });
-    });
-    it("filters by kind and by sinceTs", () => {
-        recordPerfSample(dir, "tps", 50);
-        recordPerfSample(dir, "rss_mb", 256);
-        const tps = readPerfSamples(dir, 0, "tps");
-        assert.equal(tps.length, 1);
-        assert.equal(tps[0].kind, "tps");
-        assert.equal(tps[0].value, 50);
-        const future = readPerfSamples(dir, Date.now() + 10000, "tps");
-        assert.equal(future.length, 0);
-    });
-    it("ignores non-finite values + unknown kinds (never throws, nothing added)", () => {
-        const before = readPerfSamples(dir, 0).length;
-        recordPerfSample(dir, "tps", Number.NaN);
-        recordPerfSample(dir, "tps", Infinity);
-        assert.doesNotThrow(() => recordPerfSample(dir, "bogus", 1));
-        const after = readPerfSamples(dir, 0).length;
-        assert.equal(after, before);
-    });
-    it("PERF_KINDS lists the 10 instrumentation kinds", () => {
-        assert.equal(PERF_KINDS.length, 10);
-        assert.ok(PERF_KINDS.includes("db_recompute_ms"));
-        assert.ok(PERF_KINDS.includes("cache_hit_pct"));
-    });
-});
-// ─── Provider cache lifetime aggregate tests (A.4) — each test uses its
-//     own clean stateDir so prior inserts never pollute later assertions. ───
-describe("provider cache lifetime (A.4)", () => {
-    let dir2;
-    function freshDir(prefix) {
-        if (dir2) {
-            closeStore(dir2);
-            rmSync(dir2, { recursive: true, force: true });
-        }
-        dir2 = mkdtempSync(join(tmpdir(), prefix));
-        process.env.MEGACOMPACT_STATE_DIR = dir2;
-    }
-    after(() => {
-        if (dir2) {
-            closeStore(dir2);
-            delete process.env.MEGACOMPACT_STATE_DIR;
-            rmSync(dir2, { recursive: true, force: true });
-        }
-    });
-    it("empty table returns zeros/nulls", () => {
-        freshDir("mc-a4e-");
-        const r = readProviderCacheLifetime(dir2);
-        assert.equal(r.sampleCount, 0);
-        assert.equal(r.avgHitPct, 0);
-        assert.equal(r.totalCacheRead, 0);
-        assert.equal(r.totalCacheWrite, 0);
-        assert.equal(r.totalInput, 0);
-        assert.equal(r.firstSampleAt, null);
-        assert.equal(r.latestSampleAt, null);
-    });
-    it("rows with NULL meta are counted but contribute 0 tokens", () => {
-        freshDir("mc-a4n-");
-        recordPerfSample(dir2, "cache_hit_pct", 50, null);
-        recordPerfSample(dir2, "cache_hit_pct", 60, null);
-        const r = readProviderCacheLifetime(dir2);
-        assert.equal(r.sampleCount, 2);
-        assert.equal(r.totalCacheRead, 0);
-        assert.equal(r.totalCacheWrite, 0);
-        assert.equal(r.totalInput, 0);
-    });
-    it("partial meta — missing keys treated as 0", () => {
-        freshDir("mc-a4p-");
-        recordPerfSample(dir2, "cache_hit_pct", 42, { input: 1000 });
-        const r = readProviderCacheLifetime(dir2);
-        assert.equal(r.sampleCount, 1);
-        assert.equal(r.totalCacheRead, 0);
-        assert.equal(r.totalCacheWrite, 0);
-        assert.equal(r.totalInput, 1000);
-    });
-    it("full rows produce correct sums + avg", () => {
-        freshDir("mc-a4f-");
-        // cacheRead=1000, cacheWrite=500, input=100 → hit% = 1000/1600=62.5%
-        // cacheRead=500, cacheWrite=100, input=400  → hit% = 500/1000=50.0%
-        // cacheRead=100, cacheWrite=200, input=700  → hit% = 100/1000=10.0%
-        recordPerfSample(dir2, "cache_hit_pct", 55, {
-            cacheRead: 1000,
-            cacheWrite: 500,
-            input: 100,
-        });
-        recordPerfSample(dir2, "cache_hit_pct", 56, {
-            cacheRead: 500,
-            cacheWrite: 100,
-            input: 400,
-        });
-        recordPerfSample(dir2, "cache_hit_pct", 57, {
-            cacheRead: 100,
-            cacheWrite: 200,
-            input: 700,
-        });
-        const r = readProviderCacheLifetime(dir2);
-        assert.equal(r.sampleCount, 3);
-        assert.equal(r.totalCacheRead, 1600);
-        assert.equal(r.totalCacheWrite, 800);
-        assert.equal(r.totalInput, 1200);
-        // avg: (62.5 + 50.0 + 10.0) / 3 ≈ 40.833
-        assert.ok(Math.abs(r.avgHitPct - 40.833) < 0.1);
-        assert.ok(r.firstSampleAt != null);
-        assert.ok(r.latestSampleAt != null);
-        assert.ok(new Date(r.firstSampleAt).getTime() <=
-            new Date(r.latestSampleAt).getTime());
-    });
-    it("readLatestCacheHitPct: empty → 0", () => {
-        freshDir("mc-a4le-");
-        assert.equal(readLatestCacheHitPct(dir2), 0);
-    });
-    it("readLatestCacheHitPct: most recent by ts, tie → highest id", () => {
-        freshDir("mc-a4lm-");
-        recordPerfSample(dir2, "cache_hit_pct", 20);
-        recordPerfSample(dir2, "cache_hit_pct", 80);
-        assert.equal(readLatestCacheHitPct(dir2), 80);
-    });
-});

package/dist/src/store/sqlite/raptor.test.js

@@ -1,106 +0,0 @@
-/**
- * raptor.test.ts — regression tests for RAPTOR node persistence.
- *
- * Covers:
- *   1. saveRaptorTree atomicity (withTx + openStore nesting safety): rebuilding
- *      a DIFFERENT tree for the same session leaves no stale nodes from the
- *      first tree.
- *   2. listRaptorNodes robustness: corrupt `children` JSON in a row does not
- *      throw and that row's children come back as [].
- *
- * No network. Uses node:sqlite directly via openStore.
- */
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { openStore, closeStore } from "./utils.js";
-import { saveRaptorTree, listRaptorNodes } from "./raptor.js";
-let tmpDir;
-beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "mc-raptor-persist-"));
-});
-afterEach(() => {
-    closeStore(tmpDir);
-    rmSync(tmpDir, { recursive: true, force: true });
-});
-/** Build a simple tree map with the minimal shape saveRaptorTree expects. */
-function makeTree(nodeSpecs) {
-    const nodes = new Map();
-    for (const spec of nodeSpecs) {
-        nodes.set(spec.id, {
-            id: spec.id,
-            level: spec.level,
-            parentId: spec.level === 0 ? null : "root",
-            children: spec.children,
-            summary: `summary for ${spec.id}`,
-            embedding: [1, 0, 0],
-            qualityMarker: "low",
-            tokenEstimate: 10,
-        });
-    }
-    return { nodes };
-}
-// ── Test 1: rebuild + save a different tree → no stale nodes ──────────────────
-test("saveRaptorTree: rebuilding a different tree for the same session leaves no stale nodes", () => {
-    const sid = "sess_replace";
-    const builtAt1 = 1000;
-    const builtAt2 = 2000;
-    // Tree A: nodes alpha, beta, root.
-    const treeA = makeTree([
-        { id: "alpha", level: 1, children: ["leaf_0", "leaf_1"] },
-        { id: "beta", level: 1, children: ["leaf_2", "leaf_3"] },
-        { id: "root", level: 2, children: ["leaf_0", "leaf_1", "leaf_2", "leaf_3"] },
-    ]);
-    saveRaptorTree(sid, treeA, builtAt1, tmpDir);
-    const afterA = listRaptorNodes(sid, tmpDir);
-    assert.equal(afterA.length, 3, "tree A has 3 nodes");
-    assert.deepEqual(afterA.map((n) => n.id).sort(), ["alpha", "beta", "root"], "tree A node ids match");
-    // Tree B: completely different nodes gamma, delta, root.
-    const treeB = makeTree([
-        { id: "gamma", level: 1, children: ["leaf_4", "leaf_5"] },
-        { id: "delta", level: 1, children: ["leaf_6", "leaf_7"] },
-        { id: "root", level: 2, children: ["leaf_4", "leaf_5", "leaf_6", "leaf_7"] },
-    ]);
-    saveRaptorTree(sid, treeB, builtAt2, tmpDir);
-    const afterB = listRaptorNodes(sid, tmpDir);
-    assert.equal(afterB.length, 3, "tree B has 3 nodes (stale A nodes gone)");
-    // No stale node ids from tree A survive.
-    const idsAfterB = new Set(afterB.map((n) => n.id));
-    assert.ok(!idsAfterB.has("alpha"), "stale node alpha is gone");
-    assert.ok(!idsAfterB.has("beta"), "stale node beta is gone");
-    assert.ok(idsAfterB.has("gamma"), "new node gamma present");
-    assert.ok(idsAfterB.has("delta"), "new node delta present");
-    assert.ok(idsAfterB.has("root"), "root present (upserted, not duplicated)");
-    // builtAt was updated to the new timestamp.
-    for (const n of afterB) {
-        assert.equal(n.builtAt, builtAt2, `node ${n.id} builtAt updated to tree B timestamp`);
-    }
-});
-// ── Test 2: corrupt children JSON → no throw, children = [] ──────────────────
-test("listRaptorNodes: corrupt children JSON does not throw and returns []", () => {
-    const sid = "sess_corrupt";
-    const builtAt = 5000;
-    const tree = makeTree([
-        { id: "good", level: 1, children: ["leaf_0", "leaf_1"] },
-        { id: "bad", level: 1, children: ["leaf_2", "leaf_3"] },
-        { id: "root", level: 2, children: ["leaf_0", "leaf_1", "leaf_2", "leaf_3"] },
-    ]);
-    saveRaptorTree(sid, tree, builtAt, tmpDir);
-    // Corrupt the `children` JSON for the "bad" row directly in SQLite.
-    const db = openStore(tmpDir);
-    db.prepare("UPDATE raptor_nodes SET children = ? WHERE session_id = ? AND id = ?").run("{not valid json", sid, "bad");
-    // listRaptorNodes must not throw.
-    let nodes;
-    assert.doesNotThrow(() => {
-        nodes = listRaptorNodes(sid, tmpDir);
-    }, "listRaptorNodes must not throw on corrupt children JSON");
-    const badNode = nodes.find((n) => n.id === "bad");
-    assert.ok(badNode, "bad node still present");
-    assert.deepEqual(badNode.children, [], "corrupt children parsed to []");
-    // The good node is unaffected.
-    const goodNode = nodes.find((n) => n.id === "good");
-    assert.ok(goodNode, "good node present");
-    assert.deepEqual(goodNode.children, ["leaf_0", "leaf_1"], "good node children intact");
-});