pi-mega-compact 0.8.21 → 0.8.23

package/src/importance.ts

@@ -0,0 +1,312 @@
+/**
+ * importance.ts — S40 importance scoring for compaction.
+ *
+ * A standalone, deterministic, pi-agnostic scoring module with no side
+ * effects. Scores each context item by type, age decay, recency/retention
+ * boosts, and selects the top-N for verbatim preservation (bypassing
+ * summarization) so high-importance old messages (decisions, errors) are
+ * not lost to compaction.
+ *
+ * PREVENT-PI-001 (anchor floor): importance scoring AUGMENTS, never
+ * replaces, the boundary guard. `itemsToPreserve` only marks items the
+ * caller already considered compactable; the caller's `computeDropRange`
+ * still protects the most recent N user messages.
+ * PREVENT-PI-002 (tool pairs): callers preserve pairs; `score()` itself
+ * is pair-agnostic.
+ * PREVENT-PI-PI-003 (no system role): scored items are surfaced via the
+ * existing systemPrompt-prepend path, never as role:"system".
+ *
+ * @module
+ */
+import type { EngineMessage } from "./types.js";
+
+/** The 8 content/item types that drive the type multiplier. */
+export enum ContextItemType {
+	UserMessage = "user_message",
+	AssistantMessage = "assistant_message",
+	SystemMessage = "system_message",
+	CodeBlock = "code_block",
+	Error = "error",
+	Decision = "decision",
+	FileModification = "file_modification",
+	ToolExecution = "tool_execution",
+}
+
+/** A scored context item. */
+export interface ScoredItem {
+	/** Message index or checkpoint ID (caller-supplied). */
+	id: string;
+	type: ContextItemType;
+	content: string;
+	/** Raw role from EngineMessage ("user" | "assistant" | "tool" | "custom"). */
+	role: string;
+	/** Epoch ms. */
+	timestamp: number;
+	/** Type-based multiplier, before decay/boost. */
+	rawMultiplier: number;
+	/** 0–0.7 fraction SUBTRACTED from the score. */
+	ageDecay: number;
+	/** 1.0 or 1.2. */
+	recencyBoost: number;
+	/** 1.0 or 3.0. */
+	retentionBoost: number;
+	/** Composite score. */
+	finalScore: number;
+}
+
+/** Result of a preservation pass. */
+export interface PreservationResult {
+	preservedIds: Set<string>;
+	/** Score cutoff used. */
+	threshold: number;
+	totalScored: number;
+	totalPreserved: number;
+}
+
+/**
+ * Default type multipliers (ported from the Rust reference
+ * `router/src/context/importance.rs`). Decisions (2.5x) and errors (2.0x)
+ * dominate; system/filler (0.5x) sinks.
+ */
+export const DEFAULT_MULTIPLIERS: Record<ContextItemType, number> = {
+	[ContextItemType.UserMessage]: 1.5,
+	[ContextItemType.AssistantMessage]: 1.0,
+	[ContextItemType.SystemMessage]: 0.5,
+	[ContextItemType.CodeBlock]: 1.2,
+	[ContextItemType.Error]: 2.0,
+	[ContextItemType.Decision]: 2.5,
+	[ContextItemType.FileModification]: 1.8,
+	[ContextItemType.ToolExecution]: 1.3,
+};
+
+/**
+ * Age decay: fraction to SUBTRACT from the score.
+ * Formula: `min(maxDecay, (ageMs / 3_600_000) * decayRatePerHour)`.
+ * 0 = fresh, 0.7 = very old. At 14h with 0.05/hr: 14 * 0.05 = 0.70 (capped).
+ */
+export function ageDecay(
+	itemAgeMs: number,
+	decayRatePerHour: number = 0.05,
+	maxDecay: number = 0.7,
+): number {
+	if (itemAgeMs <= 0) return 0;
+	const hours = itemAgeMs / 3_600_000;
+	return Math.min(maxDecay, hours * decayRatePerHour);
+}
+
+/** Recency boost: 1.2 if `ageMs < thresholdMs` (default 5min), else 1.0. */
+export function recencyBoost(
+	ageMs: number,
+	thresholdMs: number = 300_000,
+): number {
+	return ageMs < thresholdMs ? 1.2 : 1.0;
+}
+
+/**
+ * Retention boost: 3.0 if the user flagged the item, else 1.0.
+ * User-flagged items are also inferred by `detectItemType` returning
+ * Decision or Error.
+ */
+export function retentionBoost(userFlagged: boolean): number {
+	return userFlagged ? 3.0 : 1.0;
+}
+
+/**
+ * Classify a content blob into a `ContextItemType`.
+ *
+ * Rules are ordered by priority — first match wins:
+ * 1. role === "tool" → ToolExecution
+ * 2. role === "custom" → SystemMessage
+ * 3. error-ish content → Error
+ * 4. decision-ish content → Decision
+ * 5. fenced code block (≥20 chars) → CodeBlock
+ * 6. file-modification verbs → FileModification
+ * 7. role === "user" → UserMessage
+ * 8. role === "assistant" → AssistantMessage
+ * 9. Fallback → AssistantMessage
+ */
+export function detectItemType(
+	content: string,
+	role: "user" | "assistant" | "tool" | "custom",
+): ContextItemType {
+	const c = content ?? "";
+	if (role === "tool") return ContextItemType.ToolExecution;
+	if (role === "custom") return ContextItemType.SystemMessage;
+	// (3) errors — traceback / panic / E#### / exception / failure / crash.
+	if (/error|exception|failure|crash|panic|traceback|E\d{4}/i.test(c)) {
+		return ContextItemType.Error;
+	}
+	// (4) decisions — "we decided", "going with", "switching to", etc.
+	if (
+		/decided|we chose|going with|switching to|using .* instead|final decision|let's go with/i.test(
+			c,
+		)
+	) {
+		return ContextItemType.Decision;
+	}
+	// (5) fenced code block ≥20 chars.
+	if (/```[\s\S]{20,}/.test(c)) {
+		return ContextItemType.CodeBlock;
+	}
+	// (6) file modification verbs.
+	if (/(wrote|edited|created|modified|updated|patched)\s+\S+\.\w+/i.test(c)) {
+		return ContextItemType.FileModification;
+	}
+	if (role === "user") return ContextItemType.UserMessage;
+	if (role === "assistant") return ContextItemType.AssistantMessage;
+	// (9) Fallback.
+	return ContextItemType.AssistantMessage;
+}
+
+/**
+ * Composite score for a single item.
+ *
+ * Formula:
+ *   type = detectItemType(content, role)
+ *   rawMult = multipliers[type] ?? DEFAULT_MULTIPLIERS[type]
+ *   decay = ageDecay(now - timestamp, decayRatePerHour, maxDecay)
+ *   recency = recencyBoost(now - timestamp, recencyThresholdMs)
+ *   retention = retentionBoost(userFlagged)
+ *   finalScore = rawMult * (1 - decay) * recency * retention
+ *
+ * Clamps `finalScore` to a minimum of 0.01 (never zero, so an item is
+ * always a candidate unless explicitly filtered).
+ */
+export function score(
+	item: {
+		id: string;
+		content: string;
+		role: string;
+		timestamp: number;
+		userFlagged?: boolean;
+	},
+	now: number,
+	multipliers?: Partial<Record<ContextItemType, number>>,
+	opts?: {
+		decayRatePerHour?: number;
+		maxDecay?: number;
+		recencyThresholdMs?: number;
+	},
+): ScoredItem {
+	const content = item.content ?? "";
+	// detectItemType expects the 4-role union; narrow defensively.
+	const role = (["user", "assistant", "tool", "custom"].includes(item.role)
+		? item.role
+		: "assistant") as "user" | "assistant" | "tool" | "custom";
+	const type = detectItemType(content, role);
+	const rawMultiplier =
+		multipliers?.[type] ?? DEFAULT_MULTIPLIERS[type];
+	const ageMs = Math.max(0, now - item.timestamp);
+	const decay = ageDecay(
+		ageMs,
+		opts?.decayRatePerHour,
+		opts?.maxDecay,
+	);
+	const recency = recencyBoost(ageMs, opts?.recencyThresholdMs);
+	const retention = retentionBoost(item.userFlagged === true);
+	const finalScore = Math.max(
+		0.01,
+		rawMultiplier * (1 - decay) * recency * retention,
+	);
+	return {
+		id: item.id,
+		type,
+		content,
+		role,
+		timestamp: item.timestamp,
+		rawMultiplier,
+		ageDecay: decay,
+		recencyBoost: recency,
+		retentionBoost: retention,
+		finalScore,
+	};
+}
+
+/**
+ * Score cutoff at the `preserveRatio` percentile boundary.
+ *
+ * Sorts items by `finalScore` descending; returns the score at the
+ * `preserveRatio` quantile. Items with `finalScore >= threshold` are
+ * preserved.
+ *
+ * - `ratio = 1.0` → return 0 (preserve all)
+ * - `ratio = 0` → return Infinity (preserve none)
+ * - empty input → return Infinity
+ */
+export function preservationCutoff(
+	items: ScoredItem[],
+	preserveRatio: number,
+): number {
+	if (items.length === 0) return Infinity;
+	if (preserveRatio >= 1) return 0;
+	if (preserveRatio <= 0) return Infinity;
+	// Sort descending; the top `preserveRatio` fraction is preserved.
+	const sorted = [...items].sort((a, b) => b.finalScore - a.finalScore);
+	// Index of the lowest-scoring item in the preserved set.
+	// ceil(N * ratio) - 1, clamped to [0, N-1].
+	const cutoffIdx = Math.min(
+		sorted.length - 1,
+		Math.max(0, Math.ceil(sorted.length * preserveRatio) - 1),
+	);
+	return sorted[cutoffIdx].finalScore;
+}
+
+/**
+ * Select which items to preserve verbatim based on `preserveRatio`.
+ *
+ * Returns the IDs of items with `finalScore >= threshold`. The caller
+ * is responsible for excluding items inside the anchor window (the
+ * boundary guard already protects those).
+ */
+export function itemsToPreserve(
+	items: ScoredItem[],
+	preserveRatio: number,
+): PreservationResult {
+	const threshold = preservationCutoff(items, preserveRatio);
+	const preservedIds = new Set(
+		items.filter((i) => i.finalScore >= threshold).map((i) => i.id),
+	);
+	return {
+		preservedIds,
+		threshold,
+		totalScored: items.length,
+		totalPreserved: preservedIds.size,
+	};
+}
+
+/**
+ * Convenience: score a list of `EngineMessage`s in position order using
+ * approximate ages from their index (1 minute per position, oldest first).
+ * Real timestamps should be threaded through the extension adapter when
+ * available; this is the position-based fallback documented in S40B-2.
+ *
+ * The returned `ScoredItem[]` is in the SAME ORDER as the input — callers
+ * index back into `messages` by `id` (which is the stringified index).
+ */
+export function scoreEngineMessages(
+	messages: EngineMessage[],
+	now: number,
+	multipliers?: Partial<Record<ContextItemType, number>>,
+	opts?: {
+		decayRatePerHour?: number;
+		maxDecay?: number;
+		recencyThresholdMs?: number;
+	},
+): ScoredItem[] {
+	return messages.map((m, i) => {
+		// Oldest message (i=0) is `messages.length` minutes ago; newest is 1 min.
+		const timestamp = now - (messages.length - i) * 60_000;
+		return score(
+			{
+				id: String(i),
+				content: m.text ?? "",
+				role: m.role,
+				timestamp,
+				userFlagged: false,
+			},
+			now,
+			multipliers,
+			opts,
+		);
+	});
+}

package/src/ratio.bench.test.ts

@@ -19,7 +19,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 
-import { VectorStore, computeRegionHash } from "./vectorStore.js";
+import { VectorStore, computeRegionHash, vectorStats, vectorWasInjected, vectorMarkInjected, vectorTopSimilar } from "./vectorStore.js";
 import type { SearchHit } from "./vectorStore.js";
 import { findSuperseded } from "./supersede.js";
 import { autoCompactCheck, isChatty } from "./compact.js";
@@ -635,7 +635,7 @@ describe("Dedup Hit Rates by Similarity Level", () => {
 
     // Check stats for each session
     for (const sid of sessionIds) {
-      const stats = store.stats(sid);
+      const stats = vectorStats(store,sid);
       console.log(
         `    ${sid}: ${stats.checkpointCount} checkpoint(s), dedup rate: ${(stats.dedupHitRate * 100).toFixed(0)}%`,
       );
@@ -663,7 +663,7 @@ describe("Dedup Hit Rates by Similarity Level", () => {
     // Check stats across sessions
     let totalCheckpoints = 0;
     for (let i = 0; i < variations.length; i++) {
-      const stats = store.stats(`sess_l1_${i}`);
+      const stats = vectorStats(store,`sess_l1_${i}`);
       totalCheckpoints += stats.checkpointCount;
     }
 
@@ -693,7 +693,7 @@ describe("Dedup Hit Rates by Similarity Level", () => {
 
     let totalCheckpoints = 0;
     for (let i = 0; i < variations.length; i++) {
-      const stats = store.stats(`sess_l1neg_${i}`);
+      const stats = vectorStats(store,`sess_l1neg_${i}`);
       totalCheckpoints += stats.checkpointCount;
     }
 
@@ -733,7 +733,7 @@ describe("Dedup Hit Rates by Similarity Level", () => {
 
     let totalCheckpoints = 0;
     for (let i = 0; i < paraphrases.length; i++) {
-      const stats = store.stats(`sess_l2_${i}`);
+      const stats = vectorStats(store,`sess_l2_${i}`);
       totalCheckpoints += stats.checkpointCount;
     }
 
@@ -798,7 +798,7 @@ describe("Dedup Hit Rates by Similarity Level", () => {
       });
     }
 
-    const stats = store.stats(dedupSession);
+    const stats = vectorStats(store,dedupSession);
     const totalAdded = 3 + 4 + 3;
 
     console.log(`    Total added: ${totalAdded}`);
@@ -1113,7 +1113,7 @@ describe("Store Stats & Dedup Metrics", () => {
       });
     }
 
-    const stats = store.stats(session);
+    const stats = vectorStats(store,session);
 
     console.log(`    Total added: 5`);
     console.log(`    Checkpoints stored: ${stats.checkpointCount}`);
@@ -1136,34 +1136,34 @@ describe("Store Stats & Dedup Metrics", () => {
     const sid = "sess_inject";
 
     assert.equal(
-      store.wasInjected(sid, id1),
+      vectorWasInjected(store,sid, id1),
       false,
       "Should not be injected initially",
     );
 
-    store.markInjected(sid, id1);
+    vectorMarkInjected(store,sid, id1);
     assert.equal(
-      store.wasInjected(sid, id1),
+      vectorWasInjected(store,sid, id1),
       true,
       "Should be injected after mark",
     );
     assert.equal(
-      store.wasInjected(sid, id2),
+      vectorWasInjected(store,sid, id2),
       false,
       "Different ID should not be affected",
     );
 
-    store.markInjected(sid, id2);
+    vectorMarkInjected(store,sid, id2);
     assert.equal(
-      store.wasInjected(sid, id2),
+      vectorWasInjected(store,sid, id2),
       true,
       "Second ID should also be injected",
     );
 
     // Idempotent
-    store.markInjected(sid, id1);
+    vectorMarkInjected(store,sid, id1);
     assert.equal(
-      store.wasInjected(sid, id1),
+      vectorWasInjected(store,sid, id1),
       true,
       "Re-mark should be idempotent",
     );
@@ -1200,7 +1200,7 @@ describe("Store Stats & Dedup Metrics", () => {
     );
 
     // Mark first hit as injected
-    store.markInjected(
+    vectorMarkInjected(store,
       sid,
       results1.hits[0].checkpoint.checkpointId,
     );
@@ -1272,7 +1272,7 @@ describe("topSimilar Edge Cases & Coverage", () => {
     }
 
     for (const n of [1, 3, 5, 10]) {
-      const results = store.topSimilar(sid, n);
+      const results = vectorTopSimilar(store,sid, n);
       assert.ok(
         results.length <= n,
         `topSimilar(${n}) returned ${results.length} results (should be <= ${n})`,
@@ -1282,7 +1282,7 @@ describe("topSimilar Edge Cases & Coverage", () => {
   });
 
   it("topSimilar returns empty for empty session", () => {
-    const results = store.topSimilar("sess_unknown_empty", 5);
+    const results = vectorTopSimilar(store,"sess_unknown_empty", 5);
     assert.equal(results.length, 0, "Empty session should return no results");
   });
 });

package/src/recall.test.ts

@@ -6,7 +6,13 @@ import { join } from "node:path";
 import { VectorStore } from "./vectorStore.js";
 import { compactSession } from "./engine.js";
 import { recallAndInline, recallAndInlineAsync, formatRecallBlock } from "./recall.js";
+import { vectorList } from "./vectorStore.js";
 import { markInjectedGlobal, wasInjectedGlobal, closeIndexStore } from "./store/sqlite.js";
+import {
+  closeVectorIndex,
+  initVectorIndex,
+  rebuildFromSqlite,
+} from "./store/vectorIndex.js";
 import type { EngineMessage } from "./types.js";
 
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-recall-"));
@@ -119,58 +125,124 @@ test("Fix C: inline dedupe drops a hit already resident in the live window", ()
   );
 });
 
+// ---- S18 cross-repo global injected-set (real-data, no mocks) ----------------
+//
+// Earlier versions of these tests used `as any` mock stores with canned
+// `searchAsync` returns. That was mock data: it asserted recall's orchestration
+// against a fake search result, not the real embed → HNSW → hydrate → inject
+// path. Per the no-mock-data principle, both tests now seed a REAL foreign
+// VectorStore (real checkpoint + real TrigramEmbedder embedding persisted to
+// SQLite), rebuild the real PGlite index from it via `rebuildFromSqlite`, and
+// run the full `recallAndInlineAsync` cross-repo path against a separate self
+// store. The foreign checkpoint hydrates from the foreign store via its real
+// repoId (== stateDir, per VectorStore's repoId convention).
+
+async function seedForeignRepo(foreignStateDir: string): Promise<{ sessionId: string; checkpointId: string; summary: string }> {
+  // A real VectorStore at the foreign repo's stateDir. repoId == stateDir.
+  const foreign = new VectorStore({ stateDir: foreignStateDir, dedupSim: 0.9 });
+  const sess = "sess_foreign";
+  // Seed a real checkpoint via the real compactSession pipeline. The summary
+  // text determines the embedding; the query below must land near it.
+  const summary = "foreign repo authentication jwt token validation";
+  const result = compactSession(
+    {
+      sessionId: sess,
+      messages: [msg("user", summary), msg("assistant", "ok", "Edit")],
+      keepFrom: 2,
+      timestamp: 1,
+    },
+    foreign,
+  );
+  return { sessionId: sess, checkpointId: result.checkpointId ?? "", summary };
+}
+
 test("S18: global injected-set skips a foreign checkpoint already injected machine-wide", async () => {
+  if (process.env.MEGACOMPACT_PGLITE_DISABLED === "true") { return; } // skip when WASM index is off
   const indexDir = mkdtempSync(join(tmpdir(), "mc-gi-"));
+  const foreignStateDir = mkdtempSync(join(tmpdir(), "mc-gi-foreign-"));
+  const selfStateDir = mkdtempSync(join(tmpdir(), "mc-gi-self-"));
+  process.env.MEGACOMPACT_VECTOR_INDEX_DIR = mkdtempSync(join(tmpdir(), "mc-gi-vidx-"));
   try {
+    await closeVectorIndex(); // fresh singleton per this index dir
+    const seed = await seedForeignRepo(foreignStateDir);
+    // Populate the real PGlite index from the foreign store's real checkpoints.
+    await rebuildFromSqlite(
+      () => [{ repoId: foreignStateDir, stateDir: foreignStateDir }],
+      (sd) => {
+        // readCheckpoints: yield (sessionId, checkpointId, embedding) for every
+        // real checkpoint in this store. Mirrors the production enumerator.
+        const store = new VectorStore({ stateDir: sd, dedupSim: 0.9 });
+        return vectorList(store, seed.sessionId).map((cp) => ({
+          sessionId: seed.sessionId,
+          checkpointId: cp.checkpointId,
+          embedding: cp.embedding,
+        }));
+      },
+    );
+    const pg = await initVectorIndex();
+    assert.ok(pg, "PGlite index should initialize (WASM available)");
+
     const sess = "sess_cross";
-    // A foreign checkpoint already marked injected globally (in this session).
-    markInjectedGlobal("chkpt_foreign", "/repo/other", sess, indexDir);
-    assert.equal(wasInjectedGlobal("chkpt_foreign", sess, indexDir), true);
-    // searchAsync returns the foreign hit; recallAndInlineAsync must skip it
-    // (globally injected) → toInject is empty.
-    const mockStore = {
-      searchAsync: async () => [{
-        checkpoint: { checkpointId: "chkpt_foreign", summary: "foreign work", filesModified: [], dedupStatus: "active" },
-        score: 0.92,
-        repoId: "/repo/other",
-      }],
-      wasInjected: () => false,
-      markInjected: () => {},
-    } as any;
+    // Pre-mark the foreign checkpoint as already injected machine-wide.
+    markInjectedGlobal(seed.checkpointId, foreignStateDir, sess, indexDir);
+    assert.equal(wasInjectedGlobal(seed.checkpointId, sess, indexDir), true);
+
+    // Self store (different repo) — the cross-repo query runs against the index.
+    const selfStore = new VectorStore({ stateDir: selfStateDir, dedupSim: 0.9 });
     const r = await recallAndInlineAsync(
-      { sessionId: sess, query: "foreign", limit: 3, source: "command", crossRepo: true, globalIndexDir: indexDir },
-      mockStore,
+      { sessionId: sess, query: "foreign repo authentication jwt", limit: 3, source: "command", crossRepo: true, globalIndexDir: indexDir },
+      selfStore,
     );
     assert.equal(r.toInject.length, 0, "globally-injected foreign checkpoint skipped");
   } finally {
+    await closeVectorIndex();
     closeIndexStore();
+    delete process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
     rmSync(indexDir, { recursive: true, force: true });
+    rmSync(foreignStateDir, { recursive: true, force: true });
+    rmSync(selfStateDir, { recursive: true, force: true });
   }
 });
 
 test("S18: a fresh foreign checkpoint is injected AND recorded globally", async () => {
+  if (process.env.MEGACOMPACT_PGLITE_DISABLED === "true") { return; } // skip when WASM index is off
   const indexDir = mkdtempSync(join(tmpdir(), "mc-gi2-"));
+  const foreignStateDir = mkdtempSync(join(tmpdir(), "mc-gi2-foreign-"));
+  const selfStateDir = mkdtempSync(join(tmpdir(), "mc-gi2-self-"));
+  process.env.MEGACOMPACT_VECTOR_INDEX_DIR = mkdtempSync(join(tmpdir(), "mc-gi2-vidx-"));
   try {
+    await closeVectorIndex(); // fresh singleton per this index dir
+    const seed = await seedForeignRepo(foreignStateDir);
+    assert.equal(wasInjectedGlobal(seed.checkpointId, "sess_fresh", indexDir), false);
+    await rebuildFromSqlite(
+      () => [{ repoId: foreignStateDir, stateDir: foreignStateDir }],
+      (sd) => {
+        const store = new VectorStore({ stateDir: sd, dedupSim: 0.9 });
+        return vectorList(store, seed.sessionId).map((cp) => ({
+          sessionId: seed.sessionId,
+          checkpointId: cp.checkpointId,
+          embedding: cp.embedding,
+        }));
+      },
+    );
+    const pg = await initVectorIndex();
+    assert.ok(pg, "PGlite index should initialize (WASM available)");
+
     const sess = "sess_fresh";
-    assert.equal(wasInjectedGlobal("chkpt_new", sess, indexDir), false);
-    const mockStore = {
-      searchAsync: async () => [{
-        checkpoint: { checkpointId: "chkpt_new", summary: "brand new foreign work", filesModified: [], dedupStatus: "active" },
-        score: 0.93,
-        repoId: "/repo/alpha",
-      }],
-      wasInjected: () => false,
-      markInjected: () => {},
-    } as any;
+    const selfStore = new VectorStore({ stateDir: selfStateDir, dedupSim: 0.9 });
     const r = await recallAndInlineAsync(
-      { sessionId: sess, query: "foreign", limit: 3, source: "command", crossRepo: true, globalIndexDir: indexDir },
-      mockStore,
+      { sessionId: sess, query: "foreign repo authentication jwt", limit: 3, source: "command", crossRepo: true, globalIndexDir: indexDir },
+      selfStore,
     );
     assert.equal(r.toInject.length, 1, "fresh foreign checkpoint injected");
-    assert.equal(wasInjectedGlobal("chkpt_new", sess, indexDir), true, "recorded machine-wide");
+    assert.equal(wasInjectedGlobal(seed.checkpointId, sess, indexDir), true, "recorded machine-wide");
   } finally {
+    await closeVectorIndex();
     closeIndexStore();
+    delete process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
     rmSync(indexDir, { recursive: true, force: true });
+    rmSync(foreignStateDir, { recursive: true, force: true });
+    rmSync(selfStateDir, { recursive: true, force: true });
   }
 });
 

package/src/recall.ts

@@ -15,7 +15,7 @@
  */
 
 import { recall as searchRecall } from "./engine.js";
-import type { SearchHit, VectorStore } from "./vectorStore.js";
+import { vectorWasInjected, vectorMarkInjected, type SearchHit, type VectorStore, vectorSearchAsync } from "./vectorStore.js";
 import { estimateBlockTokens } from "./tokens.js";
 import { defaultEmbedder, cosineSimilarity } from "./embedder.js";
 
@@ -107,7 +107,7 @@ export function formatRecallBlock(hits: SearchHit[]): string {
  */
 export function recallAndInline(
   opts: RecallInjectOptions,
-  store: Pick<VectorStore, "search" | "wasInjected" | "markInjected">,
+  store: VectorStore,
 ): RecallInjectResult {
   // ── S27 Recall Demotion ─────────────────────────────────────────────
   //
@@ -134,7 +134,7 @@ export function recallAndInline(
 
   const { hits } = searchRecall(
     { sessionId: opts.sessionId, query: opts.query, limit, skipInjected: false },
-    store as VectorStore,
+    store,
   );
 
   // Precompute live-window embeddings once for inline dedupe (Fix C). Trigram
@@ -152,7 +152,7 @@ export function recallAndInline(
   let blockTokens = 0;
 
   for (const h of hits) {
-    if (skip && store.wasInjected(opts.sessionId, h.checkpoint.checkpointId)) continue;
+    if (skip && vectorWasInjected(store, opts.sessionId, h.checkpoint.checkpointId)) continue;
 
     // Inline dedupe: skip a hit already resident in the live window (Fix C).
     if (doWindowDedupe && liveEmbeddings.length > 0) {
@@ -168,7 +168,7 @@ export function recallAndInline(
     parts.push(part);
     toInject.push(h);
     blockTokens += partTokens;
-    store.markInjected(opts.sessionId, h.checkpoint.checkpointId);
+    vectorMarkInjected(store, opts.sessionId, h.checkpoint.checkpointId);
   }
 
   const block = parts.join("\n");
@@ -285,7 +285,7 @@ export async function recallMemoriesAndInline(
  */
 export async function recallAndInlineAsync(
   opts: RecallInjectOptions & { crossRepo?: boolean; repoId?: string },
-  store: Pick<VectorStore, "searchAsync" | "wasInjected" | "markInjected">,
+  store: VectorStore,
 ): Promise<RecallInjectResult> {
   const limit = opts.limit ?? 3;
   const skip = opts.skipInjected ?? true;
@@ -295,7 +295,7 @@ export async function recallAndInlineAsync(
 
   let hits: SearchHit[] = [];
   try {
-    hits = await store.searchAsync(opts.sessionId, opts.query, limit, {
+    hits = await vectorSearchAsync(store, opts.sessionId, opts.query, limit, {
       crossRepo: opts.crossRepo,
       repoId: opts.repoId,
     });
@@ -314,7 +314,7 @@ export async function recallAndInlineAsync(
   let blockTokens = 0;
 
   for (const h of hits) {
-    if (skip && store.wasInjected(opts.sessionId, h.checkpoint.checkpointId)) continue;
+    if (skip && vectorWasInjected(store, opts.sessionId, h.checkpoint.checkpointId)) continue;
     // S18: machine-wide injected-set — a foreign checkpoint already injected
     // (in any session) is never re-injected. Only applies to cross-repo hits
     // (same-repo hits have no repoId and are handled by the per-session set).
@@ -336,7 +336,7 @@ export async function recallAndInlineAsync(
     parts.push(part);
     toInject.push(h);
     blockTokens += partTokens;
-    store.markInjected(opts.sessionId, h.checkpoint.checkpointId);
+    vectorMarkInjected(store, opts.sessionId, h.checkpoint.checkpointId);
     // S18: record the cross-repo injection machine-wide so it's not re-injected
     // by a later recall (same or different session).
     if (opts.globalIndexDir && h.repoId) {