laminark 2.21.8 → 2.21.9

package/plugin/dist/index.js

@@ -1,17 +1,18 @@
 #!/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 { 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 { 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-D8un_AcG.mjs";
+import { existsSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, 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";
@@ -371,6 +372,44 @@ 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;
@@ -399,6 +438,82 @@ 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) {
@@ -430,19 +545,19 @@ function formatTimelineGroup(date, items) {
 function formatFullItem(obs) {
 	return `--- ${shortId(obs.id)} | ${obs.title ?? "untitled"} | ${obs.createdAt} ---\n${obs.content}`;
 }
-function prependNotifications$6(notificationStore, projectHash, responseText) {
+function prependNotifications$8(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$9(text) {
 	return { content: [{
 		type: "text",
 		text
 	}] };
 }
-function errorResponse$3(text) {
+function errorResponse$4(text) {
 	return {
 		content: [{
 			type: "text",
@@ -451,7 +566,15 @@ function errorResponse$3(text) {
 		isError: true
 	};
 }
-function registerRecall(server, db, projectHash, worker = null, embeddingStore = null, notificationStore = null, statusCache = null) {
+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) {
 	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.",
@@ -481,13 +604,14 @@ function registerRecall(server, db, projectHash, worker = null, embeddingStore =
 			include_purged: z.boolean().default(false).describe("Include soft-deleted items in results (needed for restore)")
 		}
 	}, async (args) => {
-		const withNotifications = (text) => textResponse$7(prependNotifications$6(notificationStore, projectHash, text));
+		const projectHash = projectHashRef.current;
+		const withNotifications = (text) => textResponse$9(prependNotifications$8(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$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}.`);
+			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}.`);
 			let observations = [];
 			let searchResults = null;
 			if (args.ids) {
@@ -514,6 +638,30 @@ function registerRecall(server, db, projectHash, worker = null, embeddingStore =
 				});
 				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
@@ -525,8 +673,21 @@ function registerRecall(server, db, projectHash, worker = null, embeddingStore =
 			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$7(prependNotifications$6(notificationStore, projectHash, originalText));
+				return textResponse$9(prependNotifications$8(notificationStore, projectHash, originalText));
 			}
 			if (args.action === "purge") {
 				const targetIds = args.ids ?? (args.id ? [args.id] : []);
@@ -558,11 +719,11 @@ function registerRecall(server, db, projectHash, worker = null, embeddingStore =
 				if (failures.length > 0) msg += ` Not found: ${failures.join(", ")}`;
 				return withNotifications(msg);
 			}
-			return errorResponse$3(`Unknown action: ${args.action}`);
+			return errorResponse$4(`Unknown action: ${args.action}`);
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "recall: error", { error: message });
-			return errorResponse$3(`Recall error: ${message}`);
+			return errorResponse$4(`Recall error: ${message}`);
 		}
 	});
 }
@@ -622,7 +783,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$7(`${body}\n${footer}`);
+	return textResponse$9(`${body}\n${footer}`);
 }
 function buildScoreMap(searchResults) {
 	const map = /* @__PURE__ */ new Map();
@@ -648,7 +809,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, projectHash, notificationStore = null, worker = null, embeddingStore = null, statusCache = null) {
+function registerSaveMemory(server, db, projectHashRef, 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.",
@@ -665,6 +826,7 @@ function registerSaveMemory(server, db, projectHash, notificationStore = null, w
 			]).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, {
@@ -693,7 +855,7 @@ function registerSaveMemory(server, db, projectHash, notificationStore = null, w
 				title: resolvedTitle
 			});
 			statusCache?.markDirty();
-			let responseText = `Saved memory "${resolvedTitle}" (id: ${obs.id})`;
+			let responseText = verboseResponse("Memory saved.", `Saved "${resolvedTitle}"`, `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;
@@ -714,6 +876,248 @@ function registerSaveMemory(server, db, projectHash, notificationStore = null, w
 	});
 }
 
+//#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
 /**
@@ -785,13 +1189,13 @@ function formatStashes(stashes) {
 	if (stashes.length <= 8) return formatDetail(stashes);
 	return formatCompact(stashes);
 }
-function prependNotifications$5(notificationStore, projectHash, responseText) {
+function prependNotifications$7(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$8(text) {
 	return { content: [{
 		type: "text",
 		text
@@ -803,7 +1207,7 @@ function textResponse$6(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, projectHash, notificationStore = null) {
+function registerTopicContext(server, db, projectHashRef, notificationStore = null) {
 	const stashManager = new StashManager(db);
 	server.registerTool("topic_context", {
 		title: "Topic Context",
@@ -813,7 +1217,8 @@ function registerTopicContext(server, db, projectHash, notificationStore = null)
 			limit: z.number().int().min(1).max(20).default(5).describe("Max threads to return")
 		}
 	}, async (args) => {
-		const withNotifications = (text) => textResponse$6(prependNotifications$5(notificationStore, projectHash, text));
+		const projectHash = projectHashRef.current;
+		const withNotifications = (text) => textResponse$8(prependNotifications$7(notificationStore, projectHash, text));
 		try {
 			debug("mcp", "topic_context: request", {
 				query: args.query,
@@ -825,6 +1230,9 @@ function registerTopicContext(server, db, projectHash, notificationStore = null)
 				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 });
@@ -832,7 +1240,7 @@ function registerTopicContext(server, db, projectHash, notificationStore = null)
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "topic_context: error", { error: message });
-			return textResponse$6(`Error retrieving context threads: ${message}`);
+			return textResponse$8(`Error retrieving context threads: ${message}`);
 		}
 	});
 }
@@ -937,19 +1345,19 @@ function formatAge(isoDate) {
 	const months = Math.floor(days / 30);
 	return `${months} month${months !== 1 ? "s" : ""} ago`;
 }
-function prependNotifications$4(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$5(text) {
+function textResponse$7(text) {
 	return { content: [{
 		type: "text",
 		text
 	}] };
 }
-function errorResponse$2(text) {
+function errorResponse$3(text) {
 	return {
 		content: [{
 			type: "text",
@@ -964,7 +1372,7 @@ function errorResponse$2(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, projectHash, notificationStore = null) {
+function registerQueryGraph(server, db, projectHashRef, notificationStore = null) {
 	initGraphSchema(db);
 	server.registerTool("query_graph", {
 		title: "Query Knowledge Graph",
@@ -977,17 +1385,18 @@ function registerQueryGraph(server, db, projectHash, 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 withNotifications = (text) => textResponse$5(prependNotifications$4(notificationStore, projectHash, text));
+		const projectHash = projectHashRef.current;
+		const withNotifications = (text) => textResponse$7(prependNotifications$6(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$2(`Invalid entity_type "${args.entity_type}". Valid types: ${ENTITY_TYPES.join(", ")}`);
+			if (args.entity_type !== void 0 && !isEntityType(args.entity_type)) return errorResponse$3(`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$2(`Invalid relationship_type "${rt}". Valid types: ${RELATIONSHIP_TYPES.join(", ")}`);
+				for (const rt of args.relationship_types) if (!isRelationshipType(rt)) return errorResponse$3(`Invalid relationship_type "${rt}". Valid types: ${RELATIONSHIP_TYPES.join(", ")}`);
 			}
 			const relationshipTypes = args.relationship_types;
 			const rootNodes = [];
@@ -1048,6 +1457,21 @@ function registerQueryGraph(server, db, projectHash, 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,
@@ -1058,180 +1482,11 @@ function registerQueryGraph(server, db, projectHash, notificationStore = null) {
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "query_graph: error", { error: message });
-			return errorResponse$2(`Graph query error: ${message}`);
+			return errorResponse$3(`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
 /**
@@ -1329,13 +1584,13 @@ function formatStats(stats) {
 	}
 	return lines.join("\n");
 }
-function prependNotifications$3(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$4(text) {
+function textResponse$6(text) {
 	return { content: [{
 		type: "text",
 		text
@@ -1348,13 +1603,14 @@ function textResponse$4(text) {
 * type distribution, degree statistics, hotspot nodes, duplicate candidates,
 * and staleness flags. No input parameters -- dashboard view.
 */
-function registerGraphStats(server, db, projectHash, notificationStore = null) {
+function registerGraphStats(server, db, projectHashRef, 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);
@@ -1363,50 +1619,170 @@ function registerGraphStats(server, db, projectHash, notificationStore = null) {
 				nodes: stats.total_nodes,
 				edges: stats.total_edges
 			});
-			return textResponse$4(prependNotifications$3(notificationStore, projectHash, formatted));
+			return textResponse$6(prependNotifications$5(notificationStore, projectHash, formatted));
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
 			debug("mcp", "graph_stats: error", { error: message });
-			return textResponse$4(`Graph stats error: ${message}`);
+			return textResponse$6(`Graph stats error: ${message}`);
 		}
 	});
 }
 
 //#endregion
-//#region src/mcp/tools/status.ts
-function prependNotifications$2(notificationStore, projectHash, responseText) {
+//#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) {
 	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$3(text) {
+function textResponse$5(text) {
 	return { content: [{
 		type: "text",
 		text
 	}] };
 }
-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 () => {
+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;
 		try {
-			debug("mcp", "status: request (cached)");
-			return textResponse$3(prependNotifications$2(notificationStore, projectHash, cache.getFormatted()));
+			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)));
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Unknown error";
-			debug("mcp", "status: error", { error: message });
-			return textResponse$3(`Status error: ${message}`);
+			debug("hygiene", "Error", { error: message });
+			return textResponse$5(`Hygiene analysis error: ${message}`);
 		}
 	});
 }
 
 //#endregion
-//#region src/mcp/status-cache.ts
-function formatUptime(seconds) {
-	const h = Math.floor(seconds / 3600);
+//#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}`);
+		}
+	});
+}
+
+//#endregion
+//#region src/mcp/status-cache.ts
+function formatUptime(seconds) {
+	const h = Math.floor(seconds / 3600);
 	const m = Math.floor(seconds % 3600 / 60);
 	const s = seconds % 60;
 	if (h > 0) return `${h}h ${m}m`;
@@ -1415,7 +1791,7 @@ function formatUptime(seconds) {
 }
 var StatusCache = class {
 	db;
-	projectHash;
+	projectHashRef;
 	projectPath;
 	hasVectorSupport;
 	isWorkerReady;
@@ -1424,9 +1800,9 @@ var StatusCache = class {
 	/** Uptime snapshot at the time cachedBody was built. */
 	builtAtUptime = 0;
 	dirty = false;
-	constructor(db, projectHash, projectPath, hasVectorSupport, isWorkerReady) {
+	constructor(db, projectHashRef, projectPath, hasVectorSupport, isWorkerReady) {
 		this.db = db;
-		this.projectHash = projectHash;
+		this.projectHashRef = projectHashRef;
 		this.projectPath = projectPath;
 		this.hasVectorSupport = hasVectorSupport;
 		this.isWorkerReady = isWorkerReady;
@@ -1453,7 +1829,7 @@ var StatusCache = class {
 	}
 	rebuild() {
 		try {
-			const ph = this.projectHash;
+			const ph = this.projectHashRef.current;
 			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;
@@ -1509,13 +1885,13 @@ var StatusCache = class {
 
 //#endregion
 //#region src/mcp/tools/discover-tools.ts
-function textResponse$2(text) {
+function textResponse$3(text) {
 	return { content: [{
 		type: "text",
 		text
 	}] };
 }
-function errorResponse$1(text) {
+function errorResponse$2(text) {
 	return {
 		content: [{
 			type: "text",
@@ -1524,7 +1900,7 @@ function errorResponse$1(text) {
 		isError: true
 	};
 }
-function prependNotifications$1(notificationStore, projectHash, responseText) {
+function prependNotifications$2(notificationStore, projectHash, responseText) {
 	if (!notificationStore) return responseText;
 	const pending = notificationStore.consumePending(projectHash);
 	if (pending.length === 0) return responseText;
@@ -1545,7 +1921,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, projectHash) {
+function registerDiscoverTools(server, toolRegistry, worker, hasVectorSupport, notificationStore, projectHashRef) {
 	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.",
@@ -1559,7 +1935,8 @@ 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 withNotifications = (text) => textResponse$2(prependNotifications$1(notificationStore, projectHash, text));
+		const projectHash = projectHashRef.current;
+		const withNotifications = (text) => textResponse$3(prependNotifications$2(notificationStore, projectHash, text));
 		try {
 			debug("mcp", "discover_tools: request", {
 				query: args.query,
@@ -1597,14 +1974,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$1(`Discover tools error: ${message}`);
+			return errorResponse$2(`Discover tools error: ${message}`);
 		}
 	});
 }
 
 //#endregion
 //#region src/mcp/tools/report-tools.ts
-function textResponse$1(text) {
+function textResponse$2(text) {
 	return { content: [{
 		type: "text",
 		text
@@ -1617,7 +1994,7 @@ function textResponse$1(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, projectHash) {
+function registerReportTools(server, toolRegistry, projectHashRef) {
 	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.",
@@ -1626,6 +2003,7 @@ function registerReportTools(server, toolRegistry, projectHash) {
 			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;
@@ -1644,7 +2022,8 @@ function registerReportTools(server, toolRegistry, projectHash) {
 					source: "config:session-report",
 					projectHash: scope === "global" ? null : projectHash,
 					description: tool.description ?? null,
-					serverName
+					serverName,
+					triggerHints: null
 				});
 				registered++;
 			}
@@ -1653,7 +2032,7 @@ function registerReportTools(server, toolRegistry, projectHash) {
 				registered,
 				skipped
 			});
-			return textResponse$1(`Registered ${registered} tools in the tool registry.${skipped > 0 ? ` Skipped ${skipped} Laminark tools (already known).` : ""}`);
+			return textResponse$2(`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 });
@@ -1670,19 +2049,19 @@ function registerReportTools(server, toolRegistry, projectHash) {
 
 //#endregion
 //#region src/mcp/tools/debug-paths.ts
-function prependNotifications(notificationStore, projectHash, responseText) {
+function prependNotifications$1(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) {
+function textResponse$1(text) {
 	return { content: [{
 		type: "text",
 		text
 	}] };
 }
-function errorResponse(text) {
+function errorResponse$1(text) {
 	return {
 		content: [{
 			type: "text",
@@ -1712,125 +2091,882 @@ function formatKissSummary(raw) {
 *
 * Tools: path_start, path_resolve, path_show, path_list
 */
-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 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("Failed to start debug path");
-			if (existingPathId && existingPathId === pathId) return withNotifications(`Debug path already active: ${pathId}`);
-			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(`path_start error: ${message}`);
-		}
-	});
-	server.registerTool("path_resolve", {
-		title: "Resolve Debug Path",
-		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 withNotifications = (text) => textResponse(prependNotifications(notificationStore, projectHash, text));
-		try {
-			debug("mcp", "path_resolve: request", { resolution: args.resolution });
-			const pathId = pathTracker.getActivePathId();
-			if (!pathId) return errorResponse("No active debug path to resolve");
-			pathTracker.resolveManually(args.resolution);
-			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(`path_resolve error: ${message}`);
+function registerDebugPathTools(server, pathRepo, pathTracker, notificationStore, projectHashRef) {
+	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));
+		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 (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}`));
+		} 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}`);
+		}
+	});
+	server.registerTool("path_resolve", {
+		title: "Resolve Debug Path",
+		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));
+		try {
+			debug("mcp", "path_resolve: request", { resolution: args.resolution });
+			const pathId = pathTracker.getActivePathId();
+			if (!pathId) return errorResponse$1("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...`));
+		} 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}`);
+		}
+	});
+	server.registerTool("path_show", {
+		title: "Show Debug Path",
+		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));
+		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}`);
+			} else {
+				pathData = pathRepo.getActivePath();
+				if (!pathData) return errorResponse$1("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}`);
+			lines.push(`Started: ${pathData.started_at}`);
+			lines.push(`Trigger: ${pathData.trigger_summary}`);
+			lines.push("");
+			lines.push(`### Waypoints (${waypoints.length})`);
+			for (let i = 0; i < waypoints.length; i++) {
+				const wp = waypoints[i];
+				lines.push(`${i + 1}. [${wp.waypoint_type}] ${wp.summary} (${wp.created_at})`);
+			}
+			lines.push("");
+			lines.push("### Resolution");
+			lines.push(pathData.resolution_summary ?? "Still active");
+			lines.push("");
+			lines.push("### KISS Summary");
+			lines.push(formatKissSummary(pathData.kiss_summary));
+			return withNotifications(lines.join("\n"));
+		} 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}`);
+		}
+	});
+	server.registerTool("path_list", {
+		title: "List Debug Paths",
+		description: "List recent debug paths, optionally filtered by status.",
+		inputSchema: {
+			status: z.enum([
+				"active",
+				"resolved",
+				"abandoned"
+			]).optional().describe("Filter by status"),
+			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));
+		try {
+			debug("mcp", "path_list: request", {
+				status: args.status,
+				limit: args.limit
+			});
+			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 });
 		}
-	});
-	server.registerTool("path_show", {
-		title: "Show Debug Path",
-		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 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(`Debug path not found: ${args.path_id}`);
-			} else {
-				pathData = pathRepo.getActivePath();
-				if (!pathData) return errorResponse("No active debug path");
-			}
-			const waypoints = pathRepo.getWaypoints(pathData.id);
-			const lines = [];
-			lines.push(`## Debug Path: ${pathData.id}`);
-			lines.push(`Status: ${pathData.status}`);
-			lines.push(`Started: ${pathData.started_at}`);
-			lines.push(`Trigger: ${pathData.trigger_summary}`);
-			lines.push("");
-			lines.push(`### Waypoints (${waypoints.length})`);
-			for (let i = 0; i < waypoints.length; i++) {
-				const wp = waypoints[i];
-				lines.push(`${i + 1}. [${wp.waypoint_type}] ${wp.summary} (${wp.created_at})`);
+	}
+	/**
+	* 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);
 			}
-			lines.push("");
-			lines.push("### Resolution");
-			lines.push(pathData.resolution_summary ?? "Still active");
-			lines.push("");
-			lines.push("### KISS Summary");
-			lines.push(formatKissSummary(pathData.kiss_summary));
-			return withNotifications(lines.join("\n"));
-		} catch (err) {
-			const message = err instanceof Error ? err.message : "Unknown error";
-			debug("mcp", "path_show: error", { error: message });
-			return errorResponse(`path_show error: ${message}`);
+			this.repo.addObservation(this.activeBranchId, obs.id, toolName, arcStage);
+			const newStage = inferArcStage(this.toolPattern, obs.classification);
+			this.repo.updateArcStage(this.activeBranchId, newStage);
 		}
-	});
-	server.registerTool("path_list", {
-		title: "List Debug Paths",
-		description: "List recent debug paths, optionally filtered by status.",
-		inputSchema: {
-			status: z.enum([
-				"active",
-				"resolved",
-				"abandoned"
-			]).optional().describe("Filter by status"),
-			limit: z.number().int().min(1).max(50).default(10).describe("Max paths to return")
+		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 });
 		}
-	}, async (args) => {
-		const withNotifications = (text) => textResponse(prependNotifications(notificationStore, projectHash, text));
-		try {
-			debug("mcp", "path_list: request", {
-				status: args.status,
-				limit: args.limit
+	}
+	/**
+	* 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
 			});
-			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 lines = [];
-			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} |`);
+		}
+	}
+	/**
+	* 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
+					});
+				}
 			}
-			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}`);
+			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;
+	}
+};
 
 //#endregion
 //#region src/analysis/worker-bridge.ts
@@ -3512,149 +4648,59 @@ var CurationAgent = class {
 		if (this.running) return;
 		this.running = true;
 		this.timer = setInterval(() => {
-			this.runOnce();
-		}, this.intervalMs);
-		process.stderr.write(`[laminark:curation] Agent started, interval: ${this.intervalMs}ms\n`);
-	}
-	/**
-	* Stop the periodic curation timer.
-	*/
-	stop() {
-		if (this.timer) {
-			clearInterval(this.timer);
-			this.timer = null;
-		}
-		this.running = false;
-		process.stderr.write("[laminark:curation] Agent stopped\n");
-	}
-	/**
-	* Execute one curation cycle. This is the main entry point.
-	*/
-	async runOnce() {
-		if (this.cycling) return {
-			startedAt: "",
-			completedAt: "",
-			observationsMerged: 0,
-			entitiesDeduplicated: 0,
-			stalenessFlagsAdded: 0,
-			lowValuePruned: 0,
-			temporalDecayUpdated: 0,
-			temporalDecayDeleted: 0,
-			errors: ["skipped: previous cycle still running"]
-		};
-		this.cycling = true;
-		try {
-			const report = await runCuration(this.db, this.graphConfig);
-			this.lastRun = report.completedAt;
-			if (this.onComplete) this.onComplete(report);
-			return report;
-		} finally {
-			this.cycling = false;
-		}
-	}
-	/**
-	* Whether the agent is currently running.
-	*/
-	isRunning() {
-		return this.running;
-	}
-	/**
-	* Timestamp of the last completed curation run.
-	*/
-	getLastRun() {
-		return this.lastRun;
-	}
-};
-
-//#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}`);
+			this.runOnce();
+		}, this.intervalMs);
+		process.stderr.write(`[laminark:curation] Agent started, interval: ${this.intervalMs}ms\n`);
+	}
+	/**
+	* Stop the periodic curation timer.
+	*/
+	stop() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = null;
 		}
-		return "";
-	} catch (error) {
+		this.running = false;
+		process.stderr.write("[laminark:curation] Agent stopped\n");
+	}
+	/**
+	* Execute one curation cycle. This is the main entry point.
+	*/
+	async runOnce() {
+		if (this.cycling) return {
+			startedAt: "",
+			completedAt: "",
+			observationsMerged: 0,
+			entitiesDeduplicated: 0,
+			stalenessFlagsAdded: 0,
+			lowValuePruned: 0,
+			temporalDecayUpdated: 0,
+			temporalDecayDeleted: 0,
+			errors: ["skipped: previous cycle still running"]
+		};
+		this.cycling = true;
 		try {
-			_session?.close();
-		} catch {}
-		_session = null;
-		throw error;
+			const report = await runCuration(this.db, this.graphConfig);
+			this.lastRun = report.completedAt;
+			if (this.onComplete) this.onComplete(report);
+			return report;
+		} finally {
+			this.cycling = false;
+		}
 	}
-}
-/**
-* 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");
-}
+	/**
+	* Whether the agent is currently running.
+	*/
+	isRunning() {
+		return this.running;
+	}
+	/**
+	* Timestamp of the last completed curation run.
+	*/
+	getLastRun() {
+		return this.lastRun;
+	}
+};
 
 //#endregion
 //#region src/intelligence/haiku-classifier-agent.ts
@@ -3706,10 +4752,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 debugging?
-   - is_error: Does this contain an error message, test failure, build failure, or exception?
+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.
    - is_resolution: Does this indicate a successful fix, passing test, or resolved 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.
+   - 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".
    - 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}
@@ -4117,6 +5163,7 @@ var HaikuProcessor = class {
 	batchSize;
 	concurrency;
 	pathTracker;
+	branchTracker;
 	timer = null;
 	constructor(db, projectHash, opts) {
 		this.db = db;
@@ -4125,6 +5172,7 @@ 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;
@@ -4148,16 +5196,30 @@ var HaikuProcessor = class {
 	}
 	async processOnce() {
 		if (!isHaikuEnabled()) return;
-		const repo = new ObservationRepository(this.db, this.projectHash);
-		const unclassified = repo.listUnclassified(this.batchSize);
+		const unclassified = ObservationRepository.listAllUnclassified(this.db, this.batchSize);
 		if (unclassified.length === 0) return;
 		debug("haiku", "Processing unclassified observations", { count: unclassified.length });
-		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)));
+		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) });
 		}
 	}
