pi-mega-compact 0.11.4 → 0.11.6

package/dist/src/sprint14.test.js

@@ -1,219 +0,0 @@
-/**
- * sprint14.test.ts — Sprint 14 full-pipeline wiring (flags, backfill, monitoring, canary).
- * Hermetic: isolated state dirs, no network, no remote.
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { VectorStore, vectorSearch } from "./vectorStore.js";
-import { defaultEmbedder } from "./embedder.js";
-import { loadDedupConfig } from "./config/dedup.js";
-import { loadMetrics, saveMetrics, recordDecision, evaluateAlerts, fpRate, p95, } from "./monitoring.js";
-import { backfillPhase, backfillRaptor } from "./store/backfill.js";
-import { listCheckpoints, closeStore } from "./store/sqlite.js";
-import { CanaryController, runCanary } from "./canary.js";
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-s14-"));
-function cfg(over = {}) {
-    return { ...loadDedupConfig(), ...over };
-}
-function store(over = {}, eventsPath) {
-    const dir = join(baseTmp, `run-${Math.floor(performance.now() * 1000)}-${Math.random()}`);
-    return new VectorStore({ stateDir: dir, config: cfg(over), eventsPath });
-}
-// --- 1. Flag matrix: 16 combos don't crash add()/search() -------------------
-test("flag matrix: all 16 L0/L1/L2/RAPTOR enable combos are safe", () => {
-    const flags = [false, true];
-    let combos = 0;
-    for (const l0 of flags)
-        for (const l1 of flags)
-            for (const l2 of flags)
-                for (const raptor of flags) {
-                    combos++;
-                    const s = store({ L0_ENABLED: l0, L1_ENABLED: l1, L2_ENABLED: l2, RAPTOR_ENABLED: raptor });
-                    s.add({ sessionId: "s", summary: "x", regionText: `region A for combo ${combos} about the cache`, timestamp: 1 });
-                    const r2 = s.add({ sessionId: "s", summary: "x", regionText: `region B for combo ${combos} about the parser`, timestamp: 2 });
-                    // search must not throw under any combination
-                    const hits = vectorSearch(s, "s", "cache", 3);
-                    assert.ok(Array.isArray(hits));
-                    // With all tiers off, the second add is always "new" (no collapse).
-                    if (!l0 && !l1 && !l2)
-                        assert.equal(r2.deduped, false);
-                }
-    assert.equal(combos, 16);
-});
-// --- 2. MARK_ONLY_L1 records but doesn't collapse ---------------------------
-test("MARK_ONLY_L1: L1 match is recorded but not collapsed (new checkpoint)", () => {
-    // Disable L2 so we isolate L1 behavior (L2 cosine would otherwise catch the near-dup).
-    const s = store({ L1_ENABLED: true, MARK_ONLY_L1: true, L2_ENABLED: false });
-    const a = s.add({ sessionId: "s", summary: "x", regionText: "the parser optimized the hot loop", timestamp: 1 });
-    const b = s.add({ sessionId: "s", summary: "x", regionText: "the parser optimized the hot loops", timestamp: 2 });
-    assert.equal(a.deduped, false);
-    // MARK_ONLY → b is NOT collapsed into a; both stored as active.
-    assert.equal(b.deduped, false);
-    const all = listCheckpoints("s", s.stateDir);
-    assert.equal(all.length, 2);
-    assert.ok(all.every((c) => c.dedupStatus === "active"));
-});
-test("MARK_ONLY_L1 off: L1 match IS collapsed", () => {
-    const s = store({ L1_ENABLED: true, MARK_ONLY_L1: false });
-    s.add({ sessionId: "s", summary: "x", regionText: "the parser optimized the hot loop", timestamp: 1 });
-    const b = s.add({ sessionId: "s", summary: "x", regionText: "the parser optimized the hot loops", timestamp: 2 });
-    assert.equal(b.deduped, true);
-    assert.equal(b.reason, "l1MinHash");
-});
-// --- 3. Backfill resumes after interrupt -------------------------------------
-test("backfill L1 resumes after simulated interrupt", () => {
-    const dir = join(baseTmp, `bf-${Math.floor(performance.now())}`);
-    // Seed 12 checkpoints, 2 per batch of 5.
-    const s = new VectorStore({ stateDir: dir, config: cfg() });
-    const texts = [
-        "The walrus drifted past the lighthouse while the baker kneaded sourdough at dawn",
-        "Quantum entanglement linked the two photons across the lab in a cryogenic chamber",
-        "A medieval scribe copied the gospel by candlelight atop a windswept cliff",
-        "The rover sampled basalt from the crater and transmitted spectra to mission control",
-        "Jazz musicians improvised a syncopated triangle rhythm beneath the streetlamp",
-        "The glacier calved a towering iceberg into the fjord with a thunderous crack",
-        "A botanist cataloged the orchid species thriving in the cloud forest canopy",
-        "The blacksmith forged a horseshoe while sparks danced across the anvil",
-        "Astronomers imaged a distant nebula glowing with newborn stellar furnaces",
-        "The ferry crossed the strait as gulls wheeled above the churning wake",
-        "A weaver threaded crimson silk through the loom in the mountain village",
-        "The surgeon sutured the incision with steady hands under the theatre lights",
-    ];
-    for (let i = 0; i < 12; i++) {
-        s.add({ sessionId: "sess_bf", summary: `n${i}`, regionText: texts[i], timestamp: i });
-    }
-    // Interrupt after batch 1 (5 rows).
-    const r1 = backfillPhase("L1", "sess_bf", dir, { batchSize: 5, interruptAfterBatches: 1 });
-    assert.equal(r1.interrupted, true);
-    assert.equal(r1.processed, 5);
-    assert.ok(r1.cursor === "chkpt_005" || r1.cursor === "chkpt_05");
-    // Resume: should continue from the cursor → process the remaining 7.
-    const r2 = backfillPhase("L1", "sess_bf", dir, { batchSize: 5 });
-    assert.equal(r2.interrupted, false);
-    assert.equal(r2.processed, 12); // total across both runs (cursor-based resume)
-    closeStore(dir);
-});
-// --- 4. Alert fires on injected FP spike -------------------------------------
-test("alert: FP spike breaches threshold → MARK_ONLY flagged + warning", () => {
-    const config = cfg();
-    const m = loadMetrics("/dev/null");
-    // Inject 100 L1 decisions, 20 false positives → 20% > FP_RATE_L1L2 (5%).
-    for (let i = 0; i < 100; i++) {
-        recordDecision(m, "L1", i < 20 ? "deduped" : "new", 5, i < 20);
-    }
-    const res = evaluateAlerts(m, config);
-    assert.ok(res.breached.includes("L1"));
-    assert.ok(res.warnings.some((w) => w.includes("DEDUP FP BREACH tier=L1")));
-    assert.ok(fpRate(m, "L1") > config.FP_RATE_L1L2);
-});
-test("alert: clean run does NOT breach", () => {
-    const config = cfg();
-    const m = loadMetrics("/dev/null");
-    for (let i = 0; i < 100; i++)
-        recordDecision(m, "L1", "new", 5, false);
-    const res = evaluateAlerts(m, config);
-    assert.equal(res.breached.length, 0);
-});
-// --- 5. Canary auto-disables a tier whose p95 exceeds budget ---------------
-test("canary: auto-disables a tier whose p95 exceeds budget", () => {
-    // Feed where L2 always has high latency (breaches P95_BUDGET_MS).
-    const feed = (_step, c) => {
-        const m = loadMetrics("/dev/null");
-        if (c.L0_ENABLED)
-            recordDecision(m, "L0", "new", 1, false);
-        if (c.L1_ENABLED)
-            recordDecision(m, "L1", "new", 1, false);
-        if (c.L2_ENABLED)
-            recordDecision(m, "L2", "new", 500, false); // > 100ms budget
-        if (c.RAPTOR_ENABLED)
-            recordDecision(m, "RAPTOR", "new", 1, false);
-        return m;
-    };
-    const { controller, disabled } = runCanary(feed, cfg({ P95_BUDGET_MS: 100 }));
-    assert.ok(disabled.includes("L2"), `expected L2 auto-disabled, got ${JSON.stringify(disabled)}`);
-    assert.equal(controller.config.L2_ENABLED, false);
-    // Lower tiers should still be enabled.
-    assert.equal(controller.config.L0_ENABLED, true);
-});
-test("canary: sequential enablement order L0→L1→L2→RAPTOR", () => {
-    const c = new CanaryController(cfg());
-    assert.deepEqual([...c.getState().enabled], ["L0"]);
-    const t1 = c.stepForward();
-    assert.equal(t1, "L1");
-    assert.equal(c.stepForward(), "L2");
-    assert.equal(c.stepForward(), "RAPTOR");
-    assert.equal(c.stepForward(), null); // all enabled
-});
-// --- 6. Monitoring: structured decision events written ----------------------
-test("monitoring: add() writes structured decision events to events.log", () => {
-    const dir = join(baseTmp, `mon-${Math.floor(performance.now())}`);
-    const eventsPath = join(dir, "events.log");
-    const s = new VectorStore({
-        stateDir: dir,
-        config: cfg(),
-        eventsPath,
-    });
-    s.add({ sessionId: "s", summary: "x", regionText: "unique region alpha one", timestamp: 1 });
-    s.add({ sessionId: "s", summary: "x", regionText: "unique region alpha one", timestamp: 2 }); // L0 content dup
-    assert.ok(existsSync(eventsPath));
-    const lines = readFileSync(eventsPath, "utf-8").trim().split("\n").filter(Boolean);
-    assert.ok(lines.length >= 2);
-    const ev = JSON.parse(lines[0]);
-    assert.ok(["L0"].includes(ev.tier));
-    assert.ok(["new", "deduped", "mark_only"].includes(ev.result));
-    closeStore(dir);
-});
-// --- 7. RAPTOR backfill builds + persists a tree ---------------------------
-test("backfill RAPTOR builds + persists a tree for a session", () => {
-    const dir = join(baseTmp, `raptorbf-${Math.floor(performance.now())}`);
-    const s = new VectorStore({ stateDir: dir, config: cfg() });
-    const texts = [
-        "The whale breached beside the research vessel near the polar ice shelf",
-        "A potter shaped the clay vessel on the spinning wheel at the riverside studio",
-        "The comet streaked across the pre dawn sky witnessed by the hilltop observatory",
-        "Lumberjacks felled the ancient cedar while the river carried the logs downstream",
-        "The chemist titrated the solution until the indicator turned faint violet",
-        "A flock of cranes migrated northward over the thawing wetland at first light",
-        "The locksmith picked the stubborn tumbler and opened the oak cabinet",
-        "Geologists hammered the schist sample from the canyon wall into the satchel",
-        "The chocolatier tempered the couverture until it snapped with a clean gloss",
-        "A fisher cast the line into the mist where the trout rose to the fly",
-        "The archivist unsealed the parchment scroll recovered from the coastal ruin",
-        "Beekeepers harvested the golden comb while the orchard blossoms drifted down",
-        "The pilot navigated the canyon winds using only the instrument panel glow",
-        "A tailor stitched the velvet cuff with silk thread by the window",
-        "The miner extracted the quartz crystal from the vein deep in the shaft",
-        "Cartographers plotted the uncharted island onto the worn leather map",
-        "The gardener pruned the rosebush and tied the canes to the cedar trellis",
-        "A violinist tuned the gut strings until the chamber rang pure and bright",
-        "The diver surfaced with the amphora lifted from the sunken galleon",
-        "Shepherds guided the flock across the high pasture toward the stone bothy",
-    ];
-    for (let i = 0; i < 20; i++) {
-        s.add({ sessionId: "sess_rb", summary: `n${i}`, regionText: texts[i], timestamp: i });
-    }
-    const res = backfillRaptor("sess_rb", dir, defaultEmbedder());
-    assert.ok(res.processed > 0);
-    // Sanity: source checkpoints remain intact (backfill is additive).
-    const nodes = listCheckpoints("sess_rb", dir).length;
-    assert.ok(nodes >= 20);
-    closeStore(dir);
-});
-// --- 8. dashboard.json metrics round-trip -----------------------------------
-test("metrics: dashboard.json persists + p95 computed", () => {
-    const path = join(baseTmp, `dash-${Math.floor(performance.now())}.json`);
-    const m = loadMetrics(path);
-    for (let i = 0; i < 10; i++)
-        recordDecision(m, "L2", "new", i * 10, false);
-    saveMetrics(path, m);
-    const reloaded = loadMetrics(path);
-    assert.equal(reloaded.decisions.L2, 10);
-    assert.equal(p95(reloaded.latency.L2), 90); // 95th pct of [0,10,..,90]
-});
-// --- cleanup ----------------------------------------------------------------
-test("Sprint 14 cleanup", () => {
-    rmSync(baseTmp, { recursive: true, force: true });
-});

package/dist/src/sprint4x-rag-verification.test.js

@@ -1,93 +0,0 @@
-/**
- * sprint4x-rag-verification.test.ts — run the S40–S47 RAG suite once against
- * the current implementation and assert the documented "default enable" claims.
- *
- * This is the verification pass demanded by the roadmap/backlog: each spec
- * claims its feature flags DEFAULT ON. The honest check (not a re-statement of
- * the spec) is: which flags actually exist in code, what do they default to,
- * and is the consuming path wired?
- *
- * Findings recorded here, per spec:
- *   S40 importance-scoring     — module src/importance.ts exists (S40A) but is
- *                                NOT consumed by compactSession/vector-paths;
- *                                no shipped flag, no adapter wiring.
- *   S41 self-rag-quality-gate  — spec-only; NO flag, NO consumer.
- *   S42 raptor-multilevel      — PARTIALLY SHIPPED: RAPTOR_MULTILEVEL_ENABLED
- *                                and RAPTOR_LEAF_EXPANSION both default true
- *                                with real consumers; the spec's claim holds.
- *   S43 hyde-vague-queries     — spec-only (QUERY_REFORMULATION_ENABLED absent).
- *   S44 three-tier-latency-routing — spec-only (TIERED_ROUTING_ENABLED absent).
- *   S45 crag-quality-metrics   — spec-only (CRAG_ENABLED absent).
- *   S46 visual-memory-map      — spec-only (MEMORY_MAP_ENABLED absent;
- *                                memory-graph endpoint not in dashboard-server).
- *   S47 auto-categorizing-wiki — spec-only (AUTO_WIKI_ENABLED absent).
- *
- * Policy: the suite runs against the flags that EXIST today. Unimplemented spec
- * claims are pinned by the S4X_SPEC_ONLY tests so regressions can't silently
- * add them in the wrong state, and this file records exactly which
- * spec-vs-implementation gaps remain.
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { loadDedupConfig } from "./config/dedup.js";
-/**
- * Clear any env pollution so the default is measured, not the override.
- */
-function fresh(envKey, get) {
-    delete process.env[envKey];
-    try {
-        return get();
-    }
-    finally {
-        delete process.env[envKey];
-    }
-}
-// ---- S42: shipped flags default ON (claim holds) ----------------------------
-test("S42 RAPTOR_MULTILEVEL_ENABLED defaults ON and honors env off", () => {
-    const d = fresh("MEGACOMPACT_RAPTOR_MULTILEVEL", () => loadDedupConfig());
-    assert.ok(d.RAPTOR_MULTILEVEL_ENABLED, "ship claim: multi-level on by default");
-    process.env.MEGACOMPACT_RAPTOR_MULTILEVEL = "false";
-    const off = loadDedupConfig();
-    assert.ok(!off.RAPTOR_MULTILEVEL_ENABLED, "env override: MEGACOMPACT_RAPTOR_MULTILEVEL=false turns it off");
-});
-test("S42 RAPTOR_LEAF_EXPANSION defaults ON and honors env off", () => {
-    const d = fresh("MEGACOMPACT_RAPTOR_LEAF_EXPANSION", () => loadDedupConfig());
-    assert.ok(d.RAPTOR_LEAF_EXPANSION, "ship claim: leaf-expansion on by default");
-    process.env.MEGACOMPACT_RAPTOR_LEAF_EXPANSION = "false";
-    const off = loadDedupConfig();
-    assert.ok(!off.RAPTOR_LEAF_EXPANSION, "env override off");
-});
-// ---- S40: module exists, claims do NOT yet hold at the flag/consumer level --
-test("S40 importance module exists in-tree (S40A artifact)", async () => {
-    // Load the module and confirm it exports the scoring surface the spec
-    // describes. This proves the S40A implementation exists even though nothing
-    // wires it into compaction/vector paths yet (documented gap).
-    const mod = await import("./importance.js");
-    assert.ok(mod && typeof mod === "object", "importance.ts loads");
-    // Exports per spec: score() plus item-type enum.
-    assert.ok(typeof mod.score === "function", "importance.ts exports score() function");
-});
-test("S40 has no shipped consumer flag in the current codebase (gap pinned)", async () => {
-    // The S40 spec claims an IMPORTANCE_SCORING flag defaults ON. In the
-    // current code no such flag exists, and no vector/compact path reads
-    // importance scores. This test documents the gap so a future wiring does
-    // not silently flip it on in the wrong shape.
-    const cfg = loadDedupConfig();
-    assert.ok(!("IMPORTANCE_SCORING" in cfg), "no IMPORTANCE_SCORING flag yet (S40 consumer wiring missing)");
-});
-// ---- S41/S43–S47: spec-only modules — pin the absence ------------------------
-test("S4X spec-only flags absent from DedupConfig", () => {
-    const cfg = loadDedupConfig();
-    const specFlags = [
-        "CRITIQUE_ENABLED", // S41
-        "QUERY_REFORMULATION_ENABLED", // S43
-        "TIERED_ROUTING_ENABLED", // S44
-        "CRAG_ENABLED", // S45
-        "CRAG_EXPANSION_ENABLED", // S45
-        "MEMORY_MAP_ENABLED", // S46
-        "AUTO_WIKI_ENABLED", // S47
-    ];
-    for (const f of specFlags) {
-        assert.ok(!(f in cfg), `${f} is spec-only — should not be present in DedupConfig`);
-    }
-});

