laminark 0.1.0 → 2.21.7

package/plugin/dist/index.js

@@ -1,18 +1,17 @@
 #!/usr/bin/env node
 import { a as isDebugEnabled, i as getProjectHash, n as getDatabaseConfig, r as getDbPath, t as getConfigDir } from "./config-t8LZeB-u.mjs";
-import { A as hybridSearch, C as getNodesByType, D as upsertNode, E as traverseFrom, F as openDatabase, I as MIGRATIONS, L as runMigrations, M as SessionRepository, N as ObservationRepository, O as SaveGuard, R as debug, S as getNodeByNameAndType, T as insertEdge, _ as detectStaleness, a as ResearchBufferRepository, b as countEdgesForNode, c as inferScope, d as executePurge, f as findAnalysis, g as saveHygieneConfig, h as resetHygieneConfig, i as NotificationStore, j as SearchEngine, k as jaccardSimilarity$1, l as inferToolType, m as loadHygieneConfig, n as PathRepository, o as BranchRepository, r as initPathSchema, s as extractServerName, t as ToolRegistryRepository, u as analyzeObservations, v as flagStaleObservation, w as initGraphSchema, x as getEdgesForNode, y as initStalenessSchema, z as debugTimed } from "./tool-registry-e710BvXq.mjs";
-import { existsSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
+import { C as rowToObservation, D as debug, E as runMigrations, O as debugTimed, S as ObservationRepository, T as MIGRATIONS, _ as SaveGuard, a as ResearchBufferRepository, b as SearchEngine, c as inferToolType, d as getNodeByNameAndType, f as getNodesByType, g as upsertNode, h as traverseFrom, i as NotificationStore, l as countEdgesForNode, m as insertEdge, n as PathRepository, o as extractServerName, p as initGraphSchema, r as initPathSchema, s as inferScope, t as ToolRegistryRepository, u as getEdgesForNode, v as jaccardSimilarity$1, w as openDatabase, x as SessionRepository, y as hybridSearch } from "./tool-registry-CZ3mJ4iR.mjs";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { z } from "zod";
 import path from "path";
 import { fileURLToPath } from "url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { readFile, readdir } from "node:fs/promises";
-import { unstable_v2_createSession } from "@anthropic-ai/claude-agent-sdk";
 import { Worker } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath$1 } from "node:url";
+import { unstable_v2_createSession } from "@anthropic-ai/claude-agent-sdk";
 import { Hono } from "hono";
 import fs from "fs";
 import { cors } from "hono/cors";
@@ -372,44 +371,6 @@ async function startServer(server) {
 	debug("mcp", "MCP server started on stdio transport");
 }
 
-//#endregion
-//#region src/config/cross-access.ts
-/**
-* Cross-Project Access Configuration
-*
-* Per-project config that controls which other projects' memories
-* the current project can read from. Read-only access — no writes
-* cross projects.
-*
-* Config stored at: {configDir}/cross-access-{projectHash}.json
-*/
-const DEFAULTS$4 = { readableProjects: [] };
-function getConfigPath(projectHash) {
-	return join(getConfigDir(), `cross-access-${projectHash}.json`);
-}
-function loadCrossAccessConfig(projectHash) {
-	const configPath = getConfigPath(projectHash);
-	try {
-		if (!existsSync(configPath)) return { ...DEFAULTS$4 };
-		const raw = readFileSync(configPath, "utf-8");
-		const parsed = JSON.parse(raw);
-		return { readableProjects: Array.isArray(parsed.readableProjects) ? parsed.readableProjects.filter((h) => typeof h === "string") : [] };
-	} catch {
-		return { ...DEFAULTS$4 };
-	}
-}
-function saveCrossAccessConfig(projectHash, config) {
-	const configPath = getConfigPath(projectHash);
-	const validated = { readableProjects: Array.isArray(config.readableProjects) ? config.readableProjects.filter((h) => typeof h === "string" && h !== projectHash) : [] };
-	writeFileSync(configPath, JSON.stringify(validated, null, 2), "utf-8");
-}
-function resetCrossAccessConfig(projectHash) {
-	const configPath = getConfigPath(projectHash);
-	try {
-		if (existsSync(configPath)) unlinkSync(configPath);
-	} catch {}
-}
-
 //#endregion
 //#region src/mcp/token-budget.ts
 const TOKEN_BUDGET = 2e3;
@@ -438,82 +399,6 @@ function enforceTokenBudget(results, formatResult, budget = TOKEN_BUDGET) {
 	};
 }
 
