pi-mega-compact 0.11.3 → 0.11.5

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

@@ -1,238 +0,0 @@
-/**
- * multilevel.test.ts — hermetic unit tests for S42A multi-level RAPTOR retrieval.
- *
- * Tests the scoreTreeLevels → expandLeafDescendants → deduplicateMultilevelHits
- * → multilevelRetrieval pipeline. No network, no live store — uses TrigramEmbedder
- * and synthetic RaptorTrees built from makeLeaves().
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { TrigramEmbedder } from "../../embedder.js";
-import { buildRaptorTree } from "./tree.js";
-import { scoreTreeLevels, expandLeafDescendants, deduplicateMultilevelHits, multilevelRetrieval, buildChildParentIndex, } from "./multilevel.js";
-function msg(text) {
-    return { role: "user", text };
-}
-/** Build N distinct leaves with deterministic content. */
-function makeLeaves(n, embedder = new TrigramEmbedder()) {
-    const leaves = [];
-    for (let i = 0; i < n; i++) {
-        const text = `topic ${i % 7}: the module ${i} validated the session token and refreshed the cache for region ${i}`;
-        leaves.push({
-            id: `leaf_${i}`,
-            messages: [msg(text)],
-            sourceText: text,
-            embedding: embedder.embed(text),
-        });
-    }
-    return leaves;
-}
-// ── test: scoreTreeLevels returns nodes at all levels ────────────────────────
-test("scoreTreeLevels returns results at multiple tree levels", () => {
-    const embedder = new TrigramEmbedder();
-    const leaves = makeLeaves(50);
-    const tree = buildRaptorTree(leaves, { embedder, clustersPerLevel: 4 });
-    const hits = scoreTreeLevels("the auth module validates the session token", tree, {
-        embedder,
-    });
-    assert.ok(hits.length > 0, "should return hits");
-    // Should include both leaf (level 0) and cluster (level ≥ 1) hits.
-    const levels = new Set(hits.map((h) => h.level));
-    assert.ok(levels.has(0), "should have leaf-level hits");
-    if (tree.levels > 1) {
-        const hasCluster = [...levels].some((l) => l >= 1);
-        assert.ok(hasCluster, "should have cluster-level hits for multi-level tree");
-    }
-    // All hits should have valid scores.
-    for (const h of hits) {
-        assert.ok(h.score >= 0 && h.score <= 1, `score ${h.score} out of range`);
-        assert.ok(h.rawScore >= 0 && h.rawScore <= 1, `rawScore ${h.rawScore} out of range`);
-        assert.ok(h.score <= h.rawScore, "weighted score <= raw score (level weights ≤ 1)");
-    }
-    // Hits should be sorted by score descending.
-    for (let i = 1; i < hits.length; i++) {
-        assert.ok(hits[i - 1].score >= hits[i].score, `hits not sorted: hit[${i - 1}].score=${hits[i - 1].score} < hit[${i}].score=${hits[i].score}`);
-    }
-});
-// ── test: level weights affect scoring ───────────────────────────────────────
-test("level weights shift scores: higher weight for level → higher weighted score", () => {
-    const embedder = new TrigramEmbedder();
-    const leaves = makeLeaves(50);
-    const tree = buildRaptorTree(leaves, { embedder, clustersPerLevel: 4 });
-    const query = "the auth module validates the session token";
-    // Uniform weights: all levels scored equally.
-    const uniform = scoreTreeLevels(query, tree, {
-        embedder,
-        levelWeights: [1.0, 1.0, 1.0, 1.0, 1.0],
-    });
-    // Penalized weights: higher levels penalized.
-    const penalized = scoreTreeLevels(query, tree, {
-        embedder,
-        levelWeights: [1.0, 0.1, 0.1, 0.1, 0.1],
-    });
-    // With penalized weights, cluster-level hits should score lower.
-    const clusterUniform = uniform.filter((h) => h.level >= 1);
-    const clusterPenalized = penalized.filter((h) => h.level >= 1);
-    if (clusterUniform.length > 0 && clusterPenalized.length > 0) {
-        const avgUniform = clusterUniform.reduce((s, h) => s + h.score, 0) / clusterUniform.length;
-        const avgPenalized = clusterPenalized.reduce((s, h) => s + h.score, 0) / clusterPenalized.length;
-        assert.ok(avgPenalized < avgUniform, `penalized cluster avg (${avgPenalized.toFixed(3)}) should be < uniform (${avgUniform.toFixed(3)})`);
-    }
-});
-// ── test: expandLeafDescendants adds leaf hits ──────────────────────────────
-test("expandLeafDescendants adds leaf descendants for cluster hits", () => {
-    const embedder = new TrigramEmbedder();
-    const leaves = makeLeaves(50);
-    const tree = buildRaptorTree(leaves, { embedder, clustersPerLevel: 4 });
-    const query = "the auth module validates the session token";
-    const scored = scoreTreeLevels(query, tree, { embedder });
-    const qv = embedder.embed(query);
-    // Take only cluster hits (level ≥ 1).
-    const clusterHits = scored.filter((h) => !h.isLeaf).slice(0, 3);
-    assert.ok(clusterHits.length > 0, "should have cluster hits");
-    const expanded = expandLeafDescendants(clusterHits, tree, 5, // maxPerCluster
-    embedder, qv);
-    // Expanded set should include leaf hits.
-    const leafHits = expanded.filter((h) => h.isLeaf);
-    assert.ok(leafHits.length > 0, "should have expanded leaf hits");
-    assert.ok(expanded.length > clusterHits.length, `expanded (${expanded.length}) should be > cluster hits (${clusterHits.length})`);
-    // No duplicate ids.
-    const ids = new Set(expanded.map((h) => h.nodeId));
-    assert.equal(ids.size, expanded.length, "no duplicate node ids");
-});
-// ── test: deduplicateMultilevelHits removes cluster when leaves present ─────
-test("deduplicateMultilevelHits removes cluster hits when leaf children are present", () => {
-    const embedder = new TrigramEmbedder();
-    const leaves = makeLeaves(50);
-    const tree = buildRaptorTree(leaves, { embedder, clustersPerLevel: 4 });
-    const query = "the auth module validates the session token";
-    const scored = scoreTreeLevels(query, tree, { embedder });
-    // Take a cluster hit and its leaf children.
-    const cluster = scored.find((h) => !h.isLeaf);
-    assert.ok(cluster, "should have a cluster hit");
-    const leafChildren = cluster.leafIds.slice(0, 2).map((lid) => ({
-        nodeId: lid,
-        level: 0,
-        score: 0.5,
-        rawScore: 0.5,
-        isLeaf: true,
-        leafIds: [lid],
-        summary: "",
-        embedding: cluster.embedding,
-    }));
-    const mixed = [cluster, ...leafChildren];
-    const deduped = deduplicateMultilevelHits(mixed);
-    // Cluster should be removed because its leaf children are present.
-    assert.ok(!deduped.find((h) => h.nodeId === cluster.nodeId), "cluster hit should be removed when leaf children are present");
-    assert.equal(deduped.length, leafChildren.length, "only leaf hits remain");
-});
-test("deduplicateMultilevelHits keeps cluster hits when no leaf children present", () => {
-    const clusterHit = {
-        nodeId: "cluster_1",
-        level: 1,
-        score: 0.8,
-        rawScore: 0.8,
-        isLeaf: false,
-        leafIds: ["leaf_1", "leaf_2"],
-        summary: "summarized content",
-        embedding: [1, 0, 0],
-    };
-    const deduped = deduplicateMultilevelHits([clusterHit]);
-    assert.equal(deduped.length, 1, "cluster should be kept when no leaf children present");
-    assert.equal(deduped[0].nodeId, "cluster_1");
-});
-// ── test: multilevelRetrieval returns cluster + leaf mix ────────────────────
-test("multilevelRetrieval returns a mix of cluster and leaf hits", () => {
-    const embedder = new TrigramEmbedder();
-    const leaves = makeLeaves(50);
-    const tree = buildRaptorTree(leaves, { embedder, clustersPerLevel: 4 });
-    const hits = multilevelRetrieval("the auth module validates the session token", tree, {
-        embedder,
-        k: 5,
-        leafExpansion: true,
-        maxLeafExpansion: 3,
-    });
-    assert.ok(hits.length > 0, "should return hits");
-    assert.ok(hits.length <= 5, "should respect k=5");
-    // Should include leaf hits.
-    const leafHits = hits.filter((h) => h.isLeaf);
-    assert.ok(leafHits.length > 0, "should include leaf hits");
-    // All hits should have valid properties.
-    for (const h of hits) {
-        assert.ok(h.nodeId, "hit should have nodeId");
-        assert.ok(typeof h.level === "number", "hit should have numeric level");
-        assert.ok(h.score >= 0, "hit score should be non-negative");
-        assert.ok(Array.isArray(h.leafIds), "hit should have leafIds array");
-    }
-});
-test("multilevelRetrieval respects k parameter", () => {
-    const embedder = new TrigramEmbedder();
-    const leaves = makeLeaves(100);
-    const tree = buildRaptorTree(leaves, { embedder, clustersPerLevel: 8 });
-    for (const k of [1, 3, 5, 10]) {
-        const hits = multilevelRetrieval("the auth module validates the session token", tree, {
-            embedder,
-            k,
-        });
-        assert.ok(hits.length <= k, `k=${k}: got ${hits.length} hits, should be ≤ ${k}`);
-    }
-});
-test("multilevelRetrieval returns empty for empty tree", () => {
-    const embedder = new TrigramEmbedder();
-    const emptyTree = { nodes: new Map(), rootId: null, levels: 0, timedOut: false };
-    const hits = multilevelRetrieval("any query", emptyTree, { embedder });
-    assert.deepEqual(hits, []);
-});
-test("multilevelRetrieval with leafExpansion=false skips leaf expansion", () => {
-    const embedder = new TrigramEmbedder();
-    const leaves = makeLeaves(50);
-    const tree = buildRaptorTree(leaves, { embedder, clustersPerLevel: 4 });
-    const hits = multilevelRetrieval("the auth module validates the session token", tree, {
-        embedder,
-        k: 5,
-        leafExpansion: false,
-    });
-    assert.ok(hits.length > 0, "should still return hits");
-    // With leaf expansion off and tree having multiple levels, we may get
-    // cluster hits that are NOT expanded. The mix depends on tree structure.
-    // Just verify we got valid results.
-    for (const h of hits) {
-        assert.ok(h.nodeId, "hit should have nodeId");
-        assert.ok(h.score >= 0, "hit score should be non-negative");
-    }
-});
-// ── test: buildChildParentIndex matches linear-scan parent ────────────────────
-test("buildChildParentIndex (multilevel): index-derived parent matches linear-scan for each leaf", () => {
-    // Hand-built tree: 8 leaves under 2 level-1 nodes under 1 root.
-    const r1_0 = {
-        id: "r1_0", level: 1, parentId: null,
-        children: ["leaf_0", "leaf_1", "leaf_2", "leaf_3"],
-        summary: "cluster A", embedding: [1, 0, 0],
-        qualityMarker: "low", tokenEstimate: 10,
-    };
-    const r1_1 = {
-        id: "r1_1", level: 1, parentId: null,
-        children: ["leaf_4", "leaf_5", "leaf_6", "leaf_7"],
-        summary: "cluster B", embedding: [0, 1, 0],
-        qualityMarker: "low", tokenEstimate: 10,
-    };
-    const root = {
-        id: "root", level: 2, parentId: null,
-        children: ["leaf_0", "leaf_1", "leaf_2", "leaf_3",
-            "leaf_4", "leaf_5", "leaf_6", "leaf_7"],
-        summary: "root", embedding: [0.5, 0.5, 0],
-        qualityMarker: "low", tokenEstimate: 20,
-    };
-    const nodes = new Map([
-        ["r1_0", r1_0], ["r1_1", r1_1], ["root", root],
-    ]);
-    const tree = { nodes, rootId: "root", levels: 3, timedOut: false };
-    const index = buildChildParentIndex(tree);
-    const leafIds = ["leaf_0", "leaf_1", "leaf_2", "leaf_3",
-        "leaf_4", "leaf_5", "leaf_6", "leaf_7"];
-    for (const lid of leafIds) {
-        const linearParent = [...tree.nodes.values()].find((n) => n.children.includes(lid));
-        const indexParent = index.get(lid);
-        assert.equal(indexParent?.id ?? null, linearParent?.id ?? null, `leaf ${lid}: index parent (${indexParent?.id}) != linear parent (${linearParent?.id})`);
-    }
-});

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

