@tekmidian/pai 0.66.1 → 0.66.2

package/dist/tools-BcOKPBtg.mjs

@@ -1,1489 +0,0 @@
-import { t as buildOutline } from "./chunker-BH4i-F2b.mjs";
-import { i as populateSlugs } from "./search-BOSphCJ1.mjs";
-import { a as formatDetectionJson, r as detectProject, t as buildWakeupContext } from "./wakeup-D8n33hYV.mjs";
-import { n as cosineSimilarity } from "./embeddings-Bx3q0QOY.mjs";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { isAbsolute, join, resolve } from "node:path";
-
-//#region src/mcp/tools/types.ts
-/**
-* Shared types and project-row helpers used across all MCP tool handler modules.
-*/
-async function lookupProjectId(registry, slug) {
-	const bySlug = await registry.getProjectBySlug(slug);
-	if (bySlug) return bySlug.id;
-	return await registry.resolveAlias(slug) ?? null;
-}
-async function detectProjectFromPath(registry, fsPath) {
-	const resolved = resolve(fsPath);
-	const exact = await registry.getProjectByRootPath(resolved);
-	if (exact) return exact;
-	const all = await registry.listProjectsByPathLengthDesc();
-	for (const project of all) if (resolved.startsWith(project.root_path + "/") || resolved === project.root_path) return project;
-	return null;
-}
-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}`,
-		`root_path: ${project.root_path}`,
-		`type: ${project.type}`,
-		`status: ${project.status}`,
-		`sessions: ${sessionCount}`
-	];
-	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}`);
-	if (project.archived_at) lines.push(`archived_at: ${new Date(project.archived_at).toISOString().slice(0, 10)}`);
-	return lines.join("\n");
-}
-
-//#endregion
-//#region src/mcp/tools/memory.ts
-/**
-* MCP tool handlers: memory_search, memory_get, memory_outline
-*/
-async function toolMemorySearch(registry, federation, params, searchDefaults) {
-	try {
-		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 {
-			content: [{
-				type: "text",
-				text: `Project not found: ${params.project}`
-			}],
-			isError: true
-		};
-		const mode = params.mode ?? searchDefaults?.mode ?? "keyword";
-		const snippetLength = params.snippetLength ?? searchDefaults?.snippetLength ?? 200;
-		const searchOpts = {
-			projectIds,
-			sources: params.sources,
-			maxResults: params.limit ?? searchDefaults?.defaultLimit ?? 5
-		};
-		let results;
-		if (mode === "keyword") results = await federation.searchKeyword(params.query, searchOpts);
-		else if (mode === "semantic" || mode === "hybrid") {
-			const { generateEmbedding } = await import("./embeddings-CcscYWwk.mjs");
-			const queryEmbedding = await generateEmbedding(params.query, true);
-			if (mode === "semantic") results = await federation.searchSemantic(queryEmbedding, searchOpts);
-			else {
-				const [kwResults, semResults] = await Promise.all([federation.searchKeyword(params.query, {
-					...searchOpts,
-					maxResults: 50
-				}), federation.searchSemantic(queryEmbedding, {
-					...searchOpts,
-					maxResults: 50
-				})]);
-				results = combineHybridResults(kwResults, semResults, searchOpts.maxResults ?? 10);
-			}
-		} else results = await federation.searchKeyword(params.query, searchOpts);
-		try {
-			const { applyLinkBoost } = await import("./link-boost-CnI7UVMJ.mjs");
-			const paths = [...new Set(results.map((r) => r.path))];
-			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;
-					edges.push({
-						sourcePath: l.sourcePath,
-						targetPath: p
-					});
-				}
-				if (edges.length > 0) results = applyLinkBoost(results, edges);
-			}
-		} catch {}
-		try {
-			const chunkIds = results.map((r) => r.chunkId).filter((id) => id != null);
-			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-CFiEzHQu.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-Bf3Kub3F.mjs");
-			results = applyRecencyBoost(results, recencyDays);
-		}
-		const withSlugs = await populateSlugs(results, registry);
-		if (withSlugs.length === 0) return { content: [{
-			type: "text",
-			text: `No results found for query: "${params.query}" (mode: ${mode})`
-		}] };
-		const rerankLabel = shouldRerank ? " +rerank" : "";
-		const useCompact = params.format === "compact";
-		const formatted = withSlugs.map((r, i) => {
-			const slug = r.projectSlug ?? `project:${r.projectId}`;
-			const idPart = r.chunkId ? ` id=${r.chunkId}` : "";
-			if (useCompact) return `[${i + 1}]${idPart} ${slug} — ${r.path} L${r.startLine}-${r.endLine} score=${r.score.toFixed(3)}`;
-			const header = `[${i + 1}]${idPart} ${slug} — ${r.path} (lines ${r.startLine}-${r.endLine}) score=${r.score.toFixed(4)} tier=${r.tier} source=${r.source}`;
-			const raw = r.snippet.trim();
-			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-B_iigYj-.mjs");
-			saveQueryResult({
-				query: params.query,
-				timestamp: Date.now(),
-				source: "memory_search",
-				sourceSlugs: withSlugs.slice(0, 5).map((r) => r.path),
-				answerPreview: withSlugs.slice(0, 3).map((r) => r.snippet.trim().slice(0, 150)).join(" | "),
-				resultCount: withSlugs.length
-			});
-		} catch {}
-		return { content: [{
-			type: "text",
-			text: `Found ${withSlugs.length} result(s) for "${params.query}" (mode: ${mode}${rerankLabel}):\n\n${formatted}`
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `Search error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-/**
-* Resolve `project` + `path` to a readable file inside the project root.
-* Shared by memory_get and memory_outline so both apply the same path and
-* access checks. Returns a ToolResult on any failure.
-*/
-async function resolveProjectFile(registry, projectSlug, requestedPath) {
-	const fail = (text) => ({
-		content: [{
-			type: "text",
-			text
-		}],
-		isError: true
-	});
-	const projectId = await lookupProjectId(registry, projectSlug);
-	if (projectId == null) return fail(`Project not found: ${projectSlug}`);
-	const project = await registry.getProjectById(projectId);
-	if (!project) return fail(`Project not found: ${projectSlug}`);
-	if (requestedPath.includes("..") || isAbsolute(requestedPath)) return fail(`Invalid path: ${requestedPath} (must be a relative path within the project root, no ../ allowed)`);
-	const fullPath = join(project.root_path, requestedPath);
-	const resolvedFull = resolve(fullPath);
-	const resolvedRoot = resolve(project.root_path);
-	if (!resolvedFull.startsWith(resolvedRoot + "/") && resolvedFull !== resolvedRoot) return fail(`Path traversal blocked: ${requestedPath}`);
-	if (!existsSync(fullPath)) return fail(`File not found: ${requestedPath} (project: ${projectSlug})`);
-	const stat = statSync(fullPath);
-	if (stat.size > 5 * 1024 * 1024) return { content: [{
-		type: "text",
-		text: `Error: file too large (${(stat.size / 1024 / 1024).toFixed(1)} MB). Maximum 5 MB.`
-	}] };
-	return { fullPath };
-}
-async function toolMemoryGet(registry, params) {
-	try {
-		const resolved = await resolveProjectFile(registry, params.project, params.path);
-		if ("content" in resolved) return resolved;
-		const { fullPath } = resolved;
-		const requestedPath = params.path;
-		const allLines = readFileSync(fullPath, "utf8").split("\n");
-		const fromLine = (params.from ?? 1) - 1;
-		const toLine = params.lines != null ? Math.min(fromLine + params.lines, allLines.length) : allLines.length;
-		const text = allLines.slice(fromLine, toLine).join("\n");
-		return { content: [{
-			type: "text",
-			text: `${params.from != null ? `${params.project}/${requestedPath} (lines ${fromLine + 1}-${toLine}):` : `${params.project}/${requestedPath}:`}\n\n${text}`
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `Read error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-function renderOutline(nodes, maxDepth, depth = 0, out = []) {
-	for (const n of nodes) {
-		out.push(`${"  ".repeat(depth)}${"#".repeat(n.level)} ${n.title}  L${n.startLine}-${n.endLine} ~${n.tokens}t`);
-		if (depth + 1 < maxDepth) renderOutline(n.children, maxDepth, depth + 1, out);
-	}
-	return out;
-}
-async function toolMemoryOutline(registry, params) {
-	try {
-		const resolved = await resolveProjectFile(registry, params.project, params.path);
-		if ("content" in resolved) return resolved;
-		const outline = buildOutline(readFileSync(resolved.fullPath, "utf8"));
-		const body = outline.length ? renderOutline(outline, params.max_depth ?? Infinity).join("\n") : "(no headings)";
-		return { content: [{
-			type: "text",
-			text: `${params.project}/${params.path} outline:\n\n${body}`
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `Read error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-/**
-* Combine keyword + semantic results using min-max normalized scoring.
-* Mirrors the logic in searchMemoryHybrid() from memory/search.ts,
-* but works on pre-computed result arrays so it works for any backend.
-*/
-function combineHybridResults(keywordResults, semanticResults, maxResults, keywordWeight = .5, semanticWeight = .5) {
-	if (keywordResults.length === 0 && semanticResults.length === 0) return [];
-	const keyFor = (r) => `${r.projectId}:${r.path}:${r.startLine}:${r.endLine}`;
-	function minMaxNormalize(items) {
-		if (items.length === 0) return /* @__PURE__ */ new Map();
-		const min = Math.min(...items.map((r) => r.score));
-		const range = Math.max(...items.map((r) => r.score)) - min;
-		const m = /* @__PURE__ */ new Map();
-		for (const r of items) m.set(keyFor(r), range === 0 ? 1 : (r.score - min) / range);
-		return m;
-	}
-	const kwNorm = minMaxNormalize(keywordResults);
-	const semNorm = minMaxNormalize(semanticResults);
-	const allKeys = new Set([...keywordResults.map(keyFor), ...semanticResults.map(keyFor)]);
-	const metaMap = /* @__PURE__ */ new Map();
-	for (const r of [...keywordResults, ...semanticResults]) metaMap.set(keyFor(r), r);
-	const combined = [];
-	for (const key of allKeys) {
-		const meta = metaMap.get(key);
-		const kwScore = kwNorm.get(key) ?? 0;
-		const semScore = semNorm.get(key) ?? 0;
-		const combinedScore = keywordWeight * kwScore + semanticWeight * semScore;
-		combined.push({
-			...meta,
-			score: combinedScore,
-			combinedScore
-		});
-	}
-	return combined.sort((a, b) => b.score - a.score).slice(0, maxResults).map(({ combinedScore: _unused, ...r }) => r);
-}
-
-//#endregion
-//#region src/mcp/tools/projects.ts
-/**
-* MCP tool handlers: project_info, project_list, project_detect,
-*                    project_health, project_todo
-*/
-async function toolProjectInfo(registry, params) {
-	try {
-		let project = null;
-		if (params.slug) {
-			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",
-				text: params.slug ? `Project not found: ${params.slug}` : `No PAI project found matching the current directory: ${process.cwd()}`
-			}],
-			isError: !params.slug
-		};
-		return { content: [{
-			type: "text",
-			text: await formatProject(registry, project)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `project_info error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-async function toolProjectList(registry, params) {
-	try {
-		const limit = params.limit ?? 50;
-		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."
-		}] };
-		const lines = projects.map((p) => `${p.slug}  [${p.status}]  ${p.root_path}  (updated: ${new Date(p.updated_at).toISOString().slice(0, 10)})`);
-		return { content: [{
-			type: "text",
-			text: `${projects.length} project(s):\n\n${lines.join("\n")}`
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `project_list error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-async function toolProjectDetect(params) {
-	try {
-		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.`
-		}] };
-		return { content: [{
-			type: "text",
-			text: formatDetectionJson(detection)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `project_detect error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-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-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) {
-			const name = pathBasename(rootPath);
-			return [
-				pathJoin(home, "dev", name),
-				pathJoin(home, "dev", "ai", name),
-				pathJoin(home, "Desktop", name),
-				pathJoin(home, "Projects", name)
-			].find((c) => fsExists(c));
-		}
-		function hasClaudeNotes(encodedDir) {
-			if (!fsExists(claudeProjects)) return false;
-			try {
-				for (const entry of readdirSync(claudeProjects)) {
-					if (entry !== encodedDir && !entry.startsWith(encodedDir)) continue;
-					const full = pathJoin(claudeProjects, entry);
-					try {
-						if (!statSync(full).isDirectory()) continue;
-					} catch {
-						continue;
-					}
-					if (fsExists(pathJoin(full, "Notes"))) return true;
-				}
-			} catch {}
-			return false;
-		}
-		function findTodoForProject(rootPath) {
-			for (const rel of [
-				"Notes/TODO.md",
-				".claude/Notes/TODO.md",
-				"tasks/todo.md",
-				"TODO.md"
-			]) {
-				const full = pathJoin(rootPath, rel);
-				if (fsExists(full)) try {
-					const raw = readFileSync(full, "utf8");
-					return {
-						found: true,
-						path: rel,
-						has_continue: /^## Continue$/m.test(raw)
-					};
-				} catch {
-					return {
-						found: true,
-						path: rel,
-						has_continue: false
-					};
-				}
-			}
-			return {
-				found: false,
-				path: null,
-				has_continue: false
-			};
-		}
-		const results = rows.map((p) => {
-			const pathExists = fsExists(p.root_path);
-			let health;
-			let suggestedPath = null;
-			if (pathExists) health = "active";
-			else {
-				suggestedPath = suggestMoved(p.root_path) ?? null;
-				health = suggestedPath ? "stale" : "dead";
-			}
-			const todo = pathExists ? findTodoForProject(p.root_path) : {
-				found: false,
-				path: null,
-				has_continue: false
-			};
-			return {
-				slug: p.slug,
-				display_name: p.display_name,
-				root_path: p.root_path,
-				status: p.status,
-				type: p.type,
-				session_count: p.session_count,
-				health,
-				suggested_path: suggestedPath,
-				has_claude_notes: hasClaudeNotes(p.encoded_dir),
-				todo
-			};
-		});
-		const filtered = !params.category || params.category === "all" ? results : results.filter((r) => r.health === params.category);
-		const summary = {
-			total: rows.length,
-			active: results.filter((r) => r.health === "active").length,
-			stale: results.filter((r) => r.health === "stale").length,
-			dead: results.filter((r) => r.health === "dead").length
-		};
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				summary,
-				projects: filtered
-			}, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `project_health error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-/**
-* TODO candidate locations searched in priority order.
-* Returns the first one that exists, along with its label.
-*/
-const TODO_LOCATIONS = [
-	{
-		rel: "Notes/TODO.md",
-		label: "Notes/TODO.md"
-	},
-	{
-		rel: ".claude/Notes/TODO.md",
-		label: ".claude/Notes/TODO.md"
-	},
-	{
-		rel: "tasks/todo.md",
-		label: "tasks/todo.md"
-	},
-	{
-		rel: "TODO.md",
-		label: "TODO.md"
-	}
-];
-/**
-* Given TODO file content, extract and surface the ## Continue section first,
-* then return the remaining content. Returns an object with:
-*   continueSection: string | null
-*   fullContent: string
-*   hasContinue: boolean
-*/
-function parseTodoContent(raw) {
-	const lines = raw.split("\n");
-	const continueIdx = lines.findIndex((l) => l.trim() === "## Continue");
-	if (continueIdx === -1) return {
-		continueSection: null,
-		fullContent: raw,
-		hasContinue: false
-	};
-	let endIdx = lines.length;
-	for (let i = continueIdx + 1; i < lines.length; i++) {
-		const trimmed = lines[i].trim();
-		if (trimmed === "---" || trimmed.startsWith("##") && trimmed !== "## Continue") {
-			endIdx = i;
-			break;
-		}
-	}
-	return {
-		continueSection: lines.slice(continueIdx, endIdx).join("\n").trim(),
-		fullContent: raw,
-		hasContinue: true
-	};
-}
-async function toolProjectTodo(registry, params) {
-	try {
-		let rootPath;
-		let projectSlug;
-		if (params.project) {
-			const projectId = await lookupProjectId(registry, params.project);
-			if (projectId == null) return {
-				content: [{
-					type: "text",
-					text: `Project not found: ${params.project}`
-				}],
-				isError: true
-			};
-			const row = await registry.getProjectById(projectId);
-			if (!row) return {
-				content: [{
-					type: "text",
-					text: `Project not found: ${params.project}`
-				}],
-				isError: true
-			};
-			rootPath = row.root_path;
-			projectSlug = row.slug;
-		} else {
-			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.`
-			}] };
-			rootPath = project.root_path;
-			projectSlug = project.slug;
-		}
-		for (const loc of TODO_LOCATIONS) {
-			const fullPath = join(rootPath, loc.rel);
-			if (existsSync(fullPath)) {
-				const { continueSection, fullContent, hasContinue } = parseTodoContent(readFileSync(fullPath, "utf8"));
-				let output;
-				if (hasContinue && continueSection) output = [
-					`TODO found: ${projectSlug}/${loc.label}`,
-					"",
-					"=== CONTINUE SECTION (surfaced first) ===",
-					continueSection,
-					"",
-					"=== FULL TODO CONTENT ===",
-					fullContent
-				].join("\n");
-				else output = [
-					`TODO found: ${projectSlug}/${loc.label}`,
-					"",
-					fullContent
-				].join("\n");
-				return { content: [{
-					type: "text",
-					text: output
-				}] };
-			}
-		}
-		const searched = TODO_LOCATIONS.map((l) => `  ${rootPath}/${l.rel}`).join("\n");
-		return { content: [{
-			type: "text",
-			text: [
-				`No TODO.md found for project: ${projectSlug}`,
-				"",
-				"Searched locations (in order):",
-				searched,
-				"",
-				"Create a TODO with: echo '## Tasks\\n- [ ] First task' > Notes/TODO.md"
-			].join("\n")
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `project_todo error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-
-//#endregion
-//#region src/mcp/tools/sessions.ts
-async function toolSessionList(registry, params) {
-	try {
-		const projectId = await lookupProjectId(registry, params.project);
-		if (projectId == null) return {
-			content: [{
-				type: "text",
-				text: `Project not found: ${params.project}`
-			}],
-			isError: true
-		};
-		const limit = params.limit ?? 10;
-		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}`
-		}] };
-		const lines = sessions.map((s) => `#${String(s.number).padStart(4, "0")}  ${s.date}  [${s.status}]  ${s.title}\n        file: Notes/${s.filename}`);
-		return { content: [{
-			type: "text",
-			text: `${sessions.length} session(s) for ${params.project}:\n\n${lines.join("\n\n")}`
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `session_list error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-/**
-* Automatically suggest which project a session belongs to.
-*
-* Strategy (in priority order):
-*   1. path   — exact or parent-directory match in the project registry
-*   2. marker — walk up from cwd looking for Notes/PAI.md
-*   3. topic  — BM25 keyword search against memory (requires context)
-*
-* 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(registry, federation, params) {
-	try {
-		const { autoRoute, formatAutoRouteJson } = await import("./auto-route-o0BOsXn7.mjs");
-		const result = await autoRoute(registry, federation, params.cwd, params.context);
-		if (!result) return { content: [{
-			type: "text",
-			text: [
-				`No project match found for: ${params.cwd ?? process.cwd()}`,
-				"",
-				"Tried: path match, PAI.md marker walk" + (params.context ? ", topic detection" : ""),
-				"",
-				"Run 'pai project add .' to register this directory,",
-				"or provide conversation context for topic-based routing."
-			].join("\n")
-		}] };
-		return { content: [{
-			type: "text",
-			text: formatAutoRouteJson(result)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `session_route error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-
-//#endregion
-//#region src/mcp/tools/registry.ts
-async function toolRegistrySearch(registry, params) {
-	try {
-		const projects = await registry.searchProjects(params.query, 20);
-		if (projects.length === 0) return { content: [{
-			type: "text",
-			text: `No projects found matching: "${params.query}"`
-		}] };
-		const lines = projects.map((p) => `${p.slug}  [${p.status}]  ${p.root_path}`);
-		return { content: [{
-			type: "text",
-			text: `${projects.length} match(es) for "${params.query}":\n\n${lines.join("\n")}`
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `registry_search error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-
-//#endregion
-//#region src/mcp/tools/zettel.ts
-async function toolZettelExplore(backend, params) {
-	try {
-		const { zettelExplore } = await import("./zettelkasten-CtGHQWPU.mjs");
-		const result = await zettelExplore(backend, {
-			startNote: params.start_note,
-			depth: params.depth,
-			direction: params.direction,
-			mode: params.mode
-		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `zettel_explore error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-async function toolZettelHealth(backend, params) {
-	try {
-		const { zettelHealth } = await import("./zettelkasten-CtGHQWPU.mjs");
-		const result = await zettelHealth(backend, {
-			scope: params.scope,
-			projectPath: params.project_path,
-			recentDays: params.recent_days,
-			include: params.include
-		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `zettel_health error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-async function toolZettelSurprise(backend, params) {
-	try {
-		const { zettelSurprise } = await import("./zettelkasten-CtGHQWPU.mjs");
-		const results = await zettelSurprise(backend, {
-			referencePath: params.reference_path,
-			vaultProjectId: params.vault_project_id,
-			limit: params.limit,
-			minSimilarity: params.min_similarity,
-			minGraphDistance: params.min_graph_distance
-		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(results, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `zettel_surprise error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-async function toolZettelSuggest(backend, params) {
-	try {
-		const { zettelSuggest } = await import("./zettelkasten-CtGHQWPU.mjs");
-		const results = await zettelSuggest(backend, {
-			notePath: params.note_path,
-			vaultProjectId: params.vault_project_id,
-			limit: params.limit,
-			excludeLinked: params.exclude_linked
-		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(results, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `zettel_suggest error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-async function toolZettelConverse(backend, params) {
-	try {
-		const { zettelConverse } = await import("./zettelkasten-CtGHQWPU.mjs");
-		const result = await zettelConverse(backend, {
-			question: params.question,
-			vaultProjectId: params.vault_project_id,
-			depth: params.depth,
-			limit: params.limit
-		});
-		try {
-			const { saveQueryResult } = await import("./query-feedback-B_iigYj-.mjs");
-			saveQueryResult({
-				query: params.question,
-				timestamp: Date.now(),
-				source: "zettel_converse",
-				sourceSlugs: result.relevantNotes.slice(0, 5).map((n) => n.path),
-				answerPreview: result.relevantNotes.slice(0, 3).map((n) => {
-					return `${n.title ?? "(untitled)"}: ${n.snippet.trim().slice(0, 100)}`;
-				}).join(" | "),
-				resultCount: result.relevantNotes.length
-			});
-		} catch {}
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `zettel_converse error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-async function toolZettelThemes(backend, params) {
-	try {
-		const { zettelThemes } = await import("./zettelkasten-CtGHQWPU.mjs");
-		const result = await zettelThemes(backend, {
-			vaultProjectId: params.vault_project_id,
-			lookbackDays: params.lookback_days,
-			minClusterSize: params.min_cluster_size,
-			maxThemes: params.max_themes,
-			similarityThreshold: params.similarity_threshold
-		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `zettel_themes error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-async function toolZettelGodNotes(backend, params) {
-	try {
-		const { zettelGodNotes } = await import("./zettelkasten-CtGHQWPU.mjs");
-		const result = await zettelGodNotes(backend, {
-			limit: params.limit,
-			minInbound: params.min_inbound
-		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `zettel_god_notes error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-async function toolZettelCommunities(backend, params) {
-	try {
-		const { zettelCommunities } = await import("./zettelkasten-CtGHQWPU.mjs");
-		const result = await zettelCommunities(backend, {
-			minSize: params.min_size,
-			maxCommunities: params.max_communities,
-			resolution: params.resolution
-		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `zettel_communities error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-
-//#endregion
-//#region src/mcp/tools/kg.ts
-async function toolKgAdd(backend, params) {
-	try {
-		if (!params.subject || !params.predicate || !params.object) return {
-			content: [{
-				type: "text",
-				text: "kg_add error: subject, predicate, and object are required"
-			}],
-			isError: true
-		};
-		const triple = await backend.addKgTriple(params);
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(triple, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `kg_add error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-async function toolKgQuery(backend, params) {
-	try {
-		const asOf = params.as_of ? new Date(params.as_of) : void 0;
-		if (asOf && isNaN(asOf.getTime())) return {
-			content: [{
-				type: "text",
-				text: `kg_query error: invalid as_of date: ${params.as_of}`
-			}],
-			isError: true
-		};
-		const triples = await backend.queryKgTriples({
-			subject: params.subject,
-			predicate: params.predicate,
-			object: params.object,
-			project_id: params.project_id,
-			as_of: asOf,
-			include_invalidated: params.include_invalidated
-		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(triples, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `kg_query error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-async function toolKgInvalidate(backend, params) {
-	try {
-		if (params.triple_id === void 0 || params.triple_id === null) return {
-			content: [{
-				type: "text",
-				text: "kg_invalidate error: triple_id is required"
-			}],
-			isError: true
-		};
-		await backend.invalidateKgTriple(params.triple_id);
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				invalidated: true,
-				triple_id: params.triple_id
-			})
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `kg_invalidate error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-async function toolKgContradictions(backend, params) {
-	try {
-		if (!params.subject) return {
-			content: [{
-				type: "text",
-				text: "kg_contradictions error: subject is required"
-			}],
-			isError: true
-		};
-		const contradictions = await backend.getKgContradictions(params.subject);
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(contradictions, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `kg_contradictions error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-
-//#endregion
-//#region src/mcp/tools/wakeup.ts
-const DEFAULT_TOKEN_BUDGET = 800;
-async function toolMemoryWakeup(registry, params) {
-	try {
-		const tokenBudget = params.token_budget ?? DEFAULT_TOKEN_BUDGET;
-		let rootPath;
-		if (params.project) {
-			const bySlug = await registry.getProjectBySlug(params.project);
-			if (bySlug) rootPath = bySlug.root_path;
-			else {
-				const detected = await detectProjectFromPath(registry, params.project);
-				if (detected) rootPath = detected.root_path;
-			}
-		} else {
-			const detected = await detectProjectFromPath(registry, process.cwd());
-			if (detected) rootPath = detected.root_path;
-		}
-		const wakeupBlock = buildWakeupContext(rootPath, tokenBudget);
-		if (!wakeupBlock) return { content: [{
-			type: "text",
-			text: "No wake-up context available. Create ~/.pai/identity.txt for L0 identity, or ensure session notes exist for L1 story."
-		}] };
-		return { content: [{
-			type: "text",
-			text: `WAKEUP CONTEXT\n\n${wakeupBlock}`
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `Wakeup context error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-
-//#endregion
-//#region src/memory/taxonomy.ts
-/**
-* Build a taxonomy of stored memory — what projects exist, how much is stored,
-* and what has been active recently.
-*
-* Registry queries (projects, sessions) go through RegistryBackend (async).
-* Storage backend queries (files, chunks) are async.
-*/
-async function getTaxonomy(registry, storage, options = {}) {
-	const includeArchived = options.include_archived ?? false;
-	const limit = options.limit ?? 50;
-	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: {
-			projects: 0,
-			sessions: 0,
-			notes: 0,
-			chunks: 0
-		},
-		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) {
-		sessionCountsByProject.set(projectId, await registry.countSessionsForProject(projectId));
-		lastSessionDateByProject.set(projectId, await registry.getMostRecentSessionDate(projectId));
-	}
-	const tagsByProject = /* @__PURE__ */ new Map();
-	for (const projectId of projectIds) tagsByProject.set(projectId, await registry.listTagsForProject(projectId));
-	const noteCountsByProject = /* @__PURE__ */ new Map();
-	const chunkCountsByProject = /* @__PURE__ */ new Map();
-	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 = 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
-	}));
-	return {
-		projects: projectRows.map((row) => ({
-			slug: row.slug,
-			display_name: row.display_name,
-			session_count: sessionCountsByProject.get(row.id) ?? 0,
-			note_count: noteCountsByProject.get(row.id) ?? 0,
-			last_activity: lastSessionDateByProject.get(row.id) ?? null,
-			top_tags: tagsByProject.get(row.id) ?? []
-		})),
-		totals: {
-			projects: totalProjects,
-			sessions: totalSessions,
-			notes: stats.files,
-			chunks: stats.chunks
-		},
-		recent_activity: recentActivity
-	};
-}
-
-//#endregion
-//#region src/mcp/tools/taxonomy.ts
-async function toolMemoryTaxonomy(registry, storage, params = {}) {
-	try {
-		const result = await getTaxonomy(registry, storage, {
-			include_archived: params.include_archived,
-			limit: params.limit
-		});
-		const lines = [];
-		lines.push(`PAI Memory Taxonomy — ${result.totals.projects} project(s), ${result.totals.sessions} session(s), ${result.totals.notes} indexed file(s), ${result.totals.chunks} chunk(s)`);
-		lines.push("");
-		if (result.projects.length === 0) lines.push("No active projects found.");
-		else {
-			lines.push("Projects:");
-			for (const p of result.projects) {
-				const tagStr = p.top_tags.length > 0 ? ` [${p.top_tags.join(", ")}]` : "";
-				const activityStr = p.last_activity ? ` last: ${p.last_activity}` : "";
-				lines.push(`  ${p.slug} — ${p.display_name}  sessions=${p.session_count}` + (p.note_count > 0 ? ` files=${p.note_count}` : "") + activityStr + tagStr);
-			}
-		}
-		if (result.recent_activity.length > 0) {
-			lines.push("");
-			lines.push("Recent activity (last 10 sessions across all projects):");
-			for (const a of result.recent_activity) lines.push(`  ${a.timestamp}  ${a.project_slug}  ${a.action}`);
-		}
-		return { content: [{
-			type: "text",
-			text: lines.join("\n")
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `memory_taxonomy error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-
-//#endregion
-//#region src/memory/tunnels.ts
-/**
-* Find cross-project concept tunnels.
-*
-* Works with both SQLite and Postgres storage backends.
-* Requires the RegistryBackend for project slug resolution.
-*
-* @param backend        Active PAI storage backend.
-* @param registry       Registry backend for project slug resolution.
-* @param options        Filter and limit options.
-*/
-async function findTunnels(backend, registry, options) {
-	return backend.findTunnels(registry, options);
-}
-
-//#endregion
-//#region src/mcp/tools/tunnels.ts
-async function toolMemoryTunnels(registry, backend, params) {
-	try {
-		const result = await findTunnels(backend, registry, {
-			min_projects: params.min_projects,
-			min_occurrences: params.min_occurrences,
-			limit: params.limit
-		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `memory_tunnels error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-
-//#endregion
-//#region src/mcp/tools/feedback.ts
-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 backend  StorageBackend for both the chunk and kg_entities portions
-* @param params   Feedback parameters
-*/
-async function toolMemoryFeedback(backend, params) {
-	try {
-		if (!Array.isArray(params.chunk_ids) || params.chunk_ids.length === 0) return {
-			content: [{
-				type: "text",
-				text: "memory_feedback error: chunk_ids must be a non-empty array"
-			}],
-			isError: true
-		};
-		const rating = params.rating;
-		if (typeof rating !== "number" || rating < 1 || rating > 5) return {
-			content: [{
-				type: "text",
-				text: "memory_feedback error: rating must be a number between 1 and 5"
-			}],
-			isError: true
-		};
-		const normalizedRating = (rating - 1) / 4;
-		const chunks = await backend.getChunksForFeedback(params.chunk_ids);
-		if (chunks.length === 0) return {
-			content: [{
-				type: "text",
-				text: "memory_feedback: no matching chunks found"
-			}],
-			isError: true
-		};
-		let updatedChunks = 0;
-		const combinedText = [];
-		for (const chunk of chunks) {
-			const oldScore = chunk.relevanceScore ?? .5;
-			const newScore = oldScore + FEEDBACK_ALPHA * (normalizedRating - oldScore);
-			await backend.updateChunkRelevanceScore(chunk.id, newScore);
-			updatedChunks++;
-			combinedText.push(chunk.text);
-		}
-		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())) {
-			await backend.updateEntityFeedbackWeight(entity.entity_id, normalizedRating, FEEDBACK_ALPHA);
-			updatedEntities++;
-		}
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				updated_chunks: updatedChunks,
-				updated_entities: updatedEntities,
-				rating,
-				normalized_rating: normalizedRating
-			})
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `memory_feedback error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-
-//#endregion
-//#region src/memory/kg-search.ts
-/**
-* 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.
-*/
-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();
-	for (const entity of entities) if (combinedText.includes(entity.name.toLowerCase())) matched.add(entity.name);
-	return Array.from(matched);
-}
-/**
-* Perform BFS over kg_triples to find neighbors of the given entity names.
-*
-* For each entity name, fetches triples where the entity is the subject
-* or the object (bi-directional expansion). Supports 1 or 2 hop depths.
-*
-* Returns all unique triples found in the BFS expansion.
-*/
-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 federation.queryKgTriples({
-				subject: name,
-				project_id: projectId
-			});
-			const asObject = await federation.queryKgTriples({
-				object: name,
-				project_id: projectId
-			});
-			for (const triple of [...asSubject, ...asObject]) if (!seen.has(triple.id)) {
-				seen.add(triple.id);
-				tripleMap.set(triple.id, triple);
-				nextFrontier.add(triple.subject);
-				nextFrontier.add(triple.object);
-			}
-		}
-		frontier.clear();
-		for (const name of nextFrontier) if (!entityNames.includes(name)) {
-			frontier.add(name);
-			entityNames.push(name);
-		}
-	}
-	return Array.from(tripleMap.values());
-}
-/**
-* Score each triple by cosine similarity to the query embedding.
-*
-* The triple text representation is: "subject predicate object"
-* We embed this on-the-fly using generateEmbedding(), which may use a cache.
-*
-* Returns triples sorted by relevance score descending.
-*/
-async function rerankTriples(triples, queryVec, maxTriples) {
-	if (triples.length === 0) return [];
-	const { generateEmbedding } = await import("./embeddings-CcscYWwk.mjs");
-	return (await Promise.all(triples.map(async (triple) => {
-		const text = `${triple.subject} ${triple.predicate} ${triple.object}`;
-		try {
-			const score = cosineSimilarity(queryVec, await generateEmbedding(text, false));
-			return {
-				...triple,
-				relevanceScore: score
-			};
-		} catch {
-			return {
-				...triple,
-				relevanceScore: 0
-			};
-		}
-	}))).sort((a, b) => b.relevanceScore - a.relevanceScore).slice(0, maxTriples);
-}
-/**
-* Graph-completion retrieval combining vector search with KG neighborhood BFS.
-*
-* @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(federation, queryVec, opts = {}) {
-	const { seedCount = 50, hops = 1, maxTriples = 20, projectId, tenantId = "default", searchOpts } = opts;
-	const seedSearchOpts = {
-		...searchOpts,
-		maxResults: seedCount,
-		projectIds: projectId != null ? [projectId] : searchOpts?.projectIds
-	};
-	let seedChunks = [];
-	try {
-		seedChunks = await federation.searchSemantic(queryVec, seedSearchOpts);
-	} catch (e) {
-		process.stderr.write(`[kg-search] Phase 1 seed search error: ${e}\n`);
-	}
-	if (seedChunks.length === 0) return {
-		triples: [],
-		seedChunks: [],
-		expandedEntities: []
-	};
-	const expandedEntities = await extractEntityMentions(federation, seedChunks, tenantId);
-	if (expandedEntities.length === 0) return {
-		triples: [],
-		seedChunks,
-		expandedEntities: []
-	};
-	let expandedTriples = [];
-	try {
-		expandedTriples = await bfsExpand(federation, [...expandedEntities], hops, projectId);
-	} catch (e) {
-		process.stderr.write(`[kg-search] Phase 3 BFS expansion error: ${e}\n`);
-	}
-	if (expandedTriples.length === 0) return {
-		triples: [],
-		seedChunks,
-		expandedEntities
-	};
-	let rankedTriples = [];
-	try {
-		rankedTriples = await rerankTriples(expandedTriples, queryVec, maxTriples);
-	} catch (e) {
-		process.stderr.write(`[kg-search] Phase 4 rerank error: ${e}\n`);
-		rankedTriples = expandedTriples.slice(0, maxTriples).map((t) => ({
-			...t,
-			relevanceScore: 0
-		}));
-	}
-	return {
-		triples: rankedTriples,
-		seedChunks,
-		expandedEntities
-	};
-}
-
-//#endregion
-//#region src/mcp/tools/kg-search.ts
-/**
-* Graph-completion search: vector search + KG neighborhood BFS.
-*
-* @param federation    Active StorageBackend for chunk/entity/kg_triples operations
-* @param params        Tool parameters
-*/
-async function toolMemoryKgSearch(federation, params) {
-	try {
-		if (!params.query || typeof params.query !== "string" || params.query.trim() === "") return {
-			content: [{
-				type: "text",
-				text: "memory_kg_search error: query is required"
-			}],
-			isError: true
-		};
-		const { generateEmbedding } = await import("./embeddings-CcscYWwk.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,
-			projectId: params.project_id,
-			tenantId: params.tenant_id ?? "default"
-		});
-		if (result.triples.length === 0) return { content: [{
-			type: "text",
-			text: `No KG triples found for query: "${params.query}"\nSeed chunks: ${result.seedChunks.length}, Expanded entities: ${result.expandedEntities.length}`
-		}] };
-		const tripleLines = result.triples.map((t, i) => `[${i + 1}] (score=${t.relevanceScore.toFixed(4)}) ${t.subject} — ${t.predicate} — ${t.object}`).join("\n");
-		const entityList = result.expandedEntities.slice(0, 10).join(", ");
-		return { content: [{
-			type: "text",
-			text: [
-				`Found ${result.triples.length} KG triple(s) for "${params.query}"`,
-				`Seed chunks: ${result.seedChunks.length}`,
-				`Expanded entities (${result.expandedEntities.length}): ${entityList}`,
-				"",
-				tripleLines
-			].join("\n")
-		}] };
-	} catch (e) {
-		return {
-			content: [{
-				type: "text",
-				text: `memory_kg_search error: ${String(e)}`
-			}],
-			isError: true
-		};
-	}
-}
-
-//#endregion
-export { detectProjectFromPath as A, toolProjectInfo as C, toolMemoryGet as D, combineHybridResults as E, lookupProjectId as M, toolMemoryOutline 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, formatProject as j, toolMemorySearch 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-BcOKPBtg.mjs.map