pi-mega-compact 0.11.4 → 0.11.5

package/dist/extensions/mega-turn-store.test.js

@@ -1,68 +0,0 @@
-/**
- * mega-turn-store.test.ts — S49C adapter routing tests.
- *
- * Proves the adapter writes to the isolated turns.db when turnsDbEnabled is
- * true and to the legacy main-db helpers when false. No network; temp dirs.
- */
-import { test, beforeEach, afterEach } 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 { DatabaseSync } from "node:sqlite";
-import { ensureConversationIdFor, recordTurnWrite, recordRecallWrite, } from "./mega-turn-store.js";
-import { closeTurnStore, turnDbPath } from "../src/store/turns/index.js";
-let tmpDir;
-let counter = 0;
-beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "mc-adapter-"));
-});
-afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-});
-function stateDir() {
-    return join(tmpDir, `run-${counter++}`);
-}
-/** Minimal MegaConfig stub — only the flag the adapter reads. */
-function cfg(turnsDbEnabled) {
-    return { turnsDbEnabled };
-}
-test("flag ON → writes land in turns.db (not main sqlite.db)", () => {
-    const dir = stateDir();
-    const c = cfg(true);
-    const conv = ensureConversationIdFor(c, "sess_on", dir);
-    const turnId = recordTurnWrite(c, {
-        conversationId: conv,
-        sessionId: "sess_on",
-        turnIndex: 0,
-        role: "assistant",
-        endedAt: Date.now(),
-    }, dir);
-    recordRecallWrite(c, turnId, [{ checkpointId: "cp_on", score: 0.5, source: "flat" }], dir);
-    closeTurnStore(dir);
-    assert.ok(existsSync(turnDbPath(dir)), "turns.db should exist");
-    assert.ok(!existsSync(join(dir, "sqlite.db")), "main sqlite.db must NOT be created on the flag-ON path");
-});
-test("flag OFF → writes land in main sqlite.db (legacy S48 path)", () => {
-    const dir = stateDir();
-    const c = cfg(false);
-    const conv = ensureConversationIdFor(c, "sess_off", dir);
-    const turnId = recordTurnWrite(c, {
-        conversationId: conv,
-        sessionId: "sess_off",
-        turnIndex: 0,
-        role: "assistant",
-        endedAt: Date.now(),
-    }, dir);
-    recordRecallWrite(c, turnId, [{ checkpointId: "cp_off", score: 0.5, source: "flat" }], dir);
-    // Legacy helpers open the main sqlite.db.
-    assert.ok(existsSync(join(dir, "sqlite.db")), "main sqlite.db should exist on the flag-OFF path");
-    assert.ok(!existsSync(turnDbPath(dir)), "turns.db must NOT be created on the flag-OFF path");
-    // And the row is actually in the main db's turns table.
-    const main = new DatabaseSync(join(dir, "sqlite.db"));
-    const rows = main
-        .prepare("SELECT * FROM turns WHERE session_id = ?")
-        .all("sess_off");
-    assert.equal(rows.length, 1);
-    main.close();
-});

package/dist/src/boundary.test.js

