pi-mega-compact 0.8.25 → 0.9.0

package/src/sprint4x-rag-verification.test.ts

@@ -0,0 +1,119 @@
+/**
+ * sprint4x-rag-verification.test.ts — run the S40–S47 RAG suite once against
+ * the current implementation and assert the documented "default enable" claims.
+ *
+ * This is the verification pass demanded by the roadmap/backlog: each spec
+ * claims its feature flags DEFAULT ON. The honest check (not a re-statement of
+ * the spec) is: which flags actually exist in code, what do they default to,
+ * and is the consuming path wired?
+ *
+ * Findings recorded here, per spec:
+ *   S40 importance-scoring     — module src/importance.ts exists (S40A) but is
+ *                                NOT consumed by compactSession/vector-paths;
+ *                                no shipped flag, no adapter wiring.
+ *   S41 self-rag-quality-gate  — spec-only; NO flag, NO consumer.
+ *   S42 raptor-multilevel      — PARTIALLY SHIPPED: RAPTOR_MULTILEVEL_ENABLED
+ *                                and RAPTOR_LEAF_EXPANSION both default true
+ *                                with real consumers; the spec's claim holds.
+ *   S43 hyde-vague-queries     — spec-only (QUERY_REFORMULATION_ENABLED absent).
+ *   S44 three-tier-latency-routing — spec-only (TIERED_ROUTING_ENABLED absent).
+ *   S45 crag-quality-metrics   — spec-only (CRAG_ENABLED absent).
+ *   S46 visual-memory-map      — spec-only (MEMORY_MAP_ENABLED absent;
+ *                                memory-graph endpoint not in dashboard-server).
+ *   S47 auto-categorizing-wiki — spec-only (AUTO_WIKI_ENABLED absent).
+ *
+ * Policy: the suite runs against the flags that EXIST today. Unimplemented spec
+ * claims are pinned by the S4X_SPEC_ONLY tests so regressions can't silently
+ * add them in the wrong state, and this file records exactly which
+ * spec-vs-implementation gaps remain.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { loadDedupConfig } from "./config/dedup.js";
+
+/**
+ * Clear any env pollution so the default is measured, not the override.
+ */
+function fresh<T extends string>(envKey: T, get: () => unknown): unknown {
+	delete process.env[envKey];
+	try {
+		return get();
+	} finally {
+		delete process.env[envKey];
+	}
+}
+
+// ---- S42: shipped flags default ON (claim holds) ----------------------------
+
+test("S42 RAPTOR_MULTILEVEL_ENABLED defaults ON and honors env off", () => {
+	const d = fresh("MEGACOMPACT_RAPTOR_MULTILEVEL", () => loadDedupConfig());
+	assert.ok(
+		(d as { RAPTOR_MULTILEVEL_ENABLED: boolean }).RAPTOR_MULTILEVEL_ENABLED,
+		"ship claim: multi-level on by default",
+	);
+	process.env.MEGACOMPACT_RAPTOR_MULTILEVEL = "false";
+	const off = loadDedupConfig();
+	assert.ok(
+		!off.RAPTOR_MULTILEVEL_ENABLED,
+		"env override: MEGACOMPACT_RAPTOR_MULTILEVEL=false turns it off",
+	);
+});
+
+test("S42 RAPTOR_LEAF_EXPANSION defaults ON and honors env off", () => {
+	const d = fresh("MEGACOMPACT_RAPTOR_LEAF_EXPANSION", () => loadDedupConfig());
+	assert.ok(
+		(d as { RAPTOR_LEAF_EXPANSION: boolean }).RAPTOR_LEAF_EXPANSION,
+		"ship claim: leaf-expansion on by default",
+	);
+	process.env.MEGACOMPACT_RAPTOR_LEAF_EXPANSION = "false";
+	const off = loadDedupConfig();
+	assert.ok(!off.RAPTOR_LEAF_EXPANSION, "env override off");
+});
+
+// ---- S40: module exists, claims do NOT yet hold at the flag/consumer level --
+
+test("S40 importance module exists in-tree (S40A artifact)", async () => {
+	// Load the module and confirm it exports the scoring surface the spec
+	// describes. This proves the S40A implementation exists even though nothing
+	// wires it into compaction/vector paths yet (documented gap).
+	const mod = await import("./importance.js");
+	assert.ok(mod && typeof mod === "object", "importance.ts loads");
+	// Exports per spec: score() plus item-type enum.
+	assert.ok(typeof (mod as Record<string, unknown>).score === "function",
+		"importance.ts exports score() function",
+	);
+});
+
+test("S40 has no shipped consumer flag in the current codebase (gap pinned)", async () => {
+	// The S40 spec claims an IMPORTANCE_SCORING flag defaults ON. In the
+	// current code no such flag exists, and no vector/compact path reads
+	// importance scores. This test documents the gap so a future wiring does
+	// not silently flip it on in the wrong shape.
+	const cfg = loadDedupConfig();
+	assert.ok(
+		!("IMPORTANCE_SCORING" in cfg),
+		"no IMPORTANCE_SCORING flag yet (S40 consumer wiring missing)",
+	);
+});
+
+// ---- S41/S43–S47: spec-only modules — pin the absence ------------------------
+
+test("S4X spec-only flags absent from DedupConfig", () => {
+	const cfg = loadDedupConfig();
+	const specFlags = [
+		"CRITIQUE_ENABLED", // S41
+		"QUERY_REFORMULATION_ENABLED", // S43
+		"TIERED_ROUTING_ENABLED", // S44
+		"CRAG_ENABLED", // S45
+		"CRAG_EXPANSION_ENABLED", // S45
+		"MEMORY_MAP_ENABLED", // S46
+		"AUTO_WIKI_ENABLED", // S47
+	] as const;
+	for (const f of specFlags) {
+		assert.ok(
+			!(f in cfg),
+			`${f} is spec-only — should not be present in DedupConfig`,
+		);
+	}
+});