-//#endregion
-//#region src/config/tool-verbosity-config.ts
-/**
-* Tool Response Verbosity Configuration
-*
-* Controls how much detail MCP tool responses include.
-* Three levels:
-*   1 (minimal): Just confirms the tool ran
-*   2 (standard): Shows title/key info (default)
-*   3 (verbose):  Full formatted text with all details
-*
-* Configuration is loaded from .laminark/tool-verbosity.json with
-* a 5-second cache to avoid repeated disk reads.
-*/
-const DEFAULTS$3 = { level: 2 };
-const CACHE_TTL_MS = 5e3;
-let cachedConfig = null;
-let cachedAt = 0;
-/**
-* Loads tool verbosity configuration from disk with a 5-second cache.
-*/
-function loadToolVerbosityConfig() {
-	const now = Date.now();
-	if (cachedConfig && now - cachedAt < CACHE_TTL_MS) return cachedConfig;
-	const configPath = join(getConfigDir(), "tool-verbosity.json");
-	try {
-		const content = readFileSync(configPath, "utf-8");
-		const level = JSON.parse(content).level;
-		if (level === 1 || level === 2 || level === 3) cachedConfig = { level };
-		else cachedConfig = { ...DEFAULTS$3 };
-		debug("config", "Loaded tool verbosity config", { level: cachedConfig.level });
-	} catch {
-		cachedConfig = { ...DEFAULTS$3 };
-	}
-	cachedAt = now;
-	return cachedConfig;
-}
-/**
-* Saves tool verbosity configuration to disk and invalidates cache.
-*/
-function saveToolVerbosityConfig(config) {
-	writeFileSync(join(getConfigDir(), "tool-verbosity.json"), JSON.stringify(config, null, 2), "utf-8");
-	cachedConfig = config;
-	cachedAt = Date.now();
-}
-/**
-* Resets tool verbosity to defaults by invalidating cache.
-*/
-function resetToolVerbosityConfig() {
-	cachedConfig = null;
-	cachedAt = 0;
-	return { ...DEFAULTS$3 };
-}
-/**
-* Selects the appropriate response text based on the current verbosity level.
-*
-* Each tool passes three pre-built strings:
-* - minimal:  Level 1 — just confirms the tool ran
-* - standard: Level 2 — shows title/key info
-* - verbose:  Level 3 — full formatted text
-*/
-function formatResponse(level, minimal, standard, verbose) {
-	switch (level) {
-		case 1: return minimal;
-		case 2: return standard;
-		case 3: return verbose;
-	}
-}
-/**
-* Convenience: loads config and selects the response in one call.
-*/
-function verboseResponse(minimal, standard, verbose) {
-	const { level } = loadToolVerbosityConfig();
-	return formatResponse(level, minimal, standard, verbose);
-}
-
 //#endregion
 //#region src/mcp/tools/recall.ts
 function shortId(id) {
@@ -545,19 +430,19 @@ function formatTimelineGroup(date, items) {
 function formatFullItem(obs) {
 	return `--- ${shortId(obs.id)} | ${obs.title ?? "untitled"} | ${obs.createdAt} ---\n${obs.content}`;
 }
-function prependNotifications$8(notificationStore, projectHash, responseText) {
+function prependNotifications$6(notificationStore, projectHash, responseText) {
 	if (!notificationStore) return responseText;
 	const pending = notificationStore.consumePending(projectHash);
 	if (pending.length === 0) return responseText;
 	return pending.map((n) => `[Laminark] ${n.message}`).join("\n") + "\n\n" + responseText;
 }
-function textResponse$9(text) {
+function textResponse$7(text) {
 	return { content: [{
 		type: "text",
 		text
 	}] };
 }
-function errorResponse$4(text) {
+function errorResponse$3(text) {
 	return {
 		content: [{
 			type: "text",
@@ -566,15 +451,7 @@ function errorResponse$4(text) {
 		isError: true
 	};
 }
-function getProjectNameMap(db) {
-	const map = /* @__PURE__ */ new Map();
-	try {
-		const rows = db.prepare("SELECT project_hash, display_name FROM project_metadata").all();
-		for (const row of rows) map.set(row.project_hash, row.display_name ?? row.project_hash.slice(0, 8));
-	} catch {}
-	return map;
-}
-function registerRecall(server, db, projectHashRef, worker = null, embeddingStore = null, notificationStore = null, statusCache = null) {
+function registerRecall(server, db, projectHash, worker = null, embeddingStore = null, notificationStore = null, statusCache = null) {
 	server.registerTool("recall", {
 		title: "Recall Memories",
 		description: "Search, view, purge, or restore memories. Search first to find matches, then act on specific results by ID.",
@@ -604,14 +481,13 @@ function registerRecall(server, db, projectHashRef, worker = null, embeddingStor
 			include_purged: z.boolean().default(false).describe("Include soft-deleted items in results (needed for restore)")
 		}
 	}, async (args) => {
-		const projectHash = projectHashRef.current;
-		const withNotifications = (text) => textResponse$9(prependNotifications$8(notificationStore, projectHash, text));
+		const withNotifications = (text) => textResponse$7(prependNotifications$6(notificationStore, projectHash, text));
 		try {
 			const repo = new ObservationRepository(db, projectHash);
 			const searchEngine = new SearchEngine(db, projectHash);
 			const hasSearch = args.query !== void 0 || args.id !== void 0 || args.title !== void 0;
-			if (args.ids && hasSearch) return errorResponse$4("Provide either a search query or IDs to act on, not both.");
-			if ((args.action === "purge" || args.action === "restore") && !args.ids && !args.id) return errorResponse$4(`Provide ids array or id to specify which memories to ${args.action}.`);
+			if (args.ids && hasSearch) return errorResponse$3("Provide either a search query or IDs to act on, not both.");
+			if ((args.action === "purge" || args.action === "restore") && !args.ids && !args.id) return errorResponse$3(`Provide ids array or id to specify which memories to ${args.action}.`);
 			let observations = [];
 			let searchResults = null;
 			if (args.ids) {
@@ -638,30 +514,6 @@ function registerRecall(server, db, projectHashRef, worker = null, embeddingStor
 				});
 				else searchResults = searchEngine.searchKeyword(args.query, { limit: args.limit });
 				observations = searchResults.map((r) => r.observation);
-				const crossConfig = loadCrossAccessConfig(projectHash);
-				if (crossConfig.readableProjects.length > 0) {
-					const nameMap = getProjectNameMap(db);
-					for (const otherHash of crossConfig.readableProjects) {
-						const otherEngine = new SearchEngine(db, otherHash);
-						let otherResults;
-						if (embeddingStore) otherResults = await hybridSearch({
-							searchEngine: otherEngine,
-							embeddingStore,
-							worker,
-							query: args.query,
-							db,
-							projectHash: otherHash,
-							options: { limit: args.limit }
-						});
-						else otherResults = otherEngine.searchKeyword(args.query, { limit: args.limit });
-						if (otherResults.length > 0) {
-							const projName = nameMap.get(otherHash) ?? otherHash.slice(0, 8);
-							for (const r of otherResults) r.observation.title = `[${projName}] ${r.observation.title ?? "untitled"}`;
-							searchResults.push(...otherResults);
-							observations.push(...otherResults.map((r) => r.observation));
-						}
-					}
-				}
 			} else if (args.title) observations = repo.getByTitle(args.title, {
 				limit: args.limit,
 				includePurged: args.include_purged
@@ -673,21 +525,8 @@ function registerRecall(server, db, projectHashRef, worker = null, embeddingStor
 			if (args.kind && observations.length > 0) observations = observations.filter((obs) => obs.kind === args.kind);
 			if (observations.length === 0) return withNotifications(`No memories found matching '${args.query ?? args.title ?? args.id ?? ""}'. Try broader search terms or check the ID.`);
 			if (args.action === "view") {
-				const verbosity = loadToolVerbosityConfig().level;
-				if (verbosity === 1) {
-					const searchTerm = args.query ?? args.title ?? "query";
-					return textResponse$9(prependNotifications$8(notificationStore, projectHash, `Found ${observations.length} memories matching "${searchTerm}"`));
-				}
-				if (verbosity === 2) {
-					const lines = observations.map((obs, i) => {
-						const title = obs.title ?? "untitled";
-						return `${i + 1}. ${title}`;
-					});
-					const footer = `\n---\n${observations.length} result(s)`;
-					return textResponse$9(prependNotifications$8(notificationStore, projectHash, lines.join("\n") + footer));
-				}
 				const originalText = formatViewResponse(observations, searchResults, args.detail, args.id !== void 0).content[0].text;
-				return textResponse$9(prependNotifications$8(notificationStore, projectHash, originalText));
+				return textResponse$7(prependNotifications$6(notificationStore, projectHash, originalText));
 			}
 			if (args.action === "purge") {
 				const targetIds = args.ids ?? (args.id ? [args.id] : []);
@@ -719,11 +558,11 @@ function registerRecall(server, db, projectHashRef, worker = null, embeddingStor
 				if (failures.length > 0) msg += ` Not found: ${failures.join(", ")}`;
 				return withNotifications(msg);
 			}
-			return errorResponse$4(`Unknown action: ${args.action}`);
+			return errorResponse$3(`Unknown action: ${args.action}`);
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "recall: error", { error: message });
-			return errorResponse$4(`Recall error: ${message}`);
+			return errorResponse$3(`Recall error: ${message}`);
 		}
 	});
 }
@@ -783,7 +622,7 @@ function formatViewResponse(observations, searchResults, detail, isSingleIdLooku
 	}
 	let footer = `---\n${observations.length} result(s) | ~${tokenEstimate} tokens | detail: ${detail}`;
 	if (truncated) footer += " | truncated (use id for full view)";
-	return textResponse$9(`${body}\n${footer}`);
+	return textResponse$7(`${body}\n${footer}`);
 }
 function buildScoreMap(searchResults) {
 	const map = /* @__PURE__ */ new Map();
@@ -809,7 +648,7 @@ function generateTitle(content) {
 * save_memory persists user-provided text as a new observation with an optional title.
 * If title is omitted, one is auto-generated from the text content.
 */
-function registerSaveMemory(server, db, projectHashRef, notificationStore = null, worker = null, embeddingStore = null, statusCache = null) {
+function registerSaveMemory(server, db, projectHash, notificationStore = null, worker = null, embeddingStore = null, statusCache = null) {
 	server.registerTool("save_memory", {
 		title: "Save Memory",
 		description: "Save a new memory observation. Provide text content and an optional title. If title is omitted, one is auto-generated from the text.",
@@ -826,7 +665,6 @@ function registerSaveMemory(server, db, projectHashRef, notificationStore = null
 			]).default("finding").describe("Observation kind: change, reference, finding, decision, or verification")
 		}
 	}, async (args) => {
-		const projectHash = projectHashRef.current;
 		try {
 			const repo = new ObservationRepository(db, projectHash);
 			const decision = await new SaveGuard(repo, {
@@ -855,7 +693,7 @@ function registerSaveMemory(server, db, projectHashRef, notificationStore = null
 				title: resolvedTitle
 			});
 			statusCache?.markDirty();
-			let responseText = verboseResponse("Memory saved.", `Saved "${resolvedTitle}"`, `Saved memory "${resolvedTitle}" (id: ${obs.id})`);
+			let responseText = `Saved memory "${resolvedTitle}" (id: ${obs.id})`;
 			if (notificationStore) {
 				const pending = notificationStore.consumePending(projectHash);
 				if (pending.length > 0) responseText = pending.map((n) => `[Laminark] ${n.message}`).join("\n") + "\n\n" + responseText;
@@ -876,248 +714,6 @@ function registerSaveMemory(server, db, projectHashRef, notificationStore = null
 	});
 }
 
-//#endregion
-//#region src/ingestion/markdown-parser.ts
-/**
-* Parse a markdown file into discrete sections split on ## headings.
-*
-* - The # (level 1) heading is the doc title, used as prefix: "DocTitle > SectionHeading"
-* - ### subsections stay within their parent ## section (not split separately)
-* - Sections with empty content after trimming are skipped
-* - Content before the first ## heading is skipped
-* - ## inside fenced code blocks are not treated as headings
-*/
-function parseMarkdownSections(fileContent, sourceFile) {
-	const lines = fileContent.split("\n");
-	const sections = [];
-	let docTitle = "";
-	let currentHeading = "";
-	let currentLines = [];
-	let sectionIndex = 0;
-	let inCodeBlock = false;
-	for (const line of lines) {
-		if (line.trimStart().startsWith("```")) inCodeBlock = !inCodeBlock;
-		if (inCodeBlock) {
-			if (currentHeading) currentLines.push(line);
-			continue;
-		}
-		if (/^# (?!#)/.test(line)) {
-			docTitle = line.slice(2).trim();
-			continue;
-		}
-		if (/^## (?!#)/.test(line)) {
-			if (currentHeading) {
-				const content = currentLines.join("\n").trim();
-				if (content.length > 0) {
-					sections.push({
-						title: docTitle ? `${docTitle} > ${currentHeading}` : currentHeading,
-						heading: currentHeading,
-						content,
-						sourceFile,
-						sectionIndex
-					});
-					sectionIndex++;
-				}
-			}
-			currentHeading = line.slice(3).trim();
-			currentLines = [];
-			continue;
-		}
-		if (currentHeading) currentLines.push(line);
-	}
-	if (currentHeading) {
-		const content = currentLines.join("\n").trim();
-		if (content.length > 0) sections.push({
-			title: docTitle ? `${docTitle} > ${currentHeading}` : currentHeading,
-			heading: currentHeading,
-			content,
-			sourceFile,
-			sectionIndex
-		});
-	}
-	return sections;
-}
-
-//#endregion
-//#region src/ingestion/knowledge-ingester.ts
-/**
-* Ingests markdown files into the knowledge store.
-*
-* Creates one observation per ## section, with idempotent re-ingestion
-* that cleans up stale sections without duplication.
-*/
-var KnowledgeIngester = class {
-	db;
-	projectHash;
-	constructor(db, projectHash) {
-		this.db = db;
-		this.projectHash = projectHash;
-	}
-	/**
-	* Detects the knowledge directory for a project.
-	* Checks in order:
-	* 1. {projectRoot}/.planning/codebase/ (GSD output)
-	* 2. {projectRoot}/.laminark/codebase/
-	* Returns the first existing directory, or null if none exist.
-	*/
-	static detectKnowledgeDir(projectRoot) {
-		const candidates = [join(projectRoot, ".planning", "codebase"), join(projectRoot, ".laminark", "codebase")];
-		for (const candidate of candidates) try {
-			if (existsSync(candidate) && statSync(candidate).isDirectory()) return candidate;
-		} catch {}
-		return null;
-	}
-	/**
-	* Ingests all markdown files from a directory.
-	* Reads all files async first, then runs DB operations in a single transaction.
-	*/
-	async ingestDirectory(dirPath) {
-		let files;
-		try {
-			files = await readdir(dirPath);
-		} catch {
-			return {
-				filesProcessed: 0,
-				sectionsCreated: 0,
-				sectionsRemoved: 0
-			};
-		}
-		const mdFiles = files.filter((f) => f.endsWith(".md"));
-		const fileContents = /* @__PURE__ */ new Map();
-		for (const file of mdFiles) {
-			const filePath = join(dirPath, file);
-			try {
-				const content = await readFile(filePath, "utf-8");
-				fileContents.set(file, content);
-			} catch {}
-		}
-		let totalCreated = 0;
-		let totalRemoved = 0;
-		for (const [filename, content] of fileContents) {
-			const stats = this.ingestFileSync(filename, content);
-			totalCreated += stats.sectionsCreated;
-			totalRemoved += stats.sectionsRemoved;
-		}
-		return {
-			filesProcessed: fileContents.size,
-			sectionsCreated: totalCreated,
-			sectionsRemoved: totalRemoved
-		};
-	}
-	/**
-	* Ingests a single markdown file.
-	* Wraps async file reading with sync ingestion.
-	*/
-	async ingestFile(filePath) {
-		try {
-			const content = await readFile(filePath, "utf-8");
-			const filename = basename(filePath);
-			return this.ingestFileSync(filename, content);
-		} catch {
-			return {
-				filesProcessed: 0,
-				sectionsCreated: 0,
-				sectionsRemoved: 0
-			};
-		}
-	}
-	/**
-	* Internal sync ingestion method (runs within transaction).
-	* Implements idempotent upsert via soft-delete + recreate.
-	*/
-	ingestFileSync(filename, fileContent) {
-		const sourceTag = `ingest:${filename}`;
-		const sections = parseMarkdownSections(fileContent, filename);
-		return this.db.transaction(() => {
-			const repo = new ObservationRepository(this.db, this.projectHash);
-			const sectionsRemoved = this.db.prepare(`UPDATE observations
-           SET deleted_at = datetime('now'), updated_at = datetime('now')
-           WHERE project_hash = ? AND source = ? AND deleted_at IS NULL`).run(this.projectHash, sourceTag).changes;
-			let sectionsCreated = 0;
-			for (const section of sections) {
-				repo.createClassified({
-					content: section.content,
-					title: section.title,
-					source: sourceTag,
-					kind: "reference",
-					sessionId: null
-				}, "discovery");
-				sectionsCreated++;
-			}
-			return {
-				filesProcessed: 1,
-				sectionsCreated,
-				sectionsRemoved
-			};
-		})();
-	}
-};
-
-//#endregion
-//#region src/mcp/tools/ingest-knowledge.ts
-/**
-* Registers the ingest_knowledge tool on the MCP server.
-*
-* ingest_knowledge transforms structured markdown documents into per-project
-* reference observations. Supports optional directory path; auto-detects
-* .planning/codebase/ or .laminark/codebase/ from project metadata when
-* directory is omitted.
-*/
-function registerIngestKnowledge(server, db, projectHashRef, notificationStore = null, statusCache = null) {
-	server.registerTool("ingest_knowledge", {
-		title: "Ingest Knowledge",
-		description: "Ingest structured markdown documents from a directory into queryable per-project memories. Reads .md files, splits by ## headings, and stores each section as a reference observation. Supports .planning/codebase/ (GSD output) and .laminark/codebase/.",
-		inputSchema: { directory: z.string().optional().describe("Directory containing .md files to ingest. If omitted, auto-detects .planning/codebase/ or .laminark/codebase/ using the project path from project_metadata.") }
-	}, async (args) => {
-		const projectHash = projectHashRef.current;
-		try {
-			let resolvedDir = args.directory;
-			if (!resolvedDir) {
-				const row = db.prepare("SELECT project_path FROM project_metadata WHERE project_hash = ? ORDER BY last_seen_at DESC LIMIT 1").get(projectHash);
-				if (!row) return {
-					content: [{
-						type: "text",
-						text: "Could not determine project path. Please provide the directory parameter explicitly."
-					}],
-					isError: true
-				};
-				const detected = KnowledgeIngester.detectKnowledgeDir(row.project_path);
-				if (!detected) return {
-					content: [{
-						type: "text",
-						text: "No knowledge directory found. Expected .planning/codebase/ or .laminark/codebase/ in the project root. Run /gsd:map-codebase first or provide a directory path."
-					}],
-					isError: true
-				};
-				resolvedDir = detected;
-			}
-			const stats = await new KnowledgeIngester(db, projectHash).ingestDirectory(resolvedDir);
-			debug("mcp", "ingest_knowledge: completed", {
-				directory: resolvedDir,
-				stats
-			});
-			statusCache?.markDirty();
-			let finalResponse = verboseResponse(`Ingested ${stats.filesProcessed} files: ${stats.sectionsCreated} sections created, ${stats.sectionsRemoved} stale sections removed.`, `Ingested ${stats.filesProcessed} file(s): ${stats.sectionsCreated} sections created, ${stats.sectionsRemoved} removed.`, `Ingested ${stats.filesProcessed} file(s) from ${resolvedDir}: ${stats.sectionsCreated} sections created, ${stats.sectionsRemoved} stale sections removed.`);
-			if (notificationStore) {
-				const pending = notificationStore.consumePending(projectHash);
-				if (pending.length > 0) finalResponse = pending.map((n) => `[Laminark] ${n.message}`).join("\n") + "\n\n" + finalResponse;
-			}
-			return { content: [{
-				type: "text",
-				text: finalResponse
-			}] };
-		} catch (err) {
-			return {
-				content: [{
-					type: "text",
-					text: `Failed to ingest knowledge: ${err instanceof Error ? err.message : "Unknown error"}`
-				}],
-				isError: true
-			};
-		}
-	});
-}
-
 //#endregion
 //#region src/commands/resume.ts
 /**
@@ -1189,13 +785,13 @@ function formatStashes(stashes) {
 	if (stashes.length <= 8) return formatDetail(stashes);
 	return formatCompact(stashes);
 }
-function prependNotifications$7(notificationStore, projectHash, responseText) {
+function prependNotifications$5(notificationStore, projectHash, responseText) {
 	if (!notificationStore) return responseText;
 	const pending = notificationStore.consumePending(projectHash);
 	if (pending.length === 0) return responseText;
 	return pending.map((n) => `[Laminark] ${n.message}`).join("\n") + "\n\n" + responseText;
 }
-function textResponse$8(text) {
+function textResponse$6(text) {
 	return { content: [{
 		type: "text",
 		text
@@ -1207,7 +803,7 @@ function textResponse$8(text) {
 * Shows recently stashed context threads. Used when the user asks
 * "where was I?" or wants to see abandoned conversation threads.
 */
-function registerTopicContext(server, db, projectHashRef, notificationStore = null) {
+function registerTopicContext(server, db, projectHash, notificationStore = null) {
 	const stashManager = new StashManager(db);
 	server.registerTool("topic_context", {
 		title: "Topic Context",
@@ -1217,8 +813,7 @@ function registerTopicContext(server, db, projectHashRef, notificationStore = nu
 			limit: z.number().int().min(1).max(20).default(5).describe("Max threads to return")
 		}
 	}, async (args) => {
-		const projectHash = projectHashRef.current;
-		const withNotifications = (text) => textResponse$8(prependNotifications$7(notificationStore, projectHash, text));
+		const withNotifications = (text) => textResponse$6(prependNotifications$5(notificationStore, projectHash, text));
 		try {
 			debug("mcp", "topic_context: request", {
 				query: args.query,
@@ -1230,9 +825,6 @@ function registerTopicContext(server, db, projectHashRef, notificationStore = nu
 				stashes = stashes.filter((s) => s.topicLabel.toLowerCase().includes(q) || s.summary.toLowerCase().includes(q));
 			}
 			if (stashes.length === 0) return withNotifications("No stashed context threads found. You're working in a single thread.");
-			const verbosity = loadToolVerbosityConfig().level;
-			if (verbosity === 1) return withNotifications(`${stashes.length} stashed thread(s)`);
-			if (verbosity === 2) return withNotifications(stashes.map((s, i) => `${i + 1}. ${s.topicLabel} (${timeAgo(s.createdAt)})`).join("\n"));
 			const formatted = formatStashes(stashes);
 			const footer = `\n---\n${stashes.length} stashed thread(s) | Use /laminark:resume {id} to restore`;
 			debug("mcp", "topic_context: returning", { count: stashes.length });
@@ -1240,7 +832,7 @@ function registerTopicContext(server, db, projectHashRef, notificationStore = nu
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "topic_context: error", { error: message });
-			return textResponse$8(`Error retrieving context threads: ${message}`);
+			return textResponse$6(`Error retrieving context threads: ${message}`);
 		}
 	});
 }
@@ -1345,19 +937,19 @@ function formatAge(isoDate) {
 	const months = Math.floor(days / 30);
 	return `${months} month${months !== 1 ? "s" : ""} ago`;
 }
-function prependNotifications$6(notificationStore, projectHash, responseText) {
+function prependNotifications$4(notificationStore, projectHash, responseText) {
 	if (!notificationStore) return responseText;
 	const pending = notificationStore.consumePending(projectHash);
 	if (pending.length === 0) return responseText;
 	return pending.map((n) => `[Laminark] ${n.message}`).join("\n") + "\n\n" + responseText;
 }
-function textResponse$7(text) {
+function textResponse$5(text) {
 	return { content: [{
 		type: "text",
 		text
 	}] };
 }
-function errorResponse$3(text) {
+function errorResponse$2(text) {
 	return {
 		content: [{
 			type: "text",
@@ -1372,7 +964,7 @@ function errorResponse$3(text) {
 * Allows Claude to search entities by name (exact or fuzzy), filter by type,
 * traverse relationships to configurable depth, and see linked observations.
 */
-function registerQueryGraph(server, db, projectHashRef, notificationStore = null) {
+function registerQueryGraph(server, db, projectHash, notificationStore = null) {
 	initGraphSchema(db);
 	server.registerTool("query_graph", {
 		title: "Query Knowledge Graph",
@@ -1385,18 +977,17 @@ function registerQueryGraph(server, db, projectHashRef, notificationStore = null
 			limit: z.number().int().min(1).max(50).default(20).describe("Max root entities to return (default: 20, max: 50)")
 		}
 	}, async (args) => {
-		const projectHash = projectHashRef.current;
-		const withNotifications = (text) => textResponse$7(prependNotifications$6(notificationStore, projectHash, text));
+		const withNotifications = (text) => textResponse$5(prependNotifications$4(notificationStore, projectHash, text));
 		try {
 			debug("mcp", "query_graph: request", {
 				query: args.query,
 				entity_type: args.entity_type,
 				depth: args.depth
 			});
-			if (args.entity_type !== void 0 && !isEntityType(args.entity_type)) return errorResponse$3(`Invalid entity_type "${args.entity_type}". Valid types: ${ENTITY_TYPES.join(", ")}`);
+			if (args.entity_type !== void 0 && !isEntityType(args.entity_type)) return errorResponse$2(`Invalid entity_type "${args.entity_type}". Valid types: ${ENTITY_TYPES.join(", ")}`);
 			const entityType = args.entity_type;
 			if (args.relationship_types) {
-				for (const rt of args.relationship_types) if (!isRelationshipType(rt)) return errorResponse$3(`Invalid relationship_type "${rt}". Valid types: ${RELATIONSHIP_TYPES.join(", ")}`);
+				for (const rt of args.relationship_types) if (!isRelationshipType(rt)) return errorResponse$2(`Invalid relationship_type "${rt}". Valid types: ${RELATIONSHIP_TYPES.join(", ")}`);
 			}
 			const relationshipTypes = args.relationship_types;
 			const rootNodes = [];
@@ -1457,21 +1048,6 @@ function registerQueryGraph(server, db, projectHashRef, notificationStore = null
 					createdAt: row.created_at
 				});
 			}
-			const verbosity = loadToolVerbosityConfig().level;
-			if (verbosity === 1) {
-				const totalTraversals = [...traversalsByNode.values()].reduce((sum, arr) => sum + arr.length, 0);
-				return withNotifications(`${rootNodes.length} entities, ${totalTraversals} connections found`);
-			}
-			if (verbosity === 2) {
-				const lines = [];
-				lines.push("## Entities Found");
-				lines.push("");
-				for (const node of rootNodes) {
-					const traversals = traversalsByNode.get(node.id) ?? [];
-					lines.push(`- ${formatEntityType(node.type)} ${node.name} (${traversals.length} connections)`);
-				}
-				return withNotifications(lines.join("\n"));
-			}
 			const formatted = formatResults(rootNodes, traversalsByNode, observations, args.query);
 			debug("mcp", "query_graph: returning", {
 				rootNodes: rootNodes.length,
@@ -1482,11 +1058,180 @@ function registerQueryGraph(server, db, projectHashRef, notificationStore = null
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "query_graph: error", { error: message });
-			return errorResponse$3(`Graph query error: ${message}`);
+			return errorResponse$2(`Graph query error: ${message}`);
 		}
 	});
 }
 
+//#endregion
+//#region src/graph/staleness.ts
+/**
+* Negation patterns: newer observation negates older one.
+* Matches when newer text contains negation keywords absent in older text
+* and both discuss similar subjects.
+*/
+const NEGATION_KEYWORDS = [
+	"not",
+	"don't",
+	"no longer",
+	"stopped",
+	"never",
+	"doesn't",
+	"won't",
+	"isn't",
+	"aren't",
+	"discontinued"
+];
+/**
+* Replacement patterns: newer observation explicitly replaces older approach.
+*/
+const REPLACEMENT_PATTERNS = [
+	/switched\s+(?:from\s+\S+\s+)?to\b/i,
+	/migrated\s+(?:from\s+\S+\s+)?to\b/i,
+	/replaced\s+(?:\S+\s+)?with\b/i,
+	/changed\s+from\b/i,
+	/moved\s+(?:from\s+\S+\s+)?to\b/i,
+	/upgraded\s+(?:from\s+\S+\s+)?to\b/i,
+	/swapped\s+(?:\S+\s+)?(?:for|with)\b/i
+];
+/**
+* Status change patterns: newer observation marks something as inactive.
+*/
+const STATUS_CHANGE_KEYWORDS = [
+	"removed",
+	"deleted",
+	"deprecated",
+	"archived",
+	"dropped",
+	"disabled",
+	"decommissioned",
+	"sunset",
+	"abandoned"
+];
+/**
+* Creates the staleness_flags table if it doesn't exist.
+* Uses a separate table rather than modifying the observations table,
+* keeping staleness metadata decoupled from core observation storage.
+*/
+function initStalenessSchema(db) {
+	db.exec(`
+    CREATE TABLE IF NOT EXISTS staleness_flags (
+      observation_id TEXT PRIMARY KEY,
+      flagged_at TEXT NOT NULL DEFAULT (datetime('now')),
+      reason TEXT NOT NULL,
+      resolved INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_staleness_resolved ON staleness_flags(resolved);
+  `);
+}
+/**
+* Detects potential staleness (contradictions) between observations
+* linked to a specific entity.
+*
+* Compares consecutive observation pairs chronologically and checks for:
+* 1. Negation patterns (newer negates older)
+* 2. Replacement patterns (newer replaces older approach)
+* 3. Status change patterns (newer marks something as inactive)
+*
+* This is DETECTION ONLY -- no data is modified.
+*
+* @param db - better-sqlite3 Database handle
+* @param entityId - Graph node ID to check observations for
+* @returns Array of StalenessReport for each detected contradiction
+*/
+function detectStaleness(db, entityId) {
+	const node = db.prepare("SELECT id, name, type, observation_ids FROM graph_nodes WHERE id = ?").get(entityId);
+	if (!node) return [];
+	const obsIds = JSON.parse(node.observation_ids);
+	if (obsIds.length < 2) return [];
+	const placeholders = obsIds.map(() => "?").join(", ");
+	const observations = db.prepare(`SELECT * FROM observations WHERE id IN (${placeholders}) AND deleted_at IS NULL ORDER BY created_at ASC`).all(...obsIds).map(rowToObservation);
+	if (observations.length < 2) return [];
+	const reports = [];
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	for (let i = 0; i < observations.length - 1; i++) {
+		const older = observations[i];
+		const newer = observations[i + 1];
+		const reason = detectContradiction(older.content, newer.content);
+		if (reason) reports.push({
+			entityId: node.id,
+			entityName: node.name,
+			entityType: node.type,
+			newerObservation: {
+				id: newer.id,
+				text: newer.content,
+				created_at: newer.createdAt
+			},
+			olderObservation: {
+				id: older.id,
+				text: older.content,
+				created_at: older.createdAt
+			},
+			reason,
+			detectedAt: now
+		});
+	}
+	return reports;
+}
+/**
+* Detects contradiction between two observation texts.
+* Returns a human-readable reason string, or null if no contradiction found.
+*/
+function detectContradiction(olderText, newerText) {
+	const olderLower = olderText.toLowerCase();
+	const newerLower = newerText.toLowerCase();
+	const negationResult = detectNegation(olderLower, newerLower);
+	if (negationResult) return negationResult;
+	const replacementResult = detectReplacement(newerLower);
+	if (replacementResult) return replacementResult;
+	const statusResult = detectStatusChange(olderLower, newerLower);
+	if (statusResult) return statusResult;
+	return null;
+}
+/**
+* Detects negation: newer text contains negation keywords that are absent
+* in the older text, suggesting the newer observation contradicts the older.
+*/
+function detectNegation(olderLower, newerLower) {
+	for (const keyword of NEGATION_KEYWORDS) if (newerLower.includes(keyword) && !olderLower.includes(keyword)) return `Newer observation contains negation ("${keyword}") not present in older observation`;
+	return null;
+}
+/**
+* Detects replacement: newer text explicitly mentions switching/replacing.
+*/
+function detectReplacement(newerLower) {
+	for (const pattern of REPLACEMENT_PATTERNS) {
+		const match = newerLower.match(pattern);
+		if (match) return `Newer observation indicates replacement ("${match[0].trim()}")`;
+	}
+	return null;
+}
+/**
+* Detects status change: newer text marks something as removed/deprecated
+* when the older text described it as active/present.
+*/
+function detectStatusChange(olderLower, newerLower) {
+	for (const keyword of STATUS_CHANGE_KEYWORDS) if (newerLower.includes(keyword) && !olderLower.includes(keyword)) return `Newer observation indicates status change ("${keyword}")`;
+	return null;
+}
+/**
+* Flags an observation as stale with an advisory reason.
+*
+* This flag is advisory -- search can use it to deprioritize but never hide
+* the observation. The observation remains fully queryable.
+*
+* Uses INSERT OR REPLACE to allow re-flagging with an updated reason.
+*
+* @param db - better-sqlite3 Database handle
+* @param observationId - ID of the observation to flag
+* @param reason - Human-readable explanation of why it's stale
+*/
+function flagStaleObservation(db, observationId, reason) {
+	initStalenessSchema(db);
+	db.prepare(`INSERT OR REPLACE INTO staleness_flags (observation_id, reason, resolved)
+     VALUES (?, ?, 0)`).run(observationId, reason);
+}
+
 //#endregion
 //#region src/mcp/tools/graph-stats.ts
 /**
@@ -1584,13 +1329,13 @@ function formatStats(stats) {
 	}
 	return lines.join("\n");
 }
-function prependNotifications$5(notificationStore, projectHash, responseText) {
+function prependNotifications$3(notificationStore, projectHash, responseText) {
 	if (!notificationStore) return responseText;
 	const pending = notificationStore.consumePending(projectHash);
 	if (pending.length === 0) return responseText;
 	return pending.map((n) => `[Laminark] ${n.message}`).join("\n") + "\n\n" + responseText;
 }
-function textResponse$6(text) {
+function textResponse$4(text) {
 	return { content: [{
 		type: "text",
 		text
@@ -1603,14 +1348,13 @@ function textResponse$6(text) {
 * type distribution, degree statistics, hotspot nodes, duplicate candidates,
 * and staleness flags. No input parameters -- dashboard view.
 */
-function registerGraphStats(server, db, projectHashRef, notificationStore = null) {
+function registerGraphStats(server, db, projectHash, notificationStore = null) {
 	initGraphSchema(db);
 	server.registerTool("graph_stats", {
 		title: "Graph Statistics",
 		description: "Get knowledge graph statistics: entity counts, relationship distribution, health metrics. Use to understand the state of accumulated knowledge.",
 		inputSchema: {}
 	}, async () => {
-		const projectHash = projectHashRef.current;
 		try {
 			debug("mcp", "graph_stats: request");
 			const stats = collectGraphStats(db);
@@ -1619,162 +1363,42 @@ function registerGraphStats(server, db, projectHashRef, notificationStore = null
 				nodes: stats.total_nodes,
 				edges: stats.total_edges
 			});
-			return textResponse$6(prependNotifications$5(notificationStore, projectHash, formatted));
+			return textResponse$4(prependNotifications$3(notificationStore, projectHash, formatted));
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "graph_stats: error", { error: message });
-			return textResponse$6(`Graph stats error: ${message}`);
+			return textResponse$4(`Graph stats error: ${message}`);
 		}
 	});
 }
 
 //#endregion
-//#region src/mcp/tools/hygiene.ts
-function formatReport(report, mode, tier) {
-	const lines = [];
-	lines.push("## Database Hygiene Report");
-	lines.push(`Analyzed ${report.totalObservations.toLocaleString()} observations`);
-	lines.push("");
-	lines.push("### Summary");
-	lines.push("| Tier | Count | Action |");
-	lines.push("|------|-------|--------|");
-	lines.push(`| High (>= 0.7) | ${report.summary.high} | Safe to purge |`);
-	lines.push(`| Medium (0.5-0.69) | ${report.summary.medium} | Review recommended |`);
-	if (report.summary.low > 0) lines.push(`| Low (< 0.5) | ${report.summary.low} | Kept |`);
-	lines.push(`| Orphan graph nodes | ${report.summary.orphanNodeCount} | Dead references |`);
-	lines.push("");
-	if (report.candidates.length === 0) {
-		lines.push("No candidates found matching the selected tier.");
-		return lines.join("\n");
-	}
-	const bySession = /* @__PURE__ */ new Map();
-	for (const c of report.candidates) {
-		const key = c.sessionId ?? "(no session)";
-		const list = bySession.get(key) ?? [];
-		list.push(c);
-		bySession.set(key, list);
-	}
-	const tierLabel = tier === "all" ? "All" : tier === "medium" ? "Medium+" : "High";
-	lines.push(`### ${tierLabel} Confidence Candidates (showing ${report.candidates.length})`);
-	lines.push("");
-	for (const [sessionId, candidates] of bySession) {
-		const sessionDate = candidates[0]?.createdAt?.substring(0, 10) ?? "";
-		lines.push(`#### Session: ${sessionId.substring(0, 8)} (${sessionDate}, ${candidates.length} obs)`);
-		lines.push("| ID | Kind | Source | Confidence | Signals | Preview |");
-		lines.push("|----|------|--------|------------|---------|---------|");
-		for (const c of candidates) {
-			const signals = [];
-			if (c.signals.orphaned) signals.push("orphaned");
-			if (c.signals.islandNode) signals.push("island");
-			if (c.signals.noiseClassified) signals.push("noise");
-			if (c.signals.shortContent) signals.push("short");
-			if (c.signals.autoCaptured) signals.push("auto");
-			if (c.signals.stale) signals.push("stale");
-			const preview = c.contentPreview.replace(/\|/g, "\\|").replace(/\n/g, " ");
-			lines.push(`| ${c.shortId} | ${c.kind} | ${c.source} | ${c.confidence.toFixed(2)} | ${signals.join(",") || "-"} | ${preview} |`);
-		}
-		lines.push("");
-	}
-	if (mode === "simulate") lines.push(`_Dry run — no data modified. Use \`hygiene(mode="purge", tier="${tier}")\` to execute._`);
-	return lines.join("\n");
-}
-function formatPurgeResult(observationsPurged, orphanNodesRemoved, tier) {
-	const lines = [];
-	lines.push("## Hygiene Purge Complete");
-	lines.push(`- Tier: ${tier}`);
-	lines.push(`- Observations soft-deleted: ${observationsPurged}`);
-	lines.push(`- Orphan graph nodes removed: ${orphanNodesRemoved}`);
-	return lines.join("\n");
-}
-function prependNotifications$4(notificationStore, projectHash, responseText) {
+//#region src/mcp/tools/status.ts
+function prependNotifications$2(notificationStore, projectHash, responseText) {
 	if (!notificationStore) return responseText;
 	const pending = notificationStore.consumePending(projectHash);
 	if (pending.length === 0) return responseText;
 	return pending.map((n) => `[Laminark] ${n.message}`).join("\n") + "\n\n" + responseText;
 }
-function textResponse$5(text) {
+function textResponse$3(text) {
 	return { content: [{
 		type: "text",
 		text
 	}] };
 }
-function registerHygiene(server, db, projectHashRef, notificationStore = null) {
-	server.registerTool("hygiene", {
-		title: "Database Hygiene",
-		description: "Analyze observations for deletion candidates with confidence scoring. Simulate mode (default) produces a dry-run report. Purge mode soft-deletes candidates and removes dead orphan graph nodes.",
-		inputSchema: {
-			mode: z.enum(["simulate", "purge"]).default("simulate").describe("simulate = dry-run report, purge = execute deletions"),
-			tier: z.enum([
-				"high",
-				"medium",
-				"all"
-			]).default("high").describe("Which confidence tier to act on"),
-			session_id: z.string().optional().describe("Optional: scope analysis to a single session"),
-			limit: z.number().int().min(1).max(200).default(50).describe("Max results to return")
-		}
-	}, async (args) => {
-		const projectHash = projectHashRef.current;
+function registerStatus(server, cache, projectHash, notificationStore = null) {
+	server.registerTool("status", {
+		title: "Laminark Status",
+		description: "Show Laminark system status: connection info, memory count, token estimates, and capabilities.",
+		inputSchema: {}
+	}, async () => {
 		try {
-			const mode = args.mode ?? "simulate";
-			const tier = args.tier ?? "high";
-			const sessionId = args.session_id;
-			const limit = args.limit ?? 50;
-			debug("hygiene", "Request", {
-				mode,
-				tier,
-				sessionId,
-				limit
-			});
-			const report = analyzeObservations(db, projectHash, {
-				sessionId,
-				limit,
-				minTier: tier === "all" ? "low" : tier
-			});
-			if (mode === "purge") {
-				const result = executePurge(db, projectHash, report, tier);
-				return textResponse$5(prependNotifications$4(notificationStore, projectHash, formatPurgeResult(result.observationsPurged, result.orphanNodesRemoved, tier)));
-			}
-			return textResponse$5(prependNotifications$4(notificationStore, projectHash, formatReport(report, mode, tier)));
+			debug("mcp", "status: request (cached)");
+			return textResponse$3(prependNotifications$2(notificationStore, projectHash, cache.getFormatted()));
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
-			debug("hygiene", "Error", { error: message });
-			return textResponse$5(`Hygiene analysis error: ${message}`);
-		}
-	});
-}
-
-//#endregion
-//#region src/mcp/tools/status.ts
-function prependNotifications$3(notificationStore, projectHash, responseText) {
-	if (!notificationStore) return responseText;
-	const pending = notificationStore.consumePending(projectHash);
-	if (pending.length === 0) return responseText;
-	return pending.map((n) => `[Laminark] ${n.message}`).join("\n") + "\n\n" + responseText;
-}
-function textResponse$4(text) {
-	return { content: [{
-		type: "text",
-		text
-	}] };
-}
-function registerStatus(server, cache, projectHashRef, notificationStore = null) {
-	server.registerTool("status", {
-		title: "Laminark Status",
-		description: "Show Laminark system status: connection info, memory count, token estimates, and capabilities.",
-		inputSchema: {}
-	}, async () => {
-		const projectHash = projectHashRef.current;
-		try {
-			debug("mcp", "status: request (cached)");
-			const verbosity = loadToolVerbosityConfig().level;
-			if (verbosity === 1) return textResponse$4(prependNotifications$3(notificationStore, projectHash, "Laminark: connected"));
-			const formatted = cache.getFormatted();
-			if (verbosity === 2) return textResponse$4(prependNotifications$3(notificationStore, projectHash, formatted.split("\n").slice(0, 8).join("\n")));
-			return textResponse$4(prependNotifications$3(notificationStore, projectHash, formatted));
-		} catch (err) {
-			const message = err instanceof Error ? err.message : "Unknown error";
-			debug("mcp", "status: error", { error: message });
-			return textResponse$4(`Status error: ${message}`);
+			debug("mcp", "status: error", { error: message });
+			return textResponse$3(`Status error: ${message}`);
 		}
 	});
 }
@@ -1791,7 +1415,7 @@ function formatUptime(seconds) {
 }
 var StatusCache = class {
 	db;
-	projectHashRef;
+	projectHash;
 	projectPath;
 	hasVectorSupport;
 	isWorkerReady;
@@ -1800,9 +1424,9 @@ var StatusCache = class {
 	/** Uptime snapshot at the time cachedBody was built. */
 	builtAtUptime = 0;
 	dirty = false;
-	constructor(db, projectHashRef, projectPath, hasVectorSupport, isWorkerReady) {
+	constructor(db, projectHash, projectPath, hasVectorSupport, isWorkerReady) {
 		this.db = db;
-		this.projectHashRef = projectHashRef;
+		this.projectHash = projectHash;
 		this.projectPath = projectPath;
 		this.hasVectorSupport = hasVectorSupport;
 		this.isWorkerReady = isWorkerReady;
@@ -1829,7 +1453,7 @@ var StatusCache = class {
 	}
 	rebuild() {
 		try {
-			const ph = this.projectHashRef.current;
+			const ph = this.projectHash;
 			const totalObs = this.db.prepare("SELECT COUNT(*) as cnt FROM observations WHERE project_hash = ? AND deleted_at IS NULL").get(ph).cnt;
 			const embeddedObs = this.db.prepare("SELECT COUNT(*) as cnt FROM observations WHERE project_hash = ? AND deleted_at IS NULL AND embedding_model IS NOT NULL").get(ph).cnt;
 			const deletedObs = this.db.prepare("SELECT COUNT(*) as cnt FROM observations WHERE project_hash = ? AND deleted_at IS NOT NULL").get(ph).cnt;
@@ -1885,13 +1509,13 @@ var StatusCache = class {
 
 //#endregion
 //#region src/mcp/tools/discover-tools.ts
-function textResponse$3(text) {
+function textResponse$2(text) {
 	return { content: [{
 		type: "text",
 		text
 	}] };
 }
-function errorResponse$2(text) {
+function errorResponse$1(text) {
 	return {
 		content: [{
 			type: "text",
@@ -1900,7 +1524,7 @@ function errorResponse$2(text) {
 		isError: true
 	};
 }
-function prependNotifications$2(notificationStore, projectHash, responseText) {
+function prependNotifications$1(notificationStore, projectHash, responseText) {
 	if (!notificationStore) return responseText;
 	const pending = notificationStore.consumePending(projectHash);
 	if (pending.length === 0) return responseText;
@@ -1921,7 +1545,7 @@ function formatToolResult(result, index) {
 * with optional scope filtering. Returns ranked results with scope, usage count,
 * and last used timestamp metadata.
 */
-function registerDiscoverTools(server, toolRegistry, worker, hasVectorSupport, notificationStore, projectHashRef) {
+function registerDiscoverTools(server, toolRegistry, worker, hasVectorSupport, notificationStore, projectHash) {
 	server.registerTool("discover_tools", {
 		title: "Discover Tools",
 		description: "Search the tool registry to find available tools by keyword or description. Supports semantic search -- \"file manipulation\" finds tools described as \"read and write files\". Returns scope, usage count, and last used timestamp for each result.",
@@ -1935,8 +1559,7 @@ function registerDiscoverTools(server, toolRegistry, worker, hasVectorSupport, n
 			limit: z.number().int().min(1).max(50).default(20).describe("Maximum results to return (default: 20)")
 		}
 	}, async (args) => {
-		const projectHash = projectHashRef.current;
-		const withNotifications = (text) => textResponse$3(prependNotifications$2(notificationStore, projectHash, text));
+		const withNotifications = (text) => textResponse$2(prependNotifications$1(notificationStore, projectHash, text));
 		try {
 			debug("mcp", "discover_tools: request", {
 				query: args.query,
@@ -1974,14 +1597,14 @@ function registerDiscoverTools(server, toolRegistry, worker, hasVectorSupport, n
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "discover_tools: error", { error: message });
-			return errorResponse$2(`Discover tools error: ${message}`);
+			return errorResponse$1(`Discover tools error: ${message}`);
 		}
 	});
 }
 
 //#endregion
 //#region src/mcp/tools/report-tools.ts
-function textResponse$2(text) {
+function textResponse$1(text) {
 	return { content: [{
 		type: "text",
 		text
@@ -1994,7 +1617,7 @@ function textResponse$2(text) {
 * each into the tool registry. Tool type, scope, and server name are inferred
 * from the tool name using the same parser as PostToolUse organic discovery.
 */
-function registerReportTools(server, toolRegistry, projectHashRef) {
+function registerReportTools(server, toolRegistry, projectHash) {
 	server.registerTool("report_available_tools", {
 		title: "Report Available Tools",
 		description: "Register all tools available in this session with Laminark. Call this once at session start with every tool name you have access to (built-in and MCP). This populates the tool registry for discovery and routing.",
@@ -2003,7 +1626,6 @@ function registerReportTools(server, toolRegistry, projectHashRef) {
 			description: z.string().optional().describe("Brief description of the tool")
 		})).min(1).describe("Array of tools available in this session") }
 	}, async (args) => {
-		const projectHash = projectHashRef.current;
 		try {
 			let registered = 0;
 			let skipped = 0;
@@ -2031,7 +1653,7 @@ function registerReportTools(server, toolRegistry, projectHashRef) {
 				registered,
 				skipped
 			});
-			return textResponse$2(`Registered ${registered} tools in the tool registry.${skipped > 0 ? ` Skipped ${skipped} Laminark tools (already known).` : ""}`);
+			return textResponse$1(`Registered ${registered} tools in the tool registry.${skipped > 0 ? ` Skipped ${skipped} Laminark tools (already known).` : ""}`);
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "report_available_tools: error", { error: message });
@@ -2048,19 +1670,19 @@ function registerReportTools(server, toolRegistry, projectHashRef) {
 
 //#endregion
 //#region src/mcp/tools/debug-paths.ts
-function prependNotifications$1(notificationStore, projectHash, responseText) {
+function prependNotifications(notificationStore, projectHash, responseText) {
 	if (!notificationStore) return responseText;
 	const pending = notificationStore.consumePending(projectHash);
 	if (pending.length === 0) return responseText;
 	return pending.map((n) => `[Laminark] ${n.message}`).join("\n") + "\n\n" + responseText;
 }
-function textResponse$1(text) {
+function textResponse(text) {
 	return { content: [{
 		type: "text",
 		text
 	}] };
 }
-function errorResponse$1(text) {
+function errorResponse(text) {
 	return {
 		content: [{
 			type: "text",
@@ -2090,25 +1712,24 @@ function formatKissSummary(raw) {
 *
 * Tools: path_start, path_resolve, path_show, path_list
 */
-function registerDebugPathTools(server, pathRepo, pathTracker, notificationStore, projectHashRef) {
+function registerDebugPathTools(server, pathRepo, pathTracker, notificationStore, projectHash) {
 	server.registerTool("path_start", {
 		title: "Start Debug Path",
 		description: "Explicitly start tracking a debug path. Use when auto-detection hasn't triggered but you're actively debugging.",
 		inputSchema: { trigger: z.string().describe("Brief description of the issue being debugged") }
 	}, async (args) => {
-		const projectHash = projectHashRef.current;
-		const withNotifications = (text) => textResponse$1(prependNotifications$1(notificationStore, projectHash, text));
+		const withNotifications = (text) => textResponse(prependNotifications(notificationStore, projectHash, text));
 		try {
 			debug("mcp", "path_start: request", { trigger: args.trigger });
 			const existingPathId = pathTracker.getActivePathId();
 			const pathId = pathTracker.startManually(args.trigger);
-			if (!pathId) return errorResponse$1("Failed to start debug path");
+			if (!pathId) return errorResponse("Failed to start debug path");
 			if (existingPathId && existingPathId === pathId) return withNotifications(`Debug path already active: ${pathId}`);
-			return withNotifications(verboseResponse("Debug path started.", `Debug path started: ${pathId}`, `Debug path started: ${pathId}\nTracking: ${args.trigger}`));
+			return withNotifications(`Debug path started: ${pathId}\nTracking: ${args.trigger}`);
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "path_start: error", { error: message });
-			return errorResponse$1(`path_start error: ${message}`);
+			return errorResponse(`path_start error: ${message}`);
 		}
 	});
 	server.registerTool("path_resolve", {
@@ -2116,18 +1737,17 @@ function registerDebugPathTools(server, pathRepo, pathTracker, notificationStore
 		description: "Explicitly resolve the active debug path with a resolution summary. Use when auto-detection hasn't detected resolution.",
 		inputSchema: { resolution: z.string().describe("What fixed the issue") }
 	}, async (args) => {
-		const projectHash = projectHashRef.current;
-		const withNotifications = (text) => textResponse$1(prependNotifications$1(notificationStore, projectHash, text));
+		const withNotifications = (text) => textResponse(prependNotifications(notificationStore, projectHash, text));
 		try {
 			debug("mcp", "path_resolve: request", { resolution: args.resolution });
 			const pathId = pathTracker.getActivePathId();
-			if (!pathId) return errorResponse$1("No active debug path to resolve");
+			if (!pathId) return errorResponse("No active debug path to resolve");
 			pathTracker.resolveManually(args.resolution);
-			return withNotifications(verboseResponse("Debug path resolved.", `Debug path resolved: ${pathId}`, `Debug path resolved: ${pathId}\nResolution: ${args.resolution}\nKISS summary generating in background...`));
+			return withNotifications(`Debug path resolved: ${pathId}\nResolution: ${args.resolution}\nKISS summary generating in background...`);
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "path_resolve: error", { error: message });
-			return errorResponse$1(`path_resolve error: ${message}`);
+			return errorResponse(`path_resolve error: ${message}`);
 		}
 	});
 	server.registerTool("path_show", {
@@ -2135,29 +1755,18 @@ function registerDebugPathTools(server, pathRepo, pathTracker, notificationStore
 		description: "Show a debug path with its waypoints and KISS summary.",
 		inputSchema: { path_id: z.string().optional().describe("Path ID to show. Omit for active path.") }
 	}, async (args) => {
-		const projectHash = projectHashRef.current;
-		const withNotifications = (text) => textResponse$1(prependNotifications$1(notificationStore, projectHash, text));
+		const withNotifications = (text) => textResponse(prependNotifications(notificationStore, projectHash, text));
 		try {
 			debug("mcp", "path_show: request", { path_id: args.path_id });
 			let pathData;
 			if (args.path_id) {
 				pathData = pathRepo.getPath(args.path_id);
-				if (!pathData) return errorResponse$1(`Debug path not found: ${args.path_id}`);
+				if (!pathData) return errorResponse(`Debug path not found: ${args.path_id}`);
 			} else {
 				pathData = pathRepo.getActivePath();
-				if (!pathData) return errorResponse$1("No active debug path");
+				if (!pathData) return errorResponse("No active debug path");
 			}
-			const verbosity = loadToolVerbosityConfig().level;
-			if (verbosity === 1) return withNotifications(`Showing debug path: ${pathData.status}`);
 			const waypoints = pathRepo.getWaypoints(pathData.id);
-			if (verbosity === 2) {
-				const lines = [];
-				lines.push(`## Debug Path: ${pathData.id}`);
-				lines.push(`**Status:** ${pathData.status} | **Trigger:** ${pathData.trigger_summary}`);
-				lines.push(`Waypoints: ${waypoints.length}`);
-				if (pathData.resolution_summary) lines.push(`Resolution: ${pathData.resolution_summary}`);
-				return withNotifications(lines.join("\n"));
-			}
 			const lines = [];
 			lines.push(`## Debug Path: ${pathData.id}`);
 			lines.push(`Status: ${pathData.status}`);
@@ -2179,7 +1788,7 @@ function registerDebugPathTools(server, pathRepo, pathTracker, notificationStore
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "path_show: error", { error: message });
-			return errorResponse$1(`path_show error: ${message}`);
+			return errorResponse(`path_show error: ${message}`);
 		}
 	});
 	server.registerTool("path_list", {
@@ -2194,8 +1803,7 @@ function registerDebugPathTools(server, pathRepo, pathTracker, notificationStore
 			limit: z.number().int().min(1).max(50).default(10).describe("Max paths to return")
 		}
 	}, async (args) => {
-		const projectHash = projectHashRef.current;
-		const withNotifications = (text) => textResponse$1(prependNotifications$1(notificationStore, projectHash, text));
+		const withNotifications = (text) => textResponse(prependNotifications(notificationStore, projectHash, text));
 		try {
 			debug("mcp", "path_list: request", {
 				status: args.status,
@@ -2204,768 +1812,25 @@ function registerDebugPathTools(server, pathRepo, pathTracker, notificationStore
 			let paths = pathRepo.listPaths(args.limit);
 			if (args.status) paths = paths.filter((p) => p.status === args.status);
 			if (paths.length === 0) return withNotifications("No debug paths found");
-			const verbosity = loadToolVerbosityConfig().level;
-			if (verbosity === 1) return withNotifications(`${paths.length} debug paths found`);
 			const lines = [];
-			lines.push("## Debug Paths");
-			lines.push("");
-			if (verbosity === 2) {
-				lines.push("| Status | Trigger |");
-				lines.push("|--------|---------|");
-				for (const p of paths) {
-					const trigger = p.trigger_summary.length > 60 ? p.trigger_summary.slice(0, 60) + "..." : p.trigger_summary;
-					lines.push(`| ${p.status} | ${trigger} |`);
-				}
-			} else {
-				lines.push("| ID (short) | Status | Trigger | Started | Resolved |");
-				lines.push("|------------|--------|---------|---------|----------|");
-				for (const p of paths) {
-					const shortId = p.id.slice(0, 8);
-					const trigger = p.trigger_summary.length > 50 ? p.trigger_summary.slice(0, 50) + "..." : p.trigger_summary;
-					const resolved = p.resolved_at ?? "-";
-					lines.push(`| ${shortId} | ${p.status} | ${trigger} | ${p.started_at} | ${resolved} |`);
-				}
-			}
-			return withNotifications(lines.join("\n"));
-		} catch (err) {
-			const message = err instanceof Error ? err.message : "Unknown error";
-			debug("mcp", "path_list: error", { error: message });
-			return errorResponse$1(`path_list error: ${message}`);
-		}
-	});
-}
-
-//#endregion
-//#region src/mcp/tools/thought-branches.ts
-function prependNotifications(notificationStore, projectHash, responseText) {
-	if (!notificationStore) return responseText;
-	const pending = notificationStore.consumePending(projectHash);
-	if (pending.length === 0) return responseText;
-	return pending.map((n) => `[Laminark] ${n.message}`).join("\n") + "\n\n" + responseText;
-}
-function textResponse(text) {
-	return { content: [{
-		type: "text",
-		text
-	}] };
-}
-function errorResponse(text) {
-	return {
-		content: [{
-			type: "text",
-			text
-		}],
-		isError: true
-	};
-}
-function registerThoughtBranchTools(server, branchRepo, obsRepo, notificationStore, projectHashRef) {
-	server.registerTool("query_branches", {
-		title: "Query Thought Branches",
-		description: "Search and list thought branches - coherent units of work (investigations, bug fixes, features). Use to see work history and what was investigated, fixed, or built.",
-		inputSchema: {
-			status: z.enum([
-				"active",
-				"completed",
-				"abandoned",
-				"merged"
-			]).optional().describe("Filter by branch status"),
-			branch_type: z.enum([
-				"investigation",
-				"bug_fix",
-				"feature",
-				"refactor",
-				"research",
-				"unknown"
-			]).optional().describe("Filter by branch type"),
-			limit: z.number().int().min(1).max(50).default(10).describe("Maximum results to return")
-		}
-	}, async (args) => {
-		const projectHash = projectHashRef.current;
-		const withNotifications = (text) => textResponse(prependNotifications(notificationStore, projectHash, text));
-		try {
-			debug("mcp", "query_branches: request", {
-				status: args.status,
-				branch_type: args.branch_type,
-				limit: args.limit
-			});
-			let branches;
-			if (args.status) branches = branchRepo.listByStatus(args.status, args.limit);
-			else if (args.branch_type) branches = branchRepo.listByType(args.branch_type, args.limit);
-			else branches = branchRepo.listBranches(args.limit);
-			if (branches.length === 0) return withNotifications("No thought branches found");
-			const verbosity = loadToolVerbosityConfig().level;
-			if (verbosity === 1) return withNotifications(`${branches.length} branches found`);
-			const lines = [];
-			lines.push("## Thought Branches");
-			lines.push("");
-			if (verbosity === 2) {
-				lines.push("| Status | Type | Title |");
-				lines.push("|--------|------|-------|");
-				for (const b of branches) {
-					const title = b.title ? b.title.length > 50 ? b.title.slice(0, 50) + "..." : b.title : "-";
-					lines.push(`| ${b.status} | ${b.branch_type} | ${title} |`);
-				}
-			} else {
-				lines.push("| ID (short) | Status | Type | Stage | Title | Observations | Started |");
-				lines.push("|------------|--------|------|-------|-------|-------------|---------|");
-				for (const b of branches) {
-					const shortId = b.id.slice(0, 8);
-					const title = b.title ? b.title.length > 40 ? b.title.slice(0, 40) + "..." : b.title : "-";
-					lines.push(`| ${shortId} | ${b.status} | ${b.branch_type} | ${b.arc_stage} | ${title} | ${b.observation_count} | ${b.started_at} |`);
-				}
-			}
-			return withNotifications(lines.join("\n"));
-		} catch (err) {
-			const message = err instanceof Error ? err.message : "Unknown error";
-			debug("mcp", "query_branches: error", { error: message });
-			return errorResponse(`query_branches error: ${message}`);
-		}
-	});
-	server.registerTool("show_branch", {
-		title: "Show Thought Branch",
-		description: "Show detailed view of a thought branch with observation timeline and arc stage annotations. Trace the full arc of a work unit.",
-		inputSchema: { branch_id: z.string().optional().describe("Branch ID to show. Omit for active branch.") }
-	}, async (args) => {
-		const projectHash = projectHashRef.current;
-		const withNotifications = (text) => textResponse(prependNotifications(notificationStore, projectHash, text));
-		try {
-			debug("mcp", "show_branch: request", { branch_id: args.branch_id });
-			let branch;
-			if (args.branch_id) {
-				branch = branchRepo.getBranch(args.branch_id);
-				if (!branch) return errorResponse(`Branch not found: ${args.branch_id}`);
-			} else {
-				branch = branchRepo.getActiveBranch();
-				if (!branch) return errorResponse("No active thought branch");
-			}
-			const verbosity = loadToolVerbosityConfig().level;
-			const branchTitle = branch.title ?? branch.id.slice(0, 12);
-			if (verbosity === 1) return withNotifications(`Showing "${branchTitle}"`);
-			const observations = branchRepo.getObservations(branch.id);
-			if (verbosity === 2) {
-				const lines = [];
-				lines.push(`## ${branchTitle}`);
-				lines.push(`**Status:** ${branch.status} | **Type:** ${branch.branch_type} | **Stage:** ${branch.arc_stage}`);
-				if (branch.summary) lines.push(branch.summary);
-				lines.push(`Observations: ${observations.length}`);
-				return withNotifications(lines.join("\n"));
-			}
-			const lines = [];
-			lines.push(`## Thought Branch: ${branchTitle}`);
-			lines.push(`**ID:** ${branch.id}`);
-			lines.push(`**Status:** ${branch.status}`);
-			lines.push(`**Type:** ${branch.branch_type}`);
-			lines.push(`**Arc Stage:** ${branch.arc_stage}`);
-			lines.push(`**Started:** ${branch.started_at}`);
-			if (branch.ended_at) lines.push(`**Ended:** ${branch.ended_at}`);
-			if (branch.trigger_source) lines.push(`**Trigger:** ${branch.trigger_source}`);
-			if (branch.linked_debug_path_id) lines.push(`**Linked Debug Path:** ${branch.linked_debug_path_id}`);
-			lines.push("");
-			const tools = Object.entries(branch.tool_pattern).sort(([, a], [, b]) => b - a);
-			if (tools.length > 0) {
-				lines.push("### Tool Usage");
-				for (const [tool, count] of tools) lines.push(`- ${tool}: ${count}`);
-				lines.push("");
-			}
-			if (branch.summary) {
-				lines.push("### Summary");
-				lines.push(branch.summary);
-				lines.push("");
-			}
-			lines.push(`### Observation Timeline (${observations.length})`);
-			for (const bo of observations) {
-				const obs = obsRepo.getById(bo.observation_id);
-				const content = obs ? obs.title ?? obs.content.slice(0, 100) : bo.observation_id.slice(0, 8);
-				const stageTag = bo.arc_stage_at_add ? `[${bo.arc_stage_at_add}]` : "";
-				const toolTag = bo.tool_name ? `(${bo.tool_name})` : "";
-				lines.push(`${bo.sequence_order}. ${stageTag} ${toolTag} ${content}`);
-			}
-			return withNotifications(lines.join("\n"));
-		} catch (err) {
-			const message = err instanceof Error ? err.message : "Unknown error";
-			debug("mcp", "show_branch: error", { error: message });
-			return errorResponse(`show_branch error: ${message}`);
-		}
-	});
-	server.registerTool("branch_summary", {
-		title: "Branch Activity Summary",
-		description: "Summary of recent work activity grouped by time window. Shows what was investigated, fixed, built, and where work left off.",
-		inputSchema: { hours: z.number().int().min(1).max(168).default(24).describe("Time window in hours (default 24)") }
-	}, async (args) => {
-		const projectHash = projectHashRef.current;
-		const withNotifications = (text) => textResponse(prependNotifications(notificationStore, projectHash, text));
-		try {
-			debug("mcp", "branch_summary: request", { hours: args.hours });
-			const branches = branchRepo.listRecentBranches(args.hours);
-			if (branches.length === 0) return withNotifications(`No work branches in the last ${args.hours} hours`);
-			const verbosity = loadToolVerbosityConfig().level;
-			if (verbosity === 1) return withNotifications(`${branches.length} branches in ${args.hours}h`);
-			const active = branches.filter((b) => b.status === "active");
-			const completed = branches.filter((b) => b.status === "completed");
-			const abandoned = branches.filter((b) => b.status === "abandoned");
-			const lines = [];
-			lines.push(`## Work Summary (last ${args.hours}h)`);
-			lines.push(`**Total branches:** ${branches.length}`);
-			lines.push("");
-			if (active.length > 0) {
-				lines.push("### Active");
-				for (const b of active) {
-					const title = b.title ?? b.id.slice(0, 8);
-					lines.push(verbosity === 2 ? `- ${title} (${b.branch_type})` : `- **${title}** (${b.branch_type}, ${b.arc_stage}) — ${b.observation_count} obs`);
-				}
-				lines.push("");
-			}
-			if (completed.length > 0) {
-				lines.push("### Completed");
-				for (const b of completed) {
-					const title = b.title ?? b.id.slice(0, 8);
-					const summary = b.summary ? `: ${b.summary.slice(0, 100)}` : "";
-					lines.push(verbosity === 2 ? `- ${title} (${b.branch_type})` : `- **${title}** (${b.branch_type})${summary}`);
-				}
-				lines.push("");
-			}
-			if (abandoned.length > 0) {
-				lines.push("### Abandoned");
-				for (const b of abandoned) {
-					const title = b.title ?? b.id.slice(0, 8);
-					lines.push(verbosity === 2 ? `- ${title} (${b.branch_type})` : `- **${title}** (${b.branch_type}) — ${b.observation_count} obs`);
-				}
-				lines.push("");
-			}
-			if (verbosity === 3) {
-				const allTools = {};
-				for (const b of branches) for (const [tool, count] of Object.entries(b.tool_pattern)) allTools[tool] = (allTools[tool] ?? 0) + count;
-				const toolEntries = Object.entries(allTools).sort(([, a], [, b]) => b - a);
-				if (toolEntries.length > 0) {
-					lines.push("### Tool Distribution");
-					for (const [tool, count] of toolEntries.slice(0, 10)) lines.push(`- ${tool}: ${count}`);
-				}
-			}
-			return withNotifications(lines.join("\n"));
-		} catch (err) {
-			const message = err instanceof Error ? err.message : "Unknown error";
-			debug("mcp", "branch_summary: error", { error: message });
-			return errorResponse(`branch_summary error: ${message}`);
-		}
-	});
-}
-
-//#endregion
-//#region src/branches/arc-detector.ts
-const BUILTIN_CATEGORY = {
-	"Read": "investigation",
-	"Glob": "investigation",
-	"Grep": "investigation",
-	"WebSearch": "investigation",
-	"WebFetch": "investigation",
-	"Task": "investigation",
-	"AskUserQuestion": "investigation",
-	"Write": "write",
-	"Edit": "write",
-	"NotebookEdit": "write",
-	"Bash": "verification",
-	"EnterPlanMode": "planning",
-	"ExitPlanMode": "planning",
-	"TaskCreate": "planning",
-	"TaskUpdate": "planning",
-	"TaskList": "planning",
-	"TaskGet": "planning",
-	"Skill": "uncategorized"
-};
-/** Keywords matched against tool descriptions (case-insensitive). */
-const DESCRIPTION_RULES = [
-	{
-		category: "planning",
-		keywords: /\b(plan|todo|task|roadmap|milestone|phase|design|architect)\b/i
-	},
-	{
-		category: "verification",
-		keywords: /\b(run|test|build|execute|evaluate|validate|verify|check|assert|lint|compile)\b/i
-	},
-	{
-		category: "write",
-		keywords: /\b(write|edit|create|update|save|upload|modify|delete|remove|fill|type|click|select|drag|press|submit|install|deploy|push|commit|insert|drop|replace)\b/i
-	},
-	{
-		category: "investigation",
-		keywords: /\b(read|search|query|find|list|get|fetch|browse|snapshot|screenshot|inspect|show|view|discover|status|stats|navigate|hover|recall|monitor|log|trace|debug|profile|measure|analyze|explore)\b/i
-	}
-];
-/**
-* Classify a tool from its description text.
-* Returns null if no confident match.
-*/
-function classifyFromDescription(description) {
-	for (const rule of DESCRIPTION_RULES) if (rule.keywords.test(description)) return rule.category;
-	return null;
-}
-const NAME_RULES = [
-	{
-		category: "planning",
-		pattern: /\b(plan|todo|task|roadmap|phase|milestone)\b/i
-	},
-	{
-		category: "verification",
-		pattern: /\b(run|test|build|exec|evaluate|validate|check|verify)\b/i
-	},
-	{
-		category: "write",
-		pattern: /\b(write|edit|create|update|save|upload|fill|type|click|select|drag|press|install)\b/i
-	},
-	{
-		category: "investigation",
-		pattern: /\b(search|query|find|list|get|read|fetch|browse|snapshot|screenshot|inspect|show|view|recall|discover|status|stats|console|network|navigate|tabs|hover)\b/i
-	}
-];
-function classifyFromName(toolName) {
-	const actionPart = toolName.includes("__") ? toolName.substring(toolName.lastIndexOf("__") + 2) : toolName;
-	for (const rule of NAME_RULES) if (rule.pattern.test(actionPart)) return rule.category;
-	if (toolName.includes("laminark")) return "investigation";
-	return "uncategorized";
-}
-const classificationCache = /* @__PURE__ */ new Map();
-let lastRegistryCount = -1;
-/**
-* Re-reads the tool_registry table and classifies every tool by its
-* description. Only rescans when the registry row count has changed.
-*
-* Call on startup and periodically (e.g., during BranchTracker maintenance).
-*/
-function primeFromRegistry(db, projectHash) {
-	try {
-		const currentCount = db.prepare("SELECT COUNT(*) AS cnt FROM tool_registry").get()?.cnt ?? 0;
-		if (currentCount === lastRegistryCount && lastRegistryCount >= 0) return;
-		const rows = db.prepare(`
-      SELECT name, description FROM tool_registry
-      WHERE status = 'active'
-        AND (scope = 'global' OR project_hash IS NULL OR project_hash = ?)
-    `).all(projectHash);
-		let primed = 0;
-		for (const row of rows) {
-			if (BUILTIN_CATEGORY[row.name]) continue;
-			let category = null;
-			if (row.description) category = classifyFromDescription(row.description);
-			if (!category) category = classifyFromName(row.name);
-			classificationCache.set(row.name, category);
-			primed++;
-		}
-		lastRegistryCount = currentCount;
-		debug("branches", "Arc detector cache primed from registry", {
-			registryTools: rows.length,
-			primed
-		});
-	} catch {}
-}
-/**
-* Classify any tool name into an arc category.
-*
-* Priority: built-in table > registry-primed cache > name-pattern fallback.
-*/
-function classifyTool(toolName) {
-	const cached = classificationCache.get(toolName);
-	if (cached) return cached;
-	const builtin = BUILTIN_CATEGORY[toolName];
-	if (builtin) {
-		classificationCache.set(toolName, builtin);
-		return builtin;
-	}
-	const fromName = classifyFromName(toolName);
-	classificationCache.set(toolName, fromName);
-	return fromName;
-}
-/**
-* Infers the current arc stage from tool usage pattern counts.
-*
-* Handles all tool types: builtins, MCP tools, plugins, skills, slash commands.
-* Uncategorized tools are excluded from ratio calculations so they don't
-* dilute the signal from known tools.
-*
-* @param toolPattern - Map of tool name to usage count within the branch
-* @param classification - Optional dominant observation classification
-* @returns The inferred arc stage
-*/
-function inferArcStage(toolPattern, classification) {
-	let investigationCount = 0;
-	let writeCount = 0;
-	let verificationCount = 0;
-	let planningCount = 0;
-	let categorizedCount = 0;
-	for (const [tool, count] of Object.entries(toolPattern)) switch (classifyTool(tool)) {
-		case "investigation":
-			investigationCount += count;
-			categorizedCount += count;
-			break;
-		case "write":
-			writeCount += count;
-			categorizedCount += count;
-			break;
-		case "verification":
-			verificationCount += count;
-			categorizedCount += count;
-			break;
-		case "planning":
-			planningCount += count;
-			categorizedCount += count;
-			break;
-		case "uncategorized": break;
-	}
-	if (categorizedCount === 0) return "investigation";
-	if (verificationCount > 0 && writeCount > 0) {
-		if (verificationCount / categorizedCount > .2) return "verification";
-	}
-	if (writeCount / categorizedCount > .4) return "execution";
-	if (planningCount > 0) {
-		if (planningCount / categorizedCount > .1) return "planning";
-	}
-	if (classification === "problem" && writeCount > 0 && investigationCount > 0) return "diagnosis";
-	return "investigation";
-}
-
-//#endregion
-//#region src/config/haiku-config.ts
-function loadHaikuConfig() {
-	return {
-		model: "claude-haiku-4-5-20251001",
-		maxTokensPerCall: 1024
-	};
-}
-
-//#endregion
-//#region src/intelligence/haiku-client.ts
-/**
-* Shared Haiku client using Claude Agent SDK V2 session.
-*
-* Routes Haiku calls through the user's Claude Code subscription
-* instead of requiring a separate API key. Uses a persistent session
-* to avoid 12s cold-start overhead on sequential calls.
-*
-* Provides the core infrastructure for all Haiku agent modules:
-* - callHaiku() helper for structured prompt/response calls
-* - extractJsonFromResponse() for defensive JSON parsing
-* - Session reuse across batch processing cycles
-*/
-let _session = null;
-function getOrCreateSession() {
-	if (!_session) _session = unstable_v2_createSession({
-		model: loadHaikuConfig().model,
-		permissionMode: "bypassPermissions",
-		allowedTools: []
-	});
-	return _session;
-}
-/**
-* Returns whether Haiku enrichment is available.
-* Always true with subscription auth -- no API key check needed.
-*/
-function isHaikuEnabled() {
-	return true;
-}
-/**
-* Calls Haiku with a system prompt and user content.
-* Returns the text content from the response.
-*
-* Uses a persistent V2 session to avoid cold-start overhead on sequential calls.
-* System prompt is embedded in the user message since session-level systemPrompt
-* is set at creation time and we need different prompts per agent.
-*
-* @param systemPrompt - Instructions for the model
-* @param userContent - The content to process
-* @param _maxTokens - Kept for signature compatibility (unused -- Agent SDK constrains output via prompts)
-* @throws Error if the Haiku call fails or session expires
-*/
-async function callHaiku(systemPrompt, userContent, _maxTokens) {
-	const session = getOrCreateSession();
-	const fullPrompt = `<instructions>\n${systemPrompt}\n</instructions>\n\n${userContent}`;
-	try {
-		await session.send(fullPrompt);
-		for await (const msg of session.stream()) if (msg.type === "result") {
-			if (msg.subtype === "success") return msg.result;
-			const errorMsg = ("errors" in msg ? msg.errors : void 0)?.join(", ") ?? msg.subtype;
-			throw new Error(`Haiku call failed: ${errorMsg}`);
-		}
-		return "";
-	} catch (error) {
-		try {
-			_session?.close();
-		} catch {}
-		_session = null;
-		throw error;
-	}
-}
-/**
-* Defensive JSON extraction from Haiku response text.
-*
-* Handles common LLM response quirks:
-* - Markdown code fences (```json ... ```)
-* - Explanatory text before/after JSON
-* - Both array and object JSON shapes
-*
-* @throws Error if no JSON structure found in text
-*/
-function extractJsonFromResponse(text) {
-	const cleaned = text.replace(/```json\s*/g, "").replace(/```\s*/g, "");
-	const arrayMatch = cleaned.match(/\[[\s\S]*\]/);
-	if (arrayMatch) return JSON.parse(arrayMatch[0]);
-	const objMatch = cleaned.match(/\{[\s\S]*\}/);
-	if (objMatch) return JSON.parse(objMatch[0]);
-	throw new Error("No JSON found in Haiku response");
-}
-
-//#endregion
-//#region src/branches/branch-classifier-agent.ts
-/**
-* Haiku agent for classifying thought branch type and generating title/summary.
-*
-* Uses a single Haiku call to determine:
-* 1. Branch type (investigation, bug_fix, feature, refactor, research)
-* 2. A concise title for the branch
-* 3. An optional summary (for completed branches)
-*
-* Follows the same pattern as haiku-classifier-agent.ts.
-*/
-const ClassifyBranchSchema = z.object({
-	branch_type: z.enum([
-		"investigation",
-		"bug_fix",
-		"feature",
-		"refactor",
-		"research"
-	]),
-	title: z.string().max(100)
-});
-const SummarizeBranchSchema = z.object({ summary: z.string().max(500) });
-const CLASSIFY_PROMPT = `You classify developer work branches for a knowledge management system.
-
-Given a sequence of observations from a work session, determine:
-1. branch_type: What kind of work is this?
-   - "investigation": Exploring code, reading docs, understanding behavior
-   - "bug_fix": Fixing an error, test failure, or unexpected behavior
-   - "feature": Building new functionality
-   - "refactor": Restructuring existing code without changing behavior
-   - "research": Looking up external resources, comparing approaches
-
-2. title: A concise title (3-8 words) describing the work unit. Use imperative form.
-   Examples: "Fix auth token refresh", "Add branch detection system", "Investigate memory leak"
-
-Return JSON: {"branch_type": "...", "title": "..."}
-No markdown, no explanation, ONLY the JSON object.`;
-const SUMMARIZE_PROMPT = `You summarize completed developer work branches for a knowledge management system.
-
-Given a sequence of observations from a completed work branch, write a concise summary (1-3 sentences) that captures:
-- What was the goal
-- What was done
-- What was the outcome
-
-Return JSON: {"summary": "..."}
-No markdown, no explanation, ONLY the JSON object.`;
-/**
-* Classifies a branch type and generates a title from observation content.
-*/
-async function classifyBranchWithHaiku(observationTexts, toolPattern) {
-	const parsed = extractJsonFromResponse(await callHaiku(CLASSIFY_PROMPT, [
-		`Tool usage: ${Object.entries(toolPattern).sort(([, a], [, b]) => b - a).map(([tool, count]) => `${tool}: ${count}`).join(", ")}`,
-		"",
-		"Observations:",
-		...observationTexts.slice(0, 10).map((t, i) => `${i + 1}. ${t.slice(0, 200)}`)
-	].join("\n"), 256));
-	return ClassifyBranchSchema.parse(parsed);
-}
-/**
-* Generates a completion summary for a finished branch.
-*/
-async function summarizeBranchWithHaiku(title, branchType, observationTexts) {
-	const parsed = extractJsonFromResponse(await callHaiku(SUMMARIZE_PROMPT, [
-		`Branch: ${title} (${branchType})`,
-		"",
-		"Observations:",
-		...observationTexts.slice(0, 15).map((t, i) => `${i + 1}. ${t.slice(0, 200)}`)
-	].join("\n"), 256));
-	return SummarizeBranchSchema.parse(parsed);
-}
-
-//#endregion
-//#region src/branches/branch-tracker.ts
-const TIME_GAP_MS = 900 * 1e3;
-var BranchTracker = class {
-	state = "idle";
-	activeBranchId = null;
-	activeProjectHash = null;
-	activeSessionId = null;
-	lastObservationTime = 0;
-	toolPattern = {};
-	repo;
-	db;
-	projectHash;
-	constructor(repo, db, projectHash) {
-		this.repo = repo;
-		this.db = db;
-		this.projectHash = projectHash;
-		primeFromRegistry(db, projectHash);
-		const activeBranch = repo.findRecentActiveBranch();
-		if (activeBranch) {
-			this.state = "tracking";
-			this.activeBranchId = activeBranch.id;
-			this.activeProjectHash = activeBranch.project_hash;
-			this.activeSessionId = activeBranch.session_id;
-			this.toolPattern = activeBranch.tool_pattern;
-			this.lastObservationTime = new Date(activeBranch.started_at).getTime();
-			debug("branches", "Recovered active branch from DB", { branchId: activeBranch.id });
-		}
-	}
-	/**
-	* Process a new observation through the boundary detection state machine.
-	* Called from HaikuProcessor after classification (Step 1.6).
-	*/
-	processObservation(obs) {
-		const now = Date.now();
-		const obsTime = new Date(obs.createdAt).getTime();
-		const toolName = this.extractToolName(obs.source);
-		const boundary = this.detectBoundary(obs, obsTime);
-		if (boundary) {
-			if (this.state === "tracking" && this.activeBranchId) this.completeBranch();
-			this.startBranch(boundary, obs);
-		} else if (this.state === "idle") this.startBranch("session_start", obs);
-		if (this.activeBranchId) {
-			const arcStage = inferArcStage(this.toolPattern, obs.classification);
-			if (toolName) {
-				this.toolPattern[toolName] = (this.toolPattern[toolName] ?? 0) + 1;
-				this.repo.updateToolPattern(this.activeBranchId, this.toolPattern);
-			}
-			this.repo.addObservation(this.activeBranchId, obs.id, toolName, arcStage);
-			const newStage = inferArcStage(this.toolPattern, obs.classification);
-			this.repo.updateArcStage(this.activeBranchId, newStage);
-		}
-		this.lastObservationTime = obsTime || now;
-		this.activeProjectHash = obs.projectHash;
-		this.activeSessionId = obs.sessionId ?? this.activeSessionId;
-	}
-	/**
-	* Notify the tracker of a topic shift (from TopicShiftHandler).
-	*/
-	onTopicShift(observationId) {
-		if (this.state === "tracking" && this.activeBranchId) {
-			this.completeBranch();
-			debug("branches", "Topic shift boundary detected", { observationId });
-		}
-	}
-	/**
-	* Link the active branch to a debug path (when PathTracker activates).
-	*/
-	linkDebugPath(debugPathId) {
-		if (this.activeBranchId) {
-			this.repo.linkDebugPath(this.activeBranchId, debugPathId);
-			debug("branches", "Linked debug path to branch", {
-				branchId: this.activeBranchId,
-				debugPathId
-			});
-		}
-	}
-	/**
-	* Get the active branch ID (for external callers).
-	*/
-	getActiveBranchId() {
-		return this.activeBranchId;
-	}
-	/**
-	* Run periodic maintenance tasks:
-	* - Classify branches with 3+ observations via Haiku
-	* - Generate summaries for recently completed branches
-	* - Auto-abandon stale branches (>24h)
-	* - Link branches to debug paths
-	*/
-	async runMaintenance() {
-		try {
-			primeFromRegistry(this.db, this.projectHash);
-			const stale = this.repo.findStaleBranches();
-			for (const branch of stale) {
-				this.repo.abandonBranch(branch.id);
-				if (this.activeBranchId === branch.id) {
-					this.state = "idle";
-					this.activeBranchId = null;
-					this.toolPattern = {};
-				}
-				debug("branches", "Auto-abandoned stale branch", { branchId: branch.id });
-			}
-			if (isHaikuEnabled()) {
-				const unclassified = this.repo.findUnclassifiedBranches(3);
-				for (const branch of unclassified) try {
-					const observations = this.repo.getObservations(branch.id);
-					const obsRepo = new ObservationRepository(this.db, branch.project_hash);
-					const texts = observations.map((bo) => {
-						const obs = obsRepo.getById(bo.observation_id);
-						return obs ? obs.title ? `${obs.title}: ${obs.content}` : obs.content : null;
-					}).filter((t) => t !== null);
-					if (texts.length === 0) continue;
-					const result = await classifyBranchWithHaiku(texts, branch.tool_pattern);
-					this.repo.updateClassification(branch.id, result.branch_type, result.title);
-					debug("branches", "Branch classified", {
-						branchId: branch.id,
-						type: result.branch_type,
-						title: result.title
-					});
-				} catch (err) {
-					const msg = err instanceof Error ? err.message : String(err);
-					debug("branches", "Branch classification failed (non-fatal)", {
-						branchId: branch.id,
-						error: msg
-					});
-				}
-				const unsummarized = this.repo.findRecentCompletedUnsummarized(2);
-				for (const branch of unsummarized) try {
-					const observations = this.repo.getObservations(branch.id);
-					const obsRepo = new ObservationRepository(this.db, branch.project_hash);
-					const texts = observations.map((bo) => {
-						const obs = obsRepo.getById(bo.observation_id);
-						return obs ? obs.title ? `${obs.title}: ${obs.content}` : obs.content : null;
-					}).filter((t) => t !== null);
-					if (texts.length === 0) continue;
-					const result = await summarizeBranchWithHaiku(branch.title ?? "Untitled", branch.branch_type, texts);
-					this.repo.updateSummary(branch.id, result.summary);
-					debug("branches", "Branch summarized", { branchId: branch.id });
-				} catch (err) {
-					const msg = err instanceof Error ? err.message : String(err);
-					debug("branches", "Branch summarization failed (non-fatal)", {
-						branchId: branch.id,
-						error: msg
-					});
-				}
-			}
-		} catch (err) {
-			debug("branches", "Maintenance error (non-fatal)", { error: err instanceof Error ? err.message : String(err) });
-		}
-	}
-	detectBoundary(obs, obsTime) {
-		if (this.activeProjectHash && obs.projectHash !== this.activeProjectHash) return "project_switch";
-		if (this.activeSessionId && obs.sessionId && obs.sessionId !== this.activeSessionId) return "session_start";
-		if (this.lastObservationTime > 0) {
-			if (obsTime - this.lastObservationTime > TIME_GAP_MS) return "time_gap";
-		}
-		return null;
-	}
-	startBranch(triggerSource, obs) {
-		const branch = this.repo.createBranch(obs.sessionId ?? null, triggerSource, obs.id);
-		this.state = "tracking";
-		this.activeBranchId = branch.id;
-		this.toolPattern = {};
-		debug("branches", "New branch started", {
-			branchId: branch.id,
-			trigger: triggerSource
-		});
-	}
-	completeBranch() {
-		if (!this.activeBranchId) return;
-		this.repo.completeBranch(this.activeBranchId);
-		debug("branches", "Branch completed", { branchId: this.activeBranchId });
-		this.state = "idle";
-		this.activeBranchId = null;
-		this.toolPattern = {};
-	}
-	extractToolName(source) {
-		if (source.startsWith("hook:")) return source.slice(5);
-		if (source.startsWith("mcp:")) return source.slice(4);
-		return null;
-	}
-};
+			lines.push("## Debug Paths");
+			lines.push("");
+			lines.push("| ID (short) | Status | Trigger | Started | Resolved |");
+			lines.push("|------------|--------|---------|---------|----------|");
+			for (const p of paths) {
+				const shortId = p.id.slice(0, 8);
+				const trigger = p.trigger_summary.length > 50 ? p.trigger_summary.slice(0, 50) + "..." : p.trigger_summary;
+				const resolved = p.resolved_at ?? "-";
+				lines.push(`| ${shortId} | ${p.status} | ${trigger} | ${p.started_at} | ${resolved} |`);
+			}
+			return withNotifications(lines.join("\n"));
+		} catch (err) {
+			const message = err instanceof Error ? err.message : "Unknown error";
+			debug("mcp", "path_list: error", { error: message });
+			return errorResponse(`path_list error: ${message}`);
+		}
+	});
+}
 
 //#endregion
 //#region src/analysis/worker-bridge.ts
@@ -4701,6 +3566,96 @@ var CurationAgent = class {
 	}
 };
 
+//#endregion
+//#region src/config/haiku-config.ts
+function loadHaikuConfig() {
+	return {
+		model: "claude-haiku-4-5-20251001",
+		maxTokensPerCall: 1024
+	};
+}
+
+//#endregion
+//#region src/intelligence/haiku-client.ts
+/**
+* Shared Haiku client using Claude Agent SDK V2 session.
+*
+* Routes Haiku calls through the user's Claude Code subscription
+* instead of requiring a separate API key. Uses a persistent session
+* to avoid 12s cold-start overhead on sequential calls.
+*
+* Provides the core infrastructure for all Haiku agent modules:
+* - callHaiku() helper for structured prompt/response calls
+* - extractJsonFromResponse() for defensive JSON parsing
+* - Session reuse across batch processing cycles
+*/
+let _session = null;
+function getOrCreateSession() {
+	if (!_session) _session = unstable_v2_createSession({
+		model: loadHaikuConfig().model,
+		permissionMode: "bypassPermissions",
+		allowedTools: []
+	});
+	return _session;
+}
+/**
+* Returns whether Haiku enrichment is available.
+* Always true with subscription auth -- no API key check needed.
+*/
+function isHaikuEnabled() {
+	return true;
+}
+/**
+* Calls Haiku with a system prompt and user content.
+* Returns the text content from the response.
+*
+* Uses a persistent V2 session to avoid cold-start overhead on sequential calls.
+* System prompt is embedded in the user message since session-level systemPrompt
+* is set at creation time and we need different prompts per agent.
+*
+* @param systemPrompt - Instructions for the model
+* @param userContent - The content to process
+* @param _maxTokens - Kept for signature compatibility (unused -- Agent SDK constrains output via prompts)
+* @throws Error if the Haiku call fails or session expires
+*/
+async function callHaiku(systemPrompt, userContent, _maxTokens) {
+	const session = getOrCreateSession();
+	const fullPrompt = `<instructions>\n${systemPrompt}\n</instructions>\n\n${userContent}`;
+	try {
+		await session.send(fullPrompt);
+		for await (const msg of session.stream()) if (msg.type === "result") {
+			if (msg.subtype === "success") return msg.result;
+			const errorMsg = ("errors" in msg ? msg.errors : void 0)?.join(", ") ?? msg.subtype;
+			throw new Error(`Haiku call failed: ${errorMsg}`);
+		}
+		return "";
+	} catch (error) {
+		try {
+			_session?.close();
+		} catch {}
+		_session = null;
+		throw error;
+	}
+}
+/**
+* Defensive JSON extraction from Haiku response text.
+*
+* Handles common LLM response quirks:
+* - Markdown code fences (```json ... ```)
+* - Explanatory text before/after JSON
+* - Both array and object JSON shapes
+*
+* @throws Error if no JSON structure found in text
+*/
+function extractJsonFromResponse(text) {
+	const cleaned = text.replace(/```json\s*/g, "").replace(/```\s*/g, "");
+	const arrayMatch = cleaned.match(/\[[\s\S]*\]/);
+	if (arrayMatch) return JSON.parse(arrayMatch[0]);
+	const objMatch = cleaned.match(/\{[\s\S]*\}/);
+	if (objMatch) return JSON.parse(objMatch[0]);
+	throw new Error("No JSON found in Haiku response");
+}
+
 //#endregion
 //#region src/intelligence/haiku-classifier-agent.ts
 /**
@@ -4751,10 +3706,10 @@ For each observation, determine:
    - "problem": error, bug, failure, or obstacle encountered
    - "solution": fix, resolution, workaround, or decision that resolved something
 
-3. debug_signal (always, even for noise): Is this related to ACTIVE debugging (the developer hit an actual error)?
-   - is_error: Did an actual error/failure OCCUR in this observation? An error message, stack trace, test failure, or build failure that happened RIGHT NOW. NOT research about errors — searching for "reconnection problems" or reading docs about error handling is NOT is_error. The tool itself must have failed or produced an error.
+3. debug_signal (always, even for noise): Is this related to debugging?
+   - is_error: Does this contain an error message, test failure, build failure, or exception?
    - is_resolution: Does this indicate a successful fix, passing test, or resolved error?
-   - waypoint_hint: If debug-related, what type? "error" (an actual error occurred), "attempt" (trying a fix), "failure" (fix didn't work), "success" (something passed), "pivot" (changing approach), "revert" (undoing a change), "discovery" (learned something new), "resolution" (final fix). null if not debug-related. WebSearch/WebFetch/AskUserQuestion are typically "discovery" or null, NOT "error".
+   - waypoint_hint: If debug-related, what type? "error" (hit an error), "attempt" (trying a fix), "failure" (fix didn't work), "success" (something passed), "pivot" (changing approach), "revert" (undoing a change), "discovery" (learned something), "resolution" (final fix). null if not debug-related.
    - confidence: 0.0-1.0 how confident this is debug activity
 
 Return JSON: {"signal": "noise"|"signal", "classification": "discovery"|"problem"|"solution"|null, "reason": "brief", "debug_signal": {"is_error": bool, "is_resolution": bool, "waypoint_hint": "type"|null, "confidence": 0.0-1.0}|null}
@@ -5162,7 +4117,6 @@ var HaikuProcessor = class {
 	batchSize;
 	concurrency;
 	pathTracker;
-	branchTracker;
 	timer = null;
 	constructor(db, projectHash, opts) {
 		this.db = db;
@@ -5171,7 +4125,6 @@ var HaikuProcessor = class {
 		this.batchSize = opts?.batchSize ?? 10;
 		this.concurrency = opts?.concurrency ?? 3;
 		this.pathTracker = opts?.pathTracker ?? null;
-		this.branchTracker = opts?.branchTracker ?? null;
 	}
 	start() {
 		if (this.timer) return;
@@ -5195,30 +4148,16 @@ var HaikuProcessor = class {
 	}
 	async processOnce() {
 		if (!isHaikuEnabled()) return;
-		const unclassified = ObservationRepository.listAllUnclassified(this.db, this.batchSize);
+		const repo = new ObservationRepository(this.db, this.projectHash);
+		const unclassified = repo.listUnclassified(this.batchSize);
 		if (unclassified.length === 0) return;
 		debug("haiku", "Processing unclassified observations", { count: unclassified.length });
-		const byProject = /* @__PURE__ */ new Map();
-		for (const obs of unclassified) {
-			const hash = obs.projectHash;
-			if (!byProject.has(hash)) byProject.set(hash, []);
-			byProject.get(hash).push(obs);
-		}
-		for (const [hash, projectObs] of byProject) {
-			const repo = new ObservationRepository(this.db, hash);
-			for (let i = 0; i < projectObs.length; i += this.concurrency) {
-				const batch = projectObs.slice(i, i + this.concurrency);
-				await Promise.all(batch.map((obs) => this.processOne(obs, repo, hash)));
-			}
-		}
-		if (this.branchTracker) try {
-			await this.branchTracker.runMaintenance();
-		} catch (err) {
-			debug("haiku", "Branch maintenance error (non-fatal)", { error: err instanceof Error ? err.message : String(err) });
+		for (let i = 0; i < unclassified.length; i += this.concurrency) {
+			const batch = unclassified.slice(i, i + this.concurrency);
+			await Promise.all(batch.map((obs) => this.processOne(obs, repo)));
 		}
 	}
-	async processOne(obs, repo, obsProjectHash) {
-		const projectHash = obsProjectHash ?? this.projectHash;
+	async processOne(obs, repo) {
 		try {
 			let classification;
 			try {
@@ -5232,23 +4171,6 @@ var HaikuProcessor = class {
 						error: msg
 					});
 				}
-				if (this.branchTracker) try {
-					this.branchTracker.processObservation({
-						id: obs.id,
-						content: obs.content,
-						source: obs.source,
-						projectHash: obsProjectHash ?? this.projectHash,
-						sessionId: void 0,
-						classification: result.classification,
-						createdAt: (/* @__PURE__ */ new Date()).toISOString()
-					});
-				} catch (branchErr) {
-					const msg = branchErr instanceof Error ? branchErr.message : String(branchErr);
-					debug("haiku", "Branch tracking failed (non-fatal)", {
-						id: obs.id,
-						error: msg
-					});
-				}
 				if (result.signal === "noise") {
 					repo.updateClassification(obs.id, "noise");
 					repo.softDelete(obs.id);
@@ -5290,7 +4212,7 @@ var HaikuProcessor = class {
 					name: entity.name,
 					metadata: { confidence: entity.confidence },
 					observation_ids: [String(obs.id)],
-					project_hash: projectHash
+					project_hash: this.projectHash
 				});
 				persistedNodes.push(node);
 			} catch {
@@ -5302,8 +4224,7 @@ var HaikuProcessor = class {
 					label: node.name,
 					type: node.type,
 					observationCount: 1,
-					createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-					projectHash
+					createdAt: (/* @__PURE__ */ new Date()).toISOString()
 				});
 				debug("haiku", "Entities persisted", {
 					id: obs.id,
@@ -5328,7 +4249,7 @@ var HaikuProcessor = class {
 							type: rel.type,
 							weight: rel.confidence,
 							metadata: { source: "haiku" },
-							project_hash: projectHash
+							project_hash: this.projectHash
 						});
 						affectedNodeIds.add(sourceNode.id);
 						affectedNodeIds.add(targetNode.id);
@@ -5725,7 +4646,7 @@ apiRoutes.get("/graph", (c) => {
 		edgeRows = [];
 	}
 	const nodeIdSet = new Set(nodes.map((n) => n.id));
-	const edges = edgeRows.filter((e) => nodeIdSet.has(e.source_id) && nodeIdSet.has(e.target_id)).map((row) => ({
+	const edges = (typeFilter ? edgeRows.filter((e) => nodeIdSet.has(e.source_id) && nodeIdSet.has(e.target_id)) : edgeRows).map((row) => ({
 		id: row.id,
 		source: row.source_id,
 		target: row.target_id,
@@ -6303,236 +5224,6 @@ apiRoutes.get("/paths/:id", (c) => {
 	}
 });
 /**
-* GET /api/tools
-*
-* Returns all tools from tool_registry with usage stats.
-*/
-apiRoutes.get("/tools", (c) => {
-	const db = getDb$1(c);
-	let tools = [];
-	try {
-		tools = db.prepare(`
-      SELECT id, name, tool_type, scope, status, usage_count, server_name, description, last_used_at, discovered_at
-      FROM tool_registry
-      ORDER BY usage_count DESC, discovered_at DESC
-    `).all();
-	} catch {}
-	return c.json({ tools: tools.map((t) => ({
-		id: t.id,
-		name: t.name,
-		toolType: t.tool_type,
-		scope: t.scope,
-		status: t.status,
-		usageCount: t.usage_count,
-		serverName: t.server_name,
-		description: t.description,
-		lastUsedAt: t.last_used_at,
-		discoveredAt: t.discovered_at
-	})) });
-});
-/**
-* GET /api/tools/flows
-*
-* Returns edges for the tool topology graph:
-* 1. Pre-computed routing_patterns (preceding_tools -> target_tool)
-* 2. Pairwise co-occurrence from tool_usage_events session sequences
-*/
-apiRoutes.get("/tools/flows", (c) => {
-	const db = getDb$1(c);
-	const projectFilter = getProjectHash$2(c);
-	const edges = [];
-	const edgeKey = /* @__PURE__ */ new Set();
-	try {
-		let sql = "SELECT target_tool, preceding_tools, frequency FROM routing_patterns";
-		const params = [];
-		if (projectFilter) {
-			sql += " WHERE project_hash = ?";
-			params.push(projectFilter);
-		}
-		sql += " ORDER BY frequency DESC LIMIT 200";
-		const rows = db.prepare(sql).all(...params);
-		for (const row of rows) {
-			let preceding;
-			try {
-				preceding = JSON.parse(row.preceding_tools);
-			} catch {
-				preceding = [];
-			}
-			for (const src of preceding) {
-				const key = src + "->" + row.target_tool;
-				if (!edgeKey.has(key)) {
-					edgeKey.add(key);
-					edges.push({
-						source: src,
-						target: row.target_tool,
-						frequency: row.frequency,
-						edgeType: "pattern"
-					});
-				}
-			}
-		}
-	} catch {}
-	try {
-		let sql = `
-      SELECT session_id, tool_name, created_at
-      FROM tool_usage_events
-      WHERE session_id IS NOT NULL
-    `;
-		const params = [];
-		if (projectFilter) {
-			sql += " AND project_hash = ?";
-			params.push(projectFilter);
-		}
-		sql += " ORDER BY session_id, created_at ASC LIMIT 5000";
-		const rows = db.prepare(sql).all(...params);
-		const pairFreq = /* @__PURE__ */ new Map();
-		let prevSession = "";
-		let prevTool = "";
-		for (const row of rows) {
-			if (row.session_id === prevSession && prevTool && prevTool !== row.tool_name) {
-				const key = prevTool + "->" + row.tool_name;
-				pairFreq.set(key, (pairFreq.get(key) || 0) + 1);
-			}
-			prevSession = row.session_id;
-			prevTool = row.tool_name;
-		}
-		for (const [key, freq] of pairFreq) if (!edgeKey.has(key) && freq >= 2) {
-			edgeKey.add(key);
-			const [source, target] = key.split("->");
-			edges.push({
-				source,
-				target,
-				frequency: freq,
-				edgeType: "session"
-			});
-		}
-	} catch {}
-	return c.json({ edges });
-});
-/**
-* GET /api/tools/:name/stats
-*
-* Returns detailed stats for a single tool.
-*/
-apiRoutes.get("/tools/:name/stats", (c) => {
-	const db = getDb$1(c);
-	const toolName = c.req.param("name");
-	const projectFilter = getProjectHash$2(c);
-	let tool;
-	try {
-		tool = db.prepare("SELECT id, name, tool_type, scope, status, usage_count, server_name, description, last_used_at, discovered_at FROM tool_registry WHERE name = ? ORDER BY usage_count DESC LIMIT 1").get(toolName);
-	} catch {}
-	if (!tool) return c.json({ error: "Tool not found" }, 404);
-	let successRate = null;
-	let totalEvents = 0;
-	try {
-		let sql = "SELECT success FROM tool_usage_events WHERE tool_name = ?";
-		const params = [toolName];
-		if (projectFilter) {
-			sql += " AND project_hash = ?";
-			params.push(projectFilter);
-		}
-		sql += " ORDER BY created_at DESC LIMIT 50";
-		const events = db.prepare(sql).all(...params);
-		totalEvents = events.length;
-		if (totalEvents > 0) successRate = events.filter((e) => e.success === 1).length / totalEvents;
-	} catch {}
-	let sessionsUsedIn = 0;
-	try {
-		let sql = "SELECT COUNT(DISTINCT session_id) as cnt FROM tool_usage_events WHERE tool_name = ? AND session_id IS NOT NULL";
-		const params = [toolName];
-		if (projectFilter) {
-			sql += " AND project_hash = ?";
-			params.push(projectFilter);
-		}
-		sessionsUsedIn = db.prepare(sql).get(...params)?.cnt ?? 0;
-	} catch {}
-	let coOccurring = [];
-	try {
-		let sql = `
-      SELECT e2.tool_name as name, COUNT(*) as count
-      FROM tool_usage_events e1
-      JOIN tool_usage_events e2
-        ON e1.session_id = e2.session_id AND e1.tool_name != e2.tool_name
-      WHERE e1.tool_name = ? AND e1.session_id IS NOT NULL
-    `;
-		const params = [toolName];
-		if (projectFilter) {
-			sql += " AND e1.project_hash = ?";
-			params.push(projectFilter);
-		}
-		sql += " GROUP BY e2.tool_name ORDER BY count DESC LIMIT 10";
-		coOccurring = db.prepare(sql).all(...params);
-	} catch {}
-	return c.json({
-		tool: {
-			id: tool.id,
-			name: tool.name,
-			toolType: tool.tool_type,
-			scope: tool.scope,
-			status: tool.status,
-			usageCount: tool.usage_count,
-			serverName: tool.server_name,
-			description: tool.description,
-			lastUsedAt: tool.last_used_at,
-			discoveredAt: tool.discovered_at
-		},
-		successRate,
-		totalEvents,
-		sessionsUsedIn,
-		coOccurring
-	});
-});
-/**
-* GET /api/tools/sessions
-*
-* Returns recent session tool sequences for the flow strip.
-*/
-apiRoutes.get("/tools/sessions", (c) => {
-	const db = getDb$1(c);
-	const projectFilter = getProjectHash$2(c);
-	const limitStr = c.req.query("limit");
-	const limit = limitStr ? Math.min(parseInt(limitStr, 10) || 10, 30) : 10;
-	let sessions = [];
-	try {
-		let sessionSql = `
-      SELECT DISTINCT session_id FROM tool_usage_events
-      WHERE session_id IS NOT NULL
-    `;
-		const sessionParams = [];
-		if (projectFilter) {
-			sessionSql += " AND project_hash = ?";
-			sessionParams.push(projectFilter);
-		}
-		sessionSql += " ORDER BY created_at DESC LIMIT ?";
-		sessionParams.push(limit);
-		const sessionIds = db.prepare(sessionSql).all(...sessionParams);
-		if (sessionIds.length > 0) {
-			const placeholders = sessionIds.map(() => "?").join(", ");
-			const ids = sessionIds.map((s) => s.session_id);
-			const eventRows = db.prepare(`
-        SELECT session_id, tool_name, created_at
-        FROM tool_usage_events
-        WHERE session_id IN (${placeholders})
-        ORDER BY session_id, created_at ASC
-      `).all(...ids);
-			const sessionMap = /* @__PURE__ */ new Map();
-			for (const row of eventRows) {
-				if (!sessionMap.has(row.session_id)) sessionMap.set(row.session_id, []);
-				sessionMap.get(row.session_id).push({
-					name: row.tool_name,
-					time: row.created_at
-				});
-			}
-			sessions = sessionIds.filter((s) => sessionMap.has(s.session_id)).map((s) => ({
-				sessionId: s.session_id,
-				tools: sessionMap.get(s.session_id)
-			}));
-		}
-	} catch {}
-	return c.json({ sessions });
-});
-/**
 * Finds connected components in the graph via BFS.
 * Shared by /api/graph/analysis and /api/graph/communities.
 */
@@ -6626,14 +5317,6 @@ function safeParseJson(json) {
 *
 * @module web/routes/admin
 */
-const __dirname = dirname(fileURLToPath$1(import.meta.url));
-const LAMINARK_VERSION = (() => {
-	try {
-		return JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8")).version || "unknown";
-	} catch {
-		return "unknown";
-	}
-})();
 function getDb(c) {
 	return c.get("db");
 }
@@ -6708,51 +5391,6 @@ adminRoutes.get("/stats", (c) => {
 	});
 });
 /**
-* GET /api/admin/system
-*
-* Returns server-scoped system info (not project-scoped).
-*/
-adminRoutes.get("/system", (c) => {
-	const db = getDb(c);
-	const mem = process.memoryUsage();
-	let dbSizeBytes = 0;
-	let pageCount = 0;
-	let pageSize = 4096;
-	try {
-		const pc = db.pragma("page_count", { simple: true });
-		const ps = db.pragma("page_size", { simple: true });
-		pageCount = pc;
-		pageSize = ps;
-		dbSizeBytes = pc * ps;
-	} catch {}
-	let walSizeBytes = 0;
-	try {
-		const dbPath = db.name;
-		if (dbPath) {
-			const walPath = dbPath + "-wal";
-			if (existsSync(walPath)) walSizeBytes = statSync(walPath).size;
-		}
-	} catch {}
-	return c.json({
-		laminarkVersion: LAMINARK_VERSION,
-		nodeVersion: process.version,
-		platform: process.platform,
-		arch: process.arch,
-		uptimeSeconds: Math.floor(process.uptime()),
-		memory: {
-			rssBytes: mem.rss,
-			heapUsedBytes: mem.heapUsed,
-			heapTotalBytes: mem.heapTotal
-		},
-		database: {
-			sizeBytes: dbSizeBytes,
-			walSizeBytes,
-			pageCount,
-			pageSize
-		}
-	});
-});
-/**
 * POST /api/admin/reset
 *
 * Hard-deletes data by group inside a transaction.
@@ -6857,66 +5495,6 @@ adminRoutes.post("/reset", async (c) => {
 		scope: scoped ? "project" : "all"
 	});
 });
-adminRoutes.get("/hygiene", (c) => {
-	const db = getDb(c);
-	const project = getProjectHash$1(c);
-	if (!project) return c.json({ error: "No project context available" }, 400);
-	const tier = c.req.query("tier") || "high";
-	const sessionId = c.req.query("session_id");
-	const limit = parseInt(c.req.query("limit") || "50", 10);
-	const config = loadHygieneConfig();
-	const report = analyzeObservations(db, project, {
-		sessionId,
-		limit,
-		minTier: tier === "all" ? "low" : tier,
-		config
-	});
-	return c.json(report);
-});
-adminRoutes.post("/hygiene/purge", async (c) => {
-	const db = getDb(c);
-	const project = getProjectHash$1(c);
-	if (!project) return c.json({ error: "No project context available" }, 400);
-	const tier = (await c.req.json()).tier || "high";
-	const config = loadHygieneConfig();
-	const result = executePurge(db, project, analyzeObservations(db, project, {
-		minTier: tier === "all" ? "low" : tier,
-		limit: 500,
-		config
-	}), tier);
-	return c.json({
-		ok: true,
-		observationsPurged: result.observationsPurged,
-		orphanNodesRemoved: result.orphanNodesRemoved,
-		tier
-	});
-});
-adminRoutes.get("/hygiene/find", (c) => {
-	const db = getDb(c);
-	const project = getProjectHash$1(c);
-	if (!project) return c.json({ error: "No project context available" }, 400);
-	const report = findAnalysis(db, project, loadHygieneConfig());
-	return c.json(report);
-});
-adminRoutes.get("/config/hygiene", (c) => {
-	return c.json(loadHygieneConfig());
-});
-adminRoutes.put("/config/hygiene", async (c) => {
-	const body = await c.req.json();
-	const configPath = join(getConfigDir(), "hygiene.json");
-	if (body && body.__reset === true) {
-		try {
-			if (existsSync(configPath)) unlinkSync(configPath);
-		} catch {}
-		return c.json(resetHygieneConfig());
-	}
-	if (typeof body !== "object" || body === null || Array.isArray(body)) return c.json({ error: "Request body must be a JSON object" }, 400);
-	const { __reset: _, ...data } = body;
-	writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
-	const validated = loadHygieneConfig();
-	saveHygieneConfig(validated);
-	return c.json(validated);
-});
 adminRoutes.get("/config/topic-detection", (c) => {
 	return c.json(loadTopicDetectionConfig());
 });
@@ -6955,39 +5533,6 @@ adminRoutes.put("/config/graph-extraction", async (c) => {
 	writeFileSync(configPath, JSON.stringify(validated, null, 2), "utf-8");
 	return c.json(validated);
 });
-adminRoutes.get("/config/cross-access", (c) => {
-	const project = c.req.query("project");
-	if (!project) return c.json({ error: "project query parameter is required" }, 400);
-	return c.json(loadCrossAccessConfig(project));
-});
-adminRoutes.put("/config/cross-access", async (c) => {
-	const project = c.req.query("project");
-	if (!project) return c.json({ error: "project query parameter is required" }, 400);
-	const body = await c.req.json();
-	if (body && body.__reset === true) {
-		resetCrossAccessConfig(project);
-		return c.json(loadCrossAccessConfig(project));
-	}
-	if (typeof body !== "object" || body === null || Array.isArray(body)) return c.json({ error: "Request body must be a JSON object" }, 400);
-	saveCrossAccessConfig(project, { readableProjects: body.readableProjects || [] });
-	return c.json(loadCrossAccessConfig(project));
-});
-adminRoutes.get("/config/tool-verbosity", (c) => {
-	return c.json(loadToolVerbosityConfig());
-});
-adminRoutes.put("/config/tool-verbosity", async (c) => {
-	const body = await c.req.json();
-	if (body && body.__reset === true) {
-		const config = resetToolVerbosityConfig();
-		saveToolVerbosityConfig(config);
-		return c.json(config);
-	}
-	if (typeof body !== "object" || body === null || Array.isArray(body)) return c.json({ error: "Request body must be a JSON object" }, 400);
-	const level = body.level;
-	if (level !== 1 && level !== 2 && level !== 3) return c.json({ error: "level must be 1, 2, or 3" }, 400);
-	saveToolVerbosityConfig({ level });
-	return c.json(loadToolVerbosityConfig());
-});
 
 //#endregion
 //#region src/web/server.ts
@@ -7096,46 +5641,14 @@ const noGui = process.argv.includes("--no_gui");
 const db = openDatabase(getDatabaseConfig());
 initGraphSchema(db.db);
 initPathSchema(db.db);
-var LiveProjectHashRef = class LiveProjectHashRef {
-	_current;
-	_lastChecked = 0;
-	_db;
-	static CHECK_INTERVAL_MS = 2e3;
-	constructor(sqliteDb) {
-		this._db = sqliteDb;
-		this._current = this.resolve();
-	}
-	get current() {
-		const now = Date.now();
-		if (now - this._lastChecked >= LiveProjectHashRef.CHECK_INTERVAL_MS) {
-			this._lastChecked = now;
-			const fresh = this.resolve();
-			if (fresh !== this._current) {
-				debug("mcp", "Project hash refreshed from database", {
-					old: this._current,
-					new: fresh
-				});
-				this._current = fresh;
-			}
-		}
-		return this._current;
-	}
-	resolve() {
-		try {
-			const row = this._db.prepare("SELECT project_hash FROM project_metadata ORDER BY last_seen_at DESC LIMIT 1").get();
-			if (row?.project_hash) return row.project_hash;
-		} catch {}
-		return getProjectHash(process.cwd());
-	}
-};
-const projectHashRef = new LiveProjectHashRef(db.db);
+const projectHash = getProjectHash(process.cwd());
 let toolRegistry = null;
 try {
 	toolRegistry = new ToolRegistryRepository(db.db);
 } catch {
 	debug("mcp", "Tool registry not available (pre-migration-16)");
 }
-const embeddingStore = db.hasVectorSupport ? new EmbeddingStore(db.db, projectHashRef.current) : null;
+const embeddingStore = db.hasVectorSupport ? new EmbeddingStore(db.db, projectHash) : null;
 const worker = new AnalysisWorker();
 worker.start().catch(() => {
 	debug("mcp", "Worker failed to start, keyword-only mode");
@@ -7148,7 +5661,7 @@ const adaptiveManager = new AdaptiveThresholdManager({
 	alpha: topicConfig.ewmaAlpha
 });
 applyConfig(topicConfig, detector, adaptiveManager);
-const historicalSeed = new ThresholdStore(db.db).loadHistoricalSeed(projectHashRef.current);
+const historicalSeed = new ThresholdStore(db.db).loadHistoricalSeed(projectHash);
 if (historicalSeed) {
 	adaptiveManager.seedFromHistory(historicalSeed.averageDistance, historicalSeed.averageVariance);
 	applyConfig(topicConfig, detector, adaptiveManager);
@@ -7159,7 +5672,7 @@ const notificationStore = new NotificationStore(db.db);
 const topicShiftHandler = new TopicShiftHandler({
 	detector,
 	stashManager,
-	observationStore: new ObservationRepository(db.db, projectHashRef.current),
+	observationStore: new ObservationRepository(db.db, projectHash),
 	config: topicConfig,
 	decisionLogger,
 	adaptiveManager
@@ -7174,8 +5687,7 @@ async function processUnembedded() {
 	if (!embeddingStore || !worker.isReady()) return;
 	const ids = embeddingStore.findUnembedded(10);
 	if (ids.length === 0) return;
-	const currentHash = projectHashRef.current;
-	const obsRepo = new ObservationRepository(db.db, currentHash);
+	const obsRepo = new ObservationRepository(db.db, projectHash);
 	let shiftDetectedThisCycle = false;
 	for (const id of ids) {
 		const obs = obsRepo.getById(id);
@@ -7192,26 +5704,24 @@ async function processUnembedded() {
 				id,
 				text: obs.content.length > 120 ? obs.content.substring(0, 120) + "..." : obs.content,
 				sessionId: obs.sessionId ?? null,
-				createdAt: obs.createdAt,
-				projectHash: currentHash
+				createdAt: obs.createdAt
 			});
 			if (topicConfig.enabled && !shiftDetectedThisCycle && TOPIC_SHIFT_SOURCES.has(obs.source)) try {
 				const obsWithEmbedding = {
 					...obs,
 					embedding
 				};
-				const result = await topicShiftHandler.handleObservation(obsWithEmbedding, obs.sessionId ?? "unknown", currentHash);
+				const result = await topicShiftHandler.handleObservation(obsWithEmbedding, obs.sessionId ?? "unknown", projectHash);
 				if (result.stashed && result.notification) {
 					shiftDetectedThisCycle = true;
-					notificationStore.add(currentHash, result.notification);
+					notificationStore.add(projectHash, result.notification);
 					debug("embed", "Topic shift detected, notification queued", { id });
 					broadcast("topic_shift", {
 						id: result.notification.substring(0, 32),
 						fromTopic: null,
 						toTopic: null,
 						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-						confidence: null,
-						projectHash: currentHash
+						confidence: null
 					});
 				}
 			} catch (topicErr) {
@@ -7222,7 +5732,7 @@ async function processUnembedded() {
 }
 let researchBufferForFlush = null;
 try {
-	researchBufferForFlush = new ResearchBufferRepository(db.db, projectHashRef.current);
+	researchBufferForFlush = new ResearchBufferRepository(db.db, projectHash);
 } catch {}
 async function processUnembeddedTools() {
 	if (!toolRegistry || !worker.isReady() || !db.hasVectorSupport) return;
@@ -7249,39 +5759,26 @@ const embedTimer = setInterval(() => {
 	} catch {}
 	statusCache.refreshIfDirty();
 }, 5e3);
-const statusCache = new StatusCache(db.db, projectHashRef, process.cwd(), db.hasVectorSupport, () => worker.isReady());
+const statusCache = new StatusCache(db.db, projectHash, process.cwd(), db.hasVectorSupport, () => worker.isReady());
 const server = createServer();
-registerSaveMemory(server, db.db, projectHashRef, notificationStore, worker, embeddingStore, statusCache);
-registerIngestKnowledge(server, db.db, projectHashRef, notificationStore, statusCache);
-registerRecall(server, db.db, projectHashRef, worker, embeddingStore, notificationStore, statusCache);
-registerTopicContext(server, db.db, projectHashRef, notificationStore);
-registerQueryGraph(server, db.db, projectHashRef, notificationStore);
-registerGraphStats(server, db.db, projectHashRef, notificationStore);
-registerHygiene(server, db.db, projectHashRef, notificationStore);
-registerStatus(server, statusCache, projectHashRef, notificationStore);
+registerSaveMemory(server, db.db, projectHash, notificationStore, worker, embeddingStore, statusCache);
+registerRecall(server, db.db, projectHash, worker, embeddingStore, notificationStore, statusCache);
+registerTopicContext(server, db.db, projectHash, notificationStore);
+registerQueryGraph(server, db.db, projectHash, notificationStore);
+registerGraphStats(server, db.db, projectHash, notificationStore);
+registerStatus(server, statusCache, projectHash, notificationStore);
 if (toolRegistry) {
-	registerDiscoverTools(server, toolRegistry, worker, db.hasVectorSupport, notificationStore, projectHashRef);
-	registerReportTools(server, toolRegistry, projectHashRef);
+	registerDiscoverTools(server, toolRegistry, worker, db.hasVectorSupport, notificationStore, projectHash);
+	registerReportTools(server, toolRegistry, projectHash);
 }
-const pathRepo = new PathRepository(db.db, projectHashRef.current);
+const pathRepo = new PathRepository(db.db, projectHash);
 const pathTracker = new PathTracker(pathRepo);
-registerDebugPathTools(server, pathRepo, pathTracker, notificationStore, projectHashRef);
-let branchRepo = null;
-let branchTracker = null;
-try {
-	branchRepo = new BranchRepository(db.db, projectHashRef.current);
-	branchTracker = new BranchTracker(branchRepo, db.db, projectHashRef.current);
-	const obsRepoForBranches = new ObservationRepository(db.db, projectHashRef.current);
-	registerThoughtBranchTools(server, branchRepo, obsRepoForBranches, notificationStore, projectHashRef);
-} catch {
-	debug("mcp", "Branch tracking not available (pre-migration-21)");
-}
-const haikuProcessor = new HaikuProcessor(db.db, projectHashRef.current, {
+registerDebugPathTools(server, pathRepo, pathTracker, notificationStore, projectHash);
+const haikuProcessor = new HaikuProcessor(db.db, projectHash, {
 	intervalMs: 3e4,
 	batchSize: 10,
 	concurrency: 3,
-	pathTracker,
-	branchTracker
+	pathTracker
 });
 startServer(server).then(() => {
 	haikuProcessor.start();
@@ -7296,7 +5793,7 @@ if (!noGui) {
 	const __filename = fileURLToPath(import.meta.url);
 	const __dirname = path.dirname(__filename);
 	const uiRoot = path.resolve(__dirname, "..", "ui");
-	startWebServer(createWebServer(db.db, uiRoot, projectHashRef.current), webPort);
+	startWebServer(createWebServer(db.db, uiRoot, projectHash), webPort);
 } else debug("mcp", "Web UI disabled (--no_gui)");
 const curationAgent = new CurationAgent(db.db, {
 	intervalMs: 300 * 1e3,