-	async processOne(obs, repo) {
+	async processOne(obs, repo, obsProjectHash) {
+		const projectHash = obsProjectHash ?? this.projectHash;
 		try {
 			let classification;
 			try {
@@ -4171,6 +5233,23 @@ 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);
@@ -4212,7 +5291,7 @@ var HaikuProcessor = class {
 					name: entity.name,
 					metadata: { confidence: entity.confidence },
 					observation_ids: [String(obs.id)],
-					project_hash: this.projectHash
+					project_hash: projectHash
 				});
 				persistedNodes.push(node);
 			} catch {
@@ -4224,7 +5303,8 @@ var HaikuProcessor = class {
 					label: node.name,
 					type: node.type,
 					observationCount: 1,
-					createdAt: (/* @__PURE__ */ new Date()).toISOString()
+					createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+					projectHash
 				});
 				debug("haiku", "Entities persisted", {
 					id: obs.id,
@@ -4249,7 +5329,7 @@ var HaikuProcessor = class {
 							type: rel.type,
 							weight: rel.confidence,
 							metadata: { source: "haiku" },
-							project_hash: this.projectHash
+							project_hash: projectHash
 						});
 						affectedNodeIds.add(sourceNode.id);
 						affectedNodeIds.add(targetNode.id);
@@ -4646,7 +5726,7 @@ apiRoutes.get("/graph", (c) => {
 		edgeRows = [];
 	}
 	const nodeIdSet = new Set(nodes.map((n) => n.id));
-	const edges = (typeFilter ? edgeRows.filter((e) => nodeIdSet.has(e.source_id) && nodeIdSet.has(e.target_id)) : edgeRows).map((row) => ({
+	const edges = edgeRows.filter((e) => nodeIdSet.has(e.source_id) && nodeIdSet.has(e.target_id)).map((row) => ({
 		id: row.id,
 		source: row.source_id,
 		target: row.target_id,
@@ -5224,6 +6304,236 @@ 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.
 */
@@ -5317,6 +6627,14 @@ 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");
 }
@@ -5391,6 +6709,51 @@ 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.
@@ -5495,6 +6858,66 @@ 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());
 });
@@ -5533,6 +6956,121 @@ 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());
+});
+/**
+* DELETE /api/admin/projects/:hash?confirm=true
+*
+* Permanently deletes all data for the given project.
+* Requires `?confirm=true` query param as a safety guard.
+* Cannot delete the currently active (most-recently-seen) project.
+*/
+adminRoutes.delete("/projects/:hash", (c) => {
+	const db = getDb(c);
+	const projectHash = c.req.param("hash");
+	if (c.req.query("confirm") !== "true") return c.json({ error: "Safety guard: append ?confirm=true to proceed with deletion" }, 400);
+	const activeProject = db.prepare("SELECT project_hash FROM project_metadata ORDER BY last_seen_at DESC LIMIT 1").get();
+	if (activeProject && projectHash === activeProject.project_hash) return c.json({ error: "Cannot delete the currently active project. Switch to a different project first." }, 400);
+	const project = db.prepare("SELECT project_hash, project_path FROM project_metadata WHERE project_hash = ?").get(projectHash);
+	if (!project) return c.json({ error: `No project found with hash '${projectHash}'` }, 404);
+	const run = (sql, params) => {
+		try {
+			db.prepare(sql).run(...params);
+		} catch {}
+	};
+	const exec = (sql) => {
+		try {
+			db.exec(sql);
+		} catch {}
+	};
+	let obsCount = 0;
+	try {
+		obsCount = db.prepare("SELECT COUNT(*) as cnt FROM observations WHERE project_hash = ?").get(projectHash).cnt;
+	} catch {}
+	db.transaction(() => {
+		exec("DROP TRIGGER IF EXISTS observations_ai");
+		exec("DROP TRIGGER IF EXISTS observations_au");
+		exec("DROP TRIGGER IF EXISTS observations_ad");
+		run("DELETE FROM observation_embeddings WHERE observation_id IN (SELECT id FROM observations WHERE project_hash = ?)", [projectHash]);
+		run("DELETE FROM staleness_flags WHERE observation_id IN (SELECT id FROM observations WHERE project_hash = ?)", [projectHash]);
+		run("DELETE FROM observations WHERE project_hash = ?", [projectHash]);
+		exec("INSERT INTO observations_fts(observations_fts) VALUES('rebuild')");
+		exec(`
+      CREATE TRIGGER observations_ai AFTER INSERT ON observations BEGIN
+        INSERT INTO observations_fts(rowid, title, content)
+          VALUES (new.rowid, new.title, new.content);
+      END
+    `);
+		exec(`
+      CREATE TRIGGER observations_au AFTER UPDATE ON observations BEGIN
+        INSERT INTO observations_fts(observations_fts, rowid, title, content)
+          VALUES('delete', old.rowid, old.title, old.content);
+        INSERT INTO observations_fts(rowid, title, content)
+          VALUES (new.rowid, new.title, new.content);
+      END
+    `);
+		exec(`
+      CREATE TRIGGER observations_ad AFTER DELETE ON observations BEGIN
+        INSERT INTO observations_fts(observations_fts, rowid, title, content)
+          VALUES('delete', old.rowid, old.title, old.content);
+      END
+    `);
+		run("DELETE FROM graph_edges WHERE project_hash = ?", [projectHash]);
+		run("DELETE FROM graph_nodes WHERE project_hash = ?", [projectHash]);
+		run("DELETE FROM sessions WHERE project_hash = ?", [projectHash]);
+		run("DELETE FROM shift_decisions WHERE project_id = ?", [projectHash]);
+		run("DELETE FROM threshold_history WHERE project_id = ?", [projectHash]);
+		run("DELETE FROM context_stashes WHERE project_id = ?", [projectHash]);
+		run("DELETE FROM pending_notifications WHERE project_id = ?", [projectHash]);
+		run("DELETE FROM research_buffer WHERE project_hash = ?", [projectHash]);
+		run("DELETE FROM tool_registry WHERE project_hash = ?", [projectHash]);
+		run("DELETE FROM tool_usage_events WHERE project_hash = ?", [projectHash]);
+		run("DELETE FROM debug_paths WHERE project_hash = ?", [projectHash]);
+		run("DELETE FROM thought_branches WHERE project_hash = ?", [projectHash]);
+		run("DELETE FROM routing_patterns WHERE project_hash = ?", [projectHash]);
+		run("DELETE FROM routing_state WHERE project_hash = ?", [projectHash]);
+		run("DELETE FROM project_metadata WHERE project_hash = ?", [projectHash]);
+	})();
+	return c.json({
+		ok: true,
+		deleted: {
+			projectPath: project.project_path,
+			projectHash,
+			observationsRemoved: obsCount
+		}
+	});
+});
 
 //#endregion
 //#region src/web/server.ts
@@ -5641,14 +7179,46 @@ const noGui = process.argv.includes("--no_gui");
 const db = openDatabase(getDatabaseConfig());
 initGraphSchema(db.db);
 initPathSchema(db.db);
-const projectHash = getProjectHash(process.cwd());
+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);
 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, projectHash) : null;
