@tekmidian/pai 0.25.2 → 0.26.0

package/dist/tools-DMAQxlOk.mjs

@@ -0,0 +1,1939 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+import { n as cosineSimilarity } from "./embeddings-Bn86ssxR.mjs";
+import { t as STOP_WORDS } from "./stop-words-BaMEGVeY.mjs";
+import { i as searchMemoryHybrid, n as populateSlugs, s as touchChunksLastAccessed } from "./search-CpTv1I24.mjs";
+import { r as formatDetectionJson, t as detectProject } from "./detect-Bf2z-oKB.mjs";
+import { a as kgContradictions, i as kgAdd, n as updateEntityFeedbackWeight, o as kgInvalidate, s as kgQuery, t as listKgEntities } from "./kg-entity-r8duqhi9.mjs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, 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.
+*/
+function lookupProjectId(registryDb, slug) {
+	const bySlug = registryDb.prepare("SELECT id FROM projects WHERE slug = ?").get(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;
+}
+function detectProjectFromPath(registryDb, 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);
+	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();
+	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);
+	const lines = [
+		`slug: ${project.slug}`,
+		`display_name: ${project.display_name}`,
+		`root_path: ${project.root_path}`,
+		`type: ${project.type}`,
+		`status: ${project.status}`,
+		`sessions: ${sessionCount}`
+	];
+	if (lastSession) lines.push(`last_session: ${lastSession.date}`);
+	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
+*/
+async function toolMemorySearch(registryDb, federation, params, searchDefaults) {
+	try {
+		const projectIds = params.project ? (() => {
+			const id = lookupProjectId(registryDb, 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;
+		const isBackend = (x) => "backendType" in x;
+		if (isBackend(federation)) if (mode === "keyword") results = await federation.searchKeyword(params.query, searchOpts);
+		else if (mode === "semantic" || mode === "hybrid") {
+			const { generateEmbedding } = await import("./embeddings-Bn86ssxR.mjs").then((n) => n.i);
+			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);
+		else {
+			const { searchMemory, searchMemorySemantic } = await import("./search-CpTv1I24.mjs").then((n) => n.o);
+			if (mode === "keyword") results = searchMemory(federation, params.query, searchOpts);
+			else if (mode === "semantic" || mode === "hybrid") {
+				const { generateEmbedding } = await import("./embeddings-Bn86ssxR.mjs").then((n) => n.i);
+				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 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);
+			}
+		} catch {}
+		const shouldRerank = params.rerank ?? searchDefaults?.rerank ?? true;
+		if (shouldRerank && results.length > 0) {
+			const { rerankResults } = await import("./reranker-CMNZcfVx.mjs").then((n) => n.r);
+			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-CpTv1I24.mjs").then((n) => n.o);
+			results = applyRecencyBoost(results, recencyDays);
+		}
+		const withSlugs = populateSlugs(results, registryDb);
+		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-BX5nSyRm.mjs").then((n) => n.t);
+			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
+		};
+	}
+}
+function toolMemoryGet(registryDb, params) {
+	try {
+		const projectId = lookupProjectId(registryDb, params.project);
+		if (projectId == null) return {
+			content: [{
+				type: "text",
+				text: `Project not found: ${params.project}`
+			}],
+			isError: true
+		};
+		const project = registryDb.prepare("SELECT root_path FROM projects WHERE id = ?").get(projectId);
+		if (!project) return {
+			content: [{
+				type: "text",
+				text: `Project not found: ${params.project}`
+			}],
+			isError: true
+		};
+		const requestedPath = params.path;
+		if (requestedPath.includes("..") || isAbsolute(requestedPath)) return {
+			content: [{
+				type: "text",
+				text: `Invalid path: ${params.path} (must be a relative path within the project root, no ../ allowed)`
+			}],
+			isError: true
+		};
+		const fullPath = join(project.root_path, requestedPath);
+		const resolvedFull = resolve(fullPath);
+		const resolvedRoot = resolve(project.root_path);
+		if (!resolvedFull.startsWith(resolvedRoot + "/") && resolvedFull !== resolvedRoot) return {
+			content: [{
+				type: "text",
+				text: `Path traversal blocked: ${params.path}`
+			}],
+			isError: true
+		};
+		if (!existsSync(fullPath)) return {
+			content: [{
+				type: "text",
+				text: `File not found: ${requestedPath} (project: ${params.project})`
+			}],
+			isError: true
+		};
+		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.`
+		}] };
+		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
+		};
+	}
+}
+/**
+* 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
+*/
+function toolProjectInfo(registryDb, 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());
+		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: formatProject(registryDb, project)
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `project_info error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+function toolProjectList(registryDb, 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);
+		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
+		};
+	}
+}
+function toolProjectDetect(registryDb, params) {
+	try {
+		const detection = detectProject(registryDb, 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(registryDb, 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-BAxjW3j8.mjs").then((n) => n.g);
+		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 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
+	};
+}
+function toolProjectTodo(registryDb, params) {
+	try {
+		let rootPath;
+		let projectSlug;
+		if (params.project) {
+			const projectId = lookupProjectId(registryDb, params.project);
+			if (projectId == null) return {
+				content: [{
+					type: "text",
+					text: `Project not found: ${params.project}`
+				}],
+				isError: true
+			};
+			const row = registryDb.prepare("SELECT root_path, slug FROM projects WHERE id = ?").get(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 = detectProjectFromPath(registryDb, 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
+function toolSessionList(registryDb, params) {
+	try {
+		const projectId = lookupProjectId(registryDb, params.project);
+		if (projectId == null) return {
+			content: [{
+				type: "text",
+				text: `Project not found: ${params.project}`
+			}],
+			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);
+		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(registryDb, federation, params) {
+	try {
+		const { autoRoute, formatAutoRouteJson } = await import("./auto-route-BWGvvpcP.mjs");
+		const result = await autoRoute(registryDb, 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
+function toolRegistrySearch(registryDb, 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);
+		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-C8BikWss.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-C8BikWss.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-C8BikWss.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-C8BikWss.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-C8BikWss.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-BX5nSyRm.mjs").then((n) => n.t);
+			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-C8BikWss.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-C8BikWss.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-C8BikWss.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(pool, 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 kgAdd(pool, 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(pool, 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 kgQuery(pool, {
+			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(pool, 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 kgInvalidate(pool, 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(pool, params) {
+	try {
+		if (!params.subject) return {
+			content: [{
+				type: "text",
+				text: "kg_contradictions error: subject is required"
+			}],
+			isError: true
+		};
+		const contradictions = await kgContradictions(pool, 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/memory/wakeup.ts
+/**
+* Wake-up context system — progressive context loading inspired by mempalace.
+*
+* Layers:
+*   L0 Identity     (~100 tokens)   — user identity from ~/.pai/identity.txt. Always loaded.
+*   L1 Essential Story (~500-800t)  — top session notes for the project, key lines extracted.
+*   L2 On-Demand                    — triggered by topic queries (handled by memory_search).
+*   L3 Deep Search                  — unlimited federated memory search (memory_search tool).
+*/
+/** Maximum tokens for the L1 essential story block. Approx 4 chars/token. */
+const L1_TOKEN_BUDGET = 800;
+L1_TOKEN_BUDGET * 4;
+/** Maximum session notes to scan when building L1. */
+const L1_MAX_NOTES = 10;
+/** Sections to extract from session notes (in priority order). */
+const EXTRACT_SECTIONS = [
+	"Work Done",
+	"Key Decisions",
+	"Next Steps",
+	"Checkpoint"
+];
+/** Identity file location. */
+const IDENTITY_FILE = join(homedir(), ".pai", "identity.txt");
+/**
+* Load L0 identity from ~/.pai/identity.txt.
+* Returns the file content, or an empty string if the file does not exist.
+* Never throws.
+*/
+function loadL0Identity() {
+	if (!existsSync(IDENTITY_FILE)) return "";
+	try {
+		return readFileSync(IDENTITY_FILE, "utf-8").trim();
+	} catch {
+		return "";
+	}
+}
+/**
+* Find the Notes directory for a project given its root_path from the registry.
+* Checks local Notes/ first, then central ~/.claude/projects/... path.
+*/
+function findNotesDirForProject(rootPath) {
+	const localCandidates = [
+		join(rootPath, "Notes"),
+		join(rootPath, "notes"),
+		join(rootPath, ".claude", "Notes")
+	];
+	for (const p of localCandidates) if (existsSync(p)) return p;
+	const encoded = rootPath.replace(/\//g, "-").replace(/\./g, "-").replace(/ /g, "-");
+	const centralNotes = join(homedir(), ".claude", "projects", encoded, "Notes");
+	if (existsSync(centralNotes)) return centralNotes;
+	return null;
+}
+/**
+* Recursively find all .md session note files in a Notes directory.
+* Handles both flat layout (Notes/*.md) and month-subdirectory layout
+* (Notes/YYYY/MM/*.md). Returns files sorted newest-first by filename
+* (note numbers are monotonically increasing, so lexicographic = newest-last,
+* so we reverse).
+*/
+function findSessionNotes(notesDir) {
+	const result = [];
+	const scanDir = (dir) => {
+		if (!existsSync(dir)) return;
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true }).map((e) => ({
+				name: e.name,
+				isDir: e.isDirectory()
+			}));
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+			if (entry.isDir) scanDir(fullPath);
+			else if (entry.name.match(/^\d{3,4}[\s_-].*\.md$/)) result.push(fullPath);
+		}
+	};
+	scanDir(notesDir);
+	const dateOf = (p) => basename(p).match(/(\d{4}-\d{2}-\d{2})/)?.[1] ?? "";
+	const numberOf = (p) => parseInt(basename(p).match(/^(\d+)/)?.[1] ?? "0", 10);
+	const mtimeOf = (p) => {
+		try {
+			return statSync(p).mtimeMs;
+		} catch {
+			return 0;
+		}
+	};
+	result.sort((a, b) => {
+		const dateA = dateOf(a);
+		const dateB = dateOf(b);
+		if (dateA !== dateB) {
+			if (!dateA) return 1;
+			if (!dateB) return -1;
+			return dateB.localeCompare(dateA);
+		}
+		const byNumber = numberOf(b) - numberOf(a);
+		if (byNumber !== 0) return byNumber;
+		return mtimeOf(b) - mtimeOf(a);
+	});
+	return result;
+}
+/**
+* Extract the most important lines from a session note.
+* Prioritises: Work Done items, Key Decisions, Next Steps, Checkpoint headings.
+* Returns a condensed string under maxChars.
+*/
+function extractKeyLines(content, maxChars) {
+	const lines = content.split("\n");
+	const selected = [];
+	let inTargetSection = false;
+	let currentSection = "";
+	let charCount = 0;
+	for (const line of lines) {
+		const h2Match = line.match(/^## (.+)$/);
+		const h3Match = line.match(/^### (.+)$/);
+		if (h2Match) {
+			currentSection = h2Match[1];
+			inTargetSection = EXTRACT_SECTIONS.some((s) => currentSection.toLowerCase().includes(s.toLowerCase()));
+			continue;
+		}
+		if (h3Match) {
+			if (inTargetSection) {
+				const label = `[${h3Match[1]}]`;
+				if (charCount + label.length < maxChars) {
+					selected.push(label);
+					charCount += label.length + 1;
+				}
+			}
+			continue;
+		}
+		if (!inTargetSection) continue;
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("<!--") || trimmed === "---") continue;
+		if (trimmed.startsWith("- ") || trimmed.startsWith("* ") || trimmed.match(/^\d+\./) || trimmed.startsWith("**")) {
+			if (charCount + trimmed.length + 1 > maxChars) break;
+			selected.push(trimmed);
+			charCount += trimmed.length + 1;
+		}
+	}
+	return selected.join("\n");
+}
+/**
+* Build the L1 essential story block.
+*
+* Reads the most recent session notes for the project and extracts the key
+* lines (Work Done, Key Decisions, Next Steps) within the token budget.
+*
+* @param rootPath   The project root path (from the registry).
+* @param tokenBudget  Max tokens to consume. Default 800 (~3200 chars).
+* @returns Formatted L1 block, or empty string if no notes found.
+*/
+function buildL1EssentialStory(rootPath, tokenBudget = L1_TOKEN_BUDGET) {
+	const charBudget = tokenBudget * 4;
+	const notesDir = findNotesDirForProject(rootPath);
+	if (!notesDir) return "";
+	const noteFiles = findSessionNotes(notesDir).slice(0, L1_MAX_NOTES);
+	if (noteFiles.length === 0) return "";
+	const sections = [];
+	let remaining = charBudget;
+	for (const noteFile of noteFiles) {
+		if (remaining <= 50) break;
+		let content;
+		try {
+			content = readFileSync(noteFile, "utf-8");
+		} catch {
+			continue;
+		}
+		const name = basename(noteFile);
+		const titleMatch = name.match(/^\d+ - (\d{4}-\d{2}-\d{2}) - (.+)\.md$/);
+		const dateLabel = titleMatch ? titleMatch[1] : "";
+		const titleLabel = titleMatch ? titleMatch[2] : name.replace(/^\d+ - /, "").replace(/\.md$/, "");
+		const perNoteChars = Math.min(remaining, Math.floor(charBudget / noteFiles.length) + 200);
+		const extracted = extractKeyLines(content, perNoteChars);
+		if (!extracted) continue;
+		const noteBlock = `[${dateLabel} - ${titleLabel}]\n${extracted}`;
+		sections.push(noteBlock);
+		remaining -= noteBlock.length + 1;
+	}
+	if (sections.length === 0) return "";
+	return sections.join("\n\n");
+}
+/**
+* Build the combined wake-up context block (L0 + L1).
+*
+* Returns a formatted string suitable for injection as a system-reminder,
+* or an empty string if both layers are empty.
+*
+* @param rootPath   Project root path for L1 note lookup. Optional.
+* @param tokenBudget  L1 token budget. Default 800.
+*/
+function buildWakeupContext(rootPath, tokenBudget = L1_TOKEN_BUDGET) {
+	const identity = loadL0Identity();
+	const essentialStory = rootPath ? buildL1EssentialStory(rootPath, tokenBudget) : "";
+	if (!identity && !essentialStory) return "";
+	const parts = [];
+	if (identity) parts.push(`## L0 Identity\n\n${identity}`);
+	if (essentialStory) parts.push(`## L1 Essential Story\n\n${essentialStory}`);
+	return parts.join("\n\n");
+}
+
+//#endregion
+//#region src/mcp/tools/wakeup.ts
+const DEFAULT_TOKEN_BUDGET = 800;
+function toolMemoryWakeup(registryDb, 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);
+			if (bySlug) rootPath = bySlug.root_path;
+			else {
+				const detected = detectProjectFromPath(registryDb, params.project);
+				if (detected) rootPath = detected.root_path;
+			}
+		} else {
+			const detected = detectProjectFromPath(registryDb, 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) are synchronous (better-sqlite3).
+* Storage backend queries (files, chunks) are async.
+*/
+async function getTaxonomy(registryDb, 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);
+	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 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);
+	}
+	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));
+	}
+	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);
+	}
+	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,
+		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(registryDb, storage, params = {}) {
+	try {
+		const result = await getTaxonomy(registryDb, 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
+/**
+* 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.
+*
+* @param backend        Active PAI storage backend.
+* @param registryDb     Registry database 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);
+}
+
+//#endregion
+//#region src/mcp/tools/tunnels.ts
+async function toolMemoryTunnels(registryDb, backend, params) {
+	try {
+		const result = await findTunnels(backend, registryDb, {
+			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.
+*
+* @param db      Federation SQLite database
+* @param params  Feedback parameters
+*/
+function toolMemoryFeedback(db, 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 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);
+		if (chunks.length === 0) return {
+			content: [{
+				type: "text",
+				text: "memory_feedback: no matching chunks found"
+			}],
+			isError: true
+		};
+		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 newScore = oldScore + FEEDBACK_ALPHA * (normalizedRating - oldScore);
+			updateStmt.run(newScore, chunk.id);
+			updatedChunks++;
+			combinedText.push(chunk.text);
+		}
+		const entities = listKgEntities(db, params.tenant_id ?? "default", 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);
+			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
+/**
+* Find entity names (from the federation.db 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);
+	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(pool, 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, {
+				subject: name,
+				project_id: projectId
+			});
+			const asObject = await kgQuery(pool, {
+				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-Bn86ssxR.mjs").then((n) => n.i);
+	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 federationDb  SQLite federation.db (for chunk/entity lookup)
+* @param pool          Postgres connection pool (for kg_triples queries)
+* @param queryVec      Pre-computed embedding for the search query
+* @param opts          Configuration options
+*/
+async function graphCompletionSearch(federationDb, pool, 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 {
+		const { searchMemorySemantic } = await import("./search-CpTv1I24.mjs").then((n) => n.o);
+		seedChunks = searchMemorySemantic(federationDb, 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 = extractEntityMentions(federationDb, seedChunks, tenantId);
+	if (expandedEntities.length === 0) return {
+		triples: [],
+		seedChunks,
+		expandedEntities: []
+	};
+	let expandedTriples = [];
+	try {
+		expandedTriples = await bfsExpand(pool, [...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 federationDb  SQLite federation.db for chunk/entity operations
+* @param pool          Postgres pool for kg_triples BFS expansion
+* @param params        Tool parameters
+*/
+async function toolMemoryKgSearch(federationDb, pool, 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-Bn86ssxR.mjs").then((n) => n.i);
+		const result = await graphCompletionSearch(federationDb, pool, 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
+//#region src/mcp/tools.ts
+var tools_exports = /* @__PURE__ */ __exportAll({
+	combineHybridResults: () => combineHybridResults,
+	detectProjectFromPath: () => detectProjectFromPath,
+	formatProject: () => formatProject,
+	lookupProjectId: () => lookupProjectId,
+	toolKgAdd: () => toolKgAdd,
+	toolKgContradictions: () => toolKgContradictions,
+	toolKgInvalidate: () => toolKgInvalidate,
+	toolKgQuery: () => toolKgQuery,
+	toolMemoryFeedback: () => toolMemoryFeedback,
+	toolMemoryGet: () => toolMemoryGet,
+	toolMemoryKgSearch: () => toolMemoryKgSearch,
+	toolMemorySearch: () => toolMemorySearch,
+	toolMemoryTaxonomy: () => toolMemoryTaxonomy,
+	toolMemoryTunnels: () => toolMemoryTunnels,
+	toolMemoryWakeup: () => toolMemoryWakeup,
+	toolProjectDetect: () => toolProjectDetect,
+	toolProjectHealth: () => toolProjectHealth,
+	toolProjectInfo: () => toolProjectInfo,
+	toolProjectList: () => toolProjectList,
+	toolProjectTodo: () => toolProjectTodo,
+	toolRegistrySearch: () => toolRegistrySearch,
+	toolSessionList: () => toolSessionList,
+	toolSessionRoute: () => toolSessionRoute,
+	toolZettelCommunities: () => toolZettelCommunities,
+	toolZettelConverse: () => toolZettelConverse,
+	toolZettelExplore: () => toolZettelExplore,
+	toolZettelGodNotes: () => toolZettelGodNotes,
+	toolZettelHealth: () => toolZettelHealth,
+	toolZettelSuggest: () => toolZettelSuggest,
+	toolZettelSurprise: () => toolZettelSurprise,
+	toolZettelThemes: () => toolZettelThemes
+});
+
+//#endregion
+export { toolMemoryWakeup as a, toolSessionRoute as c, toolProjectInfo as d, toolProjectList as f, toolMemorySearch as h, toolMemoryTaxonomy as i, toolProjectDetect as l, toolMemoryGet as m, toolMemoryKgSearch as n, toolRegistrySearch as o, toolProjectTodo as p, toolMemoryFeedback as r, toolSessionList as s, tools_exports as t, toolProjectHealth as u };
+//# sourceMappingURL=tools-DMAQxlOk.mjs.map