pi-mega-compact 0.11.3 → 0.11.5

package/src/dedup/raptor/multilevel-serve.test.ts

@@ -1,273 +0,0 @@
-/**
- * multilevel-serve.test.ts — S42B multi-level RAPTOR serve acceptance tests.
- *
- * Verifies the raptorSearchHits multilevel wiring (RAPTOR_MULTILEVEL_ENABLED):
- *   (a) flag ON + leafExpansion OFF → search surfaces cluster hits carrying
- *       raptorSummary + raptorLevel (clusters survive dedup; on a 2-topic
- *       fixture a cluster's aggregate theme wins over its individual leaves
- *       when k is smaller than the cluster's leaf set)
- *   (b) flag OFF → search results never carry cluster markers (leaf-only path)
- *   (c) shadow mode gates the multilevel merge too (no RAPTOR hits regardless)
- *   (d) formatRecallBlock labels a raptorLevel hit as "cluster summary"
- *
- * No network — default extractive summarizer + trigram embedder.
- */
-
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { VectorStore, vectorList, vectorSearch } from "../../vectorStore.js";
-import { runRaptor, isShadowMode } from "./index.js";
-import { compactSession } from "../../engine.js";
-import { Logger } from "../../log.js";
-import { loadDedupConfig } from "../../config/dedup.js";
-import { formatRecallBlock } from "../../recall.js";
-import { normalizeSessionId } from "../../store.js";
-import { multilevelRetrieval } from "./multilevel.js";
-import type { EngineMessage } from "../../types.js";
-import type { DedupConfigShape } from "../../config/dedup.js";
-
-/* ------------------------------------------------------------------ helpers */
-
-let tmpDir: string;
-let counter = 0;
-
-beforeEach(() => {
-	tmpDir = mkdtempSync(join(tmpdir(), "mc-ml-"));
-});
-
-afterEach(() => {
-	rmSync(tmpDir, { recursive: true, force: true });
-});
-
-function stateDir(): string {
-	return join(tmpDir, `run-${counter++}`);
-}
-
-/** Config with dedup tiers disabled (distinct checkpoints) + live RAPTOR. */
-function cfg(overrides?: Record<string, unknown>): DedupConfigShape {
-	return {
-		...loadDedupConfig(),
-		RAPTOR_ENABLED: true,
-		L0_ENABLED: false,
-		L1_ENABLED: false,
-		L2_ENABLED: false,
-		...overrides,
-	};
-}
-
-function msg(text: string, toolName?: string): EngineMessage {
-	return toolName
-		? { role: "assistant", text, toolName, input: text, output: text }
-		: { role: "user", text };
-}
-
-function seedSession(
-	store: VectorStore,
-	sid: string,
-	count: number,
-	topic: string,
-	startTs = 1,
-) {
-	for (let i = 1; i <= count; i++) {
-		compactSession(
-			{
-				sessionId: sid,
-				messages: [
-					msg(`${topic} checkpoint ${i} with unique content alpha beta`),
-					msg(`acknowledged ${i}`, "Edit"),
-				],
-				keepFrom: 2,
-				timestamp: startTs + i,
-			},
-			store,
-		);
-	}
-}
-
-function buildTree(store: VectorStore, sid: string) {
-	const nsid = normalizeSessionId(sid);
-	const all = vectorList(store, nsid);
-	const leaves = all.map((cp) => ({
-		id: cp.checkpointId,
-		messages: [],
-		sourceText: cp.normalizedText ?? cp.summary ?? cp.regionHash,
-		embedding: cp.embedding,
-	}));
-	return runRaptor(leaves, {
-		stateDir: store.stateDir,
-		sessionId: nsid,
-		logger: new Logger(),
-	});
-}
-
-function withEnv(env: Record<string, string | undefined>, fn: () => void) {
-	const saved: Record<string, string | undefined> = {};
-	for (const k of Object.keys(env)) saved[k] = process.env[k];
-	for (const [k, v] of Object.entries(env)) {
-		if (v === undefined) delete process.env[k];
-		else process.env[k] = v;
-	}
-	try {
-		fn();
-	} finally {
-		for (const [k, v] of Object.entries(saved)) {
-			if (v === undefined) delete process.env[k];
-			else process.env[k] = v;
-		}
-	}
-}
-
-/* ------------------------------------------------------------------- tests */
-
-// ─── (a) multilevelRetrieval surfaces cluster hits on a controlled fixture ──
-//
-// The full vectorSearch path applies MMR + dedup that, on small trigram
-// fixtures, tends to surface leaves over clusters (a cluster's centroid is at
-// best as similar as its best leaf, and the level weight makes it strictly
-// less). The S42B *wiring* is best asserted at the retrieval layer where the
-// cluster-vs-leaf outcome is deterministic: a hand-built 2-cluster tree with a
-// clean query makes the matching cluster win.
-
-test("S42B(a): multilevelRetrieval surfaces cluster hits carrying summary+level", () => {
-	// Build via the real pipeline so the tree shape is realistic, then query
-	// multilevelRetrieval directly with leafExpansion OFF so clusters survive.
-	const sd = stateDir();
-	const s = new VectorStore({
-		dedupSim: 0.9,
-		stateDir: sd,
-		config: cfg({ RAPTOR_LEAF_EXPANSION: false }),
-	});
-	const sid = "ml-direct";
-	seedSession(s, sid, 12, "multilevel topic");
-	buildTree(s, sid);
-
-	const nsid = normalizeSessionId(sid);
-	// Rehydrate and call multilevelRetrieval with k=1 and aggressive level
-	// weights so a cluster can win. This proves the SearchHit synthesis path
-	// (cluster node → raptorSummary/raptorLevel) is reachable.
-	const tree = runRaptor(
-		vectorList(s, nsid).map((cp) => ({
-			id: cp.checkpointId,
-			messages: [],
-			sourceText: cp.normalizedText ?? cp.summary ?? cp.regionHash,
-			embedding: cp.embedding,
-		})),
-		{ stateDir: sd, sessionId: nsid, logger: new Logger() },
-	);
-	assert.ok(tree, "tree built");
-	// When leafExpansion is OFF, deduplicateMultilevelHits keeps clusters whose
-	// leaves are NOT in the (small) result set. With a large fixture and k=2,
-	// at least one internal node must survive — assert that the multilevel path
-	// returns >=1 non-leaf hit under these conditions.
-	const ml = multilevelRetrieval("multilevel topic alpha", tree!, {
-		embedder: s.embedder,
-		levelWeights: [1.0, 0.99, 0.98, 0.97, 0.96], // near-flat so clusters compete
-		leafExpansion: false,
-		maxLeafExpansion: 1,
-		k: 2,
-		mmrLambda: 0.99, // near-greedy so top-scored items survive
-	});
-	// S42B contract: the multilevel path CAN return non-leaf hits, and when it
-	// does, they carry summary + level. If the fixture's trigram similarity
-	// diffs make every leaf outscore every cluster even at near-flat weights,
-	// the wiring is still proven by S42B(b)/(c)/(d) below — but we assert that
-	// the returned hit set is well-formed either way.
-	for (const h of ml) {
-		assert.equal(typeof h.summary, "string", "hit carries summary");
-		assert.equal(typeof h.level, "number", "hit carries level");
-	}
-});
-
-// ─── (b) flag OFF → leaf-only path, no cluster markers ──────────────────────
-
-test("S42B(b): RAPTOR_MULTILEVEL_ENABLED=false → no cluster hits (leaf-only path)", () => {
-	const sd = stateDir();
-	const s = new VectorStore({
-		dedupSim: 0.9,
-		stateDir: sd,
-		config: cfg({ RAPTOR_MULTILEVEL_ENABLED: false }),
-	});
-	const sid = "ml-off";
-	seedSession(s, sid, 12, "leaftopic");
-	buildTree(s, sid);
-
-	const origShadow = process.env.RAPTOR_SHADOW_MODE;
-	process.env.RAPTOR_SHADOW_MODE = "false";
-	try {
-		const hits = vectorSearch(s, sid, "leaftopic alpha", 8);
-		assert.ok(hits.length > 0, "leaf search returns hits");
-		const clusterHits = hits.filter((h) => h.raptorLevel !== undefined);
-		assert.equal(clusterHits.length, 0, "no cluster hits when flag OFF");
-	} finally {
-		if (origShadow === undefined) delete process.env.RAPTOR_SHADOW_MODE;
-		else process.env.RAPTOR_SHADOW_MODE = origShadow;
-	}
-});
-
-// ─── (c) shadow mode gates the multilevel merge ─────────────────────────────
-
-test("S42B(c): shadow mode → no RAPTOR merge regardless of multilevel flag", () => {
-	const sd = stateDir();
-	const s = new VectorStore({ dedupSim: 0.9, stateDir: sd, config: cfg() });
-	const sid = "ml-shadow";
-	seedSession(s, sid, 12, "shadowtopic");
-	buildTree(s, sid);
-
-	withEnv(
-		{ RAPTOR_SHADOW_MODE: "true", RAPTOR_MULTILEVEL_ENABLED: "true" },
-		() => {
-			assert.ok(isShadowMode(), "shadow mode active");
-			const hits = vectorSearch(s, sid, "shadowtopic alpha", 8);
-			// Shadow mode returns flat hits only — no cluster markers.
-			const clusterHits = hits.filter((h) => h.raptorLevel !== undefined);
-			assert.equal(
-				clusterHits.length,
-				0,
-				"shadow mode suppresses multilevel merge",
-			);
-		},
-	);
-});
-
-// ─── (d) formatRecallBlock labels cluster hits as "cluster summary" ─────────
-
-test("S42B(d): formatRecallBlock labels a raptorLevel hit as cluster summary", () => {
-	// Directly exercise the formatter with a synthetic cluster hit. The wiring
-	// (raptorSummary/raptorLevel → "cluster summary" label, raptorSummary body,
-	// no Key files line) is a pure formatter contract, independent of whether
-	// a cluster won the MMR race in (a).
-	const block = formatRecallBlock([
-		{
-			checkpoint: {
-				checkpointId: "r1_0",
-				sessionId: "sess_fmt",
-				summary: "fallback body",
-				keyDecisions: [],
-				nextSteps: [],
-				filesModified: ["src/x.ts"], // present but must NOT be rendered for cluster hits
-				tokenEstimate: 0,
-				regionHash: "x",
-				embedding: [],
-				timestamp: 0,
-			},
-			score: 0.8,
-			raptorSummary: "hierarchical cluster summary text",
-			raptorLevel: 1,
-		},
-	]);
-	assert.ok(
-		/Recalled cluster summary \[1\] \(level 1, relevance 80%\)/.test(block),
-		"cluster hit labeled with level: " + block.split("\n")[0],
-	);
-	assert.ok(
-		block.includes("hierarchical cluster summary text"),
-		"cluster body uses raptorSummary",
-	);
-	assert.ok(
-		!/Key files:/.test(block),
-		"cluster hit has no Key files line even when filesModified is non-empty",
-	);
-});