@@ -1,170 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { computeDropRange, isBoundarySafe, dropBefore } from "./boundary.js";
-function user(t) { return { role: "user", text: t }; }
-function assistant(t) { return { role: "assistant", text: t }; }
-function toolUse(n, i = "{}") { return { role: "assistant", text: "", toolName: n, input: i }; }
-function toolResult(n, o = "ok") { return { role: "tool", text: "", toolName: n, output: o }; }
-function custom(t) { return { role: "custom", text: t }; }
-test("walks back so first preserved message is not an orphaned tool result", () => {
-    const messages = [
-        user("Search for files"),
-        toolUse("search"),
-        toolResult("search", "found 5 files"),
-        assistant("Done."),
-    ];
-    // keepFrom=2 would start the preserved run on the tool result at index 2,
-    // orphaning it. The guard walks back to include the assistant tool-call.
-    const [start, end] = computeDropRange(messages, 2, 0);
-    assert.equal(start, 0);
-    assert.equal(end, 1);
-    const kept = messages.slice(end);
-    assert.notEqual(kept[0].role, "tool");
-    assert.equal(kept[0].toolName, "search"); // assistant tool-call preserved
-});
-test("isBoundarySafe: cut that drops a toolCall but keeps its toolResult is unsafe (PREVENT-PI-002)", () => {
-    const messages = [user("a"), toolUse("search"), toolResult("search")];
-    // keepFrom=2 drops the toolUse at index 1 but keeps the toolResult at index 2 →
-    // the preserved run starts on an orphaned tool result. This is the shape the old
-    // check mis-validated (it only compared messages[keepFrom] to messages[keepFrom-1]).
-    assert.equal(isBoundarySafe(messages, 2), false);
-    // keepFrom=1 keeps the toolCall together with its toolResult → safe.
-    assert.equal(isBoundarySafe(messages, 1), true);
-});
-test("isBoundarySafe: orphaned tool result without preceding tool use is unsafe", () => {
-    const messages = [user("a"), toolResult("search", "orphan")];
-    assert.equal(isBoundarySafe(messages, 1), false);
-});
-test("anchor floor preserves the last N user messages", () => {
-    const messages = [
-        user("u1"), user("u2"), user("u3"),
-        assistant("a1"), assistant("a2"), assistant("a3"), assistant("a4"), assistant("a5"),
-    ];
-    // Caller wants to keep from index 2 (would drop u2). Anchor=2 forces keeping
-    // from u2 (index 1) onward.
-    const out = dropBefore(messages, 2, 2);
-    assert.ok(out.some((m) => m.text === "u2"));
-    assert.ok(out.some((m) => m.text === "u3"));
-});
-test("anchor floor is a no-op when fewer users than anchor", () => {
-    const messages = [user("u1"), assistant("a1"), assistant("a2"), assistant("a3")];
-    const out = dropBefore(messages, 1, 2);
-    // only 1 user, anchor=2 → no floor; keep from index 1 (drop the user)
-    assert.ok(!out.some((m) => m.text === "u1"));
-    assert.equal(out.length, 3);
-});
-test("dropBefore returns original when range is empty", () => {
-    const messages = [user("a"), assistant("b")];
-    assert.equal(dropBefore(messages, 0, 1), messages);
-});
-// --- PREVENT-PI-002 regression cases for arbitrary interleavings ---
-test("interleaved custom message between toolCall and toolResult: walk-back keeps the call", () => {
-    // [user, assistant(tc=read), custom/bashExecution, tool(read-result)] with
-    // desired keepFrom=3. The old walk-back saw messages[2] was not a toolUse and
-    // broke at k=2, dropping the assistant toolCall at index 1 while KEEPING its
-    // tool result at index 3 → orphaned tool result → provider 400.
-    const messages = [
-        user("Search for files"),
-        toolUse("read"),
-        custom("bash: ls -la"),
-        toolResult("read", "file contents"),
-        assistant("Done."),
-    ];
-    const [start, end] = computeDropRange(messages, 3, 0);
-    assert.equal(start, 0);
-    assert.equal(end, 1); // keep the assistant toolCall at index 1 with its result
-    const kept = messages.slice(end);
-    assert.equal(kept[0].toolName, "read"); // assistant tool-call preserved
-    assert.ok(kept.some((m) => m.role === "tool" && m.toolName === "read"));
-    // The toolCall and its toolResult are both in the kept run.
-    const callIdx = kept.findIndex((m) => m.role === "assistant" && m.toolName === "read");
-    const resultIdx = kept.findIndex((m) => m.role === "tool" && m.toolName === "read");
-    assert.ok(callIdx !== -1 && resultIdx !== -1 && callIdx < resultIdx);
-});
-test("consecutive tool results sharing one call: no-op when the call cannot be kept", () => {
-    // [assistant(tc), T1, T2] with keepFrom=1: dropping the call orphans BOTH T1
-    // and T2. No pair-safe positive cut exists below keepFrom → no-op compaction
-    // (the [start,end) contract preserves a non-zero result only when one exists).
-    const messages = [toolUse("multi"), toolResult("multi", "r1"), toolResult("multi", "r2")];
-    const [start, end] = computeDropRange(messages, 1, 0);
-    assert.equal(start, 0);
-    assert.equal(end, 0); // no-op — pair rule outranks dropping
-    assert.equal(dropBefore(messages, 1, 0), messages);
-});
-test("consecutive tool results sharing one call: safe cut keeps the call with both results", () => {
-    // [user, assistant(tc), T1, T2, user2] — keepFrom=3 would orphan T2; the guard
-    // walks back to keep the call (dropEnd=1, only the first user is dropped).
-    const messages = [
-        user("u1"),
-        toolUse("multi"),
-        toolResult("multi", "r1"),
-        toolResult("multi", "r2"),
-        user("u2"),
-    ];
-    const [start, end] = computeDropRange(messages, 3, 0);
-    assert.equal(start, 0);
-    assert.equal(end, 1); // keep [assistant(tc), T1, T2, user2]
-    const kept = messages.slice(end);
-    const callIdx = kept.findIndex((m) => m.role === "assistant" && m.toolName === "multi");
-    const r1Idx = kept.findIndex((m) => m.role === "tool" && m.output === "r1");
-    const r2Idx = kept.findIndex((m) => m.role === "tool" && m.output === "r2");
-    assert.ok(callIdx < r1Idx && r1Idx < r2Idx);
-});
-test("consecutive shared-call results: dropping call + all results together is safe", () => {
-    // keepFrom=4 preserves only the trailing user — the call and BOTH results are
-    // dropped together, so nothing is orphaned.
-    const messages = [
-        user("u1"),
-        toolUse("multi"),
-        toolResult("multi", "r1"),
-        toolResult("multi", "r2"),
-        user("u2"),
-    ];
-    const [start, end] = computeDropRange(messages, 4, 0);
-    assert.equal(start, 0);
-    assert.equal(end, 4);
-    assert.deepEqual(messages.slice(end), [user("u2")]);
-});
-test("keepFrom landing on a call whose results follow is safe", () => {
-    // [user, assistant(tc1), T1, assistant(tc2), T2, user2] keepFrom=3 → preserved
-    // run starts on assistant(tc2) at index 3, whose result T2 follows. Safe.
-    const messages = [
-        user("u1"),
-        toolUse("read"),
-        toolResult("read", "r1"),
-        toolUse("write"),
-        toolResult("write", "r2"),
-        user("u2"),
-    ];
-    const [start, end] = computeDropRange(messages, 3, 0);
-    assert.equal(start, 0);
-    assert.equal(end, 3);
-    const kept = messages.slice(end);
-    assert.equal(kept[0].role, "assistant");
-    assert.equal(kept[0].toolName, "write");
-    assert.ok(kept.some((m) => m.role === "tool" && m.toolName === "write"));
-});
-test("anchor floor + pair-rule conflict: pair rule wins, drop less", () => {
-    // [assistant(tc), user, T] with anchor=1: the anchor floor wants dropEnd<=1
-    // (keep the user at index 1), but keeping from index 1 orphans T (its owner at
-    // index 0 would be dropped). The pair rule outranks the floor — we drop LESS,
-    // keeping everything (no-op) rather than cross a pair.
-    const messages = [toolUse("read"), user("keep me"), toolResult("read", "r")];
-    const out = dropBefore(messages, 2, 1);
-    assert.equal(out, messages, "anchor floor would orphan the tool result → no-op");
-});
-test("isBoundarySafe: interleaved custom between call and result is detected unsafe", () => {
-    const messages = [user("a"), toolUse("read"), custom("bash"), toolResult("read", "r")];
-    // keepFrom=3 drops the call at index 1, keeps the result at index 3 → unsafe.
-    assert.equal(isBoundarySafe(messages, 3), false);
-    // keepFrom=2 ALSO drops the call at index 1 (drop [0,2) = [user, toolUse]) and
-    // keeps the result at index 3 → still orphaned → unsafe.
-    assert.equal(isBoundarySafe(messages, 2), false);
-    // keepFrom=1 keeps the call (index 1) together with its result at index 3 → safe.
-    assert.equal(isBoundarySafe(messages, 1), true);
-});
-test("isBoundarySafe: cut before any tool result is safe", () => {
-    const messages = [user("a"), toolUse("read"), toolResult("read", "r"), assistant("done")];
-    assert.equal(isBoundarySafe(messages, 0), true); // out of range → safe
-    assert.equal(isBoundarySafe(messages, messages.length), true); // out of range → safe
-});

