@majeanson/lac 3.1.1 → 3.3.0

package/dist/mcp.mjs

@@ -4,9 +4,8 @@ import process$1 from "node:process";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import readline from "node:readline";
-import Anthropic from "@anthropic-ai/sdk";
 import { execSync } from "node:child_process";
+import "@anthropic-ai/sdk";
 
 //#region ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/core.js
 /** A special constant with type `never` */
@@ -3741,6 +3740,27 @@ const LineageSchema$1 = object$1({
 	children: array$1(string$2()).optional(),
 	spawnReason: string$2().nullable().optional()
 });
+const StatusTransitionSchema$1 = object$1({
+	from: FeatureStatusSchema$1,
+	to: FeatureStatusSchema$1,
+	date: string$2().regex(/^\d{4}-\d{2}-\d{2}$/, "date must be YYYY-MM-DD"),
+	reason: string$2().optional()
+});
+const RevisionSchema$1 = object$1({
+	date: string$2().regex(/^\d{4}-\d{2}-\d{2}$/, "date must be YYYY-MM-DD"),
+	author: string$2().min(1),
+	fields_changed: array$1(string$2()).min(1),
+	reason: string$2().min(1)
+});
+const PublicInterfaceEntrySchema$1 = object$1({
+	name: string$2().min(1),
+	type: string$2().min(1),
+	description: string$2().optional()
+});
+const CodeSnippetSchema$1 = object$1({
+	label: string$2().min(1),
+	snippet: string$2().min(1)
+});
 const FeatureSchema$1 = object$1({
 	featureKey: string$2().regex(FEATURE_KEY_PATTERN$1, "featureKey must match pattern <domain>-YYYY-NNN (e.g. feat-2026-001, proc-2026-001)"),
 	title: string$2().min(1),
@@ -3756,12 +3776,26 @@ const FeatureSchema$1 = object$1({
 	annotations: array$1(AnnotationSchema$1).optional(),
 	lineage: LineageSchema$1.optional(),
 	successCriteria: string$2().optional(),
-	domain: string$2().optional()
+	domain: string$2().optional(),
+	priority: number$2().int().min(1).max(5).optional(),
+	statusHistory: array$1(StatusTransitionSchema$1).optional(),
+	revisions: array$1(RevisionSchema$1).optional(),
+	superseded_by: string$2().regex(FEATURE_KEY_PATTERN$1, "superseded_by must be a valid featureKey").optional(),
+	superseded_from: array$1(string$2().regex(FEATURE_KEY_PATTERN$1, "each superseded_from entry must be a valid featureKey")).optional(),
+	merged_into: string$2().regex(FEATURE_KEY_PATTERN$1, "merged_into must be a valid featureKey").optional(),
+	merged_from: array$1(string$2().regex(FEATURE_KEY_PATTERN$1, "each merged_from entry must be a valid featureKey")).optional(),
+	userGuide: string$2().optional(),
+	componentFile: string$2().optional(),
+	npmPackages: array$1(string$2()).optional(),
+	publicInterface: array$1(PublicInterfaceEntrySchema$1).optional(),
+	externalDependencies: array$1(string$2()).optional(),
+	lastVerifiedDate: string$2().regex(/^\d{4}-\d{2}-\d{2}$/, "lastVerifiedDate must be YYYY-MM-DD").optional(),
+	codeSnippets: array$1(CodeSnippetSchema$1).optional()
 });
 
 //#endregion
 //#region ../feature-schema/dist/validate.mjs
-function validateFeature$1(data) {
+function validateFeature(data) {
 	const result = FeatureSchema$1.safeParse(data);
 	if (result.success) return {
 		success: true,
@@ -3775,6 +3809,563 @@ function validateFeature$1(data) {
 	};
 }
 
+//#endregion
+//#region ../feature-schema/dist/keygen.mjs
+const LAC_DIR = ".lac";
+const COUNTER_FILE = "counter";
+const KEYS_FILE = "keys";
+/**
+* Returns the current year as a number.
+*/
+function getCurrentYear() {
+	return (/* @__PURE__ */ new Date()).getFullYear();
+}
+/**
+* Pads a counter number to a zero-padded 3-digit string (e.g. 1 → "001").
+*/
+function padCounter(n) {
+	return String(n).padStart(3, "0");
+}
+/**
+* Walks up the directory tree from `fromDir` to find the nearest `.lac/` directory.
+* Returns the path to the `.lac/` directory if found, otherwise null.
+*/
+function findLacDir(fromDir) {
+	let current = path.resolve(fromDir);
+	while (true) {
+		const candidate = path.join(current, LAC_DIR);
+		if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) return candidate;
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+/**
+* Reads or initialises the `.lac/counter` file and returns the next
+* featureKey string like "feat-2026-001".
+*
+* The counter file stores a single integer representing the last-used counter
+* for the current year.  When the year changes the counter resets to 1.
+*
+* Format of the counter file (two lines):
+*   <year>
+*   <last-used-counter>
+*
+* If the file does not exist it is created, and the first key (NNN=001) is
+* returned.  The `.lac/` directory must already exist in a parent of
+* `fromDir`; if it cannot be found this function throws an Error.
+*
+* Duplicate detection: after generating the key, the `.lac/keys` file is
+* consulted. If the generated key already exists there, the counter is
+* incremented until a unique key is found.
+*
+* @param prefix  Domain prefix for the key (default: "feat"). Set via `domain`
+*                in `lac.config.json` to get keys like "proc-2026-001".
+*/
+function generateFeatureKey(fromDir, prefix = "feat") {
+	const lacDir = findLacDir(fromDir);
+	if (!lacDir) throw new Error(`Could not find a .lac/ directory in "${fromDir}" or any of its parents. Run "lac workspace init" to initialise a life-as-code workspace.`);
+	const counterPath = path.join(lacDir, COUNTER_FILE);
+	const keysPath = path.join(lacDir, KEYS_FILE);
+	const year = getCurrentYear();
+	let counter = 1;
+	if (fs.existsSync(counterPath)) try {
+		const lines = fs.readFileSync(counterPath, "utf-8").trim().split("\n").map((l) => l.trim());
+		const storedYear = parseInt(lines[0] ?? "", 10);
+		const storedCounter = parseInt(lines[1] ?? "", 10);
+		if (isNaN(storedYear) || isNaN(storedCounter)) {
+			process.stderr.write("Warning: .lac/counter was corrupt — reset to 1\n");
+			fs.writeFileSync(counterPath, `${year}\n1\n`, "utf-8");
+			counter = 1;
+		} else if (storedYear === year) counter = storedCounter + 1;
+	} catch {
+		process.stderr.write("Warning: .lac/counter was corrupt — reset to 1\n");
+		fs.writeFileSync(counterPath, `${year}\n1\n`, "utf-8");
+		counter = 1;
+	}
+	let existingKeys = /* @__PURE__ */ new Set();
+	if (fs.existsSync(keysPath)) existingKeys = new Set(fs.readFileSync(keysPath, "utf-8").trim().split("\n").filter(Boolean));
+	while (existingKeys.has(`${prefix}-${year}-${padCounter(counter)}`)) counter++;
+	const featureKey = `${prefix}-${year}-${padCounter(counter)}`;
+	existingKeys.add(featureKey);
+	const counterTmp = counterPath + ".tmp";
+	const keysTmp = keysPath + ".tmp";
+	fs.writeFileSync(counterTmp, `${year}\n${counter}\n`, "utf-8");
+	fs.writeFileSync(keysTmp, Array.from(existingKeys).join("\n") + "\n", "utf-8");
+	fs.renameSync(counterTmp, counterPath);
+	fs.renameSync(keysTmp, keysPath);
+	return featureKey;
+}
+/**
+* Registers an externally-supplied featureKey in `.lac/keys` so that future
+* auto-generated keys never collide with it. Also advances the counter if
+* the key's sequence number is ≥ the current counter value for this year.
+*
+* If no `.lac/` directory is found the call is a no-op (workspace hasn't
+* been initialised yet; the key simply won't be tracked).
+*
+* Idempotent — safe to call multiple times with the same key.
+*/
+function registerFeatureKey(fromDir, key) {
+	const lacDir = findLacDir(fromDir);
+	if (!lacDir) return;
+	const counterPath = path.join(lacDir, COUNTER_FILE);
+	const keysPath = path.join(lacDir, KEYS_FILE);
+	const year = getCurrentYear();
+	let existingKeys = /* @__PURE__ */ new Set();
+	if (fs.existsSync(keysPath)) existingKeys = new Set(fs.readFileSync(keysPath, "utf-8").trim().split("\n").filter(Boolean));
+	if (existingKeys.has(key)) return;
+	let currentCounter = 0;
+	if (fs.existsSync(counterPath)) try {
+		const lines = fs.readFileSync(counterPath, "utf-8").trim().split("\n").map((l) => l.trim());
+		const storedYear = parseInt(lines[0] ?? "", 10);
+		const storedCounter = parseInt(lines[1] ?? "", 10);
+		if (!isNaN(storedYear) && !isNaN(storedCounter) && storedYear === year) currentCounter = storedCounter;
+	} catch {}
+	const match = /^[a-z][a-z0-9]*-(\d{4})-(\d{3})$/.exec(key);
+	let newCounter = currentCounter;
+	if (match) {
+		const keyYear = parseInt(match[1], 10);
+		const keyNum = parseInt(match[2], 10);
+		if (keyYear === year && keyNum > currentCounter) newCounter = keyNum;
+	}
+	existingKeys.add(key);
+	const counterTmp = counterPath + ".tmp";
+	const keysTmp = keysPath + ".tmp";
+	fs.writeFileSync(counterTmp, `${year}\n${newCounter}\n`, "utf-8");
+	fs.writeFileSync(keysTmp, Array.from(existingKeys).join("\n") + "\n", "utf-8");
+	fs.renameSync(counterTmp, counterPath);
+	fs.renameSync(keysTmp, keysPath);
+}
+
+//#endregion
+//#region ../lac-mcp/src/tools/analysis.ts
+function scanFeatures$1(dir) {
+	const results = [];
+	walk(dir, results);
+	return results;
+}
+function walk(dir, results) {
+	try {
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
+		for (const e of entries) {
+			if ([
+				"node_modules",
+				".git",
+				"dist"
+			].includes(e.name)) continue;
+			const full = path.join(dir, e.name);
+			if (e.isDirectory()) walk(full, results);
+			else if (e.name === "feature.json") try {
+				const r = validateFeature(JSON.parse(fs.readFileSync(full, "utf-8")));
+				if (r.success) results.push({
+					feature: r.data,
+					filePath: full
+				});
+			} catch {}
+		}
+	} catch {}
+}
+function resolve(p, root) {
+	return path.isAbsolute(p) ? p : path.resolve(root, p);
+}
+const RISK_KEYWORDS = [
+	"revisit",
+	"temporary",
+	"todo",
+	"hack",
+	"fixme",
+	"workaround",
+	"short-term",
+	"quick fix"
+];
+function handleAuditDecisions(a, workspaceRoot$1) {
+	const features = scanFeatures$1(a.path ? resolve(String(a.path), workspaceRoot$1) : workspaceRoot$1);
+	const missingDecisions = [];
+	const flaggedDecisions = [];
+	const unaddressedReopens = [];
+	const domainGroups = /* @__PURE__ */ new Map();
+	let cleanCount = 0;
+	for (const { feature } of features) {
+		if (feature.status === "draft") continue;
+		let hasIssue = false;
+		if (!feature.decisions?.length) {
+			missingDecisions.push(`  ${feature.featureKey.padEnd(20)} ${feature.status}`);
+			hasIssue = true;
+		} else for (const d of feature.decisions) {
+			const text = (d.decision + " " + d.rationale).toLowerCase();
+			const found = RISK_KEYWORDS.find((k) => text.includes(k));
+			if (found) {
+				flaggedDecisions.push({
+					key: feature.featureKey,
+					decision: d.decision,
+					keyword: found
+				});
+				hasIssue = true;
+			}
+		}
+		const staleAnnotation = feature.annotations?.find((a$1) => a$1.type === "stale-review");
+		if (staleAnnotation) {
+			unaddressedReopens.push(`  ${feature.featureKey.padEnd(20)} ${feature.status.padEnd(10)} — ${staleAnnotation.body}`);
+			hasIssue = true;
+		}
+		if (feature.domain) {
+			const group = domainGroups.get(feature.domain) ?? [];
+			group.push(feature);
+			domainGroups.set(feature.domain, group);
+		}
+		if (!hasIssue) cleanCount++;
+	}
+	const duplicateSuspects = [];
+	for (const [domain, group] of domainGroups) for (let i = 0; i < group.length; i++) for (let j = i + 1; j < group.length; j++) {
+		const fi = group[i];
+		const fj = group[j];
+		if (!fi || !fj) continue;
+		const wordsA = new Set(fi.title.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+		const wordsB = new Set(fj.title.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+		if ([...wordsA].filter((w) => wordsB.has(w)).length >= 2) duplicateSuspects.push(`  ${fi.featureKey} + ${fj.featureKey} (${domain}) — "${fi.title}" / "${fj.title}"`);
+	}
+	const sections = [];
+	if (unaddressedReopens.length > 0) sections.push(`⚠ Unaddressed reopens — stale fields not yet reviewed (${unaddressedReopens.length}):\n${unaddressedReopens.join("\n")}`);
+	if (missingDecisions.length > 0) sections.push(`⚠ Missing decisions (${missingDecisions.length}):\n${missingDecisions.join("\n")}`);
+	if (flaggedDecisions.length > 0) {
+		const lines = flaggedDecisions.map((f) => `  ${f.key.padEnd(20)} "${f.decision.slice(0, 60)}" — contains "${f.keyword}"`);
+		sections.push(`⚠ Decisions flagged for review (${flaggedDecisions.length}):\n${lines.join("\n")}`);
+	}
+	if (duplicateSuspects.length > 0) sections.push(`⚠ Possible duplicates (${duplicateSuspects.length}):\n${duplicateSuspects.join("\n")}`);
+	sections.push(`✓ ${cleanCount} feature(s) with clean decisions`);
+	return { content: [{
+		type: "text",
+		text: sections.join("\n\n")
+	}] };
+}
+function handleFeatureSimilarity(a, workspaceRoot$1) {
+	if (!a.path) return {
+		content: [{
+			type: "text",
+			text: "path is required"
+		}],
+		isError: true
+	};
+	const featureDir = resolve(String(a.path), workspaceRoot$1);
+	const featurePath = path.join(featureDir, "feature.json");
+	let raw;
+	try {
+		raw = fs.readFileSync(featurePath, "utf-8");
+	} catch {
+		return {
+			content: [{
+				type: "text",
+				text: `No feature.json found at "${featurePath}"`
+			}],
+			isError: true
+		};
+	}
+	const result = validateFeature(JSON.parse(raw));
+	if (!result.success) return {
+		content: [{
+			type: "text",
+			text: `Invalid feature.json: ${result.errors.join(", ")}`
+		}],
+		isError: true
+	};
+	const target = result.data;
+	const targetTags = new Set(target.tags ?? []);
+	const targetWords = new Set((target.title + " " + target.problem).toLowerCase().split(/\W+/).filter((w) => w.length > 4));
+	const allFeatures = scanFeatures$1(workspaceRoot$1);
+	const matches = [];
+	for (const { feature } of allFeatures) {
+		if (feature.featureKey === target.featureKey) continue;
+		if (feature.lineage?.parent === target.featureKey || target.lineage?.parent === feature.featureKey) continue;
+		let score = 0;
+		const reasons = [];
+		if (target.domain && feature.domain === target.domain) {
+			score += 3;
+			reasons.push(`same domain: ${feature.domain}`);
+		}
+		const sharedTags = (feature.tags ?? []).filter((t) => targetTags.has(t));
+		if (sharedTags.length > 0) {
+			score += sharedTags.length * 2;
+			reasons.push(`shared tags: ${sharedTags.join(", ")}`);
+		}
+		const featureWords = new Set((feature.title + " " + feature.problem).toLowerCase().split(/\W+/).filter((w) => w.length > 4));
+		const wordOverlap = [...targetWords].filter((w) => featureWords.has(w)).length;
+		if (wordOverlap >= 2) {
+			score += wordOverlap;
+			reasons.push(`${wordOverlap} shared keywords`);
+		}
+		if (score > 0) matches.push({
+			feature,
+			score,
+			reasons
+		});
+	}
+	matches.sort((a$1, b) => b.score - a$1.score);
+	if (matches.length === 0) return { content: [{
+		type: "text",
+		text: `No similar features found for "${target.featureKey} — ${target.title}".`
+	}] };
+	const stars = (score) => score >= 6 ? "★★★" : score >= 4 ? "★★ " : "★  ";
+	return { content: [{
+		type: "text",
+		text: [`Similar features to "${target.featureKey} — ${target.title}":\n`, ...matches.slice(0, 10).map((m) => `${stars(m.score)} ${m.feature.featureKey.padEnd(20)} "${m.feature.title}"\n     ${m.reasons.join(" · ")}`)].join("\n")
+	}] };
+}
+
+//#endregion
+//#region ../lac-mcp/src/tools/git-tools.ts
+function handleTimeTravel(a, workspaceRoot$1) {
+	if (!a.path) return {
+		content: [{
+			type: "text",
+			text: "path is required"
+		}],
+		isError: true
+	};
+	const featureDir = path.isAbsolute(String(a.path)) ? String(a.path) : path.resolve(workspaceRoot$1, String(a.path));
+	const featurePath = path.join(featureDir, "feature.json");
+	let gitRoot;
+	try {
+		gitRoot = execSync("git rev-parse --show-toplevel", {
+			cwd: featureDir,
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+	} catch {
+		return {
+			content: [{
+				type: "text",
+				text: "Not a git repository. time_travel requires git."
+			}],
+			isError: true
+		};
+	}
+	const relPath = path.relative(gitRoot, featurePath).replace(/\\/g, "/");
+	let logOutput;
+	try {
+		logOutput = execSync(`git log --format="%H %as %s" -- "${relPath}"`, {
+			cwd: gitRoot,
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+	} catch {
+		logOutput = "";
+	}
+	if (!logOutput) return { content: [{
+		type: "text",
+		text: `No git history found for "${relPath}". Has this file been committed?`
+	}] };
+	const commits = logOutput.split("\n").map((line) => {
+		const parts = line.split(" ");
+		return {
+			sha: parts[0] ?? "",
+			date: parts[1] ?? "",
+			message: parts.slice(2).join(" ")
+		};
+	});
+	if (!a.date && !a.commit) {
+		const historyLines = commits.map((c) => `  ${c.date}  ${c.sha.slice(0, 8)}  ${c.message}`);
+		return { content: [{
+			type: "text",
+			text: `Git history for "${relPath}" (${commits.length} commit(s)):\n\n${historyLines.join("\n")}\n\nCall time_travel again with date (YYYY-MM-DD) or commit (SHA) to view a specific version.`
+		}] };
+	}
+	let targetSha;
+	if (a.commit) targetSha = String(a.commit);
+	else {
+		const targetDate = String(a.date);
+		const match = commits.find((c) => c.date <= targetDate);
+		if (!match) return { content: [{
+			type: "text",
+			text: `No commits found at or before "${targetDate}".\n\nAvailable history:\n${commits.map((c) => `  ${c.date}  ${c.sha.slice(0, 8)}  ${c.message}`).join("\n")}`
+		}] };
+		targetSha = match.sha;
+	}
+	let historicalContent;
+	try {
+		historicalContent = execSync(`git show "${targetSha}:${relPath}"`, {
+			cwd: gitRoot,
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+	} catch {
+		return {
+			content: [{
+				type: "text",
+				text: `Could not read "${relPath}" at commit ${targetSha.slice(0, 8)}.`
+			}],
+			isError: true
+		};
+	}
+	const targetCommit = commits.find((c) => c.sha === targetSha || targetSha != null && c.sha.length >= 7 && targetSha.startsWith(c.sha.slice(0, 7)));
+	const commitInfo = targetCommit ? `${targetCommit.date}  ${targetSha.slice(0, 8)}  ${targetCommit.message}` : targetSha.slice(0, 8);
+	let displayContent;
+	try {
+		const validation = validateFeature(JSON.parse(historicalContent));
+		displayContent = validation.success ? JSON.stringify(validation.data, null, 2) : historicalContent;
+	} catch {
+		displayContent = historicalContent;
+	}
+	const newerCommits = commits.filter((c) => targetCommit?.date != null ? c.date > targetCommit.date : false);
+	return { content: [{
+		type: "text",
+		text: `feature.json at: ${commitInfo}${newerCommits.length > 0 ? `\n\n[${newerCommits.length} commit(s) made after this snapshot]` : ""}\n\n${displayContent}`
+	}] };
+}
+
+//#endregion
+//#region ../lac-mcp/src/tools/impact.ts
+const SOURCE_EXTENSIONS$1 = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".py",
+	".go",
+	".rs",
+	".vue",
+	".svelte"
+]);
+function scanFeatures(dir) {
+	const results = [];
+	walkFeatures(dir, results);
+	return results;
+}
+function walkFeatures(dir, results) {
+	try {
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
+		for (const e of entries) {
+			if ([
+				"node_modules",
+				".git",
+				"dist"
+			].includes(e.name)) continue;
+			const full = path.join(dir, e.name);
+			if (e.isDirectory()) walkFeatures(full, results);
+			else if (e.name === "feature.json") try {
+				const r = validateFeature(JSON.parse(fs.readFileSync(full, "utf-8")));
+				if (r.success) results.push({
+					feature: r.data,
+					filePath: full
+				});
+			} catch {}
+		}
+	} catch {}
+}
+function getSourceFiles(dir) {
+	const files = [];
+	try {
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
+		for (const e of entries) {
+			if ([
+				"node_modules",
+				".git",
+				"dist"
+			].includes(e.name)) continue;
+			const full = path.join(dir, e.name);
+			if (e.isDirectory()) files.push(...getSourceFiles(full));
+			else if (SOURCE_EXTENSIONS$1.has(path.extname(e.name))) files.push(full);
+		}
+	} catch {}
+	return files;
+}
+function findOwningFeatureKey(filePath) {
+	let current = path.dirname(filePath);
+	while (true) {
+		const candidate = path.join(current, "feature.json");
+		if (fs.existsSync(candidate)) try {
+			const r = validateFeature(JSON.parse(fs.readFileSync(candidate, "utf-8")));
+			if (r.success) return r.data.featureKey;
+		} catch {}
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function handleCrossFeatureImpact(a, workspaceRoot$1) {
+	if (!a.file) return {
+		content: [{
+			type: "text",
+			text: "file parameter is required"
+		}],
+		isError: true
+	};
+	const targetFile = path.isAbsolute(String(a.file)) ? String(a.file) : path.resolve(workspaceRoot$1, String(a.file));
+	if (!fs.existsSync(targetFile)) return {
+		content: [{
+			type: "text",
+			text: `File not found: "${targetFile}"`
+		}],
+		isError: true
+	};
+	const targetBasename = path.basename(targetFile);
+	const targetNoExt = path.basename(targetFile, path.extname(targetFile));
+	const targetRelFromRoot = path.relative(workspaceRoot$1, targetFile).replace(/\\/g, "/");
+	const patterns = [...new Set([
+		targetBasename,
+		targetNoExt,
+		targetRelFromRoot
+	])];
+	const owningKey = findOwningFeatureKey(targetFile);
+	const features = scanFeatures(workspaceRoot$1);
+	const impacts = [];
+	for (const { feature, filePath: featureJsonPath } of features) {
+		if (feature.featureKey === owningKey) continue;
+		const featureDir = path.dirname(featureJsonPath);
+		const sourceFiles = getSourceFiles(featureDir);
+		const matchedFiles = [];
+		const matchedPatterns = [];
+		for (const srcFile of sourceFiles) {
+			if (srcFile === targetFile) continue;
+			try {
+				const content = fs.readFileSync(srcFile, "utf-8");
+				const matched = patterns.filter((p) => content.includes(p));
+				if (matched.length > 0) {
+					matchedFiles.push(path.relative(featureDir, srcFile));
+					matchedPatterns.push(...matched);
+				}
+			} catch {}
+		}
+		if (matchedFiles.length > 0) impacts.push({
+			feature,
+			matchedFiles,
+			patterns: [...new Set(matchedPatterns)]
+		});
+	}
+	const lines = [
+		`Impact analysis: ${path.relative(workspaceRoot$1, targetFile)}`,
+		"─".repeat(50),
+		owningKey ? `Owned by  : ${owningKey}` : "No owning feature found (untracked file)"
+	];
+	if (impacts.length === 0) lines.push("\nNo other features reference this file.");
+	else {
+		lines.push(`\n${impacts.length} feature(s) reference this file — changes may affect them:\n`);
+		for (const imp of impacts) {
+			lines.push(`  ${imp.feature.featureKey.padEnd(20)} ${imp.feature.status.padEnd(10)} "${imp.feature.title}"`);
+			const fileList = imp.matchedFiles.slice(0, 3).join(", ");
+			const more = imp.matchedFiles.length > 3 ? ` +${imp.matchedFiles.length - 3} more` : "";
+			lines.push(`    referenced in: ${fileList}${more}`);
+		}
+		lines.push("\n⚠ Changes to this file may affect all features listed above.");
+	}
+	return { content: [{
+		type: "text",
+		text: lines.join("\n")
+	}] };
+}
+
 //#endregion
 //#region ../lac-claude/dist/index.mjs
 Object.freeze({ status: "aborted" });
@@ -7418,6 +8009,27 @@ const LineageSchema = object({
 	children: array(string()).optional(),
 	spawnReason: string().nullable().optional()
 });
+const StatusTransitionSchema = object({
+	from: FeatureStatusSchema,
+	to: FeatureStatusSchema,
+	date: string().regex(/^\d{4}-\d{2}-\d{2}$/, "date must be YYYY-MM-DD"),
+	reason: string().optional()
+});
+const RevisionSchema = object({
+	date: string().regex(/^\d{4}-\d{2}-\d{2}$/, "date must be YYYY-MM-DD"),
+	author: string().min(1),
+	fields_changed: array(string()).min(1),
+	reason: string().min(1)
+});
+const PublicInterfaceEntrySchema = object({
+	name: string().min(1),
+	type: string().min(1),
+	description: string().optional()
+});
+const CodeSnippetSchema = object({
+	label: string().min(1),
+	snippet: string().min(1)
+});
 const FeatureSchema = object({
 	featureKey: string().regex(FEATURE_KEY_PATTERN, "featureKey must match pattern <domain>-YYYY-NNN (e.g. feat-2026-001, proc-2026-001)"),
 	title: string().min(1),
@@ -7433,55 +8045,22 @@ const FeatureSchema = object({
 	annotations: array(AnnotationSchema).optional(),
 	lineage: LineageSchema.optional(),
 	successCriteria: string().optional(),
-	domain: string().optional()
+	domain: string().optional(),
+	priority: number().int().min(1).max(5).optional(),
+	statusHistory: array(StatusTransitionSchema).optional(),
+	revisions: array(RevisionSchema).optional(),
+	superseded_by: string().regex(FEATURE_KEY_PATTERN, "superseded_by must be a valid featureKey").optional(),
+	superseded_from: array(string().regex(FEATURE_KEY_PATTERN, "each superseded_from entry must be a valid featureKey")).optional(),
+	merged_into: string().regex(FEATURE_KEY_PATTERN, "merged_into must be a valid featureKey").optional(),
+	merged_from: array(string().regex(FEATURE_KEY_PATTERN, "each merged_from entry must be a valid featureKey")).optional(),
+	userGuide: string().optional(),
+	componentFile: string().optional(),
+	npmPackages: array(string()).optional(),
+	publicInterface: array(PublicInterfaceEntrySchema).optional(),
+	externalDependencies: array(string()).optional(),
+	lastVerifiedDate: string().regex(/^\d{4}-\d{2}-\d{2}$/, "lastVerifiedDate must be YYYY-MM-DD").optional(),
+	codeSnippets: array(CodeSnippetSchema).optional()
 });
-function validateFeature(data) {
-	const result = FeatureSchema.safeParse(data);
-	if (result.success) return {
-		success: true,
-		data: result.data
-	};
-	return {
-		success: false,
-		errors: result.error.issues.map((issue$1$1) => {
-			return `${issue$1$1.path.length > 0 ? `${issue$1$1.path.join(".")}: ` : ""}${issue$1$1.message}`;
-		})
-	};
-}
-function createClient() {
-	let apiKey = process$1.env.ANTHROPIC_API_KEY;
-	if (!apiKey) {
-		const configPath = findLacConfig();
-		if (configPath) try {
-			apiKey = JSON.parse(fs.readFileSync(configPath, "utf-8"))?.ai?.apiKey;
-		} catch {}
-	}
-	if (!apiKey) throw new Error("ANTHROPIC_API_KEY not set.\nSet it via:\n  export ANTHROPIC_API_KEY=sk-ant-...\nOr add it to .lac/config.json:\n  { \"ai\": { \"apiKey\": \"sk-ant-...\" } }\nGet a key at https://console.anthropic.com/settings/keys");
-	return new Anthropic({ apiKey });
-}
-function findLacConfig() {
-	let current = process$1.cwd();
-	while (true) {
-		const candidate = path.join(current, ".lac", "config.json");
-		if (fs.existsSync(candidate)) return candidate;
-		const parent = path.dirname(current);
-		if (parent === current) return null;
-		current = parent;
-	}
-}
-async function generateText(client, systemPrompt, userMessage, model = "claude-sonnet-4-6") {
-	const content = (await client.messages.create({
-		model,
-		max_tokens: 4096,
-		system: systemPrompt,
-		messages: [{
-			role: "user",
-			content: userMessage
-		}]
-	})).content[0];
-	if (!content || content.type !== "text") throw new Error("Unexpected response type from Claude API");
-	return content.text;
-}
 const SOURCE_EXTENSIONS = new Set([
 	".ts",
 	".tsx",
@@ -7500,16 +8079,20 @@ const SOURCE_EXTENSIONS = new Set([
 ]);
 const MAX_FILE_CHARS = 8e3;
 const MAX_TOTAL_CHARS = 32e4;
-function buildContext(featureDir, feature) {
+function buildContext(featureDir, feature, opts = {}) {
+	const featurePath = path.join(featureDir, "feature.json");
+	const { files: sourceFiles, truncatedPaths } = gatherSourceFiles(featureDir, opts.maxFileChars);
 	return {
 		feature,
-		featurePath: path.join(featureDir, "feature.json"),
-		sourceFiles: gatherSourceFiles(featureDir),
-		gitLog: getGitLog(featureDir)
+		featurePath,
+		sourceFiles,
+		gitLog: getGitLog(featureDir),
+		truncatedFiles: truncatedPaths
 	};
 }
-function gatherSourceFiles(dir) {
+function gatherSourceFiles(dir, maxFileChars = MAX_FILE_CHARS) {
 	const files = [];
+	const truncatedPaths = [];
 	let totalChars = 0;
 	const priorityNames = [
 		"package.json",
@@ -7520,11 +8103,15 @@ function gatherSourceFiles(dir) {
 	for (const name of priorityNames) {
 		const p = path.join(dir, name);
 		if (fs.existsSync(p)) try {
-			const content = truncate(fs.readFileSync(p, "utf-8"), 4e3);
+			const raw = fs.readFileSync(p, "utf-8");
+			const wasTruncated = raw.length > 4e3;
+			const content = truncate(raw, 4e3);
 			files.push({
 				relativePath: name,
-				content
+				content,
+				truncated: wasTruncated || void 0
 			});
+			if (wasTruncated) truncatedPaths.push(name);
 			totalChars += content.length;
 		} catch {}
 	}
@@ -7537,16 +8124,23 @@ function gatherSourceFiles(dir) {
 		if (totalChars >= MAX_TOTAL_CHARS) break;
 		if (priorityNames.includes(path.basename(filePath))) continue;
 		try {
-			const content = truncate(fs.readFileSync(filePath, "utf-8"), MAX_FILE_CHARS);
+			const raw = fs.readFileSync(filePath, "utf-8");
+			const wasTruncated = raw.length > maxFileChars;
+			const content = truncate(raw, maxFileChars);
 			const relativePath = path.relative(dir, filePath);
 			files.push({
 				relativePath,
-				content
+				content,
+				truncated: wasTruncated || void 0
 			});
+			if (wasTruncated) truncatedPaths.push(relativePath);
 			totalChars += content.length;
 		} catch {}
 	}
-	return files;
+	return {
+		files,
+		truncatedPaths
+	};
 }
 function walkDir(dir) {
 	const results = [];
@@ -7582,6 +8176,7 @@ function getGitLog(dir) {
 }
 function contextToString(ctx) {
 	const parts = [];
+	if (ctx.truncatedFiles.length > 0) parts.push(`⚠ WARNING: ${ctx.truncatedFiles.length} file(s) were truncated — extraction may be incomplete:\n` + ctx.truncatedFiles.map((f) => `  - ${f}`).join("\n"));
 	parts.push("=== feature.json ===");
 	parts.push(JSON.stringify(ctx.feature, null, 2));
 	if (ctx.gitLog) {
@@ -7589,32 +8184,11 @@ function contextToString(ctx) {
 		parts.push(ctx.gitLog);
 	}
 	for (const file of ctx.sourceFiles) {
-		parts.push(`\n=== ${file.relativePath} ===`);
+		parts.push(`\n=== ${file.relativePath}${file.truncated ? " [truncated]" : ""} ===`);
 		parts.push(file.content);
 	}
 	return parts.join("\n");
 }
-const RESET = "\x1B[0m";
-const BOLD = "\x1B[1m";
-const GREEN = "\x1B[32m";
-const CYAN = "\x1B[36m";
-const DIM = "\x1B[2m";
-function formatValue(value) {
-	if (typeof value === "string") return value.length > 300 ? value.slice(0, 300) + "…" : value;
-	return JSON.stringify(value, null, 2);
-}
-function printDiff(diffs) {
-	const separator = "━".repeat(52);
-	for (const diff of diffs) {
-		const label = diff.wasEmpty ? "empty → generated" : "updated";
-		process.stdout.write(`\n${BOLD}${CYAN}${separator}${RESET}\n`);
-		process.stdout.write(`${BOLD}  ${diff.field}${RESET}  ${DIM}(${label})${RESET}\n`);
-		process.stdout.write(`${CYAN}${separator}${RESET}\n`);
-		const lines = formatValue(diff.proposed).split("\n");
-		for (const line of lines) process.stdout.write(`${GREEN}  ${line}${RESET}\n`);
-	}
-	process.stdout.write("\n");
-}
 const FILL_PROMPTS = {
 	analysis: {
 		system: `You are a software engineering analyst. Given a feature.json and the feature's source code, write a clear analysis section. Cover: what the code does architecturally, key patterns used, and why they were likely chosen. Be specific — name actual functions, modules, and techniques visible in the code. Write in first-person technical prose, 150-300 words. Return only the analysis text, no JSON wrapper, no markdown heading.`,
@@ -7671,16 +8245,71 @@ Return ONLY a valid JSON array — no other text:
 		system: `You are a software engineering analyst. Write a plain-language success criteria statement for this feature — "how do we know it's done and working?" Be specific and testable. 1-3 sentences. Return only the text, no JSON wrapper, no heading.`,
 		userSuffix: "Write the success criteria for this feature."
 	},
+	userGuide: {
+		system: `You are a technical writer writing for end users — not developers. Given a feature.json, write a plain-language user guide for this feature. Explain what it does and how to use it in everyday language. Avoid technical terms, implementation details, and acceptance-criteria framing. Write from the user's perspective: what they will see, what they can do, and why it helps them. 2-5 sentences or a short bullet list. Return only the guide text, no JSON wrapper, no heading.`,
+		userSuffix: "Write a plain-language user guide for this feature."
+	},
 	domain: {
 		system: `You are a software engineering analyst. Identify the primary technical domain for this feature from its code and problem statement. Return a single lowercase word or short hyphenated phrase (e.g. "auth", "payments", "notifications", "data-pipeline"). Return only the domain value — nothing else.`,
 		userSuffix: "Identify the domain for this feature."
+	},
+	componentFile: {
+		system: `You are a software engineering analyst. Given a feature.json and its source code, identify the single primary file that implements this feature. Return a relative path from the project root (e.g. "src/components/FeatureCard.tsx", "packages/lac-mcp/src/index.ts"). Return only the path — nothing else.`,
+		userSuffix: "Identify the primary source file for this feature."
+	},
+	npmPackages: {
+		system: `You are a software engineering analyst. Given a feature.json and its source code, list the npm packages this feature directly imports or depends on at runtime. Exclude dev-only tools (vitest, eslint, etc.). Exclude Node built-ins.
+
+Return ONLY a valid JSON array of package name strings — no other text:
+["package-a", "package-b"]`,
+		userSuffix: "List the npm packages this feature depends on."
+	},
+	publicInterface: {
+		system: `You are a software engineering analyst. Given a feature.json and its source code, extract the public interface — exported props, function signatures, or API surface that consumers of this feature depend on.
+
+Return ONLY a valid JSON array — no other text:
+[
+  {
+    "name": "string",
+    "type": "string",
+    "description": "string"
+  }
+]`,
+		userSuffix: "Extract the public interface for this feature."
+	},
+	externalDependencies: {
+		system: `You are a software engineering analyst. Given a feature.json and its source code, identify runtime dependencies on other features or internal modules that are NOT captured by the lineage (parent/children). These are cross-feature implementation dependencies — e.g. a feature that calls into another feature's API at runtime, or imports a shared utility that belongs to a distinct feature.
+
+Return ONLY a valid JSON array of featureKey strings or relative file paths — no other text:
+["feat-2026-003", "src/utils/shared.ts"]`,
+		userSuffix: "List the external runtime dependencies for this feature."
+	},
+	lastVerifiedDate: {
+		system: `You are a software engineering analyst. Return today's date in YYYY-MM-DD format as the lastVerifiedDate — marking that this feature.json was reviewed and confirmed accurate right now. Return only the date string — nothing else.`,
+		userSuffix: `Return today's date as the lastVerifiedDate.`
+	},
+	codeSnippets: {
+		system: `You are a software engineering analyst. Given a feature.json and its source code, extract 2-5 critical one-liners or short code blocks that are the most important to preserve verbatim — glob patterns, key API calls, non-obvious configuration, or architectural pivots. These are the snippets someone would need to reconstruct this feature accurately.
+
+Return ONLY a valid JSON array — no other text:
+[
+  {
+    "label": "string",
+    "snippet": "string"
+  }
+]`,
+		userSuffix: "Extract the critical code snippets for this feature."
 	}
 };
 const JSON_FIELDS = new Set([
 	"decisions",
 	"knownLimitations",
 	"tags",
-	"annotations"
+	"annotations",
+	"npmPackages",
+	"publicInterface",
+	"externalDependencies",
+	"codeSnippets"
 ]);
 const ALL_FILLABLE_FIELDS = [
 	"analysis",
@@ -7689,189 +8318,31 @@ const ALL_FILLABLE_FIELDS = [
 	"knownLimitations",
 	"tags",
 	"successCriteria",
-	"domain"
+	"userGuide",
+	"domain",
+	"componentFile",
+	"npmPackages",
+	"publicInterface",
+	"externalDependencies",
+	"lastVerifiedDate",
+	"codeSnippets"
 ];
 function getMissingFields(feature) {
 	return ALL_FILLABLE_FIELDS.filter((field) => {
 		const val = feature[field];
 		if (val === void 0 || val === null) return true;
 		if (typeof val === "string") return val.trim().length === 0;
-		if (Array.isArray(val)) return val.length === 0;
+		if (Array.isArray(val)) return false;
 		return false;
 	});
 }
-const GEN_PROMPTS = {
-	component: {
-		system: `You are an expert React/TypeScript developer. You will be given a feature.json describing a feature. Generate a production-quality React component implementing the core UI for this feature. Include TypeScript types, sensible props, and clear comments. Make it maintainable — any developer unfamiliar with this feature should understand it. Return only the component code, no explanation.`,
-		userSuffix: "Generate a React TypeScript component for this feature."
-	},
-	test: {
-		system: `You are an expert software testing engineer. You will be given a feature.json. Generate a comprehensive test suite using Vitest. Use the successCriteria to derive happy-path tests and the knownLimitations to derive edge-case tests. Return only the test code, no explanation.`,
-		userSuffix: "Generate a Vitest test suite for this feature."
-	},
-	migration: {
-		system: `You are an expert database engineer. You will be given a feature.json. Generate a database migration scaffold for the data model this feature implies. Use SQL with clear comments. Include both up (CREATE) and down (DROP) sections. Return only the SQL, no explanation.`,
-		userSuffix: "Generate a database migration for this feature."
-	},
-	docs: {
-		system: `You are a technical writer. You will be given a feature.json. Generate user-facing documentation for this feature. Write it clearly enough that any end user can understand it (not developer-focused). Cover: what it does, how to use it, and known limitations. Use Markdown. Return only the documentation, no explanation.`,
-		userSuffix: "Generate user-facing documentation for this feature."
-	}
-};
-async function fillFeature(options) {
-	const { featureDir, dryRun = false, skipConfirm = false, model = "claude-sonnet-4-6" } = options;
-	const featurePath = path.join(featureDir, "feature.json");
-	let raw;
-	try {
-		raw = fs.readFileSync(featurePath, "utf-8");
-	} catch {
-		throw new Error(`No feature.json found at "${featurePath}"`);
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		throw new Error(`Invalid JSON in "${featurePath}"`);
-	}
-	const result = validateFeature(parsed);
-	if (!result.success) throw new Error(`Invalid feature.json: ${result.errors.join(", ")}`);
-	const feature = result.data;
-	const client = createClient();
-	const fieldsToFill = options.fields ? options.fields : getMissingFields(feature);
-	if (fieldsToFill.length === 0) {
-		process$1.stdout.write(`  All fields already filled for ${feature.featureKey}.\n`);
-		return {
-			applied: false,
-			fields: [],
-			patch: {}
-		};
-	}
-	process$1.stdout.write(`\nAnalyzing ${feature.featureKey} (${feature.title})...\n`);
-	const ctx = buildContext(featureDir, feature);
-	const contextStr = contextToString(ctx);
-	process$1.stdout.write(`Reading ${ctx.sourceFiles.length} source file(s)...\n`);
-	process$1.stdout.write(`Generating with ${model}...\n`);
-	const patch = {};
-	const diffs = [];
-	for (const field of fieldsToFill) {
-		const prompt = FILL_PROMPTS[field];
-		if (!prompt) continue;
-		process$1.stdout.write(`  → ${field}...`);
-		try {
-			const rawValue = await generateText(client, prompt.system, `${contextStr}\n\n${prompt.userSuffix}`, model);
-			let value = rawValue.trim();
-			if (JSON_FIELDS.has(field)) try {
-				const jsonStr = rawValue.match(/```(?:json)?\s*([\s\S]*?)```/)?.[1] ?? rawValue;
-				value = JSON.parse(jsonStr.trim());
-			} catch {
-				process$1.stderr.write(`\n  Warning: could not parse JSON for "${field}", storing as string\n`);
-			}
-			patch[field] = value;
-			const existing = feature[field];
-			const wasEmpty = existing === void 0 || existing === null || typeof existing === "string" && existing.trim().length === 0 || Array.isArray(existing) && existing.length === 0;
-			diffs.push({
-				field,
-				wasEmpty,
-				proposed: value
-			});
-			process$1.stdout.write(" done\n");
-		} catch (err) {
-			process$1.stdout.write(" failed\n");
-			process$1.stderr.write(`  Error generating "${field}": ${err instanceof Error ? err.message : String(err)}\n`);
-		}
-	}
-	if (diffs.length === 0) return {
-		applied: false,
-		fields: [],
-		patch: {}
-	};
-	printDiff(diffs);
-	if (dryRun) {
-		process$1.stdout.write("  [dry-run] No changes written.\n\n");
-		return {
-			applied: false,
-			fields: Object.keys(patch),
-			patch
-		};
-	}
-	if (!skipConfirm) {
-		const answer = await askUser("Apply? [Y]es / [n]o / [f]ield-by-field: ");
-		if (answer.toLowerCase() === "n") {
-			process$1.stdout.write("  Cancelled.\n");
-			return {
-				applied: false,
-				fields: Object.keys(patch),
-				patch
-			};
-		}
-		if (answer.toLowerCase() === "f") {
-			const approved = {};
-			for (const [field, value] of Object.entries(patch)) if ((await askUser(`  Apply "${field}"? [Y/n]: `)).toLowerCase() !== "n") approved[field] = value;
-			for (const key of Object.keys(patch)) if (!(key in approved)) delete patch[key];
-			Object.assign(patch, approved);
-		}
-	}
-	const updated = {
-		...parsed,
-		...patch
-	};
-	fs.writeFileSync(featurePath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
-	const count = Object.keys(patch).length;
-	process$1.stdout.write(`\n  ✓ Updated ${feature.featureKey} — ${count} field${count === 1 ? "" : "s"} written.\n\n`);
-	return {
-		applied: true,
-		fields: Object.keys(patch),
-		patch
-	};
-}
-async function genFromFeature(options) {
-	const { featureDir, type, dryRun = false, model = "claude-sonnet-4-6" } = options;
-	const featurePath = path.join(featureDir, "feature.json");
-	let raw;
-	try {
-		raw = fs.readFileSync(featurePath, "utf-8");
-	} catch {
-		throw new Error(`No feature.json found at "${featurePath}"`);
-	}
-	const result = validateFeature(JSON.parse(raw));
-	if (!result.success) throw new Error(`Invalid feature.json: ${result.errors.join(", ")}`);
-	const feature = result.data;
-	const promptConfig = GEN_PROMPTS[type];
-	if (!promptConfig) throw new Error(`Unknown generation type: "${type}". Available: component, test, migration, docs`);
-	const client = createClient();
-	process$1.stdout.write(`\nGenerating ${type} for ${feature.featureKey} (${feature.title})...\n`);
-	process$1.stdout.write(`Model: ${model}\n\n`);
-	const contextStr = contextToString(buildContext(featureDir, feature));
-	const generated = await generateText(client, promptConfig.system, `${contextStr}\n\n${promptConfig.userSuffix}`, model);
-	if (dryRun) {
-		process$1.stdout.write(generated);
-		process$1.stdout.write("\n\n  [dry-run] No file written.\n");
-		return generated;
-	}
-	const outFile = options.outFile ?? path.join(featureDir, `${feature.featureKey}${typeToExt(type)}`);
-	fs.writeFileSync(outFile, generated, "utf-8");
-	process$1.stdout.write(`  ✓ Written to ${outFile}\n\n`);
-	return generated;
-}
-function typeToExt(type) {
-	return {
-		component: ".tsx",
-		test: ".test.ts",
-		migration: ".sql",
-		docs: ".md"
-	}[type] ?? ".txt";
-}
-function askUser(question) {
-	return new Promise((resolve) => {
-		const rl = readline.createInterface({
-			input: process$1.stdin,
-			output: process$1.stdout
-		});
-		rl.question(question, (answer) => {
-			rl.close();
-			resolve(answer.trim() || "y");
-		});
-	});
+const PROMPT_LOG_FILENAME = "prompt.log.jsonl";
+/** Append one or more entries to the feature's prompt.log.jsonl. Creates the file if absent. */
+function appendPromptLog(featureDir, entries) {
+	if (entries.length === 0) return;
+	const logPath = path.join(featureDir, PROMPT_LOG_FILENAME);
+	const lines = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+	fs.appendFileSync(logPath, lines, "utf-8");
 }
 
 //#endregion
@@ -7882,65 +8353,6 @@ const server = new Server({
 	version: "1.0.0"
 }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
-	{
-		name: "fill_feature",
-		description: "Fill missing fields in a feature.json using AI analysis of the code. Returns proposed changes and optionally applies them.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				path: {
-					type: "string",
-					description: "Absolute or relative path to the feature folder (contains feature.json)"
-				},
-				fields: {
-					type: "array",
-					items: { type: "string" },
-					description: "Specific fields to fill. Omit to fill all missing fields. Options: analysis, decisions, implementation, knownLimitations, tags, successCriteria, domain"
-				},
-				dryRun: {
-					type: "boolean",
-					description: "If true, returns proposed changes without writing to disk"
-				},
-				model: {
-					type: "string",
-					description: "Claude model to use (default: claude-sonnet-4-6)"
-				}
-			},
-			required: ["path"]
-		}
-	},
-	{
-		name: "generate_from_feature",
-		description: "Generate code artifacts from a feature.json — component, tests, migration, or docs.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				path: {
-					type: "string",
-					description: "Absolute or relative path to the feature folder"
-				},
-				type: {
-					type: "string",
-					enum: [
-						"component",
-						"test",
-						"migration",
-						"docs"
-					],
-					description: "What to generate"
-				},
-				dryRun: {
-					type: "boolean",
-					description: "If true, returns generated content without writing to disk"
-				},
-				model: {
-					type: "string",
-					description: "Claude model to use (default: claude-sonnet-4-6)"
-				}
-			},
-			required: ["path", "type"]
-		}
-	},
 	{
 		name: "blame_file",
 		description: "Show which feature owns a file — returns the feature summary.",
@@ -7955,7 +8367,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
 	},
 	{
 		name: "search_features",
-		description: "Search all features in the workspace by key, title, tags, or problem text.",
+		description: "Search all features in the workspace by key, title, tags, problem, analysis, implementation, or decisions text.",
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -7972,6 +8384,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
 						"deprecated"
 					],
 					description: "Filter by status (optional)"
+				},
+				domain: {
+					type: "string",
+					description: "Filter by domain (optional)"
+				},
+				path: {
+					type: "string",
+					description: "Directory to scan (default: workspace root)"
 				}
 			},
 			required: ["query"]
@@ -7979,7 +8399,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
 	},
 	{
 		name: "create_feature",
-		description: "Create a new feature.json in the specified directory.",
+		description: "Create a new feature.json in the specified directory. After creating, immediately call read_feature_context on the same path to analyze surrounding code and fill all required fields before calling advance_feature.",
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -7989,7 +8409,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
 				},
 				featureKey: {
 					type: "string",
-					description: "Feature key (e.g. feat-2026-042)"
+					description: "Feature key (e.g. feat-2026-042). Omit to auto-generate the next key from the workspace counter — recommended to avoid duplicates."
 				},
 				title: {
 					type: "string",
@@ -8012,7 +8432,6 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
 			},
 			required: [
 				"dir",
-				"featureKey",
 				"title",
 				"problem"
 			]
@@ -8023,10 +8442,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
 		description: "Show the parent/child lineage tree for a feature key.",
 		inputSchema: {
 			type: "object",
-			properties: { featureKey: {
-				type: "string",
-				description: "Feature key to look up"
-			} },
+			properties: {
+				featureKey: {
+					type: "string",
+					description: "Feature key to look up"
+				},
+				path: {
+					type: "string",
+					description: "Directory to scan (default: workspace root)"
+				}
+			},
 			required: ["featureKey"]
 		}
 	},
@@ -8035,10 +8460,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
 		description: "Check all features for completeness and required fields.",
 		inputSchema: {
 			type: "object",
-			properties: { path: {
-				type: "string",
-				description: "Directory to scan (default: workspace root)"
-			} }
+			properties: {
+				path: {
+					type: "string",
+					description: "Directory to scan (default: workspace root)"
+				},
+				revisionWarnings: {
+					type: "boolean",
+					description: "Include warnings for features with no revision entries (default: true). Set false during migration of existing repos."
+				}
+			}
 		}
 	},
 	{
@@ -8055,7 +8486,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
 	},
 	{
 		name: "write_feature_fields",
-		description: "Patch a feature.json with new field values. Use this after read_feature_context — write the fields you generated back to disk.",
+		description: "Patch a feature.json with new field values. Use this after read_feature_context — write the fields you generated back to disk. If you are changing intent-critical fields (problem, analysis, implementation, decisions, successCriteria), pass a revision object with author and reason. After writing, call advance_feature to check if the feature is ready to transition.",
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -8066,10 +8497,263 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
 				fields: {
 					type: "object",
 					description: "Key-value pairs to merge into feature.json. Values may be strings, arrays, or objects depending on the field."
+				},
+				revision: {
+					type: "object",
+					description: "Required when changing intent-critical fields (problem, analysis, implementation, decisions, successCriteria). Appended to the revisions array.",
+					properties: {
+						author: {
+							type: "string",
+							description: "Who is making the change."
+						},
+						reason: {
+							type: "string",
+							description: "Why these fields are being changed."
+						}
+					},
+					required: ["author", "reason"]
 				}
 			},
 			required: ["path", "fields"]
 		}
+	},
+	{
+		name: "advance_feature",
+		description: "Validate and transition a feature to a new status. Call this after write_feature_fields — it checks that required fields are filled for the target status and writes the new status. If fields are missing it returns exactly which ones so you can ask the user or fill them first. Transitions: draft→active (requires analysis, implementation, decisions, successCriteria), active→frozen (requires all fields + tags + knownLimitations), frozen→active (reopen — requires a reason describing what changed), any→deprecated.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "Absolute or relative path to the feature folder"
+				},
+				to: {
+					type: "string",
+					enum: [
+						"active",
+						"frozen",
+						"deprecated"
+					],
+					description: "Target status"
+				},
+				reason: {
+					type: "string",
+					description: "Required when reopening (frozen→active). Describe what changed."
+				}
+			},
+			required: ["path", "to"]
+		}
+	},
+	{
+		name: "spawn_child_feature",
+		description: "Spawn a child feature from a parent — use when a bug is found, a subtask is extracted, or scope is split. Creates the child feature.json with lineage.parent set and patches the parent's lineage.children. After spawning, call read_feature_context on the child path to begin its lifecycle.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				parentPath: {
+					type: "string",
+					description: "Absolute or relative path to the parent feature folder"
+				},
+				dir: {
+					type: "string",
+					description: "Directory to create the child feature in"
+				},
+				title: {
+					type: "string",
+					description: "Child feature title"
+				},
+				problem: {
+					type: "string",
+					description: "Problem the child addresses"
+				},
+				spawnReason: {
+					type: "string",
+					description: "Why this child was spawned (e.g. \"bug: login fails on Safari\", \"scope split: extract payment flow\")"
+				}
+			},
+			required: [
+				"parentPath",
+				"dir",
+				"title",
+				"problem",
+				"spawnReason"
+			]
+		}
+	},
+	{
+		name: "get_feature_status",
+		description: "Lightweight orientation tool — returns the current lifecycle state of a feature: status, filled vs missing fields, stale fields flagged from reopens, valid next transitions, and the exact next tool to call. Use this whenever picking up a feature mid-session to know where it stands before taking action.",
+		inputSchema: {
+			type: "object",
+			properties: { path: {
+				type: "string",
+				description: "Absolute or relative path to the feature folder"
+			} },
+			required: ["path"]
+		}
+	},
+	{
+		name: "extract_feature_from_code",
+		description: "Inverse of create_feature — given a directory with existing code but NO feature.json, reads all source files and returns instructions for Claude to generate a complete feature.json proposal. Use this to onboard legacy code into LAC. After calling this tool, generate the fields, then call create_feature followed by write_feature_fields.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "Directory containing source code (must NOT already have a feature.json)"
+				},
+				maxFileSize: {
+					type: "number",
+					description: "Maximum characters to read per file before truncating (default: 8000). Increase for large files."
+				}
+			},
+			required: ["path"]
+		}
+	},
+	{
+		name: "feature_changelog",
+		description: "Generate a chronological changelog for a feature — shows status transitions (from statusHistory), reopens, and spawned children in timeline form. Use this to understand the full history of a feature.",
+		inputSchema: {
+			type: "object",
+			properties: { path: {
+				type: "string",
+				description: "Absolute or relative path to the feature folder"
+			} },
+			required: ["path"]
+		}
+	},
+	{
+		name: "roadmap_view",
+		description: "Return a structured overview of all features in the workspace grouped by status (active → draft → frozen → deprecated) and sorted by priority. Shows missing fields and child counts at a glance. Use this to orient before a session or plan what to work on.",
+		inputSchema: {
+			type: "object",
+			properties: { path: {
+				type: "string",
+				description: "Directory to scan (default: workspace root)"
+			} }
+		}
+	},
+	{
+		name: "suggest_split",
+		description: "Analyze a feature and recommend whether it should be broken into child features. Reads source files, detects split signals (file count, mixed domains, \"and\" in problem statement), and returns context + instructions for Claude to propose a split and call spawn_child_feature.",
+		inputSchema: {
+			type: "object",
+			properties: { path: {
+				type: "string",
+				description: "Absolute or relative path to the feature folder"
+			} },
+			required: ["path"]
+		}
+	},
+	{
+		name: "feature_summary_for_pr",
+		description: "Generate a ready-to-paste pull request description from a feature.json — includes problem, what was built, key decisions, known limitations, success criteria, and lineage. Use this when opening a PR for a feature.",
+		inputSchema: {
+			type: "object",
+			properties: { path: {
+				type: "string",
+				description: "Absolute or relative path to the feature folder"
+			} },
+			required: ["path"]
+		}
+	},
+	{
+		name: "audit_decisions",
+		description: "Scan all features and surface technical debt in decisions: features missing decisions, decisions with risky language (revisit/temporary/hack/workaround), and features with suspiciously similar titles in the same domain that may be duplicates. Run this periodically to keep the workspace healthy.",
+		inputSchema: {
+			type: "object",
+			properties: { path: {
+				type: "string",
+				description: "Directory to scan (default: workspace root)"
+			} }
+		}
+	},
+	{
+		name: "feature_similarity",
+		description: "Find features semantically similar to a given one — same domain, shared tags, or overlapping keywords in title/problem. Use this before create_feature to avoid duplication, or to discover related work.",
+		inputSchema: {
+			type: "object",
+			properties: { path: {
+				type: "string",
+				description: "Absolute or relative path to the feature folder to compare against"
+			} },
+			required: ["path"]
+		}
+	},
+	{
+		name: "time_travel",
+		description: "Show what a feature.json looked like at a specific point in git history. Call with just path to see the full commit history for the file. Call with path + date (YYYY-MM-DD) or commit (SHA) to view that specific version.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "Absolute or relative path to the feature folder"
+				},
+				date: {
+					type: "string",
+					description: "YYYY-MM-DD — show the most recent version at or before this date"
+				},
+				commit: {
+					type: "string",
+					description: "Git commit SHA to view (full or short)"
+				}
+			},
+			required: ["path"]
+		}
+	},
+	{
+		name: "cross_feature_impact",
+		description: "Given a source file, find all features whose code imports or references it. Use this before refactoring a shared utility, changing an interface, or deleting a file — shows the blast radius across all tracked features.",
+		inputSchema: {
+			type: "object",
+			properties: { file: {
+				type: "string",
+				description: "Absolute or relative path to the source file to analyze"
+			} },
+			required: ["file"]
+		}
+	},
+	{
+		name: "summarize_workspace",
+		description: "Summarize the entire codebase by reading only feature.json files and READMEs — no source code. Returns a structured overview: project purpose, features grouped by domain, key decisions, and stats. Ideal for fast orientation before a coding session or for injecting project context into an AI prompt.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "Directory to scan (default: workspace root)"
+				},
+				format: {
+					type: "string",
+					enum: ["markdown", "json"],
+					description: "Output format: \"markdown\" (default) or \"json\""
+				}
+			},
+			required: []
+		}
+	},
+	{
+		name: "extract_all_features",
+		description: "Scan a repository and return a manifest of all directories that should have feature.json files but do not yet. Useful for onboarding a legacy or external repo into LAC. After calling this tool, iterate over the returned candidates and call extract_feature_from_code on each one.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "Root directory to scan (default: workspace root)"
+				},
+				strategy: {
+					type: "string",
+					enum: ["module", "directory"],
+					description: "\"module\" (default) — directories containing package.json, go.mod, Cargo.toml, index.ts, etc. \"directory\" — every directory that contains source files."
+				},
+				depth: {
+					type: "number",
+					description: "Maximum directory depth to descend (default: 4 for module, 2 for directory)"
+				}
+			}
+		}
 	}
 ] }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -8077,131 +8761,683 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 	const a = args ?? {};
 	try {
 		switch (name) {
-			case "fill_feature": {
-				const result = await fillFeature({
-					featureDir: resolvePath(String(a.path)),
-					fields: a.fields,
-					dryRun: a.dryRun ?? false,
-					skipConfirm: true,
-					model: a.model ?? "claude-sonnet-4-6"
+			case "blame_file": {
+				const filePath = resolvePath(String(a.file));
+				const feature = findNearestFeature(path.dirname(filePath));
+				if (!feature) return { content: [{
+					type: "text",
+					text: `No feature.json found for "${a.file}". The file may not be under any tracked feature directory.`
+				}] };
+				return { content: [{
+					type: "text",
+					text: `File      : ${String(a.file)}\n${formatFeatureSummary(feature)}`
+				}] };
+			}
+			case "search_features": {
+				const query = String(a.query).toLowerCase();
+				const statusFilter = a.status;
+				const domainFilter = a.domain;
+				const matches = scanAllFeatures(a.path ? resolvePath(String(a.path)) : workspaceRoot).filter(({ feature }) => {
+					if (statusFilter && feature.status !== statusFilter) return false;
+					if (domainFilter && feature.domain !== domainFilter) return false;
+					const decisionsText = (feature.decisions ?? []).map((d) => d.decision + " " + d.rationale).join(" ");
+					return [
+						feature.featureKey,
+						feature.title,
+						feature.problem,
+						feature.analysis ?? "",
+						feature.implementation ?? "",
+						decisionsText,
+						...feature.tags ?? []
+					].join(" ").toLowerCase().includes(query);
+				});
+				if (matches.length === 0) return { content: [{
+					type: "text",
+					text: `No features found matching "${a.query}".`
+				}] };
+				const lines = matches.map(({ feature }) => `${statusIcon(feature.status)} ${feature.featureKey.padEnd(18)} ${feature.status.padEnd(12)} ${feature.title}\n   ${feature.problem.slice(0, 80)}`);
+				return { content: [{
+					type: "text",
+					text: `Found ${matches.length} feature(s):\n\n${lines.join("\n\n")}`
+				}] };
+			}
+			case "create_feature": {
+				const dir = resolvePath(String(a.dir));
+				const featurePath = path.join(dir, "feature.json");
+				if (fs.existsSync(featurePath)) return { content: [{
+					type: "text",
+					text: `feature.json already exists at "${featurePath}".`
+				}] };
+				fs.mkdirSync(dir, { recursive: true });
+				let featureKey;
+				if (a.featureKey) {
+					featureKey = String(a.featureKey);
+					registerFeatureKey(dir, featureKey);
+				} else featureKey = generateFeatureKey(dir);
+				const feature = {
+					featureKey,
+					title: String(a.title),
+					status: String(a.status ?? "draft"),
+					problem: String(a.problem),
+					schemaVersion: 1
+				};
+				fs.writeFileSync(featurePath, JSON.stringify(feature, null, 2) + "\n", "utf-8");
+				return { content: [{
+					type: "text",
+					text: `Created "${featureKey}" at "${featurePath}" (${feature.status}).\n\nNext: call read_feature_context on "${dir}" to analyze the code and fill missing fields, then advance_feature when ready.`
+				}] };
+			}
+			case "get_lineage": {
+				const featureKey = String(a.featureKey);
+				const features = scanAllFeatures(a.path ? resolvePath(String(a.path)) : workspaceRoot);
+				const featureMap = new Map(features.map(({ feature }) => [feature.featureKey, feature]));
+				const root = featureMap.get(featureKey);
+				if (!root) return { content: [{
+					type: "text",
+					text: `Feature "${featureKey}" not found.`
+				}] };
+				const childrenOf = /* @__PURE__ */ new Map();
+				for (const { feature } of features) {
+					const parent = feature.lineage?.parent;
+					if (parent) {
+						const existing = childrenOf.get(parent) ?? [];
+						existing.push(feature.featureKey);
+						childrenOf.set(parent, existing);
+					}
+				}
+				return { content: [{
+					type: "text",
+					text: buildLineageTree(root, featureMap, childrenOf, 0)
+				}] };
+			}
+			case "lint_workspace": {
+				const scanDir = a.path ? resolvePath(String(a.path)) : workspaceRoot;
+				const revisionWarnings = a.revisionWarnings !== false;
+				const features = scanAllFeatures(scanDir);
+				const featureKeys = new Set(features.map(({ feature }) => feature.featureKey));
+				const INTENT_CRITICAL_LINT = [
+					"problem",
+					"analysis",
+					"implementation",
+					"decisions",
+					"successCriteria"
+				];
+				const results = features.map(({ feature, filePath }) => {
+					const issues = [];
+					const warnings = [];
+					const raw = feature;
+					if (!feature.problem?.trim()) issues.push("missing problem");
+					if (feature.status === "active") {
+						if (!feature.analysis?.trim()) issues.push("missing analysis");
+						if (!feature.implementation?.trim()) issues.push("missing implementation");
+						if (!feature.decisions?.length) issues.push("no decisions recorded");
+					}
+					if (feature.lineage?.parent && !featureKeys.has(feature.lineage.parent)) issues.push(`orphaned: parent "${feature.lineage.parent}" not found`);
+					for (const child of feature.lineage?.children ?? []) if (!featureKeys.has(child)) issues.push(`broken child ref: "${child}" not found`);
+					if (raw.superseded_by && !featureKeys.has(String(raw.superseded_by))) issues.push(`broken superseded_by ref: "${raw.superseded_by}" not found`);
+					if (raw.merged_into && !featureKeys.has(String(raw.merged_into))) issues.push(`broken merged_into ref: "${raw.merged_into}" not found`);
+					for (const key of raw.merged_from ?? []) if (!featureKeys.has(key)) issues.push(`broken merged_from ref: "${key}" not found`);
+					if (feature.status === "active" || feature.status === "draft") {
+						const preFreeze = getMissingForTransition(feature, "frozen");
+						if (preFreeze.length > 0) warnings.push(`will block freeze — missing: ${preFreeze.join(", ")}`);
+					}
+					if (raw.superseded_by && feature.status !== "deprecated") warnings.push(`superseded_by set but status is "${feature.status}" — consider deprecating`);
+					if (raw.merged_into && feature.status !== "deprecated") warnings.push(`merged_into set but status is "${feature.status}" — consider deprecating`);
+					const hasRevisions = Array.isArray(raw.revisions) && raw.revisions.length > 0;
+					if (revisionWarnings && !hasRevisions) {
+						const filledCritical = INTENT_CRITICAL_LINT.filter((f) => {
+							const val = raw[f];
+							if (val === void 0 || val === null) return false;
+							if (typeof val === "string") return val.trim().length > 0;
+							if (Array.isArray(val)) return val.length > 0;
+							return false;
+						});
+						if (filledCritical.length > 0) warnings.push(`no revisions recorded for: ${filledCritical.join(", ")}`);
+					}
+					return {
+						feature,
+						filePath,
+						issues,
+						warnings
+					};
 				});
+				const featureByKey = new Map(features.map(({ feature }) => [feature.featureKey, feature]));
+				for (const result of results) {
+					const raw = featureByKey.get(result.feature.featureKey);
+					if (!raw) continue;
+					if (raw.merged_into) {
+						const target = featureByKey.get(String(raw.merged_into));
+						if (target) {
+							if (!(target.merged_from ?? []).includes(result.feature.featureKey)) result.warnings.push(`merged_into "${raw.merged_into}" but that feature does not list this key in merged_from`);
+						}
+					}
+					for (const sourceKey of raw.merged_from ?? []) {
+						const source = featureByKey.get(sourceKey);
+						if (source && source.merged_into !== result.feature.featureKey) result.warnings.push(`merged_from includes "${sourceKey}" but that feature does not point merged_into this key`);
+					}
+					if (raw.superseded_by) {
+						const successor = featureByKey.get(String(raw.superseded_by));
+						if (successor) {
+							if (!(successor.superseded_from ?? []).includes(result.feature.featureKey)) result.warnings.push(`superseded_by "${raw.superseded_by}" but that feature does not list this key in superseded_from`);
+						}
+					}
+				}
+				const keyCount = /* @__PURE__ */ new Map();
+				for (const { feature, filePath } of features) {
+					const paths = keyCount.get(feature.featureKey) ?? [];
+					paths.push(filePath);
+					keyCount.set(feature.featureKey, paths);
+				}
+				const duplicateKeys = [...keyCount.entries()].filter(([, paths]) => paths.length > 1);
+				const failures = results.filter((r) => r.issues.length > 0);
+				const warned = results.filter((r) => r.warnings.length > 0);
+				const passes = results.filter((r) => r.issues.length === 0);
+				const lines = [...passes.map((r) => `  ✓  ${r.feature.featureKey.padEnd(18)} ${r.feature.status}${r.warnings.length > 0 ? ` ⚠ ${r.warnings.join("; ")}` : ""}`), ...failures.map((r) => `  ✗  ${r.feature.featureKey.padEnd(18)} ${r.feature.status}\n       ${r.issues.join(", ")}${r.warnings.length > 0 ? `\n       ⚠ ${r.warnings.join("; ")}` : ""}`)];
+				if (duplicateKeys.length > 0) {
+					lines.push("");
+					lines.push(`⛔ Duplicate featureKeys detected (${duplicateKeys.length}):`);
+					for (const [key, paths] of duplicateKeys) {
+						lines.push(`  ${key}`);
+						for (const p of paths) lines.push(`    ${path.relative(scanDir, p)}`);
+					}
+				}
+				return { content: [{
+					type: "text",
+					text: `${passes.length} passed, ${failures.length} failed, ${warned.length} warned — ${results.length} features checked${duplicateKeys.length > 0 ? ` ⛔ ${duplicateKeys.length} duplicate key(s)` : ""}\n\n${lines.join("\n")}`
+				}] };
+			}
+			case "read_feature_context": {
+				const featureDir = resolvePath(String(a.path));
+				const featurePath = path.join(featureDir, "feature.json");
+				let raw;
+				try {
+					raw = fs.readFileSync(featurePath, "utf-8");
+				} catch {
+					return {
+						content: [{
+							type: "text",
+							text: `No feature.json found at "${featurePath}"`
+						}],
+						isError: true
+					};
+				}
+				const result = validateFeature(JSON.parse(raw));
+				if (!result.success) return {
+					content: [{
+						type: "text",
+						text: `Invalid feature.json: ${result.errors.join(", ")}`
+					}],
+					isError: true
+				};
+				const feature = result.data;
+				const contextStr = contextToString(buildContext(featureDir, feature));
+				const missingFields = getMissingFields(feature);
+				let componentFileWarning = "";
+				if (feature.componentFile) {
+					const notFound = feature.componentFile.split(",").map((s) => s.trim()).filter(Boolean).filter((p) => {
+						return [path.resolve(featureDir, p), path.resolve(workspaceRoot, p)].every((c) => !fs.existsSync(c));
+					});
+					if (notFound.length > 0) componentFileWarning = `\n## ⚠ componentFile drift\nThese paths do not exist on disk — update componentFile to match actual source files:\n${notFound.map((p) => `  - ${p}`).join("\n")}\n`;
+				}
+				const fieldInstructions = missingFields.map((field) => {
+					const prompt = FILL_PROMPTS[field];
+					const isJson = JSON_FIELDS.has(field);
+					return `### ${field}\n${prompt.system}\n${prompt.userSuffix}\n${isJson ? "(Return valid JSON for this field)" : "(Return plain text for this field)"}`;
+				}).join("\n\n");
+				const staleAnnotation = feature.annotations?.find((ann) => ann.type === "stale-review");
+				const staleWarning = staleAnnotation ? `## ⚠ Stale fields (feature was reopened)\n${staleAnnotation.body}\nReview and rewrite these fields against the current code, then call write_feature_fields.\n\n` : "";
+				const instructions = missingFields.length === 0 ? staleWarning || "All fillable fields are already populated. No generation needed." : `${staleWarning}## Missing fields to fill (${missingFields.join(", ")})\n\nGenerate each field described below, then call write_feature_fields with all values at once. Fill ALL missing fields before calling advance_feature.\n\n${fieldInstructions}`;
+				return { content: [{
+					type: "text",
+					text: `${componentFileWarning}${instructions}\n\n## Context\n\n${contextStr}`
+				}] };
+			}
+			case "write_feature_fields": {
+				const featureDir = resolvePath(String(a.path));
+				const featurePath = path.join(featureDir, "feature.json");
+				let raw;
+				try {
+					raw = fs.readFileSync(featurePath, "utf-8");
+				} catch {
+					return {
+						content: [{
+							type: "text",
+							text: `No feature.json found at "${featurePath}"`
+						}],
+						isError: true
+					};
+				}
+				const existing = JSON.parse(raw);
+				const fields = a.fields;
+				if (!fields || typeof fields !== "object" || Array.isArray(fields)) return {
+					content: [{
+						type: "text",
+						text: "fields must be a JSON object"
+					}],
+					isError: true
+				};
+				const INTENT_CRITICAL = new Set([
+					"problem",
+					"analysis",
+					"implementation",
+					"decisions",
+					"successCriteria"
+				]);
+				const changingCritical = Object.keys(fields).filter((k) => INTENT_CRITICAL.has(k));
+				const updated = {
+					...existing,
+					...fields
+				};
+				updated.lastVerifiedDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+				const revisionInput = a.revision;
+				let revisionWarning = "";
+				if (changingCritical.length > 0) if (revisionInput?.author && revisionInput?.reason) {
+					const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+					updated.revisions = [...existing.revisions ?? [], {
+						date: today,
+						author: revisionInput.author,
+						fields_changed: changingCritical,
+						reason: revisionInput.reason
+					}];
+					updated.annotations = (existing.annotations ?? []).filter((ann) => ann.type !== "stale-review");
+				} else revisionWarning = `\n\n⚠ Intent-critical fields changed (${changingCritical.join(", ")}) without a revision entry. Pass a "revision" object with author and reason to attribute this change.`;
+				fs.writeFileSync(featurePath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+				const now = (/* @__PURE__ */ new Date()).toISOString();
+				appendPromptLog(featureDir, Object.keys(fields).map((field) => {
+					const val = fields[field];
+					return {
+						date: now,
+						field,
+						source: "mcp",
+						value_preview: (typeof val === "string" ? val : JSON.stringify(val)).slice(0, 120)
+					};
+				}));
+				const writtenKeys = Object.keys(fields);
+				const afterResult = validateFeature(JSON.parse(fs.readFileSync(featurePath, "utf-8")));
+				const stillMissing = afterResult.success ? getMissingFields(afterResult.data) : [];
+				const nextHint = stillMissing.length > 0 ? `${stillMissing.length} field(s) still missing: ${stillMissing.join(", ")}. Fill all remaining fields with write_feature_fields before calling advance_feature.` : `All AI fields filled. Call advance_feature to transition status when ready.`;
 				return { content: [{
 					type: "text",
-					text: result.applied ? `Applied ${result.fields.length} field(s) to feature.json: ${result.fields.join(", ")}` : `Proposed changes (dry-run): ${result.fields.join(", ")}\n\n${JSON.stringify(result.patch, null, 2)}`
+					text: `✓ Wrote ${writtenKeys.length} field(s) to ${featurePath}: ${writtenKeys.join(", ")}\n\n${nextHint}${revisionWarning}`
 				}] };
 			}
-			case "generate_from_feature": return { content: [{
-				type: "text",
-				text: await genFromFeature({
-					featureDir: resolvePath(String(a.path)),
-					type: a.type,
-					dryRun: a.dryRun ?? false,
-					model: a.model ?? "claude-sonnet-4-6"
-				})
-			}] };
-			case "blame_file": {
-				const filePath = resolvePath(String(a.file));
-				const feature = findNearestFeature(path.dirname(filePath));
-				if (!feature) return { content: [{
+			case "advance_feature": {
+				const featureDir = resolvePath(String(a.path));
+				const featurePath = path.join(featureDir, "feature.json");
+				let raw;
+				try {
+					raw = fs.readFileSync(featurePath, "utf-8");
+				} catch {
+					return {
+						content: [{
+							type: "text",
+							text: `No feature.json found at "${featurePath}"`
+						}],
+						isError: true
+					};
+				}
+				const parsed = JSON.parse(raw);
+				const result = validateFeature(parsed);
+				if (!result.success) return {
+					content: [{
+						type: "text",
+						text: `Invalid feature.json: ${result.errors.join(", ")}`
+					}],
+					isError: true
+				};
+				const feature = result.data;
+				const to = String(a.to);
+				const from = feature.status;
+				const reason = a.reason ? String(a.reason) : void 0;
+				const illegal = checkIllegalTransition(from, to);
+				if (illegal) return { content: [{
 					type: "text",
-					text: `No feature.json found for "${a.file}".`
+					text: illegal
 				}] };
-				return { content: [{
+				if (from === "frozen" && to === "active" && !reason) return { content: [{
 					type: "text",
-					text: formatFeatureSummary(feature)
+					text: "Reopening a frozen feature requires a reason. Call advance_feature again with the reason parameter describing what changed."
 				}] };
-			}
-			case "search_features": {
-				const query = String(a.query).toLowerCase();
-				const statusFilter = a.status;
-				const matches = scanAllFeatures(workspaceRoot).filter(({ feature }) => {
-					if (statusFilter && feature.status !== statusFilter) return false;
-					return [
-						feature.featureKey,
-						feature.title,
-						feature.problem,
-						...feature.tags ?? [],
-						feature.analysis ?? ""
-					].join(" ").toLowerCase().includes(query);
-				});
-				if (matches.length === 0) return { content: [{
+				const missing = getMissingForTransition(feature, to);
+				if (missing.length > 0) return { content: [{
 					type: "text",
-					text: `No features found matching "${a.query}".`
+					text: `Cannot advance "${feature.featureKey}" to "${to}" — ${missing.length} required field(s) missing: ${missing.join(", ")}.\n\nCall read_feature_context on this path, fill the missing fields with write_feature_fields, then try advance_feature again.`
 				}] };
-				const lines = matches.map(({ feature }) => `${statusIcon(feature.status)} ${feature.featureKey.padEnd(18)} ${feature.status.padEnd(12)} ${feature.title}\n   ${feature.problem.slice(0, 80)}`);
+				let deprecationHint = "";
+				if (to === "deprecated") {
+					const hasSuperseeded = !!parsed.superseded_by;
+					const hasMerged = !!parsed.merged_into;
+					if (!hasSuperseeded && !hasMerged) deprecationHint = "\n\n⚠ No lifecycle pointer set. Consider running `lac supersede` or `lac merge`, or call write_feature_fields with superseded_by or merged_into before deprecating so future readers know where this feature went.";
+				}
+				const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+				const updated = {
+					...parsed,
+					status: to
+				};
+				if (to === "frozen") updated.lastVerifiedDate = today;
+				updated.statusHistory = [...updated.statusHistory ?? [], {
+					from,
+					to,
+					date: today,
+					...reason ? { reason } : {}
+				}];
+				if (from === "frozen" && to === "active" && reason) {
+					const filledCritical = [
+						"analysis",
+						"implementation",
+						"decisions",
+						"successCriteria"
+					].filter((f) => {
+						const val = feature[f];
+						if (val === void 0 || val === null) return false;
+						if (typeof val === "string") return val.trim().length > 0;
+						if (Array.isArray(val)) return val.length > 0;
+						return false;
+					});
+					const staleBody = filledCritical.length > 0 ? `Fields that may need updating after reopen: ${filledCritical.join(", ")}` : "Review all intent-critical fields after reopen";
+					updated.annotations = [
+						...updated.annotations ?? [],
+						{
+							id: `reopen-${Date.now()}`,
+							author: "lac advance",
+							date: today,
+							type: "reopen",
+							body: reason
+						},
+						{
+							id: `stale-${Date.now() + 1}`,
+							author: "lac advance",
+							date: today,
+							type: "stale-review",
+							body: staleBody
+						}
+					];
+				}
+				fs.writeFileSync(featurePath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+				const nextStep = to === "active" ? from === "frozen" ? "Feature reopened. Call read_feature_context to review stale fields, update with write_feature_fields, then advance_feature to frozen when ready." : "Feature is active. Call read_feature_context to fill any missing fields, then advance_feature to frozen when complete." : to === "frozen" ? "Feature is frozen. If a bug is found or requirements change, call spawn_child_feature or advance_feature with to: \"active\" and a reason." : "Feature deprecated.";
 				return { content: [{
 					type: "text",
-					text: `Found ${matches.length} feature(s):\n\n${lines.join("\n\n")}`
+					text: `✓ "${feature.featureKey}" ${from} → ${to}.\n\n${nextStep}${deprecationHint}`
 				}] };
 			}
-			case "create_feature": {
-				const dir = resolvePath(String(a.dir));
-				const featurePath = path.join(dir, "feature.json");
-				if (fs.existsSync(featurePath)) return { content: [{
+			case "spawn_child_feature": {
+				const parentDir = resolvePath(String(a.parentPath));
+				const parentFeaturePath = path.join(parentDir, "feature.json");
+				let parentRaw;
+				try {
+					parentRaw = fs.readFileSync(parentFeaturePath, "utf-8");
+				} catch {
+					return {
+						content: [{
+							type: "text",
+							text: `No feature.json found at "${parentFeaturePath}"`
+						}],
+						isError: true
+					};
+				}
+				const parentParsed = JSON.parse(parentRaw);
+				const parentResult = validateFeature(parentParsed);
+				if (!parentResult.success) return {
+					content: [{
+						type: "text",
+						text: `Invalid parent feature.json: ${parentResult.errors.join(", ")}`
+					}],
+					isError: true
+				};
+				const parentFeature = parentResult.data;
+				const childDir = resolvePath(String(a.dir));
+				const childFeaturePath = path.join(childDir, "feature.json");
+				if (fs.existsSync(childFeaturePath)) return { content: [{
 					type: "text",
-					text: `feature.json already exists at "${featurePath}".`
+					text: `feature.json already exists at "${childFeaturePath}".`
 				}] };
-				const feature = {
-					featureKey: String(a.featureKey),
+				fs.mkdirSync(childDir, { recursive: true });
+				const childKey = generateFeatureKey(childDir);
+				const child = {
+					featureKey: childKey,
 					title: String(a.title),
-					status: String(a.status ?? "draft"),
+					status: "draft",
 					problem: String(a.problem),
-					schemaVersion: 1
+					schemaVersion: 1,
+					...parentFeature.domain ? { domain: parentFeature.domain } : {},
+					...parentFeature.tags?.length ? { tags: parentFeature.tags } : {},
+					lineage: {
+						parent: parentFeature.featureKey,
+						spawnReason: String(a.spawnReason)
+					}
 				};
-				fs.mkdirSync(dir, { recursive: true });
-				fs.writeFileSync(featurePath, JSON.stringify(feature, null, 2) + "\n", "utf-8");
+				fs.writeFileSync(childFeaturePath, JSON.stringify(child, null, 2) + "\n", "utf-8");
+				const existingChildren = parentParsed.lineage?.children ?? [];
+				const updatedParent = {
+					...parentParsed,
+					lineage: {
+						...parentParsed.lineage ?? {},
+						children: [...existingChildren, childKey]
+					}
+				};
+				fs.writeFileSync(parentFeaturePath, JSON.stringify(updatedParent, null, 2) + "\n", "utf-8");
 				return { content: [{
 					type: "text",
-					text: `Created feature.json at "${featurePath}".`
+					text: `✓ Spawned "${childKey}" under "${parentFeature.featureKey}".\nReason: ${a.spawnReason}\nChild path: ${childDir}\n\nNext: call read_feature_context on "${childDir}" to begin the child feature's lifecycle.`
 				}] };
 			}
-			case "get_lineage": {
-				const featureKey = String(a.featureKey);
-				const features = scanAllFeatures(workspaceRoot);
-				const featureMap = new Map(features.map(({ feature }) => [feature.featureKey, feature]));
-				const root = featureMap.get(featureKey);
-				if (!root) return { content: [{
+			case "get_feature_status": {
+				const featureDir = resolvePath(String(a.path));
+				const featurePath = path.join(featureDir, "feature.json");
+				let raw;
+				try {
+					raw = fs.readFileSync(featurePath, "utf-8");
+				} catch {
+					return {
+						content: [{
+							type: "text",
+							text: `No feature.json found at "${featurePath}"`
+						}],
+						isError: true
+					};
+				}
+				const result = validateFeature(JSON.parse(raw));
+				if (!result.success) return {
+					content: [{
+						type: "text",
+						text: `Invalid feature.json: ${result.errors.join(", ")}`
+					}],
+					isError: true
+				};
+				const feature = result.data;
+				const missingFields = getMissingFields(feature);
+				const staleAnnotation = feature.annotations?.find((ann) => ann.type === "stale-review");
+				const validTransitions = [];
+				if (feature.status !== "deprecated") validTransitions.push("deprecated");
+				if (feature.status === "draft") validTransitions.push("active");
+				if (feature.status === "active") validTransitions.push("frozen");
+				if (feature.status === "frozen") validTransitions.push("active (requires reason)");
+				const nextAction = missingFields.length > 0 ? `call read_feature_context to fill: ${missingFields.join(", ")}` : staleAnnotation ? `call read_feature_context to review stale fields (reopened feature)` : feature.status === "draft" ? `call advance_feature with to: "active"` : feature.status === "active" ? `call advance_feature with to: "frozen" when complete` : feature.status === "frozen" ? `frozen — call spawn_child_feature for bugs, or advance_feature to reopen` : "deprecated — no action needed";
+				const sinceDate = (feature.statusHistory ? [...feature.statusHistory].reverse().find((h) => h.to === feature.status) : void 0)?.date ?? null;
+				return { content: [{
 					type: "text",
-					text: `Feature "${featureKey}" not found.`
+					text: [
+						`Key        : ${feature.featureKey}`,
+						`Title      : ${feature.title}`,
+						`Status     : ${statusIcon(feature.status)} ${feature.status}${sinceDate ? ` (since ${sinceDate})` : ""}`,
+						`Missing    : ${missingFields.length === 0 ? "none" : missingFields.join(", ")}`,
+						`Stale      : ${staleAnnotation ? staleAnnotation.body : "none"}`,
+						`Transitions: ${validTransitions.join(", ")}`,
+						`Parent     : ${feature.lineage?.parent ?? "none"}`,
+						`Children   : ${feature.lineage?.children?.length ?? 0}`,
+						``,
+						`Next action: ${nextAction}`
+					].join("\n")
 				}] };
-				const childrenOf = /* @__PURE__ */ new Map();
-				for (const { feature } of features) {
-					const parent = feature.lineage?.parent;
-					if (parent) {
-						const existing = childrenOf.get(parent) ?? [];
-						existing.push(feature.featureKey);
-						childrenOf.set(parent, existing);
-					}
+			}
+			case "extract_feature_from_code": {
+				const dir = resolvePath(String(a.path));
+				const featurePath = path.join(dir, "feature.json");
+				if (fs.existsSync(featurePath)) return { content: [{
+					type: "text",
+					text: `feature.json already exists at "${featurePath}". Use read_feature_context instead.`
+				}] };
+				const placeholder = {
+					featureKey: "extract-pending",
+					title: "(pending)",
+					status: "draft",
+					problem: "(to be determined)"
+				};
+				const maxFileChars = a.maxFileSize ? Number(a.maxFileSize) : void 0;
+				const ctx = buildContext(dir, placeholder, maxFileChars !== void 0 ? { maxFileChars } : {});
+				if (ctx.sourceFiles.length === 0) return { content: [{
+					type: "text",
+					text: `No source files found in "${dir}". Is this the right directory?`
+				}] };
+				const parts = [];
+				if (ctx.truncatedFiles.length > 0) {
+					parts.push(`⚠ WARNING: ${ctx.truncatedFiles.length} file(s) were truncated at ${maxFileChars ?? 8e3} chars — extraction may be incomplete:`);
+					for (const f of ctx.truncatedFiles) parts.push(`  - ${f}`);
+					parts.push(`Tip: re-call with maxFileSize set higher (e.g. 16000) to capture the full content.`);
+					parts.push("");
 				}
+				if (ctx.gitLog) {
+					parts.push("=== git log (last 20 commits) ===");
+					parts.push(ctx.gitLog);
+				}
+				for (const file of ctx.sourceFiles) {
+					parts.push(`\n=== ${file.relativePath}${file.truncated ? " [truncated]" : ""} ===`);
+					parts.push(file.content);
+				}
+				const rawContext = parts.join("\n");
 				return { content: [{
 					type: "text",
-					text: buildLineageTree(root, featureMap, childrenOf, 0)
+					text: `${`## Extract feature.json from existing code
+
+No feature.json exists at "${dir}". Analyze the ${ctx.sourceFiles.length} source file(s) below and generate a complete feature.json proposal.
+
+When done, execute in order:
+1. Call create_feature with: dir="${dir}", plus your generated title and problem
+2. Call write_feature_fields with: path="${dir}", fields containing analysis, decisions, implementation, knownLimitations, tags, successCriteria, domain
+3. Call advance_feature to transition when ready
+
+### Fields to generate
+**title** — Short descriptive name (5-10 words)
+**problem** — What problem does this code solve? 1-2 sentences.
+**domain** — Single lowercase word or hyphenated phrase (e.g. "auth", "data-pipeline")
+**tags** — 3-6 lowercase tags as JSON array: ["tag1", "tag2"]
+**analysis** — Architectural overview, key patterns, why they were chosen. 150-300 words.
+**decisions** — 2-4 key technical decisions as JSON array: [{"decision":"...","rationale":"...","alternativesConsidered":["..."]}]
+**implementation** — Main components, data flow, non-obvious patterns. 100-200 words.
+**knownLimitations** — 2-4 limitations/TODOs as JSON array: ["..."]
+**successCriteria** — How do we know this works? 1-3 testable sentences.`}\n\n## Source files\n\n${rawContext}`
 				}] };
 			}
-			case "lint_workspace": {
-				const results = scanAllFeatures(a.path ? resolvePath(String(a.path)) : workspaceRoot).map(({ feature, filePath }) => {
-					const issues = [];
-					if (!feature.problem?.trim()) issues.push("missing problem");
-					if (feature.status === "active") {
-						if (!feature.analysis?.trim()) issues.push("missing analysis");
-						if (!feature.implementation?.trim()) issues.push("missing implementation");
-						if (!feature.decisions?.length) issues.push("no decisions recorded");
-					}
+			case "feature_changelog": {
+				const featureDir = resolvePath(String(a.path));
+				const featurePath = path.join(featureDir, "feature.json");
+				let raw;
+				try {
+					raw = fs.readFileSync(featurePath, "utf-8");
+				} catch {
 					return {
-						feature,
-						filePath,
-						issues
+						content: [{
+							type: "text",
+							text: `No feature.json found at "${featurePath}"`
+						}],
+						isError: true
 					};
+				}
+				const result = validateFeature(JSON.parse(raw));
+				if (!result.success) return {
+					content: [{
+						type: "text",
+						text: `Invalid feature.json: ${result.errors.join(", ")}`
+					}],
+					isError: true
+				};
+				const feature = result.data;
+				const events = [];
+				if (feature.statusHistory?.length) for (const h of feature.statusHistory) events.push({
+					date: h.date,
+					label: `${statusIcon(h.to)} ${h.from} → ${h.to}${h.reason ? ` — "${h.reason}"` : ""}`
 				});
-				const failures = results.filter((r) => r.issues.length > 0);
-				const passes = results.filter((r) => r.issues.length === 0);
-				const lines = [...passes.map((r) => `  ✓  ${r.feature.featureKey.padEnd(18)} ${r.feature.status}`), ...failures.map((r) => `  ✗  ${r.feature.featureKey.padEnd(18)} ${r.feature.status}\n       ${r.issues.join(", ")}`)];
+				else events.push({
+					date: "(unknown)",
+					label: `${statusIcon(feature.status)} current: ${feature.status}`
+				});
+				for (const rev of feature.revisions ?? []) events.push({
+					date: rev.date,
+					label: `✎ revision by ${rev.author}: ${rev.fields_changed.join(", ")} — ${rev.reason}`
+				});
+				for (const ann of feature.annotations ?? []) if (ann.type === "spawn") events.push({
+					date: ann.date,
+					label: `↳ spawned child — ${ann.body}`
+				});
+				else if (ann.type === "reopen") events.push({
+					date: ann.date,
+					label: `↺ reopened — ${ann.body}`
+				});
+				else if (ann.type === "stale-review") events.push({
+					date: ann.date,
+					label: `⚠ stale-review — ${ann.body}`
+				});
+				else events.push({
+					date: ann.date,
+					label: `[${ann.type}] ${ann.body} (by ${ann.author})`
+				});
+				const annotatedChildren = new Set((feature.annotations ?? []).filter((a$1) => a$1.type === "spawn").map((a$1) => a$1.body));
+				for (const child of feature.lineage?.children ?? []) if (!annotatedChildren.has(child)) events.push({
+					date: "(unknown)",
+					label: `↳ spawned child: ${child}`
+				});
+				events.sort((a$1, b) => a$1.date.localeCompare(b.date));
+				const decisionsLine = feature.decisions?.length ? `\nDecisions: ${feature.decisions.map((d) => `"${d.decision}"`).join(" · ")}` : "";
 				return { content: [{
 					type: "text",
-					text: `${passes.length} passed, ${failures.length} failed — ${results.length} features checked\n\n${lines.join("\n")}`
+					text: `${`${feature.featureKey} — "${feature.title}"\n${"─".repeat(50)}`}\n${events.map((e) => `${e.date.padEnd(12)} ${e.label}`).join("\n")}${decisionsLine}`
 				}] };
 			}
-			case "read_feature_context": {
+			case "roadmap_view": {
+				const features = scanAllFeatures(a.path ? resolvePath(String(a.path)) : workspaceRoot);
+				const byStatus = {
+					active: [],
+					draft: [],
+					frozen: [],
+					deprecated: []
+				};
+				for (const f of features) {
+					const group = byStatus[f.feature.status];
+					if (group) group.push(f);
+				}
+				for (const group of Object.values(byStatus)) group.sort((a$1, b) => {
+					const pa = a$1.feature.priority ?? 9999;
+					const pb = b.feature.priority ?? 9999;
+					return pa !== pb ? pa - pb : a$1.feature.featureKey.localeCompare(b.feature.featureKey);
+				});
+				const formatGroup = (status, items) => {
+					if (items.length === 0) return "";
+					const rows = items.map(({ feature }) => {
+						const priority = feature.priority ? `P${feature.priority}` : " - ";
+						const childCount = feature.lineage?.children?.length ?? 0;
+						const childNote = childCount > 0 ? `  [${childCount}↳]` : "";
+						const missing = getMissingFields(feature);
+						const warn = missing.length > 0 ? `  ⚠ missing: ${missing.join(", ")}` : "";
+						return `  ${priority.padEnd(3)} ${feature.featureKey.padEnd(18)} ${feature.title}${childNote}${warn}`;
+					});
+					return [`${statusIcon(status)} ${status.toUpperCase()} (${items.length})`, ...rows].join("\n");
+				};
+				const sections = [
+					"active",
+					"draft",
+					"frozen",
+					"deprecated"
+				].map((s) => formatGroup(s, byStatus[s] ?? [])).filter(Boolean);
+				if (sections.length === 0) return { content: [{
+					type: "text",
+					text: "No features found."
+				}] };
+				return { content: [{
+					type: "text",
+					text: sections.join("\n\n")
+				}] };
+			}
+			case "suggest_split": {
 				const featureDir = resolvePath(String(a.path));
 				const featurePath = path.join(featureDir, "feature.json");
 				let raw;
@@ -8216,7 +9452,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 						isError: true
 					};
 				}
-				const result = validateFeature$1(JSON.parse(raw));
+				const result = validateFeature(JSON.parse(raw));
 				if (!result.success) return {
 					content: [{
 						type: "text",
@@ -8225,19 +9461,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 					isError: true
 				};
 				const feature = result.data;
-				const contextStr = contextToString(buildContext(featureDir, feature));
-				const missingFields = getMissingFields(feature);
-				const fieldInstructions = missingFields.map((field) => {
-					const prompt = FILL_PROMPTS[field];
-					const isJson = JSON_FIELDS.has(field);
-					return `### ${field}\n${prompt.system}\n${prompt.userSuffix}\n${isJson ? "(Return valid JSON for this field)" : "(Return plain text for this field)"}`;
-				}).join("\n\n");
+				const ctx = buildContext(featureDir, feature);
+				const contextStr = contextToString(ctx);
+				const signals = [
+					ctx.sourceFiles.length > 8 ? `⚠ ${ctx.sourceFiles.length} source files (large)` : null,
+					(feature.decisions?.length ?? 0) > 4 ? `⚠ ${feature.decisions.length} decisions (broad scope)` : null,
+					(feature.title + " " + feature.problem).toLowerCase().includes(" and ") ? "⚠ title/problem contains \"and\" (possible dual concern)" : null
+				].filter(Boolean);
+				const signalNote = signals.length > 0 ? `\n**Signals detected:**\n${signals.map((s) => `- ${s}`).join("\n")}\n` : "\n**No obvious split signals — evaluate from the code.**\n";
 				return { content: [{
 					type: "text",
-					text: `${missingFields.length === 0 ? "All fillable fields are already populated. No generation needed." : `## Missing fields to fill (${missingFields.join(", ")})\n\nFor each field below, generate the value described, then call write_feature_fields with all generated values.\n\n${fieldInstructions}`}\n\n## Context\n\n${contextStr}`
+					text: `${`## Suggest split for "${feature.featureKey}" — "${feature.title}"
+${signalNote}
+Analyze the source files and determine whether this feature should be broken into smaller child features.
+
+**Split signals to look for:**
+- Source files with distinct concerns that don't depend on each other
+- Multiple technical domains in the same codebase
+- Decisions covering unrelated areas
+- Problem statement describes multiple independent things
+
+**Your response:**
+1. Recommend: split or keep as-is, with 2-3 sentence justification
+2. If split: propose 2-4 child features each with title, problem, spawnReason, and which files belong to it
+   Then call spawn_child_feature for each (parentPath="${featureDir}", dir=<new subfolder>)
+3. If keep: explain what makes this feature cohesive`}\n\n## Context\n\n${contextStr}`
 				}] };
 			}
-			case "write_feature_fields": {
+			case "feature_summary_for_pr": {
 				const featureDir = resolvePath(String(a.path));
 				const featurePath = path.join(featureDir, "feature.json");
 				let raw;
@@ -8252,24 +9503,317 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 						isError: true
 					};
 				}
-				const existing = JSON.parse(raw);
-				const fields = a.fields;
-				if (!fields || typeof fields !== "object" || Array.isArray(fields)) return {
+				const result = validateFeature(JSON.parse(raw));
+				if (!result.success) return {
 					content: [{
 						type: "text",
-						text: "fields must be a JSON object"
+						text: `Invalid feature.json: ${result.errors.join(", ")}`
 					}],
 					isError: true
 				};
-				const updated = {
-					...existing,
-					...fields
+				const feature = result.data;
+				const lines = [
+					`## ${feature.featureKey} — ${feature.title}`,
+					"",
+					`**Problem:** ${feature.problem}`
+				];
+				if (feature.implementation) lines.push("", "**What was built:**", feature.implementation);
+				else if (feature.analysis) lines.push("", "**Overview:**", feature.analysis.slice(0, 300) + (feature.analysis.length > 300 ? "…" : ""));
+				if (feature.decisions?.length) {
+					lines.push("", "**Key decisions:**");
+					for (const d of feature.decisions) lines.push(`- **${d.decision}** — ${d.rationale}`);
+				}
+				if (feature.knownLimitations?.length) {
+					lines.push("", "**Known limitations:**");
+					for (const l of feature.knownLimitations) lines.push(`- ${l}`);
+				}
+				if (feature.successCriteria) lines.push("", `**Success criteria:** ${feature.successCriteria}`);
+				const lineageParts = [];
+				if (feature.lineage?.parent) lineageParts.push(`child of \`${feature.lineage.parent}\``);
+				if (feature.lineage?.children?.length) lineageParts.push(`spawned: ${feature.lineage.children.map((c) => `\`${c}\``).join(", ")}`);
+				if (lineageParts.length) lines.push("", `**Lineage:** ${lineageParts.join(" · ")}`);
+				if (feature.tags?.length) lines.push("", `**Tags:** ${feature.tags.map((t) => `\`${t}\``).join(", ")}`);
+				lines.push("", "---", `*Generated from [\`${feature.featureKey}\`](feature.json) via LAC*`);
+				return { content: [{
+					type: "text",
+					text: lines.join("\n")
+				}] };
+			}
+			case "summarize_workspace": {
+				const scanDir = a.path ? resolvePath(String(a.path)) : workspaceRoot;
+				const format = a.format === "json" ? "json" : "markdown";
+				function readReadmeSummary(dir) {
+					for (const name$1 of [
+						"README.md",
+						"readme.md",
+						"Readme.md"
+					]) {
+						const p = path.join(dir, name$1);
+						if (!fs.existsSync(p)) continue;
+						try {
+							const lines$1 = fs.readFileSync(p, "utf-8").split("\n");
+							const parts = [];
+							let started = false;
+							for (const line of lines$1) {
+								if (!started && line.trim()) started = true;
+								if (!started) continue;
+								parts.push(line);
+								if (parts.length >= 2 && line.trim() === "") break;
+								if (parts.length >= 8) break;
+							}
+							const text = parts.join("\n").trim();
+							return text.length > 300 ? text.slice(0, 297) + "…" : text;
+						} catch {}
+					}
+					return null;
+				}
+				const allFeatures = scanAllFeatures(scanDir);
+				if (allFeatures.length === 0) return { content: [{
+					type: "text",
+					text: "No features found."
+				}] };
+				const rootReadme = readReadmeSummary(scanDir);
+				const readmeCache = /* @__PURE__ */ new Map();
+				const cachedReadme = (dir) => {
+					if (!readmeCache.has(dir)) readmeCache.set(dir, readReadmeSummary(dir));
+					return readmeCache.get(dir) ?? null;
 				};
-				fs.writeFileSync(featurePath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
-				const writtenKeys = Object.keys(fields);
+				const statusCounts = {
+					active: 0,
+					draft: 0,
+					frozen: 0,
+					deprecated: 0
+				};
+				let staleCount = 0;
+				for (const { feature } of allFeatures) {
+					const s = feature.status;
+					if (s in statusCounts) statusCounts[s] = (statusCounts[s] ?? 0) + 1;
+					if (feature.annotations?.some((a$1) => a$1.type === "stale-review")) staleCount++;
+				}
+				const byDomain = /* @__PURE__ */ new Map();
+				const noDomain = [];
+				for (const f of allFeatures) {
+					const d = f.feature.domain;
+					if (d) {
+						const group = byDomain.get(d) ?? [];
+						group.push(f);
+						byDomain.set(d, group);
+					} else noDomain.push(f);
+				}
+				if (format === "json") {
+					const data = {
+						rootReadme: rootReadme ?? null,
+						stats: {
+							total: allFeatures.length,
+							byStatus: statusCounts,
+							domains: [...byDomain.keys()]
+						},
+						domains: Object.fromEntries([...byDomain.entries()].map(([domain, features]) => [domain, features.map(({ feature, filePath }) => ({
+							key: feature.featureKey,
+							title: feature.title,
+							status: feature.status,
+							problem: feature.problem,
+							tags: feature.tags ?? [],
+							decisionsCount: feature.decisions?.length ?? 0,
+							readme: readReadmeSummary(path.dirname(filePath)),
+							path: filePath
+						}))])),
+						uncategorized: noDomain.map(({ feature, filePath }) => ({
+							key: feature.featureKey,
+							title: feature.title,
+							status: feature.status,
+							problem: feature.problem,
+							tags: feature.tags ?? [],
+							decisionsCount: feature.decisions?.length ?? 0,
+							readme: readReadmeSummary(path.dirname(filePath)),
+							path: filePath
+						}))
+					};
+					return { content: [{
+						type: "text",
+						text: JSON.stringify(data, null, 2)
+					}] };
+				}
+				const lines = [];
+				if (rootReadme) lines.push("## Project", "", rootReadme, "");
+				lines.push("## Stats", `${allFeatures.length} features — ${statusCounts.active} active · ${statusCounts.draft} draft · ${statusCounts.frozen} frozen · ${statusCounts.deprecated} deprecated${staleCount > 0 ? ` · ${staleCount} stale (needs review)` : ""}`, "");
+				const formatRow = (feature, filePath) => {
+					const readme = cachedReadme(path.dirname(filePath));
+					const problem = feature.problem.length > 100 ? feature.problem.slice(0, 97) + "…" : feature.problem;
+					const tags = feature.tags?.length ? `  [${feature.tags.join(", ")}]` : "";
+					const dec = feature.decisions?.length ? `  ${feature.decisions.length} decisions` : "";
+					const readmeLine = readme ? `\n     ${(readme.split("\n")[0] ?? "").replace(/^#+\s*/, "").slice(0, 80)}` : "";
+					return `  ${statusIcon(feature.status)} ${feature.featureKey.padEnd(18)} ${feature.title}${tags}${dec}\n     ${problem}${readmeLine}`;
+				};
+				for (const [domain, features] of [...byDomain.entries()].sort(([a$1], [b]) => a$1.localeCompare(b))) {
+					lines.push(`### ${domain}`);
+					for (const { feature, filePath } of features) lines.push(formatRow(feature, filePath));
+					lines.push("");
+				}
+				if (noDomain.length > 0) {
+					lines.push("### (no domain)");
+					for (const { feature, filePath } of noDomain) lines.push(formatRow(feature, filePath));
+					lines.push("");
+				}
+				return { content: [{
+					type: "text",
+					text: lines.join("\n")
+				}] };
+			}
+			case "audit_decisions": return { ...handleAuditDecisions(a, workspaceRoot) };
+			case "feature_similarity": return { ...handleFeatureSimilarity(a, workspaceRoot) };
+			case "time_travel": return { ...handleTimeTravel(a, workspaceRoot) };
+			case "cross_feature_impact": return { ...handleCrossFeatureImpact(a, workspaceRoot) };
+			case "extract_all_features": {
+				const toUnix = (p) => p.replace(/\\/g, "/");
+				const scanRoot = a.path ? resolvePath(String(a.path)) : workspaceRoot;
+				const strategy = String(a.strategy ?? "module");
+				const defaultDepth = strategy === "directory" ? 2 : 4;
+				const maxDepth = a.depth ? Number(a.depth) : defaultDepth;
+				const MODULE_SIGNALS = new Set([
+					"package.json",
+					"go.mod",
+					"Cargo.toml",
+					"pyproject.toml",
+					"setup.py",
+					"pom.xml",
+					"build.gradle",
+					"build.gradle.kts",
+					"Gemfile",
+					"composer.json",
+					"index.ts",
+					"index.js",
+					"index.tsx",
+					"mod.ts",
+					"main.rs",
+					"main.go",
+					"main.ts",
+					"main.js",
+					"main.py",
+					"__init__.py",
+					"lib.rs"
+				]);
+				const SOURCE_EXTS = new Set([
+					".ts",
+					".tsx",
+					".js",
+					".jsx",
+					".py",
+					".go",
+					".rs",
+					".java",
+					".kt",
+					".cs",
+					".rb",
+					".php",
+					".vue",
+					".svelte",
+					".sql",
+					".c",
+					".cpp",
+					".swift"
+				]);
+				const SKIP = new Set([
+					"node_modules",
+					".git",
+					"dist",
+					"build",
+					"out",
+					"__pycache__",
+					".turbo",
+					"coverage",
+					"vendor",
+					"target",
+					".next",
+					".nuxt",
+					".cache",
+					".venv",
+					"venv",
+					"_archive",
+					"tmp",
+					"temp",
+					"migrations",
+					"fixtures",
+					"mocks",
+					"__mocks__"
+				]);
+				const candidates = [];
+				const alreadyDocumented = [];
+				function mcpWalk(dir, depth) {
+					if (depth > maxDepth) return;
+					let entries;
+					try {
+						entries = fs.readdirSync(dir, { withFileTypes: true });
+					} catch {
+						return;
+					}
+					const names = new Set(entries.filter((e) => e.isFile()).map((e) => e.name));
+					if (names.has("feature.json")) alreadyDocumented.push(toUnix(path.relative(scanRoot, dir)) || ".");
+					else if (depth > 0) {
+						const signals = [];
+						let sourceFileCount = 0;
+						for (const name$1 of names) {
+							if (MODULE_SIGNALS.has(name$1) || name$1.endsWith(".csproj")) signals.push(name$1);
+							if (SOURCE_EXTS.has(path.extname(name$1))) sourceFileCount++;
+						}
+						if (strategy === "module" ? signals.length > 0 : sourceFileCount > 0) candidates.push({
+							dir,
+							relativePath: toUnix(path.relative(scanRoot, dir)),
+							signals,
+							sourceFileCount,
+							alreadyHasFeature: false,
+							parentDir: null
+						});
+					}
+					for (const e of entries) {
+						if (!e.isDirectory() || e.name.startsWith(".") || SKIP.has(e.name)) continue;
+						mcpWalk(path.join(dir, e.name), depth + 1);
+					}
+				}
+				mcpWalk(scanRoot, 0);
+				candidates.sort((a$1, b) => a$1.dir.split(path.sep).length - b.dir.split(path.sep).length);
+				const candidateDirs = new Set(candidates.map((c) => c.dir));
+				for (const c of candidates) {
+					let parent = path.dirname(c.dir);
+					while (parent !== scanRoot && parent !== path.dirname(parent)) {
+						if (candidateDirs.has(parent)) {
+							c.parentDir = parent;
+							break;
+						}
+						parent = path.dirname(parent);
+					}
+				}
+				if (candidates.length === 0) return { content: [{
+					type: "text",
+					text: [
+						`No undocumented modules found in "${scanRoot}".`,
+						alreadyDocumented.length > 0 ? `${alreadyDocumented.length} director${alreadyDocumented.length === 1 ? "y is" : "ies are"} already documented:\n${alreadyDocumented.map((p) => `  - \`${p}\``).join("\n")}` : "",
+						strategy === "module" ? "Tip: try strategy=\"directory\" to capture all directories with source files." : ""
+					].filter(Boolean).join("\n")
+				}] };
+				const lines = [
+					`## extract_all_features — ${scanRoot}`,
+					"",
+					`**Strategy:** ${strategy}   **Depth:** ${maxDepth}`,
+					`**Found:** ${candidates.length} undocumented module${candidates.length === 1 ? "" : "s"}`,
+					alreadyDocumented.length > 0 ? `**Already documented:** ${alreadyDocumented.length} (skipped):\n${alreadyDocumented.map((p) => `  - \`${p}\``).join("\n")}` : null,
+					"",
+					"### Candidates",
+					""
+				].filter((s) => s !== null);
+				for (const c of candidates) {
+					const indent = c.parentDir ? "  " : "";
+					const sigStr = c.signals.length > 0 ? ` [${c.signals.slice(0, 3).join(", ")}]` : "";
+					const parentNote = c.parentDir ? ` (child of ${toUnix(path.relative(scanRoot, c.parentDir))})` : "";
+					lines.push(`${indent}- \`${c.relativePath}\`  —  ${c.sourceFileCount} src file${c.sourceFileCount === 1 ? "" : "s"}${sigStr}${parentNote}`);
+				}
+				lines.push("");
+				lines.push("### Next steps");
+				lines.push("");
+				lines.push("Call `extract_feature_from_code` on each candidate path above, in order (parents before children).", "Then call `create_feature` + `write_feature_fields` for each.", "Finally, wire lineage: for each child feature, set `lineage.parent` in write_feature_fields.", "", `**First call:** \`extract_feature_from_code("${candidates[0]?.dir}")\``);
 				return { content: [{
 					type: "text",
-					text: `✓ Wrote ${writtenKeys.length} field(s) to ${featurePath}: ${writtenKeys.join(", ")}`
+					text: lines.join("\n")
 				}] };
 			}
 			default: return { content: [{
@@ -8295,7 +9839,7 @@ function findNearestFeature(startDir) {
 	while (true) {
 		const candidate = path.join(current, "feature.json");
 		if (fs.existsSync(candidate)) try {
-			const result = validateFeature$1(JSON.parse(fs.readFileSync(candidate, "utf-8")));
+			const result = validateFeature(JSON.parse(fs.readFileSync(candidate, "utf-8")));
 			if (result.success) return result.data;
 		} catch {}
 		const parent = path.dirname(current);
@@ -8312,11 +9856,11 @@ function walkForFeatures(dir, results) {
 	try {
 		const entries = fs.readdirSync(dir, { withFileTypes: true });
 		for (const entry of entries) {
-			if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") continue;
+			if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist" || entry.name === "_archive") continue;
 			const full = path.join(dir, entry.name);
 			if (entry.isDirectory()) walkForFeatures(full, results);
 			else if (entry.name === "feature.json") try {
-				const result = validateFeature$1(JSON.parse(fs.readFileSync(full, "utf-8")));
+				const result = validateFeature(JSON.parse(fs.readFileSync(full, "utf-8")));
 				if (result.success) results.push({
 					feature: result.data,
 					filePath: full
@@ -8335,13 +9879,18 @@ function formatFeatureSummary(feature) {
 	if (feature.analysis) lines.push(`Analysis  : ${feature.analysis.slice(0, 200)}`);
 	if (feature.successCriteria) lines.push(`Success   : ${feature.successCriteria}`);
 	if (feature.domain) lines.push(`Domain    : ${feature.domain}`);
+	if (feature.priority) lines.push(`Priority  : P${feature.priority}/5`);
 	if (feature.decisions?.length) lines.push(`Decisions : ${feature.decisions.length} recorded`);
 	if (feature.lineage?.parent) lines.push(`Parent    : ${feature.lineage.parent}`);
 	if (feature.lineage?.children?.length) lines.push(`Children  : ${feature.lineage.children.join(", ")}`);
 	return lines.join("\n");
 }
 function buildLineageTree(feature, map, childrenOf, depth) {
-	return [`${"    ".repeat(depth)}${statusIcon(feature.status)} ${feature.featureKey} (${feature.status}) — ${feature.title}`, ...(childrenOf.get(feature.featureKey) ?? feature.lineage?.children ?? []).flatMap((key) => {
+	return [`${"    ".repeat(depth)}${statusIcon(feature.status)} ${feature.featureKey} (${feature.status}) — ${feature.title}`, ...(childrenOf.get(feature.featureKey) ?? feature.lineage?.children ?? []).slice().sort((a, b) => {
+		const pa = map.get(a)?.priority ?? 9999;
+		const pb = map.get(b)?.priority ?? 9999;
+		return pa !== pb ? pa - pb : a.localeCompare(b);
+	}).flatMap((key) => {
 		const child = map.get(key);
 		return child ? [buildLineageTree(child, map, childrenOf, depth + 1)] : [];
 	})].join("\n");
@@ -8354,6 +9903,47 @@ function statusIcon(status) {
 		deprecated: "⊘"
 	}[status] ?? "?";
 }
+const REQUIRED_FOR_ACTIVE = [
+	"analysis",
+	"implementation",
+	"successCriteria"
+];
+const REQUIRED_FOR_FROZEN = [
+	"analysis",
+	"implementation",
+	"successCriteria",
+	"knownLimitations",
+	"tags",
+	"userGuide",
+	"componentFile"
+];
+function getMissingForTransition(feature, to) {
+	const required$2 = to === "active" ? REQUIRED_FOR_ACTIVE : to === "frozen" ? REQUIRED_FOR_FROZEN : [];
+	const missing = [];
+	for (const field of required$2) {
+		const val = feature[field];
+		if (val === void 0 || val === null) {
+			missing.push(field);
+			continue;
+		}
+		if (typeof val === "string" && val.trim().length === 0) {
+			missing.push(field);
+			continue;
+		}
+		if (Array.isArray(val) && val.length === 0) {
+			missing.push(field);
+			continue;
+		}
+	}
+	if ((to === "active" || to === "frozen") && (!feature.decisions || feature.decisions.length === 0)) missing.push("decisions");
+	return [...new Set(missing)];
+}
+function checkIllegalTransition(from, to) {
+	if (from === to) return `Feature is already "${to}".`;
+	if (from === "deprecated") return `Cannot transition from deprecated. Create a new feature instead.`;
+	if (to === "draft") return `Cannot transition back to draft. Use "active" to reopen.`;
+	return null;
+}
 async function main() {
 	const transport = new StdioServerTransport();
 	await server.connect(transport);