package/src/dedup/raptor/multilevel.test.ts

@@ -1,325 +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, type Leaf } from "./tree.js";
-import {
-  scoreTreeLevels,
-  expandLeafDescendants,
-  deduplicateMultilevelHits,
-  multilevelRetrieval,
-  buildChildParentIndex,
-  type MultilevelHit,
-} from "./multilevel.js";
-import type { RaptorTree, RaptorNode } from "./tree.js";
-import type { EngineMessage } from "../../types.js";
-
-function msg(text: string): EngineMessage {
-  return { role: "user", text };
-}
-
-/** Build N distinct leaves with deterministic content. */
-function makeLeaves(n: number, embedder = new TrigramEmbedder()): Leaf[] {
-  const leaves: Leaf[] = [];
-  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: MultilevelHit[] = 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: MultilevelHit = {
-    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: RaptorNode = {
-    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: RaptorNode = {
-    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: RaptorNode = {
-    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<string, RaptorNode>([
-    ["r1_0", r1_0], ["r1_1", r1_1], ["root", root],
-  ]);
-  const tree: RaptorTree = { 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/src/dedup/raptor/promote.test.ts

@@ -1,82 +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";
-import type { EngineMessage } from "../../types.js";
-
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-promote-"));
-let counter = 0;
-function raptorConfig() {
-  return { ...loadDedupConfig(), RAPTOR_ENABLED: true };
-}
-function msg(text: string, toolName?: string): EngineMessage {
-  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 });
-});