package/dist/src/compact.test.js

@@ -1,78 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { formatCompactSummary, summarizeMessages, mergeCompactSummaries, shouldCompact, autoCompactCheck, collectKeyFiles, inferPendingWork, extractFileCandidates, } from "./compact.js";
-import { estimateSessionTokens } from "./tokens.js";
-function user(text) { return { role: "user", text }; }
-function assistant(text) { return { role: "assistant", text }; }
-function toolUse(name, input) { return { role: "assistant", text: "", toolName: name, input }; }
-function toolResult(name, output) { return { role: "tool", text: "", toolName: name, output }; }
-test("formatCompactSummary strips analysis and formats summary block (claw-code parity)", () => {
-    const summary = "<analysis>scratch</analysis>\n<summary>Kept work</summary>";
-    assert.equal(formatCompactSummary(summary), "Summary:\nKept work");
-});
-test("leaves small sessions unchanged (shouldCompact false)", () => {
-    const messages = [user("hello")];
-    assert.equal(shouldCompact(messages, 1, 4), false);
-});
-test("compacts older messages into a summary with Scope + timeline", () => {
-    const messages = [
-        user("one ".repeat(200)),
-        assistant("two ".repeat(200)),
-        toolResult("bash", "ok ".repeat(200)),
-        assistant("recent"),
-    ];
-    assert.equal(shouldCompact(messages, 1, 2), true);
-    const summary = summarizeMessages(messages.slice(0, 2));
-    const formatted = formatCompactSummary(summary);
-    assert.ok(formatted.includes("Scope:"));
-    assert.ok(formatted.includes("Key timeline:"));
-});
-test("merge keeps previous compacted context when compacting again", () => {
-    const first = summarizeMessages([
-        user("Investigate src/compact.ts"),
-        assistant("I will inspect the compact flow."),
-    ]);
-    const second = summarizeMessages([
-        user("Also update src/boundary.ts"),
-        assistant("Next: preserve prior summary context."),
-    ]);
-    const merged = mergeCompactSummaries(first, second);
-    assert.ok(merged.includes("Previously compacted context:"));
-    assert.ok(merged.includes("Newly compacted context:"));
-    assert.ok(merged.includes("src/boundary.ts"));
-});
-test("infers pending work from recent messages", () => {
-    const pending = inferPendingWork([
-        user("done"),
-        assistant("Next: update tests and follow up on remaining CLI polish."),
-    ]);
-    assert.equal(pending.length, 1);
-    assert.ok(pending[0].includes("Next: update tests"));
-});
-test("extracts key files from message content", () => {
-    const files = collectKeyFiles([
-        user("Update src/compact.ts and extensions/mega-compact.ts next."),
-    ]);
-    assert.ok(files.includes("src/compact.ts"));
-    assert.ok(files.includes("extensions/mega-compact.ts"));
-});
-test("extractFileCandidates ignores plain words and non-interesting extensions", () => {
-    const files = extractFileCandidates("look at foo/bar.png and src/x.ts and justaword");
-    assert.deepEqual(files, ["src/x.ts"]);
-});
-test("summarizeMessages lists tool names sorted + deduped", () => {
-    const summary = summarizeMessages([toolUse("search", "{}"), toolUse("bash", "{}"), toolResult("search", "ok")]);
-    assert.ok(summary.includes("Tools mentioned: bash, search."));
-});
-test("autoCompactCheck reports utilization and threshold gate", () => {
-    const under = autoCompactCheck(10000, 50000);
-    assert.equal(under.shouldCompact, false);
-    assert.equal(under.utilizationPct, 20);
-    const over = autoCompactCheck(60000, 50000);
-    assert.equal(over.shouldCompact, true);
-});
-test("token estimator counts text + tool payloads", () => {
-    const total = estimateSessionTokens([user("abcd"), toolResult("bash", "abcd")]);
-    // "abcd"/4+1 = 2 for user; tool: name "bash"/4+1=2 plus output "abcd"/4+1=2 => 4
-    assert.equal(total, 2 + 4);
-});