package/dist/src/store/compression.test.js

@@ -1,139 +0,0 @@
-/**
- * compression.test.ts — versioned compression tiers + backward compatibility.
- *
- * Proves Sprint 8's root-cause fix: the 0x03 tag collision is impossible because
- * new blobs carry a 2-byte version magic, and legacy blobs (untagged gzip, legacy
- * single-tag incl. the old 0x03=brotli) still decompress.
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { gzipSync, brotliCompressSync } from "node:zlib";
-import { compressSmart, decompressSmart, compressZstd, decompressZstd, isVersioned, detectFormat, decompressSyncAuto, } from "./compression.js";
-const buf = (s, n) => Buffer.from(s.repeat(n));
-test("versioned format: all size tiers roundtrip and are versioned", () => {
-    const cases = [
-        { label: "tiny", data: buf("x", 100), expectTag: 0x00 },
-        { label: "small", data: buf("a", 600), expectTag: 0x01 },
-        { label: "medium", data: buf("b", 8000), expectTag: 0x02 },
-        { label: "large", data: buf("c", 40000), expectTag: 0x05 },
-    ];
-    for (const { label, data, expectTag } of cases) {
-        const c = compressSmart(data);
-        // New 2-byte magic header present.
-        assert.ok(isVersioned(c), `${label}: should be versioned (0xEC 0x01)`);
-        assert.equal(c[0], 0xec, `${label}: magic hi`);
-        assert.equal(c[1], 0x01, `${label}: magic lo (version)`);
-        assert.equal(c[2], 0x01, `${label}: format version 1`);
-        assert.equal(c[3], expectTag, `${label}: tier tag ${expectTag.toString(16)}`);
-        // Roundtrips exactly.
-        assert.deepEqual(decompressSmart(c), data, `${label}: roundtrip`);
-    }
-});
-test("large tier actually compresses better than raw (brotli 0x05)", () => {
-    const data = buf("this is a long summary of a coding session. ", 900);
-    const c = compressSmart(data);
-    assert.ok(c.length < data.length, "compressed smaller than raw");
-    assert.equal(c[3], 0x05, "tag is brotli-4");
-    assert.deepEqual(decompressSmart(c), data);
-});
-test("legacy untagged gzip (0x1f magic) still decompresses", () => {
-    const data = Buffer.from(JSON.stringify({ legacy: true }));
-    const legacyGzip = gzipSync(data); // no tag byte, starts with 0x1f
-    assert.equal(legacyGzip[0], 0x1f, "gzip magic present");
-    assert.equal(detectFormat(legacyGzip), "legacy-gzip");
-    assert.deepEqual(JSON.parse(decompressSmart(legacyGzip).toString()), { legacy: true });
-});
-test("legacy single-tag 0x03=brotli (the collision case) still decompresses", () => {
-    const data = buf("legacy brotli payload ", 200);
-    // Reconstruct the EXACT v0.1.0 legacy brotli frame: tag 0x03 + brotli payload.
-    const legacy = Buffer.concat([Buffer.from([0x03]), brotliCompressSync(data)]);
-    assert.equal(detectFormat(legacy), "legacy-tag");
-    assert.deepEqual(decompressSmart(legacy), data, "legacy 0x03 brotli roundtrips");
-});
-test("detectFormat classifies all eras", () => {
-    assert.equal(detectFormat(compressSmart(buf("q", 700))), "versioned");
-    assert.equal(detectFormat(gzipSync(buf("q", 10))), "legacy-gzip");
-    assert.equal(detectFormat(Buffer.from([0x00, 1, 2, 3])), "legacy-tag");
-    assert.equal(detectFormat(Buffer.from([0x99, 0x88])), "unknown");
-});
-test("zstd helper roundtrips (async) and is not sync-decoded", async () => {
-    const data = buf("zstd dr export payload ", 1500);
-    const c = await compressZstd(data);
-    assert.ok(c.length < data.length, "zstd compresses");
-    // decompressSyncAuto reports zstd without throwing (caller awaits decompressZstd).
-    const auto = decompressSyncAuto(c);
-    assert.equal(auto.isZstd, true, "flagged as zstd");
-    assert.deepEqual(await decompressZstd(c), data, "zstd roundtrip");
-});
-test("module loads without a top-level zstd import (Fix A: no load crash)", async () => {
-    // The extension must load even when the @mongodb-js/zstd native addon is
-    // absent (clean/allowScripts-blocked install). The dynamic import() lives
-    // inside the helpers, so importing this module must never throw.
-    const mod = await import("./compression.js");
-    assert.equal(typeof mod.compressSmart, "function", "compressSmart exported");
-    assert.equal(typeof mod.compressZstd, "function", "compressZstd exported");
-    // The real invariant: no STATIC `import ... from "@mongodb-js/zstd"` at the
-    // top level (that's what crashed the whole extension). zstd must be loaded
-    // lazily inside the helpers only. Check the source text.
-    const { readFileSync } = await import("node:fs");
-    const { join } = await import("node:path");
-    // Tests run with cwd at repo root (`node --test`), so resolve the source.
-    const src = readFileSync(join(process.cwd(), "src/store/compression.ts"), "utf-8");
-    const staticImport = /^import\s+.+\s+from\s+["']@mongodb-js\/zstd["'];?$/m;
-    assert.equal(staticImport.test(src), false, "no static top-level import of @mongodb-js/zstd (would crash load if binary absent)");
-    assert.ok(src.includes('await import("@mongodb-js/zstd")'), "zstd is loaded lazily via dynamic import() inside the helpers");
-});
-test("compressSmart escalates brotli quality with pressure (Fix E)", () => {
-    // Large (>32KB) payloads hit the brotli tier; higher pressure → brotli-11
-    // → smaller output than the default brotli-4, and still decodes.
-    const words = Array.from({ length: 6000 }, (_, i) => "word" + ((i * 2654435761) % 9973));
-    const big = Buffer.from(words.join(" "));
-    const low = compressSmart(big, 0);
-    const high = compressSmart(big, 1);
-    assert.equal(isVersioned(low), true, "versioned header preserved at p=0");
-    assert.equal(isVersioned(high), true, "versioned header preserved at p=1");
-    assert.ok(high.length < low.length, "high pressure compresses smaller");
-    assert.deepEqual(decompressSmart(low), big, "p=0 roundtrip");
-    assert.deepEqual(decompressSmart(high), big, "p=1 roundtrip");
-    // Small payloads ignore pressure (gzip tier) but still roundtrip.
-    const small = buf("hello world ", 300);
-    assert.deepEqual(decompressSmart(compressSmart(small, 1)), small, "small ignores pressure");
-    // pressure out of range is clamped (no throw, still versioned + decodable).
-    assert.deepEqual(decompressSmart(compressSmart(big, 5)), big, "over-pressure clamped");
-    assert.deepEqual(decompressSmart(compressSmart(big, -1)), big, "under-pressure clamped");
-});
-test("pressureFromPct + preserveRecentForPressure scale with context (Fix E)", async () => {
-    const { pressureFromPct, preserveRecentForPressure } = await import("../config.js");
-    assert.equal(pressureFromPct(50), 0.5, "pct→pressure");
-    assert.equal(pressureFromPct(null), 0, "null pct → 0");
-    assert.equal(pressureFromPct(150), 1, "pct clamped");
-    // low pressure keeps preserveRecent; high pressure compacts deeper (min floor).
-    assert.equal(preserveRecentForPressure(0, 4, 2), 4, "p=0 → preserveRecent");
-    assert.equal(preserveRecentForPressure(1, 4, 2), 2, "p=1 → preserveRecentMin");
-    assert.equal(preserveRecentForPressure(0.5, 4, 2), 3, "p=0.5 → interpolates");
-    assert.ok(preserveRecentForPressure(1, 4, 2) >= 2, "never below floor");
-});
-test("S24: pressureRatio + pressureBand + memoryReviewCadence unify the signal", async () => {
-    const { pressureRatio, pressureBand, memoryReviewCadence } = await import("../config.js");
-    // pressureRatio: current/threshold, clamped to [0,1].
-    assert.equal(pressureRatio(50_000, 100_000), 0.5, "half threshold → 0.5");
-    assert.equal(pressureRatio(0, 100_000), 0, "no tokens → 0");
-    assert.equal(pressureRatio(10_000_000, 100_000), 1, "over threshold → clamped 1");
-    assert.equal(pressureRatio(50_000, 0), 0, "zero threshold → 0");
-    assert.equal(pressureRatio(NaN, 100_000), 0, "NaN current → 0");
-    // pressureBand: discrete bands drive the toolbar/dashboard tier label.
-    assert.equal(pressureBand(0.2), "low");
-    assert.equal(pressureBand(0.5), "medium");
-    assert.equal(pressureBand(0.75), "high");
-    assert.equal(pressureBand(0.9), "ultra");
-    assert.equal(pressureBand(1.0), "mega");
-    assert.equal(pressureBand(2.0), "mega", "over 1 → mega");
-    assert.equal(pressureBand(-1), "low", "below 0 → low");
-    // memoryReviewCadence: higher pressure → smaller (more frequent) divisor.
-    assert.equal(memoryReviewCadence("low", 10), 10, "low keeps base interval");
-    assert.equal(memoryReviewCadence("medium", 10), 7, "medium shortens");
-    assert.equal(memoryReviewCadence("high", 10), 5, "high halves");
-    assert.equal(memoryReviewCadence("ultra", 10), 3, "ultra shortens more");
-    assert.equal(memoryReviewCadence("mega", 10), 2, "mega near base/5");
-    assert.equal(memoryReviewCadence("high", 0), 1, "never below 1");
-});

package/dist/src/store/memoryIndex.test.js

@@ -1,51 +0,0 @@
-import { test } 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 { defaultEmbedder } from "../embedder.js";
-import { upsertMemoryEmbedding, searchMemoriesAsync, initMemoryIndex, closeMemoryIndex, isMemoryIndexDisabled, } from "./memoryIndex.js";
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-memidx-"));
-test("memoryIndex: disabled when MEGACOMPACT_PGLITE_DISABLED", async () => {
-    process.env.MEGACOMPACT_PGLITE_DISABLED = "true";
-    try {
-        assert.equal(isMemoryIndexDisabled(), true, "kill-switch honored");
-        const hits = await searchMemoriesAsync(defaultEmbedder().embed("anything"), { k: 3 });
-        assert.deepEqual(hits, [], "search returns [] when disabled");
-    }
-    finally {
-        delete process.env.MEGACOMPACT_PGLITE_DISABLED;
-    }
-});
-test("memoryIndex: cross-repo upsert + NN search returns the right repo's memory", async () => {
-    // Isolate the global PGlite dir so concurrent test runs don't collide.
-    process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
-    const repoA = "/tmp/repo-a";
-    const repoB = "/tmp/repo-b";
-    try {
-        await initMemoryIndex();
-        // Two memories in different repos, with clearly distinct content so their
-        // trigram embeddings separate.
-        const vecA = defaultEmbedder().embed("We standardized on node:sqlite for the store backend");
-        const vecB = defaultEmbedder().embed("The deployment target is a raspberry pi in the closet");
-        await upsertMemoryEmbedding(repoA, 1, "We standardized on node:sqlite for the store backend", vecA);
-        await upsertMemoryEmbedding(repoB, 7, "The deployment target is a raspberry pi in the closet", vecB);
-        // Query close to A's content → top hit should be A's memory, not B's.
-        const q = defaultEmbedder().embed("standardized node:sqlite store backend choice");
-        const hits = await searchMemoriesAsync(q, { k: 3 });
-        assert.ok(hits.length >= 1, "at least one hit");
-        assert.equal(hits[0].repoId, repoA, "nearest neighbor is repo A");
-        assert.equal(hits[0].memoryId, 1, "correct memory id");
-        assert.ok(hits[0].score > 0.5, "high cosine for the matching memory");
-        // Scope to repoB only → A must not appear.
-        const scoped = await searchMemoriesAsync(q, { k: 3, repoId: repoB });
-        assert.ok(scoped.every((h) => h.repoId === repoB), "scoped search stays within repoB");
-    }
-    finally {
-        await closeMemoryIndex();
-        delete process.env.MEGACOMPACT_INDEX_DIR;
-    }
-});
-test("memoryIndex: cleanup", () => {
-    rmSync(baseTmp, { recursive: true, force: true });
-});

package/dist/src/store/migrate.test.js

@@ -1,139 +0,0 @@
-/**
- * migrate + recall integration test — Sprint 8 acceptance proofs.
- *
- * 1. Migration is lossless: a v0.1.0 `<sess>.checkpoints.json.gz` roundtrips
- *    into SQLite with checkpoint count + regionHash set identical, and the JSON
- *    file is retained as a DR snapshot.
- * 2. Cross-process recall: compact in one VectorStore, then recall via a FRESH
- *    VectorStore over the SAME stateDir (re-opens the same sqlite.db file) — the
- *    checkpoint must reappear. Mirrors Sprint 6.1's durability requirement.
- *
- * Uses MEGACOMPACT_STATE_DIR overrides; never the real user state dir.
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { VectorStore, vectorMarkInjected, vectorWasInjected, vectorSearch } from "../vectorStore.js";
-import { writeGzJson } from "../store.js";
-import { migrateJsonToSqlite, readLegacyCheckpointFile } from "../store/migrate.js";
-import { listCheckpoints, closeStore } from "../store/sqlite.js";
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-migrate-"));
-let counter = 0;
-function stateDir() {
-    return join(baseTmp, `run-${counter++}`);
-}
-function msgVec() {
-    // Deterministic 8-dim vector.
-    return [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8];
-}
-function fakeCheckpoints(sessionId) {
-    return [
-        {
-            checkpointId: "chkpt_001",
-            sessionId,
-            summary: "Investigated the vector store and added a cosine helper.",
-            topicSummary: "Added cosine similarity helper to vector store.",
-            summaryHash: "a1b2c3d4e5f6a7b8",
-            keyDecisions: ["use linear scan"],
-            nextSteps: ["add tests"],
-            filesModified: ["src/vectorStore.ts"],
-            tokenEstimate: 1200,
-            regionHash: "r1",
-            embedding: msgVec(),
-            timestamp: 1,
-        },
-        {
-            checkpointId: "chkpt_002",
-            sessionId,
-            summary: "Refactored the recall path to dedupe against the window.",
-            topicSummary: "Recall dedup against injected set.",
-            summaryHash: "b2c3d4e5f6a7b8c9",
-            keyDecisions: [],
-            nextSteps: [],
-            filesModified: ["src/recall.ts"],
-            tokenEstimate: 900,
-            regionHash: "r2",
-            embedding: msgVec().map((v) => v + 0.01),
-            timestamp: 2,
-        },
-    ];
-}
-test("migration: v0.1.0 JSON checkpoints migrate losslessly into SQLite", () => {
-    const dir = stateDir();
-    const sid = "sess_migrate_lossless";
-    // Write a legacy JSON checkpoint file (the format v0.1.0 shipped).
-    writeGzJson(join(dir, `${sid}.checkpoints.json.gz`), fakeCheckpoints(sid));
-    const result = migrateJsonToSqlite(dir);
-    assert.equal(result.sessionsScanned, 1);
-    assert.equal(result.checkpointsMigrated, 2);
-    assert.equal(result.alreadyPresent, 0);
-    // SQLite now has both checkpoints, regionHash preserved.
-    const migrated = listCheckpoints(sid, dir);
-    assert.equal(migrated.length, 2, "both checkpoints present");
-    assert.ok(migrated.every((c) => c.regionHash && c.regionHash.length > 0), "regionHash preserved");
-    assert.deepEqual(migrated.map((c) => c.checkpointId).sort(), ["chkpt_001", "chkpt_002"]);
-    // content_hash columns populated (needed by Sprint 9).
-    const legacy = readLegacyCheckpointFile(sid, dir);
-    assert.equal(legacy.length, 2, "legacy file intact (DR snapshot retained)");
-    assert.ok(existsSync(join(dir, `${sid}.checkpoints.json.gz`)), "JSON DR snapshot retained");
-    closeStore(dir);
-});
-test("migration: re-running is idempotent (no duplicates)", () => {
-    const dir = stateDir();
-    const sid = "sess_migrate_idem";
-    writeGzJson(join(dir, `${sid}.checkpoints.json.gz`), fakeCheckpoints(sid));
-    migrateJsonToSqlite(dir);
-    const r2 = migrateJsonToSqlite(dir);
-    assert.equal(r2.checkpointsMigrated, 0, "nothing new migrated");
-    assert.equal(r2.alreadyPresent, 2, "both counted as already present");
-    assert.equal(listCheckpoints(sid, dir).length, 2);
-    closeStore(dir);
-});
-test("cross-process recall: fresh VectorStore over same dir recalls prior checkpoint", () => {
-    const dir = stateDir();
-    const sid = "sess_xproc";
-    // Process A: compact a checkpoint into the store.
-    const a = new VectorStore({ stateDir: dir });
-    const added = a.add({
-        sessionId: sid,
-        summary: "Cross-process recall proof: persisted in process A.",
-        topicSummary: "Persisted checkpoint in process A.",
-        regionText: "cross process recall proof session A write path",
-        tokenEstimate: 500,
-        timestamp: 1,
-    });
-    assert.equal(added.deduped, false);
-    assert.equal(added.checkpoint.checkpointId, "chkpt_001");
-    // Force a clean reopen (simulates a new process opening the same file).
-    closeStore(dir);
-    // Process B: brand-new VectorStore, same stateDir.
-    const b = new VectorStore({ stateDir: dir });
-    const hits = vectorSearch(b, sid, "cross process recall proof", 5);
-    assert.equal(hits.length, 1, "checkpoint survives cross-process reopen");
-    assert.equal(hits[0].checkpoint.checkpointId, "chkpt_001");
-    assert.ok(hits[0].score > 0.5, "recall is relevant");
-    closeStore(dir);
-});
-test("cross-process recall: injected state persists across reopen", () => {
-    const dir = stateDir();
-    const sid = "sess_xproc_inj";
-    const a = new VectorStore({ stateDir: dir });
-    const added = a.add({
-        sessionId: sid,
-        summary: "A checkpoint to inject and remember across processes.",
-        topicSummary: "Injected checkpoint.",
-        regionText: "injected state persists across process reopen test",
-        timestamp: 1,
-    });
-    vectorMarkInjected(a, sid, added.checkpoint.checkpointId);
-    assert.equal(vectorWasInjected(a, sid, added.checkpoint.checkpointId), true);
-    closeStore(dir);
-    const b = new VectorStore({ stateDir: dir });
-    assert.equal(vectorWasInjected(b, sid, added.checkpoint.checkpointId), true, "injection remembered");
-    closeStore(dir);
-});
-test("cleanup", () => {
-    rmSync(baseTmp, { recursive: true, force: true });
-});