+const embeddingStore = db.hasVectorSupport ? new EmbeddingStore(db.db, projectHashRef.current) : null;
 const worker = new AnalysisWorker();
 worker.start().catch(() => {
 	debug("mcp", "Worker failed to start, keyword-only mode");
@@ -5661,7 +7231,7 @@ const adaptiveManager = new AdaptiveThresholdManager({
 	alpha: topicConfig.ewmaAlpha
 });
 applyConfig(topicConfig, detector, adaptiveManager);
-const historicalSeed = new ThresholdStore(db.db).loadHistoricalSeed(projectHash);
+const historicalSeed = new ThresholdStore(db.db).loadHistoricalSeed(projectHashRef.current);
 if (historicalSeed) {
 	adaptiveManager.seedFromHistory(historicalSeed.averageDistance, historicalSeed.averageVariance);
 	applyConfig(topicConfig, detector, adaptiveManager);
@@ -5672,7 +7242,7 @@ const notificationStore = new NotificationStore(db.db);
 const topicShiftHandler = new TopicShiftHandler({
 	detector,
 	stashManager,
-	observationStore: new ObservationRepository(db.db, projectHash),
+	observationStore: new ObservationRepository(db.db, projectHashRef.current),
 	config: topicConfig,
 	decisionLogger,
 	adaptiveManager
@@ -5687,7 +7257,8 @@ async function processUnembedded() {
 	if (!embeddingStore || !worker.isReady()) return;
 	const ids = embeddingStore.findUnembedded(10);
 	if (ids.length === 0) return;
-	const obsRepo = new ObservationRepository(db.db, projectHash);
+	const currentHash = projectHashRef.current;
+	const obsRepo = new ObservationRepository(db.db, currentHash);
 	let shiftDetectedThisCycle = false;
 	for (const id of ids) {
 		const obs = obsRepo.getById(id);
@@ -5704,24 +7275,26 @@ async function processUnembedded() {
 				id,
 				text: obs.content.length > 120 ? obs.content.substring(0, 120) + "..." : obs.content,
 				sessionId: obs.sessionId ?? null,
-				createdAt: obs.createdAt
+				createdAt: obs.createdAt,
+				projectHash: currentHash
 			});
 			if (topicConfig.enabled && !shiftDetectedThisCycle && TOPIC_SHIFT_SOURCES.has(obs.source)) try {
 				const obsWithEmbedding = {
 					...obs,
 					embedding
 				};
-				const result = await topicShiftHandler.handleObservation(obsWithEmbedding, obs.sessionId ?? "unknown", projectHash);
+				const result = await topicShiftHandler.handleObservation(obsWithEmbedding, obs.sessionId ?? "unknown", currentHash);
 				if (result.stashed && result.notification) {
 					shiftDetectedThisCycle = true;
-					notificationStore.add(projectHash, result.notification);
+					notificationStore.add(currentHash, 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
+						confidence: null,
+						projectHash: currentHash
 					});
 				}
 			} catch (topicErr) {
@@ -5732,7 +7305,7 @@ async function processUnembedded() {
 }
 let researchBufferForFlush = null;
 try {
-	researchBufferForFlush = new ResearchBufferRepository(db.db, projectHash);
+	researchBufferForFlush = new ResearchBufferRepository(db.db, projectHashRef.current);
 } catch {}
 async function processUnembeddedTools() {
 	if (!toolRegistry || !worker.isReady() || !db.hasVectorSupport) return;
@@ -5759,26 +7332,39 @@ const embedTimer = setInterval(() => {
 	} catch {}
 	statusCache.refreshIfDirty();
 }, 5e3);
-const statusCache = new StatusCache(db.db, projectHash, process.cwd(), db.hasVectorSupport, () => worker.isReady());
+const statusCache = new StatusCache(db.db, projectHashRef, process.cwd(), db.hasVectorSupport, () => worker.isReady());
 const server = createServer();
-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);
+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);
 if (toolRegistry) {
-	registerDiscoverTools(server, toolRegistry, worker, db.hasVectorSupport, notificationStore, projectHash);
-	registerReportTools(server, toolRegistry, projectHash);
+	registerDiscoverTools(server, toolRegistry, worker, db.hasVectorSupport, notificationStore, projectHashRef);
+	registerReportTools(server, toolRegistry, projectHashRef);
 }
-const pathRepo = new PathRepository(db.db, projectHash);
+const pathRepo = new PathRepository(db.db, projectHashRef.current);
 const pathTracker = new PathTracker(pathRepo);
-registerDebugPathTools(server, pathRepo, pathTracker, notificationStore, projectHash);
-const haikuProcessor = new HaikuProcessor(db.db, projectHash, {
+registerDebugPathTools(server, pathRepo, pathTracker, notificationStore, projectHashRef);
+let branchRepo = null;
+let branchTracker;
+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, {
 	intervalMs: 3e4,
 	batchSize: 10,
 	concurrency: 3,
-	pathTracker
+	pathTracker,
+	branchTracker
 });
 startServer(server).then(() => {
 	haikuProcessor.start();
@@ -5793,7 +7379,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, projectHash), webPort);
+	startWebServer(createWebServer(db.db, uiRoot, projectHashRef.current), webPort);
 } else debug("mcp", "Web UI disabled (--no_gui)");
 const curationAgent = new CurationAgent(db.db, {
 	intervalMs: 300 * 1e3,