package/src/store/repoKey.ts

@@ -0,0 +1,50 @@
+/**
+ * repoKey.ts — S25-B: the single repo-scope key for BOTH global PGlite indexes.
+ *
+ * Before S25 the checkpoint index (vector_index) keyed on stateDir while the
+ * memory index (memory_index) keyed on the git root — two scopes that meant
+ * cross-repo checkpoint hydration had no way back from repo_id → the repo's
+ * store. This helper unifies both indexes on ONE key: the resolved git root,
+ * falling back to stateDir outside git worktrees.
+ *
+ * stateDirForRepo() reverses the mapping via the machine-wide
+ * repo_registry (src/store/sqlite/global-index.ts): a repo_id hit from the
+ * index resolves to that repo's stateDir so getCheckpoint() can hydrate from
+ * the authoritative node:sqlite store. Returns undefined when unresolvable —
+ * the caller skips the hit (degrade, never crash).
+ *
+ * PREVENT-PI-004: `git rev-parse` is local + read-only (annotated below).
+ */
+
+import { execSync } from "node:child_process"; // guardrails-allow PREVENT-PI-004: read-only `git rev-parse` to scope the vector index per-repo
+import { getRepoRegistry } from "./sqlite/global-index.js";
+
+/**
+ * Resolve the canonical repo key for a state dir. Git root when inside a
+ * worktree, stateDir otherwise. Two repos sharing a git root (e.g. nested
+ * checkouts pointing at the same repo) collapse to one scope — intended.
+ */
+export function repoKey(stateDir: string): string {
+  try {
+    const out = execSync("git rev-parse --show-toplevel", {
+      cwd: stateDir,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return out || stateDir;
+  } catch {
+    return stateDir;
+  }
+}
+
+/**
+ * Reverse map: repo_id → stateDir. Registry hit wins (git-root scope, S25);
+ * otherwise the key is assumed to be a legacy/ungit-scoped stateDir and
+ * returned verbatim (callers treat undefined-unopenable dirs as skip/degrade).
+ */
+export function stateDirForRepo(
+  repoId: string,
+  indexDir?: string,
+): string | undefined {
+  return getRepoRegistry(repoId, indexDir)?.stateDir ?? repoId;
+}

package/src/store/sqlite/turns.ts

@@ -25,28 +25,28 @@ import type { DatabaseSync } from "node:sqlite";
 
 /** A row in `turns`. */
 export interface TurnRow {
-  id: number;
-  conversationId: string;
-  sessionId: string;
-  turnIndex: number;
-  role: string | null;
-  startedAt: number;
-  endedAt: number | null;
-  ctxTokens: number | null;
-  ctxPercent: number | null;
-  pressureBand: string | null;
-  modelId: string | null;
-  epochId: string | null;
+	id: number;
+	conversationId: string;
+	sessionId: string;
+	turnIndex: number;
+	role: string | null;
+	startedAt: number;
+	endedAt: number | null;
+	ctxTokens: number | null;
+	ctxPercent: number | null;
+	pressureBand: string | null;
+	modelId: string | null;
+	epochId: string | null;
 }
 
 /** A row in `turn_recall`. */
 export interface TurnRecallRow {
-  id: number;
-  turnId: number;
-  checkpointId: string;
-  score: number;
-  source: string;
-  raptorLevel: number | null;
+	id: number;
+	turnId: number;
+	checkpointId: string;
+	score: number;
+	source: string;
+	raptorLevel: number | null;
 }
 
 /** Where a recalled hit came from (recorded on turn_recall.source). */
@@ -54,24 +54,24 @@ export type RecallSource = "flat" | "raptor" | "cross-repo" | "memory";
 
 /** Generate a new conversation id (`conv_` + 16 hex). */
 export function newConversationId(): string {
-  return `conv_${randomBytes(8).toString("hex")}`;
+	return `conv_${randomBytes(8).toString("hex")}`;
 }
 
 function rowToTurn(r: Record<string, unknown>): TurnRow {
-  return {
-    id: r.id as number,
-    conversationId: r.conversation_id as string,
-    sessionId: r.session_id as string,
-    turnIndex: r.turn_index as number,
-    role: (r.role as string | null) ?? null,
-    startedAt: r.started_at as number,
-    endedAt: (r.ended_at as number | null) ?? null,
-    ctxTokens: (r.ctx_tokens as number | null) ?? null,
-    ctxPercent: (r.ctx_percent as number | null) ?? null,
-    pressureBand: (r.pressure_band as string | null) ?? null,
-    modelId: (r.model_id as string | null) ?? null,
-    epochId: (r.epoch_id as string | null) ?? null,
-  };
+	return {
+		id: r.id as number,
+		conversationId: r.conversation_id as string,
+		sessionId: r.session_id as string,
+		turnIndex: r.turn_index as number,
+		role: (r.role as string | null) ?? null,
+		startedAt: r.started_at as number,
+		endedAt: (r.ended_at as number | null) ?? null,
+		ctxTokens: (r.ctx_tokens as number | null) ?? null,
+		ctxPercent: (r.ctx_percent as number | null) ?? null,
+		pressureBand: (r.pressure_band as string | null) ?? null,
+		modelId: (r.model_id as string | null) ?? null,
+		epochId: (r.epoch_id as string | null) ?? null,
+	};
 }
 
 /**
@@ -80,26 +80,26 @@ function rowToTurn(r: Record<string, unknown>): TurnRow {
  * Idempotent on (session_id, turn_index) — re-upserting overwrites metrics.
  */
 export function recordTurn(
-  input: {
-    conversationId: string;
-    sessionId: string;
-    turnIndex: number;
-    role?: string;
-    startedAt?: number;
-    endedAt?: number;
-    ctxTokens?: number;
-    ctxPercent?: number;
-    pressureBand?: string;
-    modelId?: string;
-    epochId?: string;
-  },
-  stateDir: string = getStateDir(),
+	input: {
+		conversationId: string;
+		sessionId: string;
+		turnIndex: number;
+		role?: string;
+		startedAt?: number;
+		endedAt?: number;
+		ctxTokens?: number;
+		ctxPercent?: number;
+		pressureBand?: string;
+		modelId?: string;
+		epochId?: string;
+	},
+	stateDir: string = getStateDir(),
 ): number {
-  const db = openStore(stateDir);
-  const sid = normalizeSessionId(input.sessionId);
-  const startedAt = input.startedAt ?? Date.now();
-  db.prepare(
-    `INSERT INTO turns (conversation_id, session_id, turn_index, role, started_at,
+	const db = openStore(stateDir);
+	const sid = normalizeSessionId(input.sessionId);
+	const startedAt = input.startedAt ?? Date.now();
+	db.prepare(
+		`INSERT INTO turns (conversation_id, session_id, turn_index, role, started_at,
                          ended_at, ctx_tokens, ctx_percent, pressure_band, model_id, epoch_id)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(session_id, turn_index) DO UPDATE SET
@@ -112,23 +112,23 @@ export function recordTurn(
        pressure_band = COALESCE(excluded.pressure_band, pressure_band),
        model_id = COALESCE(excluded.model_id, model_id),
        epoch_id = COALESCE(excluded.epoch_id, epoch_id)`,
-  ).run(
-    input.conversationId,
-    sid,
-    input.turnIndex,
-    input.role ?? null,
-    startedAt,
-    input.endedAt ?? null,
-    input.ctxTokens ?? null,
-    input.ctxPercent ?? null,
-    input.pressureBand ?? null,
-    input.modelId ?? null,
-    input.epochId ?? null,
-  );
-  const row = db
-    .prepare("SELECT id FROM turns WHERE session_id = ? AND turn_index = ?")
-    .get(sid, input.turnIndex) as { id: number };
-  return row.id;
+	).run(
+		input.conversationId,
+		sid,
+		input.turnIndex,
+		input.role ?? null,
+		startedAt,
+		input.endedAt ?? null,
+		input.ctxTokens ?? null,
+		input.ctxPercent ?? null,
+		input.pressureBand ?? null,
+		input.modelId ?? null,
+		input.epochId ?? null,
+	);
+	const row = db
+		.prepare("SELECT id FROM turns WHERE session_id = ? AND turn_index = ?")
+		.get(sid, input.turnIndex) as { id: number };
+	return row.id;
 }
 
 /**
@@ -137,108 +137,116 @@ export function recordTurn(
  * path + score. RAPTOR cluster hits carry raptorLevel. Best-effort + non-fatal.
  */
 export function recordTurnRecall(
-  turnId: number,
-  hits: {
-    checkpointId: string;
-    score: number;
-    source: RecallSource;
-    raptorLevel?: number;
-  }[],
-  stateDir: string = getStateDir(),
+	turnId: number,
+	hits: {
+		checkpointId: string;
+		score: number;
+		source: RecallSource;
+		raptorLevel?: number;
+	}[],
+	stateDir: string = getStateDir(),
 ): void {
-  if (hits.length === 0) return;
-  const db = openStore(stateDir);
-  const stmt = db.prepare(
-    `INSERT INTO turn_recall (turn_id, checkpoint_id, score, source, raptor_level)
+	if (hits.length === 0) return;
+	const db = openStore(stateDir);
+	const stmt = db.prepare(
+		`INSERT INTO turn_recall (turn_id, checkpoint_id, score, source, raptor_level)
      VALUES (?, ?, ?, ?, ?)
      ON CONFLICT(turn_id, checkpoint_id) DO UPDATE SET
        score = excluded.score, source = excluded.source,
        raptor_level = excluded.raptor_level`,
-  );
-  withTx(db, () => {
-    for (const h of hits) {
-      stmt.run(turnId, h.checkpointId, h.score, h.source, h.raptorLevel ?? null);
-    }
-  });
+	);
+	withTx(db, () => {
+		for (const h of hits) {
+			stmt.run(
+				turnId,
+				h.checkpointId,
+				h.score,
+				h.source,
+				h.raptorLevel ?? null,
+			);
+		}
+	});
 }
 
 /** Get a turn by conversation id + turn index (the lookup a fork uses). */
 export function getTurn(
-  conversationId: string,
-  turnIndex: number,
-  stateDir: string = getStateDir(),
+	conversationId: string,
+	turnIndex: number,
+	stateDir: string = getStateDir(),
 ): TurnRow | null {
-  const db = openStore(stateDir);
-  const row = db
-    .prepare(
-      `SELECT * FROM turns WHERE conversation_id = ? AND turn_index = ?`,
-    )
-    .get(conversationId, turnIndex) as Record<string, unknown> | undefined;
-  return row ? rowToTurn(row) : null;
+	const db = openStore(stateDir);
+	const row = db
+		.prepare(`SELECT * FROM turns WHERE conversation_id = ? AND turn_index = ?`)
+		.get(conversationId, turnIndex) as Record<string, unknown> | undefined;
+	return row ? rowToTurn(row) : null;
 }
 
 /** Get a turn by its global id. */
 export function getTurnById(
-  turnId: number,
-  stateDir: string = getStateDir(),
+	turnId: number,
+	stateDir: string = getStateDir(),
 ): TurnRow | null {
-  const db = openStore(stateDir);
-  const row = db
-    .prepare("SELECT * FROM turns WHERE id = ?")
-    .get(turnId) as Record<string, unknown> | undefined;
-  return row ? rowToTurn(row) : null;
+	const db = openStore(stateDir);
+	const row = db.prepare("SELECT * FROM turns WHERE id = ?").get(turnId) as
+		| Record<string, unknown>
+		| undefined;
+	return row ? rowToTurn(row) : null;
 }
 
 /** All turn_recall rows for a turn (what was injected at that turn). */
 export function listTurnRecall(
-  turnId: number,
-  stateDir: string = getStateDir(),
+	turnId: number,
+	stateDir: string = getStateDir(),
 ): TurnRecallRow[] {
-  const db = openStore(stateDir);
-  const rows = db
-    .prepare(
-      `SELECT id, turn_id, checkpoint_id, score, source, raptor_level
+	const db = openStore(stateDir);
+	const rows = db
+		.prepare(
+			`SELECT id, turn_id, checkpoint_id, score, source, raptor_level
        FROM turn_recall WHERE turn_id = ? ORDER BY score DESC`,
-    )
-    .all(turnId) as Array<Record<string, unknown>>;
-  return rows.map((r) => ({
-    id: r.id as number,
-    turnId: r.turn_id as number,
-    checkpointId: r.checkpoint_id as string,
-    score: r.score as number,
-    source: r.source as string,
-    raptorLevel: (r.raptor_level as number | null) ?? null,
-  }));
+		)
+		.all(turnId) as Array<Record<string, unknown>>;
+	return rows.map((r) => ({
+		id: r.id as number,
+		turnId: r.turn_id as number,
+		checkpointId: r.checkpoint_id as string,
+		score: r.score as number,
+		source: r.source as string,
+		raptorLevel: (r.raptor_level as number | null) ?? null,
+	}));
 }
 
 /** All turns in a conversation, ascending by turn_index. */
 export function listConversationTurns(
-  conversationId: string,
-  stateDir: string = getStateDir(),
+	conversationId: string,
+	stateDir: string = getStateDir(),
 ): TurnRow[] {
-  const db = openStore(stateDir);
-  const rows = db
-    .prepare(
-      `SELECT * FROM turns WHERE conversation_id = ? ORDER BY turn_index ASC`,
-    )
-    .all(conversationId) as Array<Record<string, unknown>>;
-  return rows.map(rowToTurn);
+	const db = openStore(stateDir);
+	const rows = db
+		.prepare(
+			`SELECT * FROM turns WHERE conversation_id = ? ORDER BY turn_index ASC`,
+		)
+		.all(conversationId) as Array<Record<string, unknown>>;
+	return rows.map(rowToTurn);
 }
 
 /** Resolve a session's conversation id, generating + persisting one if none.
  *  A resumed session inherits its existing conversationId from session_state. */
 export function ensureConversationId(
-  sessionId: string,
-  stateDir: string = getStateDir(),
+	sessionId: string,
+	stateDir: string = getStateDir(),
 ): string {
-  const st = loadSessionState(sessionId, stateDir);
-  if (st.conversationId) return st.conversationId;
-  const conv = newConversationId();
-  saveSessionState(sessionId, {
-    ...st,
-    conversationId: conv,
-  }, stateDir);
-  return conv;
+	const st = loadSessionState(sessionId, stateDir);
+	if (st.conversationId) return st.conversationId;
+	const conv = newConversationId();
+	saveSessionState(
+		sessionId,
+		{
+			...st,
+			conversationId: conv,
+		},
+		stateDir,
+	);
+	return conv;
 }
 
 /**
@@ -252,41 +260,43 @@ export function ensureConversationId(
  * injected in the new session's session_state so they're not re-recalled.
  */
 export function forkConversation(
-  parentConversationId: string,
-  forkTurnId: number,
-  stateDir: string = getStateDir(),
+	parentConversationId: string,
+	forkTurnId: number,
+	stateDir: string = getStateDir(),
 ): { conversationId: string; recalled: TurnRecallRow[] } {
-  const childId = newConversationId();
-  const db: DatabaseSync = openStore(stateDir);
-  withTx(db, () => {
-    db.prepare(
-      `INSERT INTO conversation_branches
+	const childId = newConversationId();
+	const db: DatabaseSync = openStore(stateDir);
+	withTx(db, () => {
+		db.prepare(
+			`INSERT INTO conversation_branches
          (conversation_id, parent_conversation_id, fork_turn_id, created_at)
        VALUES (?, ?, ?, ?)
        ON CONFLICT(conversation_id) DO NOTHING`,
-    ).run(childId, parentConversationId, forkTurnId, Date.now());
-  });
-  // Replay set: the parent's injected checkpoints at the fork turn.
-  const recalled = listTurnRecall(forkTurnId, stateDir);
-  return { conversationId: childId, recalled };
+		).run(childId, parentConversationId, forkTurnId, Date.now());
+	});
+	// Replay set: the parent's injected checkpoints at the fork turn.
+	const recalled = listTurnRecall(forkTurnId, stateDir);
+	return { conversationId: childId, recalled };
 }
 
 /** Clear turn tracking rows for a session (tests / DR). */
 export function clearTurns(
-  sessionId: string,
-  stateDir: string = getStateDir(),
+	sessionId: string,
+	stateDir: string = getStateDir(),
 ): void {
-  const db: DatabaseSync = openStore(stateDir);
-  const sid = normalizeSessionId(sessionId);
-  withTx(db, () => {
-    const turnIds = db
-      .prepare("SELECT id FROM turns WHERE session_id = ?")
-      .all(sid) as Array<{ id: number }>;
-    const ids = turnIds.map((t) => t.id);
-    if (ids.length > 0) {
-      const placeholders = ids.map(() => "?").join(",");
-      db.prepare(`DELETE FROM turn_recall WHERE turn_id IN (${placeholders})`).run(...ids);
-    }
-    db.prepare("DELETE FROM turns WHERE session_id = ?").run(sid);
-  });
+	const db: DatabaseSync = openStore(stateDir);
+	const sid = normalizeSessionId(sessionId);
+	withTx(db, () => {
+		const turnIds = db
+			.prepare("SELECT id FROM turns WHERE session_id = ?")
+			.all(sid) as Array<{ id: number }>;
+		const ids = turnIds.map((t) => t.id);
+		if (ids.length > 0) {
+			const placeholders = ids.map(() => "?").join(",");
+			db.prepare(
+				`DELETE FROM turn_recall WHERE turn_id IN (${placeholders})`,
+			).run(...ids);
+		}
+		db.prepare("DELETE FROM turns WHERE session_id = ?").run(sid);
+	});
 }

package/src/store/vectorIndex.test.ts

@@ -12,7 +12,7 @@
 
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -95,6 +95,30 @@ test("dimension guard: non-512 vectors are skipped, never corrupt the index", as
   }
 });
 
