pi-mega-compact 0.11.4 → 0.11.5

package/dist/src/vectorStore.test.js

@@ -1,479 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { VectorStore, computeRegionHash, vectorStats, vectorDedupe, vectorWasInjected, vectorMarkInjected, vectorList, vectorTopSimilar, vectorRepoStats, vectorSearch } from "./vectorStore.js";
-import { TrigramEmbedder, cosineSimilarity, l2Normalize, defaultEmbedder, } from "./embedder.js";
-import { normalizeSessionId, decompressSmart } from "./store.js";
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-test-"));
-// Each store() gets its own isolated state dir passed explicitly (no global
-// env var) so parallel/concurrent tests never share on-disk checkpoints.
-let counter = 0;
-function store(opts = {}) {
-    const dir = join(baseTmp, `run-${counter++}`);
-    return new VectorStore({ dedupSim: opts.dedupSim ?? 0.9, stateDir: dir });
-}
-test("cleanup temp dir", () => {
-    assert.ok(baseTmp.startsWith(tmpdir()));
-});
-test("embedder is deterministic and normalized", () => {
-    const e = defaultEmbedder();
-    const a = e.embed("compact the session context");
-    const b = e.embed("compact the session context");
-    assert.deepEqual(a, b);
-    const n = l2Normalize(a);
-    const mag = Math.sqrt(n.reduce((s, x) => s + x * x, 0));
-    assert.ok(Math.abs(mag - 1) < 1e-9);
-});
-test("cosine similarity is 1 for identical, <1 for different", () => {
-    const e = new TrigramEmbedder();
-    const a = e.embed("read src/server.ts and fix the bug");
-    const b = e.embed("read src/server.ts and fix the bug");
-    const c = e.embed("play a song on the guitar");
-    assert.ok(Math.abs(cosineSimilarity(a, b) - 1) < 1e-9);
-    assert.ok(cosineSimilarity(a, c) < 1);
-});
-test("add then search returns the planted checkpoint top-1", () => {
-    const s = store();
-    s.add({
-        sessionId: "sess_abc",
-        summary: "Investigated src/compact.ts and added truncation.",
-        regionText: "user asked to investigate src/compact.ts assistant added truncate helper",
-        keyDecisions: ["add truncate helper"],
-        filesModified: ["src/compact.ts"],
-        tokenEstimate: 1200,
-        timestamp: 1000,
-    });
-    const hits = vectorSearch(s, "sess_abc", "src/compact.ts truncate helper", 3);
-    assert.equal(hits.length, 1);
-    assert.ok(hits[0].score > 0.5);
-    assert.equal(hits[0].checkpoint.summary.includes("src/compact.ts"), true);
-});
-test("dedup by regionHash: identical region is not double-stored", () => {
-    const s = store();
-    const region = "the same conversation region text";
-    const r1 = s.add({
-        sessionId: "sess_dup",
-        summary: "first",
-        regionText: region,
-        timestamp: 1,
-    });
-    const r2 = s.add({
-        sessionId: "sess_dup",
-        summary: "second",
-        regionText: region,
-        timestamp: 2,
-    });
-    assert.equal(r1.deduped, false);
-    assert.equal(r2.deduped, true);
-    assert.equal(r1.checkpoint.checkpointId, r2.checkpoint.checkpointId);
-    assert.equal(vectorSearch(s, "sess_dup", "anything", 10).length, 1);
-});
-test("dedup cascade: summaryHash catches same-topic incremental compactions", () => {
-    const s = store();
-    const r1 = s.add({
-        sessionId: "sess_sh",
-        summary: "step 1",
-        topicSummary: "User working on auth module refactor in src/auth.ts.",
-        regionText: "first region text for step 1",
-        timestamp: 100,
-    });
-    // Different regionText (incremental compaction adds messages), same topicSummary
-    const r2 = s.add({
-        sessionId: "sess_sh",
-        summary: "step 2",
-        topicSummary: "User working on auth module refactor in src/auth.ts.",
-        regionText: "second region text for step 2 with additional messages",
-        timestamp: 200,
-    });
-    assert.equal(r1.deduped, false);
-    assert.equal(r2.deduped, true);
-    assert.equal(r2.reason, "summaryHash");
-    assert.equal(r1.checkpoint.checkpointId, r2.checkpoint.checkpointId);
-    // Timestamp should be updated to the newer one
-    assert.equal(r2.checkpoint.timestamp, 200);
-});
-test("dedup cascade: summaryHash dedup still stores only one checkpoint", () => {
-    const s = store();
-    const summary = "same summary for both adds";
-    const ts = "some topic summary that is identical";
-    s.add({ sessionId: "sess_sh2", summary, topicSummary: ts, regionText: "region a", timestamp: 1 });
-    s.add({ sessionId: "sess_sh2", summary, topicSummary: ts, regionText: "region b", timestamp: 2 });
-    assert.equal(vectorStats(s, "sess_sh2").checkpointCount, 1);
-});
-test("dedupe() sentinel returns true for a stored region", () => {
-    const s = store();
-    const region = "region for sentinel test";
-    const hash = computeRegionHash(region);
-    s.add({
-        sessionId: "sess_sent",
-        summary: "x",
-        regionText: region,
-        timestamp: 1,
-    });
-    assert.equal(vectorDedupe(s, "sess_sent", hash), true);
-    assert.equal(vectorDedupe(s, "sess_sent", "deadbeef"), false);
-});
-test("near-duplicate collapse keeps only the top of a near-identical pair", () => {
-    const s = store();
-    s.add({
-        sessionId: "sess_nd",
-        summary: "alpha",
-        regionText: "user investigated src/compact.ts and added a truncate helper for summaries",
-        timestamp: 1,
-    });
-    s.add({
-        sessionId: "sess_nd",
-        summary: "beta",
-        regionText: "user investigated src/compact.ts and added a truncate helper for the summaries",
-        timestamp: 2,
-    });
-    const hits = vectorSearch(s, "sess_nd", "user investigated src/compact.ts and added a truncate helper for summaries", 5);
-    assert.equal(hits.length, 1);
-});
-test("markInjected / wasInjected track injection", () => {
-    const s = store();
-    const r = s.add({
-        sessionId: "sess_inj",
-        summary: "y",
-        regionText: "inject region",
-        timestamp: 1,
-    });
-    assert.equal(vectorWasInjected(s, "sess_inj", r.checkpoint.checkpointId), false);
-    vectorMarkInjected(s, "sess_inj", r.checkpoint.checkpointId);
-    assert.equal(vectorWasInjected(s, "sess_inj", r.checkpoint.checkpointId), true);
-});
-test("normalizeSessionId handles null, prefixed, and uuid forms", () => {
-    assert.match(normalizeSessionId("sess_abc"), /^sess_/);
-    assert.equal(normalizeSessionId("sess_abc"), "sess_abc");
-    assert.match(normalizeSessionId("550e8400-e29b-41d4-a716-446655440000"), /^sess_[0-9a-f]{16}$/);
-    assert.match(normalizeSessionId(undefined), /^sess_[0-9a-f]{16}$/);
-});
-test("nextCheckpointId is sequential per session", () => {
-    const s = store();
-    const a = s.add({
-        sessionId: "sess_seq",
-        summary: "1",
-        regionText: "r1",
-        timestamp: 1,
-    });
-    const b = s.add({
-        sessionId: "sess_seq",
-        summary: "2",
-        regionText: "r2",
-        timestamp: 2,
-    });
-    assert.equal(a.checkpoint.checkpointId, "chkpt_001");
-    assert.equal(b.checkpoint.checkpointId, "chkpt_002");
-});
-test("checkpoints survive a fresh store instance (on-disk)", () => {
-    const dir = join(baseTmp, `run-${counter++}`);
-    const s1 = new VectorStore({ dedupSim: 0.9, stateDir: dir });
-    s1.add({
-        sessionId: "sess_persist",
-        summary: "persisted",
-        regionText: "persist region text",
-        timestamp: 1,
-    });
-    const s2 = new VectorStore({ dedupSim: 0.9, stateDir: dir }); // new instance, same disk state
-    const hits = vectorSearch(s2, "sess_persist", "persist region text", 3);
-    assert.equal(hits.length, 1);
-    assert.equal(hits[0].checkpoint.summary, "persisted");
-});
-test("corrupt checkpoint file falls back to empty (no throw)", () => {
-    const dir = join(baseTmp, `run-${counter++}`);
-    mkdirSync(dir, { recursive: true });
-    const file = join(dir, "sess_corrupt.checkpoints.json.gz");
-    writeFileSync(file, Buffer.from("not a gzip"));
-    const s = new VectorStore({ dedupSim: 0.9, stateDir: dir });
-    assert.equal(vectorSearch(s, "sess_corrupt", "q", 3).length, 0);
-});
-test("stats reports counts, last checkpoint, and dedup rate", () => {
-    const s = store();
-    s.add({
-        sessionId: "sess_stats",
-        summary: "alpha",
-        regionText: "region alpha text",
-        tokenEstimate: 500,
-        timestamp: 1,
-    });
-    s.add({
-        sessionId: "sess_stats",
-        summary: "beta",
-        regionText: "region beta text",
-        tokenEstimate: 700,
-        timestamp: 2,
-    });
-    const st1 = vectorStats(s, "sess_stats");
-    assert.equal(st1.checkpointCount, 2);
-    assert.equal(st1.lastCheckpointId, "chkpt_002");
-    assert.equal(st1.totalTokenEstimate, 1200);
-    assert.equal(st1.injectedCount, 0);
-    assert.equal(st1.dedupHitRate, 0);
-    vectorMarkInjected(s, "sess_stats", "chkpt_001");
-    const st2 = vectorStats(s, "sess_stats");
-    assert.equal(st2.injectedCount, 1);
-    assert.ok(Math.abs(st2.dedupHitRate - 0.5) < 1e-9);
-});
-test("tokensSaved = original − stored per session; deduped add saves the whole region", () => {
-    const s = store();
-    // Two genuinely new checkpoints. saved = original − stored.
-    //   cp1: orig 2000, stored 500 → saved 1500
-    //   cp2: orig 3000, stored 700 → saved 2300
-    s.add({ sessionId: "sess_saved", summary: "alpha", regionText: "region alpha text", tokenEstimate: 500, originalTokenEstimate: 2000, timestamp: 1 });
-    s.add({ sessionId: "sess_saved", summary: "beta", regionText: "region beta text", tokenEstimate: 700, originalTokenEstimate: 3000, timestamp: 2 });
-    const st = vectorStats(s, "sess_saved");
-    assert.equal(st.totalTokenEstimate, 1200, "Σ stored summaries");
-    assert.equal(st.originalTokens, 5000, "Σ original region tokens");
-    assert.equal(st.tokensSaved, 3800, "per-session saved = Σ(original − stored) = 1500 + 2300");
-    assert.equal(st.dedupCollapsed, 0);
-    assert.equal(st.dedupAttempts, 2);
-    // A third add that dedups onto an existing region: whole original region (2000)
-    // is discarded (nothing new stored) → repo saved grows by the full original,
-    // dedupCollapsed bumps, and no new checkpoint row is created.
-    const deduped = s.add({ sessionId: "sess_saved", summary: "alpha", regionText: "region alpha text", tokenEstimate: 500, originalTokenEstimate: 2000, timestamp: 3 });
-    assert.ok(deduped.deduped, "identical region should dedup");
-    const st3 = vectorStats(s, "sess_saved");
-    // Per-session DB sum only covers stored rows (deduped adds create no row), so
-    // the per-session figure is unchanged; the deduped save lands in the repo meta.
-    assert.equal(st3.tokensSaved, 3800, "per-session DB sum unchanged by deduped add");
-    assert.equal(st3.dedupCollapsed, 1, "deduped collapse counted");
-    assert.equal(st3.dedupAttempts, 3);
-    // Repo cumulative counter DID capture the deduped region's full original size.
-    assert.equal(vectorRepoStats(s).tokensSaved, 3800 + 2000, "repo saved includes deduped original");
-});
-test("repoStats aggregates every session + counts deduped original tokens", () => {
-    const dir = join(baseTmp, `repo-${counter++}`);
-    const a = new VectorStore({ dedupSim: 0.9, stateDir: dir });
-    const b = new VectorStore({ dedupSim: 0.9, stateDir: dir }); // same disk store, diff instance
-    a.add({ sessionId: "sess_a", summary: "alpha", regionText: "region alpha text", tokenEstimate: 500, originalTokenEstimate: 2000, timestamp: 1 });
-    b.add({ sessionId: "sess_b", summary: "beta", regionText: "region beta text", tokenEstimate: 700, originalTokenEstimate: 3000, timestamp: 2 });
-    const repo = vectorRepoStats(a);
-    assert.equal(repo.checkpointCount, 2, "checkpoints across both sessions");
-    assert.equal(repo.sessionCount, 2, "two distinct sessions");
-    assert.equal(repo.totalTokenEstimate, 1200, "Σ stored");
-    assert.equal(repo.originalTokens, 5000, "Σ original");
-    assert.equal(repo.tokensSaved, 3800, "repo saved = Σ(original − stored) = 1500 + 2300");
-    assert.equal(repo.dedupCollapsed, 0);
-    // A deduped add into sess_a: whole original region saved, no new row.
-    const deduped = a.add({ sessionId: "sess_a", summary: "alpha", regionText: "region alpha text", tokenEstimate: 500, originalTokenEstimate: 2000, timestamp: 3 });
-    assert.ok(deduped.deduped);
-    const repo2 = vectorRepoStats(a);
-    assert.equal(repo2.tokensSaved, 3800 + 2000, "deduped collapse adds full original region to repo saved");
-    assert.equal(repo2.dedupCollapsed, 1);
-    assert.equal(repo2.checkpointCount, 2, "still two stored checkpoints");
-});
-test("computeRegionHash normalizes whitespace before hashing", () => {
-    const h1 = computeRegionHash("foo  bar");
-    const h2 = computeRegionHash("foo bar");
-    const h3 = computeRegionHash("  foo   bar  ");
-    assert.equal(h1, h2, "double space and single space should hash the same");
-    assert.equal(h2, h3, "leading/trailing spaces should hash the same");
-    // Sanity: different content still hashes differently.
-    assert.notEqual(h1, computeRegionHash("foo baz"));
-});
-test("whitespace-variant region is deduplicated", () => {
-    const s = store();
-    const r1 = s.add({
-        sessionId: "sess_ws",
-        summary: "first",
-        regionText: "user  changed  config.ts",
-        timestamp: 1,
-    });
-    assert.equal(r1.deduped, false);
-    const r2 = s.add({
-        sessionId: "sess_ws",
-        summary: "second",
-        regionText: "user changed config.ts",
-        timestamp: 2,
-    });
-    assert.equal(r2.deduped, true, "whitespace-variant should be deduplicated");
-    assert.equal(vectorStats(s, "sess_ws").checkpointCount, 1, "only one checkpoint stored");
-});
-test("topSimilar returns n most similar checkpoints to the current (most recent)", () => {
-    const s = store();
-    s.add({
-        sessionId: "sess_top",
-        summary: "guitar",
-        regionText: "play a song on the guitar",
-        timestamp: 1,
-    });
-    s.add({
-        sessionId: "sess_top",
-        summary: "compact",
-        regionText: "fix bug in src/compact.ts truncation",
-        timestamp: 2,
-    });
-    // most recent (current) is chkpt_003, also about compact.ts but clearly
-    // distinct content so L1 near-dup dedup does not collapse it.
-    s.add({
-        sessionId: "sess_top",
-        summary: "current",
-        regionText: "fix the buffer overflow in src/compact.ts by adding a bounds check before truncate",
-        timestamp: 3,
-    });
-    const hits = vectorTopSimilar(s, "sess_top", 10);
-    assert.equal(hits.length, 2); // two other checkpoints
-    // The compact.ts checkpoint should rank above the guitar checkpoint
-    assert.equal(hits[0].checkpoint.summary, "compact");
-    assert.equal(hits[1].checkpoint.summary, "guitar");
-    assert.ok(hits[0].score >= hits[1].score);
-});
-test("topSimilar excludes the current checkpoint itself", () => {
-    const s = store();
-    s.add({
-        sessionId: "sess_self",
-        summary: "a",
-        regionText: "alpha region text one",
-        timestamp: 1,
-    });
-    s.add({
-        sessionId: "sess_self",
-        summary: "b",
-        regionText: "alpha region text two",
-        timestamp: 2,
-    });
-    const hits = vectorTopSimilar(s, "sess_self", 5);
-    assert.equal(hits.length, 1);
-    assert.notEqual(hits[0].checkpoint.checkpointId, "chkpt_002"); // not the current
-});
-test("topSimilar returns empty for sessions with 0 or 1 checkpoints", () => {
-    const s = store();
-    assert.deepEqual(vectorTopSimilar(s, "sess_none", 5), []);
-    s.add({
-        sessionId: "sess_one",
-        summary: "solo",
-        regionText: "only checkpoint",
-        timestamp: 1,
-    });
-    assert.deepEqual(vectorTopSimilar(s, "sess_one", 5), []);
-});
-test("topSimilar respects the n limit", () => {
-    const s = store();
-    const regions = [
-        "the compiler optimized the hot loop with loop unrolling",
-        "the database added a covering index to speed up queries",
-        "the frontend introduced a virtualized list for large tables",
-        "the api added rate limiting using a token bucket algorithm",
-        "the worker pool now backpressures when the queue is overloaded",
-    ];
-    for (let i = 0; i < regions.length; i++) {
-        s.add({
-            sessionId: "sess_limit",
-            summary: `c${i + 1}`,
-            regionText: regions[i],
-            timestamp: i + 1,
-        });
-    }
-    const hits = vectorTopSimilar(s, "sess_limit", 2);
-    assert.equal(hits.length, 2);
-});
-test("stats on empty session returns zeros and nulls", () => {
-    const s = store();
-    const st = vectorStats(s, "sess_empty");
-    assert.equal(st.checkpointCount, 0);
-    assert.equal(st.lastCheckpointId, undefined);
-    assert.equal(st.totalTokenEstimate, 0);
-    assert.equal(st.dedupHitRate, 0);
-});
-// --- Sprint 9: L0 content-addressable dedup -------------------------------
-test("L0 content-hash dedup: identical content under different regionText collapses to one row", () => {
-    const s = store();
-    const r1 = s.add({
-        sessionId: "sess_l0",
-        summary: "fix the parser",
-        regionText: "user asked to fix the parser assistant patched src/parse.ts",
-        timestamp: 1,
-    });
-    const r2 = s.add({
-        sessionId: "sess_l0",
-        summary: "fix the parser",
-        regionText: "  user   asked to fix the parser   assistant patched src/parse.ts  ",
-        timestamp: 2,
-    });
-    assert.equal(r1.deduped, false);
-    assert.equal(r2.deduped, true);
-    assert.equal(r2.reason, "contentHash");
-    assert.equal(vectorList(s, "sess_l0").length, 1);
-});
-test("L0 content-hash dedup stores both hash fields and bumps timestamp on hit", () => {
-    const s = store();
-    const region = "the quick brown fox jumps over the lazy dog";
-    s.add({ sessionId: "sess_l0ts", summary: "first", regionText: region, timestamp: 10 });
-    const r2 = s.add({
-        sessionId: "sess_l0ts",
-        summary: "second",
-        regionText: region,
-        timestamp: 99,
-    });
-    assert.equal(r2.deduped, true);
-    assert.equal(r2.reason, "contentHash");
-    const cp = vectorList(s, "sess_l0ts")[0];
-    assert.equal(cp.contentHash?.length, 64);
-    assert.equal(cp.contentHash2?.length, 64);
-    assert.equal(cp.contentHashVersion, 1);
-    assert.equal(cp.timestamp, 99);
-});
-test("compressed_original roundtrips through versioned compression", () => {
-    const s = store();
-    const raw = "raw region text preserved for audit and replay";
-    s.add({ sessionId: "sess_co", summary: "x", regionText: raw, timestamp: 1 });
-    const cp = vectorList(s, "sess_co")[0];
-    assert.ok(cp.compressedOriginal instanceof Buffer);
-    const restored = decompressSmart(cp.compressedOriginal).toString("utf-8");
-    assert.equal(restored, raw);
-});
-test("summaryHash is now full 64-hex SHA-256", () => {
-    const s = store();
-    const ts = "topic summary for same-topic incremental compaction";
-    const r1 = s.add({
-        sessionId: "sess_sh64",
-        summary: "a",
-        topicSummary: ts,
-        regionText: "region alpha",
-        timestamp: 1,
-    });
-    assert.equal(r1.checkpoint.summaryHash?.length, 64);
-    const r2 = s.add({
-        sessionId: "sess_sh64",
-        summary: "b",
-        topicSummary: ts,
-        regionText: "region bravo",
-        timestamp: 2,
-    });
-    assert.equal(r2.deduped, true);
-    assert.equal(r2.reason, "summaryHash");
-});
-// --- Sprint 11: L1 MinHash/LSH near-duplicate dedup ------------------------
-test("L1 catches a one-word-diff near-duplicate that L0 misses", () => {
-    const s = store();
-    const r1 = s.add({
-        sessionId: "sess_l1",
-        summary: "user reviewed the auth module and merged the pull request",
-        regionText: "user reviewed the authentication module and merged the pull request",
-        timestamp: 1,
-    });
-    // One word inserted + different case/whitespace → L0 content-hash differs,
-    // but the text is a near-duplicate caught by the L1 trigram verify.
-    const r2 = s.add({
-        sessionId: "sess_l1",
-        summary: "user reviewed the auth module and merged the pull request",
-        regionText: "  USER   reviewed the authentication module and merged the pull request now ",
-        timestamp: 2,
-    });
-    assert.equal(r1.deduped, false);
-    assert.equal(r2.deduped, true);
-    assert.equal(r2.reason, "l1MinHash");
-    assert.equal(vectorList(s, "sess_l1").length, 1);
-});
-test("L1 does NOT falsely dedup genuinely different content", () => {
-    const s = store();
-    s.add({ sessionId: "sess_l1b", summary: "a", regionText: "the database migration added three indexes", timestamp: 1 });
-    const r2 = s.add({ sessionId: "sess_l1b", summary: "b", regionText: "the frontend added a dark mode toggle", timestamp: 2 });
-    assert.equal(r2.deduped, false);
-    assert.equal(vectorList(s, "sess_l1b").length, 2);
-});
-test("cleanup", () => {
-    rmSync(baseTmp, { recursive: true, force: true });
-});