@@ -1,69 +0,0 @@
-/**
- * promote.test.ts — Fix D: RAPTOR tree served by vectorStore.search.
- *
- * Asserts that, when a RAPTOR tree has been built + persisted for a session,
- * VectorStore.search returns the tree's staged-expansion hits (broader, O(log n)
- * coverage) merged with the flat hits — so the dormant tree becomes the live
- * recall surface. No network: default extractive summarizer + trigram embedder.
- */
-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 { VectorStore, vectorList, vectorSearch } from "../../vectorStore.js";
-import { runRaptor } from "./index.js";
-import { compactSession } from "../../engine.js";
-import { Logger } from "../../log.js";
-import { loadDedupConfig } from "../../config/dedup.js";
-import { listRaptorNodes } from "../../store/sqlite.js";
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-promote-"));
-let counter = 0;
-function raptorConfig() {
-    return { ...loadDedupConfig(), RAPTOR_ENABLED: true };
-}
-function msg(text, toolName) {
-    return toolName ? { role: "assistant", text, toolName, input: text, output: text } : { role: "user", text };
-}
-const SESS = "sess_promote";
-test("Fix D: vectorStore.search serves a persisted RAPTOR tree (broader recall)", () => {
-    const stateDir = join(baseTmp, `run-${counter++}`);
-    const s = new VectorStore({ dedupSim: 0.9, stateDir, config: raptorConfig() });
-    // Persist several distinct checkpoints.
-    for (let i = 1; i <= 5; i++) {
-        compactSession({ sessionId: SESS, messages: [msg(`topic alpha wire ${i} and bootstrap sequence`), msg(`ok ${i}`, "Edit")], keepFrom: 2, timestamp: i }, s);
-    }
-    // No tree yet → flat search only, returns hits, no RAPTOR coverage.
-    assert.equal(listRaptorNodes(SESS, stateDir).length, 0, "no tree initially");
-    const flat = vectorSearch(s, SESS, "alpha wire bootstrap", 3);
-    assert.ok(flat.length > 0, "flat search returns hits");
-    // Build + persist a RAPTOR tree for the session (mirrors runCompact refresh).
-    const all = vectorList(s, SESS);
-    const leaves = all.map((cp) => ({
-        id: cp.checkpointId,
-        messages: [],
-        sourceText: cp.normalizedText ?? cp.summary ?? cp.regionHash,
-        embedding: cp.embedding,
-    }));
-    const tree = runRaptor(leaves, { stateDir, sessionId: SESS, logger: new Logger() });
-    assert.ok(tree && listRaptorNodes(SESS, stateDir).length > 0, "tree persisted");
-    // With the tree live + RAPTOR_ENABLED, search still returns hits and now
-    // exercises the RAPTOR-served path without regression.
-    const withTree = vectorSearch(s, SESS, "alpha wire bootstrap", 3);
-    assert.ok(withTree.length > 0, "search returns hits with RAPTOR promoted");
-    // Every returned hit is a real checkpoint in the session.
-    for (const h of withTree) {
-        assert.ok(all.some((cp) => cp.checkpointId === h.checkpoint.checkpointId), "hit is a real checkpoint");
-    }
-});
-test("Fix D: search still works for a session with <2 leaves (no tree)", () => {
-    const stateDir = join(baseTmp, `run-${counter++}`);
-    const s = new VectorStore({ dedupSim: 0.9, stateDir, config: raptorConfig() });
-    compactSession({ sessionId: SESS, messages: [msg("only one topic here"), msg("ok", "Edit")], keepFrom: 2, timestamp: 1 }, s);
-    const r = vectorSearch(s, SESS, "only one topic", 3);
-    assert.ok(r.length > 0, "single-checkpoint search still works (no tree)");
-    assert.equal(listRaptorNodes(SESS, stateDir).length, 0, "no tree built for <2 leaves");
-});
-test("cleanup", () => {
-    rmSync(baseTmp, { recursive: true, force: true });
-});

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