+test("corrupt-dir self-heal: torn PGlite dir is deleted + retried, never crashes", async () => {
+  delete process.env.MEGACOMPACT_PGLITE_DISABLED;
+  const dir = isolateIndexDir();
+  try {
+    await closeVectorIndex();
+    // Tear the dir: garbage bytes where PGlite expects its data/ files.
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "data"), Buffer.from([0xde, 0xad, 0xbe, 0xef, 0xde, 0xad]));
+    // openPgLite(retryOnCorrupt=true) deletes + retries; if that still fails it
+    // disables gracefully. Either path must NOT throw.
+    const pg = await initVectorIndex();
+    assert.ok(pg, "index self-healed after corruption ");
+    // And the index works after heal: upsert + search round-trip.
+    await upsertEmbedding("/repoE/.pi/mega-compact", "sessE", "chkpt_001", spikeVec(7));
+    const hits = await searchAsync(spikeVec(7), { k: 1 });
+    assert.equal(hits.length, 1, "search works on the healed index");
+    assert.equal(hits[0].checkpointId, "chkpt_001");
+  } finally {
+    await closeVectorIndex();
+    rmSync(dir, { recursive: true, force: true });
+    delete process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
+  }
+});
+
 test("kill-switch: MEGACOMPACT_PGLITE_DISABLED disables the index gracefully", async () => {
   const dir = isolateIndexDir();
   process.env.MEGACOMPACT_PGLITE_DISABLED = "true";

package/src/vector-search.ts

@@ -14,6 +14,7 @@
 import { cosineSimilarity } from "./embedder.js";
 import { normalizeSessionId } from "./store.js";
 import { mmrRerank, type MmrItem } from "./dedup/mmr.js";
+import { stateDirForRepo } from "./store/repoKey.js";
 import { topK } from "./dedup/topk.js";
 import {
 	listCheckpoints,
@@ -320,13 +321,17 @@ export async function vectorSearchAsync(
 		// Index empty/unavailable → synchronous per-session fallback (this repo).
 		return vectorSearch(store, sid, query, k);
 	}
-	// Hydrate each index hit from the authoritative node:sqlite store. repoId is
-	// that repo's stateDir, so cross-repo hits resolve against their own store.
-	// Tag cross-repo hits with their source repoId so the recall block can label
-	// them ("from repo <name>"); same-repo hits stay unlabeled.
+	// Hydrate each index hit from the authoritative node:sqlite store. The
+	// index keys on repo_id (S25: git root via repoKey; legacy rows keyed by
+	// stateDir) — resolve repo_id → stateDir via stateDirForRepo, and skip
+	// unresolvable/foreign hits (degrade, never crash). Cross-repo hits carry
+	// their source repoId so the recall block can label them; same-repo stays
+	// unlabeled.
 	const hydrated: SearchHit[] = [];
 	for (const h of indexHits) {
-		const cp = getCheckpoint(h.sessionId, h.checkpointId, h.repoId);
+		const hitStateDir = stateDirForRepo(h.repoId);
+		if (!hitStateDir) continue;
+		const cp = getCheckpoint(h.sessionId, h.checkpointId, hitStateDir);
 		if (cp && cp.dedupStatus !== "removed") {
 			const crossRepo =
 				opts.crossRepo && selfRepo && h.repoId && h.repoId !== selfRepo;