@tekmidian/pai 0.54.0 → 0.55.0

package/dist/{tools-BEqiJt_j.mjs → tools-Diro2s8J.mjs}

@@ -1,9 +1,6 @@
-import { n as cosineSimilarity } from "./embeddings-DvRKcQyt.mjs";
-import { t as STOP_WORDS } from "./stop-words-BaMEGVeY.mjs";
-import { c as touchChunksLastAccessed, i as populateSlugs, o as searchMemoryHybrid } from "./search-B69cQwDB.mjs";
-import { r as formatDetectionJson, t as detectProject } from "./detect-Bf2z-oKB.mjs";
-import { t as buildWakeupContext } from "./wakeup-Yk5lQ0jb.mjs";
-import { a as kgContradictions, i as kgAdd, n as updateEntityFeedbackWeight, o as kgInvalidate, s as kgQuery, t as listKgEntities } from "./kg-entity-BSW7ra8i.mjs";
+import { i as populateSlugs } from "./search-BaTbyWjK.mjs";
+import { a as formatDetectionJson, r as detectProject, t as buildWakeupContext } from "./wakeup-D0uvqLsE.mjs";
+import { n as cosineSimilarity } from "./embeddings-DfrYNIng.mjs";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 
@@ -11,29 +8,24 @@ import { isAbsolute, join, resolve } from "node:path";
 /**
 * Shared types and project-row helpers used across all MCP tool handler modules.
 */