package/dist/src/config/themes.test.js

@@ -1,94 +0,0 @@
-/**
- * themes.test.ts — S30 theme palette source-of-truth tests.
- * Pi-agnostic: no pi runtime imports.
- */
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { THEMES, THEME_IDS, DEFAULT_THEME, getTheme, isValidTheme, nextTheme, themeCssVars, themeDataBlock, } from "./themes.js";
-describe("themes (S30)", () => {
-    it("defines exactly 6 themes", () => {
-        assert.equal(THEMES.length, 6);
-        assert.equal(THEME_IDS.length, 6);
-    });
-    it("has unique ids", () => {
-        assert.equal(new Set(THEME_IDS).size, 6);
-    });
-    it("default theme is transparent", () => {
-        assert.equal(DEFAULT_THEME, "transparent");
-        assert.ok(isValidTheme(DEFAULT_THEME));
-    });
-    it("includes retro, orange-bold, cyan-neon, amber-mono, grayscale", () => {
-        for (const id of ["retro", "orange-bold", "cyan-neon", "amber-mono", "grayscale"]) {
-            assert.ok(isValidTheme(id), `missing ${id}`);
-        }
-    });
-    it("transparent theme has null bg (CSS + ANSI)", () => {
-        const t = getTheme("transparent");
-        assert.ok(t);
-        assert.equal(t.css.bg, null);
-        assert.equal(t.ansi.bg, null);
-    });
-    it("every non-transparent theme has a non-null bg", () => {
-        for (const t of THEMES) {
-            if (t.id === "transparent")
-                continue;
-            assert.ok(t.css.bg, `${t.id} css.bg`);
-            assert.ok(t.ansi.bg, `${t.id} ansi.bg`);
-        }
-    });
-    it("every theme has css + ansi {fg,accent,mega} strings", () => {
-        for (const t of THEMES) {
-            assert.ok(typeof t.css.fg === "string" && t.css.fg.startsWith("#"));
-            assert.ok(typeof t.css.accent === "string");
-            assert.ok(typeof t.css.mega === "string");
-            assert.ok(typeof t.ansi.fg === "string");
-            assert.ok(typeof t.ansi.accent === "string");
-            assert.ok(typeof t.ansi.mega === "string");
-        }
-    });
-    it("getTheme returns undefined for unknown id", () => {
-        assert.equal(getTheme("nope"), undefined);
-    });
-    it("isValidTheme is false for unknown", () => {
-        assert.equal(isValidTheme("nope"), false);
-    });
-    it("nextTheme cycles through all themes and wraps", () => {
-        const seen = [];
-        let cur = DEFAULT_THEME;
-        for (let i = 0; i < THEME_IDS.length; i++) {
-            cur = nextTheme(cur);
-            seen.push(cur);
-        }
-        // after N steps we've visited every theme once
-        assert.equal(new Set(seen).size, THEME_IDS.length);
-        // wraps: one more step from the last returns to the first
-        const first = nextTheme(THEME_IDS[THEME_IDS.length - 1]);
-        assert.equal(first, THEME_IDS[0]);
-    });
-    it("nextTheme falls back to DEFAULT_THEME for unknown current", () => {
-        assert.equal(nextTheme("garbage"), DEFAULT_THEME);
-    });
-});
-describe("themeCssVars / themeDataBlock (S32)", () => {
-    it("themeCssVars emits --bg/--fg/--accent/--mega for a normal theme", () => {
-        const t = getTheme("retro");
-        const vars = themeCssVars(t);
-        assert.match(vars, /--bg: #003300;/);
-        assert.match(vars, /--fg: #33ff33;/);
-        assert.match(vars, /--accent: #00ff41;/);
-        assert.match(vars, /--mega: #39ff14;/);
-    });
-    it("themeCssVars maps null bg to 'transparent'", () => {
-        const t = getTheme("transparent");
-        const vars = themeCssVars(t);
-        assert.match(vars, /--bg: transparent;/);
-        assert.match(vars, /--fg: #c9d1d9;/);
-    });
-    it("themeDataBlock wraps vars in a :root[data-theme=\"<id\"] selector", () => {
-        const t = getTheme("cyan-neon");
-        const block = themeDataBlock(t);
-        assert.equal(block.startsWith(':root[data-theme="cyan-neon"]{ '), true);
-        assert.equal(block.endsWith(" }"), true);
-        assert.ok(block.includes("--accent: #22d3ee;"));
-    });
-});

package/dist/src/dedup/dedup.test.js

@@ -1,41 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { normalize, stripAnsi } from "./normalize.js";
-import { computeContentDigest, CONTENT_HASH_VERSION } from "./digest.js";
-test("normalize collapses whitespace/newline variants to one form (Sprint 9)", () => {
-    // Sprint 9 normalizes whitespace/newlines/ANSI (not case — that is Sprint 10).
-    const variants = [
-        "foo  bar",
-        "foo bar",
-        "foo\tbar",
-        "foo\nbar",
-        "  foo   bar  ",
-        "foo\r\nbar",
-    ];
-    const digests = variants.map((v) => computeContentDigest(v).contentHash);
-    const unique = new Set(digests);
-    assert.equal(unique.size, 1, "all whitespace/newline variants must collapse to one digest");
-});
-test("normalize is idempotent", () => {
-    const input = "  Hello   World  \n";
-    assert.equal(normalize(normalize(input)), normalize(input));
-});
-test("stripAnsi removes terminal color codes", () => {
-    const colored = "err\x1b[31m fatal\x1b[0m boom";
-    assert.equal(stripAnsi(colored), "err fatal boom");
-});
-test("computeContentDigest emits full 64-hex dual hashes + version", () => {
-    const d = computeContentDigest("the same region text");
-    assert.equal(d.contentHash.length, 64);
-    assert.equal(d.contentHash2.length, 64);
-    assert.equal(d.contentHashVersion, CONTENT_HASH_VERSION);
-    assert.equal(d.normalizedText, "the same region text");
-    // Secondary is an independent view (reversed) so it differs from primary.
-    assert.notEqual(d.contentHash, d.contentHash2);
-});
-test("dual-hash: distinct content yields a distinct pair (both must agree to dedup)", () => {
-    const a = computeContentDigest("region about authentication");
-    const b = computeContentDigest("region about authorization");
-    assert.notEqual(a.contentHash, b.contentHash);
-    assert.notEqual(a.contentHash2, b.contentHash2);
-});

package/dist/src/dedup/l1.test.js

@@ -1,50 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { minhashSignature, shingles, signatureSimilarity, NUM_HASHES } from "./l1-minhash.js";
-import { lshBands, BANDS, ROWS_PER_BAND } from "./l1-lsh.js";
-import { trigramSimilarity, isNearDuplicate, L1_VERIFY_THRESHOLD } from "./l1-verify.js";
-test("minhashSignature is deterministic across calls (same input → same sig)", () => {
-    const a = minhashSignature("the authentication module handles login securely");
-    const b = minhashSignature("the authentication module handles login securely");
-    assert.deepEqual(a, b);
-    assert.equal(a.length, NUM_HASHES);
-});
-test("minhashSignature of near-identical text is more similar than of unrelated text", () => {
-    const s1 = minhashSignature("user logged in and viewed the dashboard");
-    const s2 = minhashSignature("user logged in and viewed the dashboard page"); // one word added
-    const s3 = minhashSignature("the compiler optimized the hot loop aggressively");
-    assert.ok(signatureSimilarity(s1, s2) > signatureSimilarity(s1, s3));
-});
-test("lshBands produces BANDS keys and is stable per session", () => {
-    const sig = minhashSignature("some text to band");
-    const k1 = lshBands(sig, "sess_a", 1);
-    const k2 = lshBands(sig, "sess_a", 1);
-    assert.equal(k1.length, BANDS);
-    assert.equal(BANDS * ROWS_PER_BAND, NUM_HASHES);
-    assert.deepEqual(k1, k2);
-    // Different session → different bucket keys (scoped, deterministic).
-    const k3 = lshBands(sig, "sess_b", 1);
-    assert.notDeepEqual(k1, k3);
-});
-test("lshBands keys are stable across restarts (no entropy source)", () => {
-    // Recomputed in a fresh call path — determinism is structural, not time-based.
-    const sig = minhashSignature("deterministic bucket key check");
-    const first = lshBands(sig, "sess_x", 1);
-    const again = lshBands(sig, "sess_x", 1);
-    assert.deepEqual(first, again);
-});
-test("trigramSimilarity is 1 for identical, high for one-word-edit, low for unrelated", () => {
-    const a = "the quick brown fox jumps";
-    assert.equal(trigramSimilarity(a, a), 1);
-    assert.ok(trigramSimilarity(a, "the quick brown fox jumps over") >= L1_VERIFY_THRESHOLD);
-    assert.ok(trigramSimilarity(a, "a completely different sentence about databases") < 0.5);
-});
-test("isNearDuplicate thresholds at 0.85", () => {
-    assert.equal(isNearDuplicate("user fixed the parser bug", "user fixed the parser bug today"), true);
-    assert.equal(isNearDuplicate("alpha beta gamma", "totally different words here"), false);
-});
-test("shingles are capped at 50K (complexity guard)", () => {
-    const huge = "x".repeat(200_000);
-    const sh = shingles(huge);
-    assert.ok(sh.length <= 50_000);
-});