@@ -1,248 +0,0 @@
-/**
- * raptor.test.ts — hermetic unit tests for the Sprint 13 RAPTOR module.
- *
- * No network: the default summarizer is deterministic extractive, and Ollama is
- * only reached when MEGACOMPACT_RAPTOR_MODEL is set (never here). Retrieval from
- * the live store is never touched (shadow mode), so recallAndInline output is
- * unchanged by construction.
- */
-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 { TrigramEmbedder } from "../../embedder.js";
-import { kmeanspp } from "./kmeans.js";
-import { applyHallucinationGuardrails, sourceTokenSet, extractEntities, makeUngroundedSummary, } from "./guardrails.js";
-import { buildRaptorTree } from "./tree.js";
-import { stagedExpansion } from "./retrieval.js";
-import { runRaptor } from "./index.js";
-import { Logger } from "../../log.js";
-import { listRaptorNodes, clearRaptorNodes, closeStore, } from "../../store/sqlite.js";
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-raptor-"));
-function msg(text) {
-    return { role: "user", text };
-}
-/** Build N distinct leaves with deterministic content. */
-function makeLeaves(n, embedder = new TrigramEmbedder()) {
-    const leaves = [];
-    for (let i = 0; i < n; i++) {
-        const text = `topic ${i % 7}: the module ${i} validated the session token and refreshed the cache for region ${i}`;
-        leaves.push({
-            id: `leaf_${i}`,
-            messages: [msg(text)],
-            sourceText: text,
-            embedding: embedder.embed(text),
-        });
-    }
-    return leaves;
-}
-// --- kmeans: near-zero-variance merge guard ---------------------------------
-test("kmeanspp merges identical points into a single cluster (QA #11)", () => {
-    const p = [1, 0, 0];
-    const points = [p, p, p, p, p];
-    const r = kmeanspp(points, 3, { seed: 1 });
-    assert.equal(r.k, 1);
-    assert.deepEqual(r.assignments, [0, 0, 0, 0, 0]);
-});
-test("kmeanspp separates two well-separated clusters", () => {
-    const a = [1, 0, 0];
-    const b = [0, 1, 0];
-    const points = [a, a, a, b, b, b];
-    const r = kmeanspp(points, 2, { seed: 7 });
-    assert.equal(r.k, 2);
-    // All the a's share one assignment, all the b's another.
-    const firstGroup = r.assignments[0];
-    const secondGroup = r.assignments[3];
-    assert.notEqual(firstGroup, secondGroup);
-    for (let i = 0; i < 3; i++)
-        assert.equal(r.assignments[i], firstGroup);
-    for (let i = 3; i < 6; i++)
-        assert.equal(r.assignments[i], secondGroup);
-});
-// --- guardrails: catch hallucination (QA #16) ------------------------------
-test("guardrails flag an un-grounded entity as extractive_fallback", () => {
-    const embedder = new TrigramEmbedder();
-    const realSource = "the auth module validates the session token";
-    const summary = makeUngroundedSummary(realSource, "ZkPhant0mCorp");
-    const sources = [realSource];
-    const r = applyHallucinationGuardrails({
-        summary,
-        sources,
-        centroid: embedder.embed(realSource),
-        embedder,
-        sourceTokens: sourceTokenSet(sources),
-    });
-    assert.equal(r.marker, "extractive_fallback");
-    assert.equal(r.grounded, false);
-});
-test("guardrails pass a faithful, grounded summary", () => {
-    const embedder = new TrigramEmbedder();
-    const src = "the auth module validates the session token and refreshes the cache";
-    const summary = "the auth module validates the session token";
-    const sources = [src];
-    const r = applyHallucinationGuardrails({
-        summary,
-        sources,
-        centroid: embedder.embed(src),
-        embedder,
-        sourceTokens: sourceTokenSet(sources),
-    });
-    assert.equal(r.grounded, true);
-    assert.ok(r.marker === "high" || r.marker === "low");
-    assert.notEqual(r.marker, "extractive_fallback");
-});
-test("extractEntities lowercases candidate tokens", () => {
-    const e = extractEntities("The AuthModule validates the token_abc 42 times");
-    assert.ok(e.includes("authmodule"));
-    assert.ok(e.includes("token_abc"));
-});
-// --- tree: <10 leaves → single node -----------------------------------------
-test("tree with <10 leaves yields a single root node", () => {
-    const leaves = makeLeaves(5);
-    const tree = buildRaptorTree(leaves, { embedder: new TrigramEmbedder() });
-    assert.equal(tree.nodes.size, 1);
-    assert.equal(tree.rootId, "r0_0");
-    assert.equal(tree.levels, 1);
-    assert.equal(tree.timedOut, false);
-});
-// --- tree: 1K fixture builds within budget ----------------------------------
-test("tree builds within 5s on a 1000-leaf fixture", () => {
-    const leaves = makeLeaves(1000);
-    const t0 = Date.now();
-    const tree = buildRaptorTree(leaves, {
-        embedder: new TrigramEmbedder(),
-        budgetMs: 5000,
-        clustersPerLevel: 8,
-    });
-    const elapsed = Date.now() - t0;
-    assert.ok(elapsed < 5000, `build took ${elapsed}ms (over 5s budget)`);
-    assert.ok(tree.nodes.size > 1, "expected a multi-level tree");
-    assert.ok(tree.rootId !== null);
-});
-// --- tree: budget timeout → extractive fallback root ------------------------
-test("tree respects the budget: a tiny budget forces an extractive fallback root", () => {
-    const leaves = makeLeaves(200);
-    const tree = buildRaptorTree(leaves, {
-        embedder: new TrigramEmbedder(),
-        budgetMs: 0, // forces immediate timeout on the first level
-        clustersPerLevel: 4,
-    });
-    assert.equal(tree.timedOut, true);
-    assert.equal(tree.rootId, "r99_0");
-    assert.ok(tree.nodes.has("r99_0"));
-});
-// --- extractiveFallbackRoot returns levels: 100 ------------------------------
-test("extractiveFallbackRoot returns levels: 100 (via zero budget)", () => {
-    const leaves = makeLeaves(50);
-    const tree = buildRaptorTree(leaves, {
-        embedder: new TrigramEmbedder(),
-        budgetMs: 0, // forces extractive fallback on first within() check
-        clustersPerLevel: 4,
-    });
-    assert.equal(tree.timedOut, true);
-    assert.equal(tree.levels, 100, "extractive fallback root must report levels: 100");
-    assert.ok(tree.rootId, "fallback root has a rootId");
-    const root = tree.nodes.get(tree.rootId);
-    assert.ok(root, "fallback root node exists in nodes map");
-    assert.equal(root.level, 99, "fallback root node level is 99");
-    assert.equal(root.parentId, null, "fallback root parentId is null");
-});
-// --- parentId population on a multi-level tree --------------------------------
-test("buildRaptorTree populates parentId for non-root internal nodes, root keeps null", () => {
-    const embedder = new TrigramEmbedder();
-    // >= 10 leaves with clustersPerLevel small enough to produce 2 levels
-    // of internal nodes (level-1 cluster nodes + level-2 root via collapse).
-    const leaves = makeLeaves(20);
-    const tree = buildRaptorTree(leaves, { embedder, clustersPerLevel: 4 });
-    // Must have at least 2 levels of internal nodes.
-    assert.ok(tree.levels >= 2, `expected >= 2 levels, got ${tree.levels}`);
-    assert.ok(tree.rootId, "tree must have a root");
-    // The root keeps parentId null.
-    const root = tree.nodes.get(tree.rootId);
-    assert.ok(root, "root node in map");
-    assert.equal(root.parentId, null, "root parentId must be null");
-    // Every non-root internal node must have a non-null parentId pointing to
-    // another node in the tree (its parent).
-    let nonRootCount = 0;
-    for (const node of tree.nodes.values()) {
-        if (node.id === tree.rootId)
-            continue;
-        nonRootCount++;
-        assert.ok(node.parentId !== null, `non-root node ${node.id} must have non-null parentId`);
-        assert.ok(tree.nodes.has(node.parentId), `parentId ${node.parentId} of node ${node.id} must exist in tree`);
-        assert.notEqual(node.parentId, node.id, `node ${node.id} must not be its own parent`);
-    }
-    assert.ok(nonRootCount > 0, "tree must have at least one non-root internal node");
-});
-// --- retrieval: staged expansion returns leaf ids ---------------------------
-test("stagedExpansion returns diversified leaf ids for a query", () => {
-    const leaves = makeLeaves(20);
-    const tree = buildRaptorTree(leaves, { embedder: new TrigramEmbedder(), clustersPerLevel: 4 });
-    const hits = stagedExpansion("the auth module validates the session token", tree, {
-        embedder: new TrigramEmbedder(),
-        k: 3,
-        topM: 3,
-    });
-    assert.ok(hits.length > 0);
-    assert.ok(hits.length <= 3);
-    // All returned ids are raw leaf ids (not internal node ids).
-    for (const id of hits)
-        assert.ok(id.startsWith("leaf_"));
-});
-// --- shadow mode: builds + persists, never alters retrieval -----------------
-test("runRaptor builds + persists a shadow tree without throwing", () => {
-    const dir = join(baseTmp, `shadow-${Math.floor(performance.now())}`);
-    const leaves = makeLeaves(40);
-    const logger = new Logger({
-        enabled: true,
-        now: () => 0,
-        path: join(dir, "events.log"),
-    });
-    const tree = runRaptor(leaves, {
-        stateDir: dir,
-        sessionId: "sess_raptor",
-        embedder: new TrigramEmbedder(),
-        logger,
-    });
-    assert.ok(tree !== null);
-    // Tree was persisted to raptor_nodes.
-    const stored = listRaptorNodes("sess_raptor", dir);
-    assert.ok(stored.length > 0, "shadow tree should be persisted");
-    // Quality markers are valid values.
-    for (const n of stored) {
-        assert.ok(["high", "low", "extractive_fallback"].includes(n.qualityMarker) || n.qualityMarker === "low");
-    }
-    clearRaptorNodes("sess_raptor", dir);
-    closeStore(dir);
-});
-test("shadow mode does NOT change recallAndInline output (separation)", () => {
-    // The orchestrator persists to raptor_nodes only. The live store's
-    // recallAndInline path (vectorStore.search) reads context_chunks, never
-    // raptor_nodes, so building a RAPTOR tree is observably independent.
-    const dir = join(baseTmp, `sep-${Math.floor(performance.now())}`);
-    const leaves = makeLeaves(15);
-    const before = listRaptorNodes("sess_sep", dir);
-    runRaptor(leaves, {
-        stateDir: dir,
-        sessionId: "sess_sep",
-        embedder: new TrigramEmbedder(),
-    });
-    const after = listRaptorNodes("sess_sep", dir);
-    // Building RAPTOR only ever writes raptor_nodes; context_chunks is untouched.
-    assert.deepEqual(before, []);
-    assert.ok(after.length > 0);
-    clearRaptorNodes("sess_sep", dir);
-    closeStore(dir);
-});
-// --- eval: redundancy reduction ≥ 15% (nodes << leaves) ---------------------
-test("eval: RAPTOR reduces node count substantially vs flat (≥15%)", () => {
-    const leaves = makeLeaves(100);
-    const tree = buildRaptorTree(leaves, { embedder: new TrigramEmbedder(), clustersPerLevel: 8 });
-    const reduction = 1 - tree.nodes.size / leaves.length;
-    assert.ok(reduction >= 0.15, `redundancy reduction ${reduction.toFixed(2)} < 0.15`);
-});
-// --- cleanup ----------------------------------------------------------------
-test("RAPTOR cleanup", () => {
-    rmSync(baseTmp, { recursive: true, force: true });
-});

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