package/dist/src/wiki.test.js

@@ -1,171 +0,0 @@
-/**
- * wiki.test.ts — S51C extractive wiki page tests. No network; temp dirs.
- * Includes the honest-boundary grep-assert (no ollama/llm/fetch) required by s47/s51.
- */
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, readFileSync, readdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { extractiveSummary, generateWikiPage, buildWikiIndex } from "./wiki.js";
-let tmpDir;
-beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "mc-wiki-"));
-});
-afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-});
-function mkTopic(id, label, termScores) {
-    return { id, label, termScores, memoryCount: 0, lastUpdated: 0 };
-}
-function mkAssignment(memId, topicId, confidence = 0.8) {
-    return {
-        memoryId: memId,
-        sessionId: "s",
-        topicId,
-        confidence,
-        assignedAt: 0,
-        method: "kmeans+tfidf",
-    };
-}
-test("extractiveSummary returns top sentences joined", () => {
-    const topic = mkTopic("t1", "sqlite", [{ term: "sqlite", score: 1 }]);
-    const assignments = [mkAssignment("a", "t1"), mkAssignment("b", "t1")];
-    const getContent = (id) => {
-        if (id === "a")
-            return "SQLite uses WAL mode. SQLite uses WAL mode. SQLite uses WAL mode.";
-        if (id === "b")
-            return "Postgres uses WAL mode. Postgres uses WAL mode.";
-        return "";
-    };
-    const summary = extractiveSummary(topic, assignments, getContent);
-    // Should be non-empty and contain at least one sentence
-    assert.ok(summary.length > 0);
-    assert.ok(summary.includes("WAL"));
-});
-test("extractiveSummary returns empty string when topic has no members", () => {
-    const topic = mkTopic("t1", "empty", []);
-    const summary = extractiveSummary(topic, [], () => "");
-    assert.equal(summary, "");
-});
-test("generateWikiPage produces page with summary + key/recent memories", () => {
-    const topic = mkTopic("t1", "sqlite", [{ term: "sqlite", score: 1 }]);
-    const assignments = [
-        mkAssignment("a", "t1", 0.9),
-        mkAssignment("b", "t1", 0.5),
-    ];
-    const getMemoryInfo = (id) => {
-        if (id === "a")
-            return {
-                content: "First memory content",
-                timestamp: 100,
-                importance: 0.9,
-            };
-        if (id === "b")
-            return {
-                content: "Second memory content",
-                timestamp: 200,
-                importance: 0.5,
-            };
-        return null;
-    };
-    const allTopics = [topic];
-    const page = generateWikiPage(topic, assignments, getMemoryInfo, allTopics);
-    assert.equal(page.topic.id, "t1");
-    assert.equal(page.keyMemories.length, 2);
-    // Key memories sorted by importance DESC
-    assert.equal(page.keyMemories[0].importance, 0.9);
-    // Recent memories sorted by timestamp DESC
-    assert.equal(page.recentMemories[0].timestamp, 200);
-    assert.equal(page.relatedTopics.length, 0);
-    assert.ok(page.generatedAt > 0);
-});
-test("generateWikiPage finds related topics via co-occurrence", () => {
-    const topicA = mkTopic("A", "topic-a", []);
-    const topicB = mkTopic("B", "topic-b", []);
-    const topicC = mkTopic("C", "topic-c", []);
-    // Memory "shared" appears in both topicA and topicB → A and B are related.
-    // Memory "a-only" only in topicA.
-    // Memory "c-only" only in topicC (no overlap with A).
-    const assignments = [
-        mkAssignment("shared", "A"),
-        mkAssignment("shared", "B"),
-        mkAssignment("a-only", "A"),
-        mkAssignment("c-only", "C"),
-    ];
-    const getMemoryInfo = (id) => ({
-        content: `content for ${id}`,
-        timestamp: 100,
-        importance: 0.5,
-    });
-    const page = generateWikiPage(topicA, assignments, getMemoryInfo, [
-        topicA,
-        topicB,
-        topicC,
-    ]);
-    // topicB should be related (shares "shared" with topicA); topicC should not.
-    const relatedIds = page.relatedTopics.map((t) => t.id);
-    assert.ok(relatedIds.includes("B"), `expected B in related topics, got ${relatedIds.join(",")}`);
-    assert.ok(!relatedIds.includes("C"), `C has no co-occurrence with A, should not be related`);
-});
-test("buildWikiIndex aggregates topics + memory counts", () => {
-    const topics = [mkTopic("t1", "sqlite", []), mkTopic("t2", "wal", [])];
-    topics[0].memoryCount = 5;
-    topics[1].memoryCount = 3;
-    topics[0].lastUpdated = 1000;
-    topics[1].lastUpdated = 2000;
-    const idx = buildWikiIndex(topics);
-    assert.equal(idx.totalTopics, 2);
-    assert.equal(idx.totalMemories, 8);
-    assert.equal(idx.topics.length, 2);
-    assert.ok(idx.lastRebuildAt !== null);
-});
-test("buildWikiIndex handles empty topics", () => {
-    const idx = buildWikiIndex([]);
-    assert.equal(idx.totalTopics, 0);
-    assert.equal(idx.totalMemories, 0);
-    assert.equal(idx.lastRebuildAt, null);
-});
-test("honest boundary: no LLM/network/keyword-literals in src/wiki.ts", () => {
-    const here = dirname(fileURLToPath(import.meta.url));
-    const wikiPath = join(here, "..", "..", "src", "wiki.ts");
-    const text = readFileSync(wikiPath, "utf8");
-    const banned = [/ollama/i, /\bllm\b/i, /\bfetch\s*\(/, /\bhybrid\b/i];
-    const fabricated = [
-        "graphql",
-        "docker",
-        "stacktrace",
-        "bottleneck",
-        "trade-off",
-    ];
-    for (const re of banned) {
-        assert.ok(!re.test(text), `wiki.ts must not contain ${re} (PREVENT-PI-004 / no-model boundary)`);
-    }
-    for (const word of fabricated) {
-        assert.ok(!text.toLowerCase().includes(`"${word}"`), `wiki.ts must not hardcode fabricated taxonomy term "${word}"`);
-    }
-});
-test("honest boundary: no LLM/Ollama/network in src/topics/* (non-test)", () => {
-    const here = dirname(fileURLToPath(import.meta.url));
-    // dist/src/wiki.test.js → ../../src/topics
-    const topicsDir = join(here, "..", "..", "src", "topics");
-    const files = readdirSync(topicsDir).filter((f) => f.endsWith(".ts") && !f.endsWith(".test.ts"));
-    const banned = [/ollama/i, /\bllm\b/i, /\bfetch\s*\(/, /\bhybrid\b/i];
-    const fabricated = [
-        "graphql",
-        "docker",
-        "stacktrace",
-        "bottleneck",
-        "trade-off",
-    ];
-    for (const f of files) {
-        const text = readFileSync(join(topicsDir, f), "utf8");
-        for (const re of banned) {
-            assert.ok(!re.test(text), `${f} must not contain ${re}`);
-        }
-        for (const word of fabricated) {
-            assert.ok(!text.toLowerCase().includes(`"${word}"`), `${f} must not hardcode fabricated taxonomy term "${word}"`);
-        }
-    }
-});