-function lookupProjectId(registryDb, slug) {
-	const bySlug = registryDb.prepare("SELECT id FROM projects WHERE slug = ?").get(slug);
+async function lookupProjectId(registry, slug) {
+	const bySlug = await registry.getProjectBySlug(slug);
 	if (bySlug) return bySlug.id;
-	const byAlias = registryDb.prepare("SELECT project_id FROM aliases WHERE alias = ?").get(slug);
-	if (byAlias) return byAlias.project_id;
-	return null;
+	return await registry.resolveAlias(slug) ?? null;
 }
-function detectProjectFromPath(registryDb, fsPath) {
+async function detectProjectFromPath(registry, fsPath) {
 	const resolved = resolve(fsPath);
-	const exact = registryDb.prepare("SELECT id, slug, display_name, root_path, type, status, created_at, updated_at FROM projects WHERE root_path = ?").get(resolved);
+	const exact = await registry.getProjectByRootPath(resolved);
 	if (exact) return exact;
-	const all = registryDb.prepare("SELECT id, slug, display_name, root_path, type, status, created_at, updated_at FROM projects ORDER BY LENGTH(root_path) DESC").all();
+	const all = await registry.listProjectsByPathLengthDesc();
 	for (const project of all) if (resolved.startsWith(project.root_path + "/") || resolved === project.root_path) return project;
 	return null;
 }
-function formatProject(registryDb, project) {
-	const sessionCount = registryDb.prepare("SELECT COUNT(*) AS n FROM sessions WHERE project_id = ?").get(project.id).n;
-	const lastSession = registryDb.prepare("SELECT date FROM sessions WHERE project_id = ? ORDER BY date DESC LIMIT 1").get(project.id);
-	const tags = registryDb.prepare(`SELECT t.name FROM tags t
-         JOIN project_tags pt ON pt.tag_id = t.id
-         WHERE pt.project_id = ?
-         ORDER BY t.name`).all(project.id).map((r) => r.name);
-	const aliases = registryDb.prepare("SELECT alias FROM aliases WHERE project_id = ? ORDER BY alias").all(project.id).map((r) => r.alias);
+async function formatProject(registry, project) {
+	const sessionCount = await registry.countSessionsForProject(project.id);
+	const lastSessionDate = await registry.getMostRecentSessionDate(project.id);
+	const tags = await registry.listTagsForProject(project.id);
+	const aliases = await registry.listAliasesForProject(project.id);
 	const lines = [
 		`slug: ${project.slug}`,
 		`display_name: ${project.display_name}`,
@@ -42,7 +34,7 @@ function formatProject(registryDb, project) {
 		`status: ${project.status}`,
 		`sessions: ${sessionCount}`
 	];
-	if (lastSession) lines.push(`last_session: ${lastSession.date}`);
+	if (lastSessionDate) lines.push(`last_session: ${lastSessionDate}`);
 	if (tags.length) lines.push(`tags: ${tags.join(", ")}`);
 	if (aliases.length) lines.push(`aliases: ${aliases.join(", ")}`);
 	if (project.obsidian_link) lines.push(`obsidian_link: ${project.obsidian_link}`);
@@ -55,10 +47,10 @@ function formatProject(registryDb, project) {
 /**
 * MCP tool handlers: memory_search, memory_get
 */
-async function toolMemorySearch(registryDb, federation, params, searchDefaults) {
+async function toolMemorySearch(registry, federation, params, searchDefaults) {
 	try {
-		const projectIds = params.project ? (() => {
-			const id = lookupProjectId(registryDb, params.project);
+		const projectIds = params.project ? await (async () => {
+			const id = await lookupProjectId(registry, params.project);
 			return id != null ? [id] : [];
 		})() : void 0;
 		if (params.project && (!projectIds || projectIds.length === 0)) return {
@@ -76,10 +68,9 @@ async function toolMemorySearch(registryDb, federation, params, searchDefaults)
 			maxResults: params.limit ?? searchDefaults?.defaultLimit ?? 5
 		};
 		let results;
-		const isBackend = (x) => "backendType" in x;
-		if (isBackend(federation)) if (mode === "keyword") results = await federation.searchKeyword(params.query, searchOpts);
+		if (mode === "keyword") results = await federation.searchKeyword(params.query, searchOpts);
 		else if (mode === "semantic" || mode === "hybrid") {
-			const { generateEmbedding } = await import("./embeddings-ClqKtLZ8.mjs");
+			const { generateEmbedding } = await import("./embeddings-BNv3TQC5.mjs");
 			const queryEmbedding = await generateEmbedding(params.query, true);
 			if (mode === "semantic") results = await federation.searchSemantic(queryEmbedding, searchOpts);
 			else {
@@ -93,20 +84,10 @@ async function toolMemorySearch(registryDb, federation, params, searchDefaults)
 				results = combineHybridResults(kwResults, semResults, searchOpts.maxResults ?? 10);
 			}
 		} else results = await federation.searchKeyword(params.query, searchOpts);
-		else {
-			const { searchMemory, searchMemorySemantic } = await import("./search-fb-5ovj4.mjs");
-			if (mode === "keyword") results = searchMemory(federation, params.query, searchOpts);
-			else if (mode === "semantic" || mode === "hybrid") {
-				const { generateEmbedding } = await import("./embeddings-ClqKtLZ8.mjs");
-				const queryEmbedding = await generateEmbedding(params.query, true);
-				if (mode === "semantic") results = searchMemorySemantic(federation, queryEmbedding, searchOpts);
-				else results = searchMemoryHybrid(federation, params.query, queryEmbedding, searchOpts);
-			} else results = searchMemory(federation, params.query, searchOpts);
-		}
 		try {
-			const { applyLinkBoost } = await import("./link-boost-C5PaNdzm.mjs");
+			const { applyLinkBoost } = await import("./link-boost-BptbAPuv.mjs");
 			const paths = [...new Set(results.map((r) => r.path))];
-			if (isBackend(federation) && paths.length > 1) {
+			if (paths.length > 1) {
 				const edges = [];
 				for (const p of paths) for (const l of await federation.getLinksToTarget(p)) {
 					if (l.confidence && l.confidence !== "EXTRACTED") continue;
@@ -120,22 +101,19 @@ async function toolMemorySearch(registryDb, federation, params, searchDefaults)
 		} catch {}
 		try {
 			const chunkIds = results.map((r) => r.chunkId).filter((id) => id != null);
-			if (chunkIds.length > 0) {
-				const rawDb = !isBackend(federation) ? federation : federation.getSqliteDb?.() ?? null;
-				if (rawDb) touchChunksLastAccessed(rawDb, chunkIds);
-			}
+			if (chunkIds.length > 0) await federation.touchChunksLastAccessed(chunkIds);
 		} catch {}
 		const shouldRerank = params.rerank ?? searchDefaults?.rerank ?? true;
 		if (shouldRerank && results.length > 0) {
-			const { rerankResults } = await import("./reranker-B5qUTamW.mjs");
+			const { rerankResults } = await import("./reranker-BS5gqGeF.mjs");
 			results = await rerankResults(params.query, results, { topK: searchOpts.maxResults ?? 5 });
 		}
 		const recencyDays = params.recencyBoost ?? searchDefaults?.recencyBoostDays ?? 0;
 		if (recencyDays > 0 && results.length > 0) {
-			const { applyRecencyBoost } = await import("./search-fb-5ovj4.mjs");
+			const { applyRecencyBoost } = await import("./search-BQHL5wDr.mjs");
 			results = applyRecencyBoost(results, recencyDays);
 		}
-		const withSlugs = populateSlugs(results, registryDb);
+		const withSlugs = await populateSlugs(results, registry);
 		if (withSlugs.length === 0) return { content: [{
 			type: "text",
 			text: `No results found for query: "${params.query}" (mode: ${mode})`
@@ -151,7 +129,7 @@ async function toolMemorySearch(registryDb, federation, params, searchDefaults)
 			return `${header}\n${raw.length > snippetLength ? raw.slice(0, snippetLength) + "..." : raw}`;
 		}).join(useCompact ? "\n" : "\n\n---\n\n");
 		try {
-			const { saveQueryResult } = await import("./query-feedback-Bm6XvCmg.mjs");
+			const { saveQueryResult } = await import("./query-feedback-COYCnvHQ.mjs");
 			saveQueryResult({
 				query: params.query,
 				timestamp: Date.now(),
@@ -175,9 +153,9 @@ async function toolMemorySearch(registryDb, federation, params, searchDefaults)
 		};
 	}
 }
-function toolMemoryGet(registryDb, params) {
+async function toolMemoryGet(registry, params) {
 	try {
-		const projectId = lookupProjectId(registryDb, params.project);
+		const projectId = await lookupProjectId(registry, params.project);
 		if (projectId == null) return {
 			content: [{
 				type: "text",
@@ -185,7 +163,7 @@ function toolMemoryGet(registryDb, params) {
 			}],
 			isError: true
 		};
-		const project = registryDb.prepare("SELECT root_path FROM projects WHERE id = ?").get(projectId);
+		const project = await registry.getProjectById(projectId);
 		if (!project) return {
 			content: [{
 				type: "text",
@@ -283,13 +261,13 @@ function combineHybridResults(keywordResults, semanticResults, maxResults, keywo
 * MCP tool handlers: project_info, project_list, project_detect,
 *                    project_health, project_todo
 */
-function toolProjectInfo(registryDb, params) {
+async function toolProjectInfo(registry, params) {
 	try {
 		let project = null;
 		if (params.slug) {
-			const projectId = lookupProjectId(registryDb, params.slug);
-			if (projectId != null) project = registryDb.prepare("SELECT id, slug, display_name, root_path, type, status, created_at, updated_at, archived_at, parent_id, obsidian_link FROM projects WHERE id = ?").get(projectId);
-		} else project = detectProjectFromPath(registryDb, process.cwd());
+			const projectId = await lookupProjectId(registry, params.slug);
+			if (projectId != null) project = await registry.getProjectById(projectId);
+		} else project = await detectProjectFromPath(registry, process.cwd());
 		if (!project) return {
 			content: [{
 				type: "text",
@@ -299,7 +277,7 @@ function toolProjectInfo(registryDb, params) {
 		};
 		return { content: [{
 			type: "text",
-			text: formatProject(registryDb, project)
+			text: await formatProject(registry, project)
 		}] };
 	} catch (e) {
 		return {
@@ -311,26 +289,15 @@ function toolProjectInfo(registryDb, params) {
 		};
 	}
 }
-function toolProjectList(registryDb, params) {
+async function toolProjectList(registry, params) {
 	try {
-		const conditions = [];
-		const queryParams = [];
-		if (params.status) {
-			conditions.push("p.status = ?");
-			queryParams.push(params.status);
-		}
-		if (params.tag) {
-			conditions.push("p.id IN (SELECT pt.project_id FROM project_tags pt JOIN tags t ON pt.tag_id = t.id WHERE t.name = ?)");
-			queryParams.push(params.tag);
-		}
-		const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
 		const limit = params.limit ?? 50;
-		queryParams.push(limit);
-		const projects = registryDb.prepare(`SELECT p.id, p.slug, p.display_name, p.root_path, p.type, p.status, p.updated_at
-         FROM projects p
-         ${where}
-         ORDER BY p.updated_at DESC
-         LIMIT ?`).all(...queryParams);
+		const projects = await registry.listProjects({
+			status: params.status,
+			tagName: params.tag,
+			orderBy: "updated_desc",
+			limit
+		});
 		if (projects.length === 0) return { content: [{
 			type: "text",
 			text: "No projects found matching the given filters."
@@ -350,9 +317,9 @@ function toolProjectList(registryDb, params) {
 		};
 	}
 }
-function toolProjectDetect(registryDb, params) {
+async function toolProjectDetect(params) {
 	try {
-		const detection = detectProject(registryDb, params.cwd);
+		const detection = await detectProject(params.cwd);
 		if (!detection) return { content: [{
 			type: "text",
 			text: `No registered project found for path: ${params.cwd ?? process.cwd()}\n\nRun 'pai project add .' to register this directory.`
@@ -371,16 +338,13 @@ function toolProjectDetect(registryDb, params) {
 		};
 	}
 }
-async function toolProjectHealth(registryDb, params) {
+async function toolProjectHealth(registry, params) {
 	try {
 		const { existsSync: fsExists, readdirSync, statSync } = await import("node:fs");
 		const { join: pathJoin, basename: pathBasename } = await import("node:path");
 		const { homedir } = await import("node:os");
-		const { encodeDir: enc } = await import("./utils-BD8g8oSf.mjs");
-		const rows = registryDb.prepare(`SELECT p.id, p.slug, p.display_name, p.root_path, p.encoded_dir, p.status, p.type,
-           (SELECT COUNT(*) FROM sessions s WHERE s.project_id = p.id) AS session_count
-         FROM projects p
-         ORDER BY p.slug ASC`).all();
+		const { encodeDir: enc } = await import("./utils-BrX9FLeK.mjs");
+		const rows = (await registry.listProjectsWithSessionStats()).slice().sort((a, b) => a.slug.localeCompare(b.slug));
 		const home = homedir();
 		const claudeProjects = pathJoin(home, ".claude", "projects");
 		function suggestMoved(rootPath) {
@@ -539,12 +503,12 @@ function parseTodoContent(raw) {
 		hasContinue: true
 	};
 }
-function toolProjectTodo(registryDb, params) {
+async function toolProjectTodo(registry, params) {
 	try {
 		let rootPath;
 		let projectSlug;
 		if (params.project) {
-			const projectId = lookupProjectId(registryDb, params.project);
+			const projectId = await lookupProjectId(registry, params.project);
 			if (projectId == null) return {
 				content: [{
 					type: "text",
@@ -552,7 +516,7 @@ function toolProjectTodo(registryDb, params) {
 				}],
 				isError: true
 			};
-			const row = registryDb.prepare("SELECT root_path, slug FROM projects WHERE id = ?").get(projectId);
+			const row = await registry.getProjectById(projectId);
 			if (!row) return {
 				content: [{
 					type: "text",
@@ -563,7 +527,7 @@ function toolProjectTodo(registryDb, params) {
 			rootPath = row.root_path;
 			projectSlug = row.slug;
 		} else {
-			const project = detectProjectFromPath(registryDb, process.cwd());
+			const project = await detectProjectFromPath(registry, process.cwd());
 			if (!project) return { content: [{
 				type: "text",
 				text: `No PAI project found matching the current directory: ${process.cwd()}\n\nProvide a project slug or run 'pai project add .' to register this directory.`
@@ -621,9 +585,9 @@ function toolProjectTodo(registryDb, params) {
 
 //#endregion
 //#region src/mcp/tools/sessions.ts
-function toolSessionList(registryDb, params) {
+async function toolSessionList(registry, params) {
 	try {
-		const projectId = lookupProjectId(registryDb, params.project);
+		const projectId = await lookupProjectId(registry, params.project);
 		if (projectId == null) return {
 			content: [{
 				type: "text",
@@ -631,19 +595,12 @@ function toolSessionList(registryDb, params) {
 			}],
 			isError: true
 		};
-		const conditions = ["project_id = ?"];
-		const queryParams = [projectId];
-		if (params.status) {
-			conditions.push("status = ?");
-			queryParams.push(params.status);
-		}
 		const limit = params.limit ?? 10;
-		queryParams.push(limit);
-		const sessions = registryDb.prepare(`SELECT number, date, title, filename, status
-         FROM sessions
-         WHERE ${conditions.join(" AND ")}
-         ORDER BY number DESC
-         LIMIT ?`).all(...queryParams);
+		const sessions = await registry.listSessions({
+			projectId,
+			status: params.status,
+			limit
+		});
 		if (sessions.length === 0) return { content: [{
 			type: "text",
 			text: `No sessions found for project: ${params.project}`
@@ -674,10 +631,10 @@ function toolSessionList(registryDb, params) {
 * Call this at session start (e.g., from CLAUDE.md or a session-start hook)
 * to automatically route the session to the correct project.
 */
-async function toolSessionRoute(registryDb, federation, params) {
+async function toolSessionRoute(registry, federation, params) {
 	try {
-		const { autoRoute, formatAutoRouteJson } = await import("./auto-route-CcD0OWWB.mjs");
-		const result = await autoRoute(registryDb, federation, params.cwd, params.context);
+		const { autoRoute, formatAutoRouteJson } = await import("./auto-route-CF8WNaoy.mjs");
+		const result = await autoRoute(registry, federation, params.cwd, params.context);
 		if (!result) return { content: [{
 			type: "text",
 			text: [
@@ -706,16 +663,9 @@ async function toolSessionRoute(registryDb, federation, params) {
 
 //#endregion
 //#region src/mcp/tools/registry.ts
-function toolRegistrySearch(registryDb, params) {
+async function toolRegistrySearch(registry, params) {
 	try {
-		const q = `%${params.query}%`;
-		const projects = registryDb.prepare(`SELECT id, slug, display_name, root_path, type, status, updated_at
-         FROM projects
-         WHERE slug LIKE ?
-            OR display_name LIKE ?
-            OR root_path LIKE ?
-         ORDER BY updated_at DESC
-         LIMIT 20`).all(q, q, q);
+		const projects = await registry.searchProjects(params.query, 20);
 		if (projects.length === 0) return { content: [{
 			type: "text",
 			text: `No projects found matching: "${params.query}"`
@@ -740,7 +690,7 @@ function toolRegistrySearch(registryDb, params) {
 //#region src/mcp/tools/zettel.ts
 async function toolZettelExplore(backend, params) {
 	try {
-		const { zettelExplore } = await import("./zettelkasten-DezbXghl.mjs");
+		const { zettelExplore } = await import("./zettelkasten-BPxSOalU.mjs");
 		const result = await zettelExplore(backend, {
 			startNote: params.start_note,
 			depth: params.depth,
@@ -763,7 +713,7 @@ async function toolZettelExplore(backend, params) {
 }
 async function toolZettelHealth(backend, params) {
 	try {
-		const { zettelHealth } = await import("./zettelkasten-DezbXghl.mjs");
+		const { zettelHealth } = await import("./zettelkasten-BPxSOalU.mjs");
 		const result = await zettelHealth(backend, {
 			scope: params.scope,
 			projectPath: params.project_path,
@@ -786,7 +736,7 @@ async function toolZettelHealth(backend, params) {
 }
 async function toolZettelSurprise(backend, params) {
 	try {
-		const { zettelSurprise } = await import("./zettelkasten-DezbXghl.mjs");
+		const { zettelSurprise } = await import("./zettelkasten-BPxSOalU.mjs");
 		const results = await zettelSurprise(backend, {
 			referencePath: params.reference_path,
 			vaultProjectId: params.vault_project_id,
@@ -810,7 +760,7 @@ async function toolZettelSurprise(backend, params) {
 }
 async function toolZettelSuggest(backend, params) {
 	try {
-		const { zettelSuggest } = await import("./zettelkasten-DezbXghl.mjs");
+		const { zettelSuggest } = await import("./zettelkasten-BPxSOalU.mjs");
 		const results = await zettelSuggest(backend, {
 			notePath: params.note_path,
 			vaultProjectId: params.vault_project_id,
@@ -833,7 +783,7 @@ async function toolZettelSuggest(backend, params) {
 }
 async function toolZettelConverse(backend, params) {
 	try {
-		const { zettelConverse } = await import("./zettelkasten-DezbXghl.mjs");
+		const { zettelConverse } = await import("./zettelkasten-BPxSOalU.mjs");
 		const result = await zettelConverse(backend, {
 			question: params.question,
 			vaultProjectId: params.vault_project_id,
@@ -841,7 +791,7 @@ async function toolZettelConverse(backend, params) {
 			limit: params.limit
 		});
 		try {
-			const { saveQueryResult } = await import("./query-feedback-Bm6XvCmg.mjs");
+			const { saveQueryResult } = await import("./query-feedback-COYCnvHQ.mjs");
 			saveQueryResult({
 				query: params.question,
 				timestamp: Date.now(),
@@ -869,7 +819,7 @@ async function toolZettelConverse(backend, params) {
 }
 async function toolZettelThemes(backend, params) {
 	try {
-		const { zettelThemes } = await import("./zettelkasten-DezbXghl.mjs");
+		const { zettelThemes } = await import("./zettelkasten-BPxSOalU.mjs");
 		const result = await zettelThemes(backend, {
 			vaultProjectId: params.vault_project_id,
 			lookbackDays: params.lookback_days,
@@ -893,7 +843,7 @@ async function toolZettelThemes(backend, params) {
 }
 async function toolZettelGodNotes(backend, params) {
 	try {
-		const { zettelGodNotes } = await import("./zettelkasten-DezbXghl.mjs");
+		const { zettelGodNotes } = await import("./zettelkasten-BPxSOalU.mjs");
 		const result = await zettelGodNotes(backend, {
 			limit: params.limit,
 			minInbound: params.min_inbound
@@ -914,7 +864,7 @@ async function toolZettelGodNotes(backend, params) {
 }
 async function toolZettelCommunities(backend, params) {
 	try {
-		const { zettelCommunities } = await import("./zettelkasten-DezbXghl.mjs");
+		const { zettelCommunities } = await import("./zettelkasten-BPxSOalU.mjs");
 		const result = await zettelCommunities(backend, {
 			minSize: params.min_size,
 			maxCommunities: params.max_communities,
@@ -937,7 +887,7 @@ async function toolZettelCommunities(backend, params) {
 
 //#endregion
 //#region src/mcp/tools/kg.ts
-async function toolKgAdd(pool, params) {
+async function toolKgAdd(backend, params) {
 	try {
 		if (!params.subject || !params.predicate || !params.object) return {
 			content: [{
@@ -946,7 +896,7 @@ async function toolKgAdd(pool, params) {
 			}],
 			isError: true
 		};
-		const triple = await kgAdd(pool, params);
+		const triple = await backend.addKgTriple(params);
 		return { content: [{
 			type: "text",
 			text: JSON.stringify(triple, null, 2)
@@ -961,7 +911,7 @@ async function toolKgAdd(pool, params) {
 		};
 	}
 }
-async function toolKgQuery(pool, params) {
+async function toolKgQuery(backend, params) {
 	try {
 		const asOf = params.as_of ? new Date(params.as_of) : void 0;
 		if (asOf && isNaN(asOf.getTime())) return {
@@ -971,7 +921,7 @@ async function toolKgQuery(pool, params) {
 			}],
 			isError: true
 		};
-		const triples = await kgQuery(pool, {
+		const triples = await backend.queryKgTriples({
 			subject: params.subject,
 			predicate: params.predicate,
 			object: params.object,
@@ -993,7 +943,7 @@ async function toolKgQuery(pool, params) {
 		};
 	}
 }
-async function toolKgInvalidate(pool, params) {
+async function toolKgInvalidate(backend, params) {
 	try {
 		if (params.triple_id === void 0 || params.triple_id === null) return {
 			content: [{
@@ -1002,7 +952,7 @@ async function toolKgInvalidate(pool, params) {
 			}],
 			isError: true
 		};
-		await kgInvalidate(pool, params.triple_id);
+		await backend.invalidateKgTriple(params.triple_id);
 		return { content: [{
 			type: "text",
 			text: JSON.stringify({
@@ -1020,7 +970,7 @@ async function toolKgInvalidate(pool, params) {
 		};
 	}
 }
-async function toolKgContradictions(pool, params) {
+async function toolKgContradictions(backend, params) {
 	try {
 		if (!params.subject) return {
 			content: [{
@@ -1029,7 +979,7 @@ async function toolKgContradictions(pool, params) {
 			}],
 			isError: true
 		};
-		const contradictions = await kgContradictions(pool, params.subject);
+		const contradictions = await backend.getKgContradictions(params.subject);
 		return { content: [{
 			type: "text",
 			text: JSON.stringify(contradictions, null, 2)
@@ -1048,19 +998,19 @@ async function toolKgContradictions(pool, params) {
 //#endregion
 //#region src/mcp/tools/wakeup.ts
 const DEFAULT_TOKEN_BUDGET = 800;
-function toolMemoryWakeup(registryDb, params) {
+async function toolMemoryWakeup(registry, params) {
 	try {
 		const tokenBudget = params.token_budget ?? DEFAULT_TOKEN_BUDGET;
 		let rootPath;
 		if (params.project) {
-			const bySlug = registryDb.prepare("SELECT root_path FROM projects WHERE slug = ?").get(params.project);
+			const bySlug = await registry.getProjectBySlug(params.project);
 			if (bySlug) rootPath = bySlug.root_path;
 			else {
-				const detected = detectProjectFromPath(registryDb, params.project);
+				const detected = await detectProjectFromPath(registry, params.project);
 				if (detected) rootPath = detected.root_path;
 			}
 		} else {
-			const detected = detectProjectFromPath(registryDb, process.cwd());
+			const detected = await detectProjectFromPath(registry, process.cwd());
 			if (detected) rootPath = detected.root_path;
 		}
 		const wakeupBlock = buildWakeupContext(rootPath, tokenBudget);
@@ -1089,18 +1039,20 @@ function toolMemoryWakeup(registryDb, params) {
 * Build a taxonomy of stored memory — what projects exist, how much is stored,
 * and what has been active recently.
 *
-* Registry queries (projects, sessions) are synchronous (better-sqlite3).
+* Registry queries (projects, sessions) go through RegistryBackend (async).
 * Storage backend queries (files, chunks) are async.
 */
-async function getTaxonomy(registryDb, storage, options = {}) {
+async function getTaxonomy(registry, storage, options = {}) {
 	const includeArchived = options.include_archived ?? false;
 	const limit = options.limit ?? 50;
-	const statusFilter = includeArchived ? "status IN ('active', 'archived', 'migrating')" : "status = 'active'";
-	const projectRows = registryDb.prepare(`SELECT id, slug, display_name, status, created_at, updated_at
-       FROM projects
-       WHERE ${statusFilter}
-       ORDER BY updated_at DESC
-       LIMIT ?`).all(limit);
+	const projectRows = includeArchived ? await registry.listProjects({
+		orderBy: "updated_desc",
+		limit
+	}) : await registry.listProjects({
+		status: "active",
+		orderBy: "updated_desc",
+		limit
+	});
 	if (projectRows.length === 0) return {
 		projects: [],
 		totals: {
@@ -1112,48 +1064,27 @@ async function getTaxonomy(registryDb, storage, options = {}) {
 		recent_activity: []
 	};
 	const projectIds = projectRows.map((p) => p.id);
+	const projectIdSet = new Set(projectIds);
 	const sessionCountsByProject = /* @__PURE__ */ new Map();
 	const lastSessionDateByProject = /* @__PURE__ */ new Map();
 	for (const projectId of projectIds) {
-		const countRow = registryDb.prepare("SELECT COUNT(*) AS n FROM sessions WHERE project_id = ?").get(projectId);
-		sessionCountsByProject.set(projectId, countRow.n);
-		const lastRow = registryDb.prepare("SELECT date FROM sessions WHERE project_id = ? ORDER BY number DESC LIMIT 1").get(projectId);
-		lastSessionDateByProject.set(projectId, lastRow?.date ?? null);
+		sessionCountsByProject.set(projectId, await registry.countSessionsForProject(projectId));
+		lastSessionDateByProject.set(projectId, await registry.getMostRecentSessionDate(projectId));
 	}
 	const tagsByProject = /* @__PURE__ */ new Map();
-	for (const projectId of projectIds) {
-		const tags = registryDb.prepare(`SELECT t.name
-         FROM tags t
-         JOIN project_tags pt ON pt.tag_id = t.id
-         WHERE pt.project_id = ?
-         ORDER BY t.name`).all(projectId);
-		tagsByProject.set(projectId, tags.map((t) => t.name));
-	}
+	for (const projectId of projectIds) tagsByProject.set(projectId, await registry.listTagsForProject(projectId));
 	const noteCountsByProject = /* @__PURE__ */ new Map();
 	const chunkCountsByProject = /* @__PURE__ */ new Map();
-	const isBackend = (x) => x.backendType === "sqlite";
-	if (isBackend(storage)) {
-		const rawDb = storage.getRawDb?.();
-		if (rawDb) for (const projectId of projectIds) {
-			const noteRow = rawDb.prepare("SELECT COUNT(*) AS n FROM memory_files WHERE project_id = ?").get(projectId);
-			noteCountsByProject.set(projectId, noteRow.n);
-			const chunkRow = rawDb.prepare("SELECT COUNT(*) AS n FROM memory_chunks WHERE project_id = ?").get(projectId);
-			chunkCountsByProject.set(projectId, chunkRow.n);
-		}
-	} else for (const projectId of projectIds) {
-		noteCountsByProject.set(projectId, 0);
-		chunkCountsByProject.set(projectId, 0);
+	for (const projectId of projectIds) {
+		const projectStats = await storage.getProjectStats(projectId);
+		noteCountsByProject.set(projectId, projectStats.files);
+		chunkCountsByProject.set(projectId, projectStats.chunks);
 	}
 	const stats = await storage.getStats();
-	const totalProjects = registryDb.prepare(`SELECT COUNT(*) AS n FROM projects WHERE ${statusFilter}`).get().n;
-	const totalSessions = registryDb.prepare("SELECT COUNT(*) AS n FROM sessions").get().n;
-	const recentActivity = registryDb.prepare(`SELECT s.date, s.title, p.slug
-       FROM sessions s
-       JOIN projects p ON p.id = s.project_id
-       WHERE p.${statusFilter.replace("status", "p.status")}
-       ORDER BY s.created_at DESC
-       LIMIT 10`).all().map((row) => ({
-		project_slug: row.slug,
+	const totalProjects = includeArchived ? await registry.countProjects() : await registry.countProjects({ status: "active" });
+	const totalSessions = [...sessionCountsByProject.values()].reduce((a, b) => a + b, 0);
+	const recentActivity = (await registry.listSessions({ limit: Math.max(50, limit) })).filter((s) => projectIdSet.has(s.project_id)).slice(0, 10).map((row) => ({
+		project_slug: row.project_slug,
 		action: `session: ${row.title || "(untitled)"}`,
 		timestamp: row.date
 	}));
@@ -1178,9 +1109,9 @@ async function getTaxonomy(registryDb, storage, options = {}) {
 
 //#endregion
 //#region src/mcp/tools/taxonomy.ts
-async function toolMemoryTaxonomy(registryDb, storage, params = {}) {
+async function toolMemoryTaxonomy(registry, storage, params = {}) {
 	try {
-		const result = await getTaxonomy(registryDb, storage, {
+		const result = await getTaxonomy(registry, storage, {
 			include_archived: params.include_archived,
 			limit: params.limit
 		});
@@ -1219,209 +1150,24 @@ async function toolMemoryTaxonomy(registryDb, storage, params = {}) {
 //#endregion
 //#region src/memory/tunnels.ts
 /**
-* tunnels.ts — cross-project concept detection ("palace graph / tunnel detection")
-*
-* A "tunnel" is a concept (word or short phrase) that appears in chunks from
-* at least two distinct projects.  These serendipitous cross-project connections
-* are surfaced so the user can discover unexpected relationships between their
-* work streams.
-*
-* Algorithm:
-*  1. Pull the top-N most frequent significant terms from memory_chunks via BM25 FTS.
-*     We use the FTS5 vocab table (if available) or fall back to term frequency
-*     aggregation over the raw text via a trigram approach.
-*  2. For each candidate term, count how many distinct projects have at least one
-*     chunk containing it and aggregate occurrence stats.
-*  3. Filter by min_projects and min_occurrences, sort by project breadth then
-*     frequency, return top limit results.
-*
-* Backend support:
-*  - SQLite  — uses `memory_fts` MATCH to count per-project occurrences.
-*  - Postgres — uses `memory_chunks` tsvector + ts_stat for term extraction and
-*               per-project term frequency counting via plainto_tsquery.
-*/
-/**
-* Extract candidate terms from the SQLite FTS5 index using the vocabulary
-* approach: iterate the fts5vocab table (if it exists) for the most common
-* terms, then per-term count distinct projects.
-*/
-async function findTunnelsSqlite(db, slugMap, opts) {
-	const projectIds = Object.keys(slugMap).map(Number);
-	if (projectIds.length < 2) return {
-		tunnels: [],
-		projects_analyzed: projectIds.length,
-		total_concepts_evaluated: 0
-	};
-	let candidateTerms = [];
-	try {
-		candidateTerms = db.prepare(`SELECT term, SUM(doc) AS doc_count, SUM(cnt) AS total_cnt
-         FROM memory_fts_v
-         GROUP BY term
-         HAVING SUM(cnt) >= ?
-         ORDER BY SUM(doc) DESC
-         LIMIT 500`).all(opts.min_occurrences).map((r) => r.term).filter((t) => t.length >= 3 && !STOP_WORDS.has(t));
-	} catch {
-		const sampleRows = db.prepare(`SELECT LOWER(text) AS text FROM memory_chunks
-         WHERE LENGTH(text) > 20
-         ORDER BY RANDOM()
-         LIMIT 2000`).all();
-		const freq = /* @__PURE__ */ new Map();
-		for (const { text } of sampleRows) {
-			const tokens = text.split(/[\s\p{P}]+/u).filter(Boolean).filter((t) => t.length >= 3 && !STOP_WORDS.has(t));
-			for (const t of tokens) freq.set(t, (freq.get(t) ?? 0) + 1);
-		}
-		candidateTerms = [...freq.entries()].filter(([, n]) => n >= opts.min_occurrences).sort((a, b) => b[1] - a[1]).slice(0, 200).map(([t]) => t);
-	}
-	if (candidateTerms.length === 0) return {
-		tunnels: [],
-		projects_analyzed: projectIds.length,
-		total_concepts_evaluated: 0
-	};
-	const tunnels = [];
-	for (const term of candidateTerms) try {
-		const rows = db.prepare(`SELECT c.project_id, COUNT(*) AS cnt,
-                  MIN(c.updated_at) AS first_seen,
-                  MAX(c.updated_at) AS last_seen
-           FROM memory_fts f
-           JOIN memory_chunks c ON c.id = f.id
-           WHERE memory_fts MATCH ?
-             AND c.project_id IN (${projectIds.map(() => "?").join(", ")})
-           GROUP BY c.project_id`).all(`"${term.replace(/"/g, "\"\"")}"`, ...projectIds);
-		if (rows.length < opts.min_projects) continue;
-		const totalOccurrences = rows.reduce((s, r) => s + Number(r.cnt), 0);
-		if (totalOccurrences < opts.min_occurrences) continue;
-		const projects = rows.map((r) => slugMap[r.project_id] ?? String(r.project_id)).filter(Boolean);
-		const firstSeen = Math.min(...rows.map((r) => r.first_seen));
-		const lastSeen = Math.max(...rows.map((r) => r.last_seen));
-		tunnels.push({
-			concept: term,
-			projects,
-			occurrences: totalOccurrences,
-			first_seen: firstSeen,
-			last_seen: lastSeen
-		});
-	} catch {
-		continue;
-	}
-	tunnels.sort((a, b) => {
-		const byProjects = b.projects.length - a.projects.length;
-		if (byProjects !== 0) return byProjects;
-		return b.occurrences - a.occurrences;
-	});
-	return {
-		tunnels: tunnels.slice(0, opts.limit),
-		projects_analyzed: projectIds.length,
-		total_concepts_evaluated: candidateTerms.length
-	};
-}
-/**
-* Use Postgres ts_stat() + plainto_tsquery to efficiently find terms that
-* appear across multiple projects.
-*/
-async function findTunnelsPostgres(pool, slugMap, opts) {
-	const projectIds = Object.keys(slugMap).map(Number);
-	if (projectIds.length < 2) return {
-		tunnels: [],
-		projects_analyzed: projectIds.length,
-		total_concepts_evaluated: 0
-	};
-	let candidateTerms = (await pool.query(`SELECT word, ndoc, nentry
-     FROM ts_stat(
-       'SELECT to_tsvector(''simple'', text) FROM memory_chunks WHERE project_id = ANY($1)'
-     )
-     WHERE length(word) >= 3
-       AND nentry >= $2
-     ORDER BY ndoc DESC
-     LIMIT 500`, [projectIds, opts.min_occurrences])).rows.map((r) => r.word).filter((t) => !STOP_WORDS.has(t));
-	if (candidateTerms.length === 0) return {
-		tunnels: [],
-		projects_analyzed: projectIds.length,
-		total_concepts_evaluated: 0
-	};
-	candidateTerms = candidateTerms.slice(0, 200);
-	const valuesClause = candidateTerms.map((t, i) => `($${i + 2}::text)`).join(", ");
-	const batchResult = await pool.query(`SELECT v.concept, c.project_id::text, COUNT(*) AS cnt,
-            MIN(c.updated_at) AS first_seen,
-            MAX(c.updated_at) AS last_seen
-     FROM (VALUES ${valuesClause}) AS v(concept)
-     JOIN memory_chunks c
-       ON to_tsvector('simple', c.text) @@ plainto_tsquery('simple', v.concept)
-      AND c.project_id = ANY($1)
-     GROUP BY v.concept, c.project_id`, [projectIds, ...candidateTerms]);
-	const byConceptMap = /* @__PURE__ */ new Map();
-	for (const row of batchResult.rows) {
-		const existing = byConceptMap.get(row.concept) ?? {
-			projects: /* @__PURE__ */ new Set(),
-			occurrences: 0,
-			firstSeen: Infinity,
-			lastSeen: -Infinity
-		};
-		existing.projects.add(parseInt(row.project_id, 10));
-		existing.occurrences += parseInt(row.cnt, 10);
-		const fs = parseInt(row.first_seen, 10);
-		const ls = parseInt(row.last_seen, 10);
-		if (fs < existing.firstSeen) existing.firstSeen = fs;
-		if (ls > existing.lastSeen) existing.lastSeen = ls;
-		byConceptMap.set(row.concept, existing);
-	}
-	const tunnels = [];
-	for (const [concept, data] of byConceptMap) {
-		if (data.projects.size < opts.min_projects) continue;
-		if (data.occurrences < opts.min_occurrences) continue;
-		const projects = [...data.projects].map((id) => slugMap[id] ?? String(id)).filter(Boolean);
-		tunnels.push({
-			concept,
-			projects,
-			occurrences: data.occurrences,
-			first_seen: data.firstSeen === Infinity ? 0 : data.firstSeen,
-			last_seen: data.lastSeen === -Infinity ? 0 : data.lastSeen
-		});
-	}
-	tunnels.sort((a, b) => {
-		const byProjects = b.projects.length - a.projects.length;
-		if (byProjects !== 0) return byProjects;
-		return b.occurrences - a.occurrences;
-	});
-	return {
-		tunnels: tunnels.slice(0, opts.limit),
-		projects_analyzed: projectIds.length,
-		total_concepts_evaluated: candidateTerms.length
-	};
-}
-/**
 * Find cross-project concept tunnels.
 *
 * Works with both SQLite and Postgres storage backends.
-* Requires the `registryDb` (better-sqlite3) for project slug resolution.
+* Requires the RegistryBackend for project slug resolution.
 *
 * @param backend        Active PAI storage backend.
-* @param registryDb     Registry database for project slug resolution.
+* @param registry       Registry backend for project slug resolution.
 * @param options        Filter and limit options.
 */
-async function findTunnels(backend, registryDb, options) {
-	const opts = {
-		min_projects: options?.min_projects ?? 2,
-		min_occurrences: options?.min_occurrences ?? 3,
-		limit: options?.limit ?? 20
-	};
-	const projectRows = registryDb.prepare("SELECT id, slug FROM projects WHERE status != 'archived'").all();
-	const slugMap = {};
-	for (const { id, slug } of projectRows) slugMap[id] = slug;
-	if (backend.backendType === "postgres") {
-		const pool = backend.getPool?.();
-		if (!pool) throw new Error("findTunnels: Postgres backend does not expose getPool()");
-		return findTunnelsPostgres(pool, slugMap, opts);
-	}
-	const rawDb = backend.getRawDb?.();
-	if (!rawDb) throw new Error("findTunnels: SQLite backend does not expose getRawDb()");
-	return findTunnelsSqlite(rawDb, slugMap, opts);
+async function findTunnels(backend, registry, options) {
+	return backend.findTunnels(registry, options);
 }
 
 //#endregion
 //#region src/mcp/tools/tunnels.ts
-async function toolMemoryTunnels(registryDb, backend, params) {
+async function toolMemoryTunnels(registry, backend, params) {
 	try {
-		const result = await findTunnels(backend, registryDb, {
+		const result = await findTunnels(backend, registry, {
 			min_projects: params.min_projects,
 			min_occurrences: params.min_occurrences,
 			limit: params.limit
@@ -1446,11 +1192,13 @@ async function toolMemoryTunnels(registryDb, backend, params) {
 const FEEDBACK_ALPHA = .1;
 /**
 * Apply relevance feedback to memory chunks and associated KG entities.
+* Both memory_chunks.relevance_score and kg_entities.feedback_weight go
+* through the passed StorageBackend, so this works on either backend.
 *
-* @param db      Federation SQLite database
-* @param params  Feedback parameters
+* @param backend  StorageBackend for both the chunk and kg_entities portions
+* @param params   Feedback parameters
 */
-function toolMemoryFeedback(db, params) {
+async function toolMemoryFeedback(backend, params) {
 	try {
 		if (!Array.isArray(params.chunk_ids) || params.chunk_ids.length === 0) return {
 			content: [{
@@ -1468,8 +1216,7 @@ function toolMemoryFeedback(db, params) {
 			isError: true
 		};
 		const normalizedRating = (rating - 1) / 4;
-		const placeholders = params.chunk_ids.map(() => "?").join(", ");
-		const chunks = db.prepare(`SELECT id, text, relevance_score FROM memory_chunks WHERE id IN (${placeholders})`).all(...params.chunk_ids);
+		const chunks = await backend.getChunksForFeedback(params.chunk_ids);
 		if (chunks.length === 0) return {
 			content: [{
 				type: "text",
@@ -1479,19 +1226,19 @@ function toolMemoryFeedback(db, params) {
 		};
 		let updatedChunks = 0;
 		const combinedText = [];
-		const updateStmt = db.prepare("UPDATE memory_chunks SET relevance_score = ? WHERE id = ?");
 		for (const chunk of chunks) {
-			const oldScore = chunk.relevance_score ?? .5;
+			const oldScore = chunk.relevanceScore ?? .5;
 			const newScore = oldScore + FEEDBACK_ALPHA * (normalizedRating - oldScore);
-			updateStmt.run(newScore, chunk.id);
+			await backend.updateChunkRelevanceScore(chunk.id, newScore);
 			updatedChunks++;
 			combinedText.push(chunk.text);
 		}
-		const entities = listKgEntities(db, params.tenant_id ?? "default", void 0, 500);
+		const tenantId = params.tenant_id ?? "default";
+		const entities = await backend.listKgEntities(tenantId, void 0, 500);
 		const text = combinedText.join("\n").toLowerCase();
 		let updatedEntities = 0;
 		for (const entity of entities) if (text.includes(entity.name.toLowerCase())) {
-			updateEntityFeedbackWeight(db, entity.entity_id, normalizedRating, FEEDBACK_ALPHA);
+			await backend.updateEntityFeedbackWeight(entity.entity_id, normalizedRating, FEEDBACK_ALPHA);
 			updatedEntities++;
 		}
 		return { content: [{
@@ -1517,13 +1264,28 @@ function toolMemoryFeedback(db, params) {
 //#endregion
 //#region src/memory/kg-search.ts
 /**
-* Find entity names (from the federation.db kg_entities table) that appear
+* kg-search.ts — Graph-completion retrieval (MR1).
+*
+* Implements graphCompletionSearch: a multi-phase retrieval strategy that
+* combines vector search with knowledge-graph neighborhood expansion.
+*
+* Algorithm:
+*   Phase 1: Wide vector search (50 candidates) using queryVec
+*   Phase 2: Extract entity mentions from retrieved chunks (substring match vs kg_entities)
+*   Phase 3: BFS neighborhood expansion in kg_triples (1-2 hops from matched entities)
+*   Phase 4: Re-rank all collected triples against query embedding using cosine similarity
+*
+* The result is a ranked list of KgTriple objects most relevant to the query,
+* augmented with graph-derived context that pure vector search would miss.
+*/
+/**
+* Find entity names (from the kg_entities table) that appear
 * as substrings in the given text chunks.
 *
 * Returns a deduplicated list of matching entity names.
 */
-function extractEntityMentions(federationDb, chunks, tenantId = "default") {
-	const entities = listKgEntities(federationDb, tenantId, void 0, 500);
+async function extractEntityMentions(federation, chunks, tenantId = "default") {
+	const entities = await federation.listKgEntities(tenantId, void 0, 500);
 	if (entities.length === 0) return [];
 	const combinedText = chunks.map((c) => c.snippet).join("\n").toLowerCase();
 	const matched = /* @__PURE__ */ new Set();
@@ -1538,18 +1300,18 @@ function extractEntityMentions(federationDb, chunks, tenantId = "default") {
 *
 * Returns all unique triples found in the BFS expansion.
 */
-async function bfsExpand(pool, entityNames, hops, projectId) {
+async function bfsExpand(federation, entityNames, hops, projectId) {
 	const seen = /* @__PURE__ */ new Set();
 	const tripleMap = /* @__PURE__ */ new Map();
 	const frontier = new Set(entityNames);
 	for (let hop = 0; hop < hops; hop++) {
 		const nextFrontier = /* @__PURE__ */ new Set();
 		for (const name of frontier) {
-			const asSubject = await kgQuery(pool, {
+			const asSubject = await federation.queryKgTriples({
 				subject: name,
 				project_id: projectId
 			});
-			const asObject = await kgQuery(pool, {
+			const asObject = await federation.queryKgTriples({
 				object: name,
 				project_id: projectId
 			});
@@ -1578,7 +1340,7 @@ async function bfsExpand(pool, entityNames, hops, projectId) {
 */
 async function rerankTriples(triples, queryVec, maxTriples) {
 	if (triples.length === 0) return [];
-	const { generateEmbedding } = await import("./embeddings-ClqKtLZ8.mjs");
+	const { generateEmbedding } = await import("./embeddings-BNv3TQC5.mjs");
 	return (await Promise.all(triples.map(async (triple) => {
 		const text = `${triple.subject} ${triple.predicate} ${triple.object}`;
 		try {
@@ -1598,12 +1360,11 @@ async function rerankTriples(triples, queryVec, maxTriples) {
 /**
 * Graph-completion retrieval combining vector search with KG neighborhood BFS.
 *
-* @param federationDb  SQLite federation.db (for chunk/entity lookup)
-* @param pool          Postgres connection pool (for kg_triples queries)
+* @param federation    Active StorageBackend (for chunk/entity/kg_triples lookup)
 * @param queryVec      Pre-computed embedding for the search query
 * @param opts          Configuration options
 */
-async function graphCompletionSearch(federationDb, pool, queryVec, opts = {}) {
+async function graphCompletionSearch(federation, queryVec, opts = {}) {
 	const { seedCount = 50, hops = 1, maxTriples = 20, projectId, tenantId = "default", searchOpts } = opts;
 	const seedSearchOpts = {
 		...searchOpts,
@@ -1612,8 +1373,7 @@ async function graphCompletionSearch(federationDb, pool, queryVec, opts = {}) {
 	};
 	let seedChunks = [];
 	try {
-		const { searchMemorySemantic } = await import("./search-fb-5ovj4.mjs");
-		seedChunks = searchMemorySemantic(federationDb, queryVec, seedSearchOpts);
+		seedChunks = await federation.searchSemantic(queryVec, seedSearchOpts);
 	} catch (e) {
 		process.stderr.write(`[kg-search] Phase 1 seed search error: ${e}\n`);
 	}
@@ -1622,7 +1382,7 @@ async function graphCompletionSearch(federationDb, pool, queryVec, opts = {}) {
 		seedChunks: [],
 		expandedEntities: []
 	};
-	const expandedEntities = extractEntityMentions(federationDb, seedChunks, tenantId);
+	const expandedEntities = await extractEntityMentions(federation, seedChunks, tenantId);
 	if (expandedEntities.length === 0) return {
 		triples: [],
 		seedChunks,
@@ -1630,7 +1390,7 @@ async function graphCompletionSearch(federationDb, pool, queryVec, opts = {}) {
 	};
 	let expandedTriples = [];
 	try {
-		expandedTriples = await bfsExpand(pool, [...expandedEntities], hops, projectId);
+		expandedTriples = await bfsExpand(federation, [...expandedEntities], hops, projectId);
 	} catch (e) {
 		process.stderr.write(`[kg-search] Phase 3 BFS expansion error: ${e}\n`);
 	}
@@ -1661,11 +1421,10 @@ async function graphCompletionSearch(federationDb, pool, queryVec, opts = {}) {
 /**
 * Graph-completion search: vector search + KG neighborhood BFS.
 *
-* @param federationDb  SQLite federation.db for chunk/entity operations
-* @param pool          Postgres pool for kg_triples BFS expansion
+* @param federation    Active StorageBackend for chunk/entity/kg_triples operations
 * @param params        Tool parameters
 */
-async function toolMemoryKgSearch(federationDb, pool, params) {
+async function toolMemoryKgSearch(federation, params) {
 	try {
 		if (!params.query || typeof params.query !== "string" || params.query.trim() === "") return {
 			content: [{
@@ -1674,8 +1433,8 @@ async function toolMemoryKgSearch(federationDb, pool, params) {
 			}],
 			isError: true
 		};
-		const { generateEmbedding } = await import("./embeddings-ClqKtLZ8.mjs");
-		const result = await graphCompletionSearch(federationDb, pool, await generateEmbedding(params.query, true), {
+		const { generateEmbedding } = await import("./embeddings-BNv3TQC5.mjs");
+		const result = await graphCompletionSearch(federation, await generateEmbedding(params.query, true), {
 			seedCount: params.wide_k ?? 50,
 			hops: params.neighborhood_depth ?? 1,
 			maxTriples: params.top_k ?? 20,
@@ -1711,4 +1470,4 @@ async function toolMemoryKgSearch(federationDb, pool, params) {
 
 //#endregion
 export { formatProject as A, toolProjectInfo as C, toolMemoryGet as D, combineHybridResults as E, toolMemorySearch as O, toolProjectHealth as S, toolProjectTodo as T, toolZettelThemes as _, toolMemoryWakeup as a, toolSessionRoute as b, toolKgInvalidate as c, toolZettelConverse as d, toolZettelExplore as f, toolZettelSurprise as g, toolZettelSuggest as h, toolMemoryTaxonomy as i, lookupProjectId as j, detectProjectFromPath as k, toolKgQuery as l, toolZettelHealth as m, toolMemoryFeedback as n, toolKgAdd as o, toolZettelGodNotes as p, toolMemoryTunnels as r, toolKgContradictions as s, toolMemoryKgSearch as t, toolZettelCommunities as u, toolRegistrySearch as v, toolProjectList as w, toolProjectDetect as x, toolSessionList as y };
-//# sourceMappingURL=tools-BEqiJt_j.mjs.map
+//# sourceMappingURL=tools-Diro2s8J.mjs.map