@@ -1,95 +0,0 @@
-/**
- * retrieval.test.ts — unit tests for the reverse-index parent lookup.
- *
- * Verifies that buildChildParentIndex (retrieval.ts) produces the same
- * parent for each leaf as the old linear-scan semantics:
- *   [...tree.nodes.values()].find(n => n.children.includes(lid))
- *
- * Uses a hand-built tree with a known structure so the comparison is
- * deterministic and independent of the tree builder.
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { buildChildParentIndex } from "./retrieval.js";
-/** Build a minimal hand-crafted RaptorTree with 2 levels of internal nodes. */
-function handBuiltTree() {
-    // 8 leaves (leaf_0..leaf_7) under 2 level-1 nodes, under 1 root.
-    const r1_0 = {
-        id: "r1_0",
-        level: 1,
-        parentId: null, // will be set by builder in production, but not needed here
-        children: ["leaf_0", "leaf_1", "leaf_2", "leaf_3"],
-        summary: "cluster A",
-        embedding: [1, 0, 0],
-        qualityMarker: "low",
-        tokenEstimate: 10,
-    };
-    const r1_1 = {
-        id: "r1_1",
-        level: 1,
-        parentId: null,
-        children: ["leaf_4", "leaf_5", "leaf_6", "leaf_7"],
-        summary: "cluster B",
-        embedding: [0, 1, 0],
-        qualityMarker: "low",
-        tokenEstimate: 10,
-    };
-    const root = {
-        id: "root",
-        level: 2,
-        parentId: null,
-        children: [
-            "leaf_0", "leaf_1", "leaf_2", "leaf_3",
-            "leaf_4", "leaf_5", "leaf_6", "leaf_7",
-        ],
-        summary: "root summary",
-        embedding: [0.5, 0.5, 0],
-        qualityMarker: "low",
-        tokenEstimate: 20,
-    };
-    const nodes = new Map([
-        ["r1_0", r1_0],
-        ["r1_1", r1_1],
-        ["root", root],
-    ]);
-    return { nodes, rootId: "root", levels: 3, timedOut: false };
-}
-test("buildChildParentIndex: index-derived parent matches linear-scan parent for each leaf", () => {
-    const tree = handBuiltTree();
-    const leafIds = [
-        "leaf_0", "leaf_1", "leaf_2", "leaf_3",
-        "leaf_4", "leaf_5", "leaf_6", "leaf_7",
-    ];
-    const index = buildChildParentIndex(tree);
-    for (const lid of leafIds) {
-        // Old linear-scan semantics: find the first node whose children include lid.
-        const linearParent = [...tree.nodes.values()].find((n) => n.children.includes(lid));
-        // Index-derived parent.
-        const indexParent = index.get(lid);
-        // Both must agree.
-        assert.equal(indexParent?.id ?? null, linearParent?.id ?? null, `leaf ${lid}: index parent (${indexParent?.id}) != linear parent (${linearParent?.id})`);
-    }
-});
-test("buildChildParentIndex: first writer wins (no overwrite for shared leaf)", () => {
-    // If two internal nodes both list the same leaf id in their children, the
-    // index keeps the FIRST one encountered — matching the find() semantics
-    // which also returns the first match.
-    const r1_0 = {
-        id: "r1_0", level: 1, parentId: null,
-        children: ["leaf_0", "leaf_1"],
-        summary: "A", embedding: [1, 0], qualityMarker: "low", tokenEstimate: 5,
-    };
-    const r1_1 = {
-        id: "r1_1", level: 1, parentId: null,
-        children: ["leaf_0", "leaf_2"], // leaf_0 shared with r1_0
-        summary: "B", embedding: [0, 1], qualityMarker: "low", tokenEstimate: 5,
-    };
-    const nodes = new Map([["r1_0", r1_0], ["r1_1", r1_1]]);
-    const tree = { nodes, rootId: null, levels: 2, timedOut: false };
-    const index = buildChildParentIndex(tree);
-    // leaf_0 appears in both r1_0 and r1_1. The index and find() both return
-    // whichever comes first in iteration order.
-    const linearParent = [...tree.nodes.values()].find((n) => n.children.includes("leaf_0"));
-    const indexParent = index.get("leaf_0");
-    assert.equal(indexParent?.id ?? null, linearParent?.id ?? null, "first-writer wins: index and linear scan agree on shared leaf");
-});