@majeanson/lac 3.1.0 → 3.2.0

package/dist/index.mjs

@@ -2,10 +2,11 @@ import { Command } from "commander";
 import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import process$1 from "node:process";
 import fs, { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
-import path, { dirname, join, resolve } from "node:path";
+import path, { basename, dirname, join, resolve } from "node:path";
 import readline from "node:readline";
 import Anthropic from "@anthropic-ai/sdk";
 import { execSync, spawn, spawnSync } from "node:child_process";
+import crypto from "node:crypto";
 import prompts from "prompts";
 import http from "node:http";
 
@@ -141,7 +142,7 @@ function mergeDefs$1(...defs) {
 	}
 	return Object.defineProperties({}, mergedDescriptors);
 }
-function esc$1(str) {
+function esc$2(str) {
 	return JSON.stringify(str);
 }
 function slugify$1(input) {
@@ -1543,7 +1544,7 @@ const $ZodObjectJIT$1 = /* @__PURE__ */ $constructor$1("$ZodObjectJIT", (inst, d
 		]);
 		const normalized = _normalized.value;
 		const parseStr = (key) => {
-			const k = esc$1(key);
+			const k = esc$2(key);
 			return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
 		};
 		doc.write(`const input = payload.value;`);
@@ -1553,7 +1554,7 @@ const $ZodObjectJIT$1 = /* @__PURE__ */ $constructor$1("$ZodObjectJIT", (inst, d
 		doc.write(`const newResult = {};`);
 		for (const key of normalized.keys) {
 			const id = ids[key];
-			const k = esc$1(key);
+			const k = esc$2(key);
 			const isOptionalOut = shape[key]?._zod?.optout === "optional";
 			doc.write(`const ${id} = ${parseStr(key)};`);
 			if (isOptionalOut) doc.write(`
@@ -3742,6 +3743,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),
@@ -3757,7 +3779,20 @@ 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(),
+	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
@@ -3797,7 +3832,7 @@ function padCounter(n) {
 * 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$2(fromDir) {
+function findLacDir$3(fromDir) {
 	let current = path.resolve(fromDir);
 	while (true) {
 		const candidate = path.join(current, LAC_DIR$2);
@@ -3830,7 +3865,7 @@ function findLacDir$2(fromDir) {
 *                in `lac.config.json` to get keys like "proc-2026-001".
 */
 function generateFeatureKey(fromDir, prefix = "feat") {
-	const lacDir = findLacDir$2(fromDir);
+	const lacDir = findLacDir$3(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$1);
 	const keysPath = path.join(lacDir, KEYS_FILE);
@@ -3870,8 +3905,9 @@ function generateFeatureKey(fromDir, prefix = "feat") {
 * Recursively finds all feature.json files under a directory.
 * Returns an array of { filePath, feature } for each valid feature.json found.
 * Files that fail validation are skipped with a warning printed to stderr.
+* Skips _archive/ directories unless includeArchived is true.
 */
-async function scanFeatures(dir) {
+async function scanFeatures(dir, scanOptions = {}) {
 	const results = [];
 	async function walk(currentDir) {
 		let entries;
@@ -3892,6 +3928,7 @@ async function scanFeatures(dir) {
 			const fullPath = join(currentDir, entry.name);
 			if (entry.isDirectory()) {
 				if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+				if (entry.name === "_archive" && !scanOptions.includeArchived) continue;
 				await walk(fullPath);
 			} else if (entry.isFile() && entry.name === "feature.json") {
 				let raw;
@@ -3927,7 +3964,7 @@ async function scanFeatures(dir) {
 
 //#endregion
 //#region src/commands/archive.ts
-const archiveCommand = new Command("archive").description("Mark a feature as deprecated (archived)").argument("<key>", "featureKey to archive (e.g. feat-2026-001)").option("-d, --dir <path>", "Directory to scan (default: cwd)").action(async (key, options) => {
+const archiveCommand = new Command("archive").description("Mark a feature as deprecated (archived)").argument("<key>", "featureKey to archive (e.g. feat-2026-001)").option("-d, --dir <path>", "Directory to scan (default: cwd)").option("--superseded-by <key>", "featureKey that supersedes this one").option("--merged-into <key>", "featureKey this one was merged into").action(async (key, options) => {
 	const scanDir = options.dir ?? process$1.cwd();
 	const found = (await scanFeatures(scanDir)).find((f) => f.feature.featureKey === key);
 	if (!found) {
@@ -3938,16 +3975,27 @@ const archiveCommand = new Command("archive").description("Mark a feature as dep
 		process$1.stdout.write(`Already deprecated: ${key}\n`);
 		process$1.exit(0);
 	}
+	if (options.supersededBy && !FEATURE_KEY_PATTERN$1.test(options.supersededBy)) {
+		process$1.stderr.write(`Error: --superseded-by "${options.supersededBy}" is not a valid featureKey\n`);
+		process$1.exit(1);
+	}
+	if (options.mergedInto && !FEATURE_KEY_PATTERN$1.test(options.mergedInto)) {
+		process$1.stderr.write(`Error: --merged-into "${options.mergedInto}" is not a valid featureKey\n`);
+		process$1.exit(1);
+	}
 	const raw = await readFile(found.filePath, "utf-8");
 	const parsed = JSON.parse(raw);
 	parsed["status"] = "deprecated";
+	if (options.supersededBy) parsed["superseded_by"] = options.supersededBy;
+	if (options.mergedInto) parsed["merged_into"] = options.mergedInto;
 	const validation = validateFeature$1(parsed);
 	if (!validation.success) {
 		process$1.stderr.write(`Validation error: ${validation.errors.join(", ")}\n`);
 		process$1.exit(1);
 	}
 	await writeFile(found.filePath, JSON.stringify(validation.data, null, 2) + "\n", "utf-8");
-	process$1.stdout.write(`✓ ${key} archived (status → deprecated)\n`);
+	const pointerNote = options.supersededBy ? ` (superseded by ${options.supersededBy})` : options.mergedInto ? ` (merged into ${options.mergedInto})` : "";
+	process$1.stdout.write(`✓ ${key} archived (status → deprecated)${pointerNote}\n`);
 });
 
 //#endregion
@@ -4079,7 +4127,7 @@ function mergeDefs(...defs) {
 	}
 	return Object.defineProperties({}, mergedDescriptors);
 }
-function esc(str) {
+function esc$1(str) {
 	return JSON.stringify(str);
 }
 function slugify(input) {
@@ -5450,7 +5498,7 @@ const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def)
 		]);
 		const normalized = _normalized.value;
 		const parseStr = (key) => {
-			const k = esc(key);
+			const k = esc$1(key);
 			return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
 		};
 		doc.write(`const input = payload.value;`);
@@ -5460,7 +5508,7 @@ const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def)
 		doc.write(`const newResult = {};`);
 		for (const key of normalized.keys) {
 			const id = ids[key];
-			const k = esc(key);
+			const k = esc$1(key);
 			const isOptionalOut = shape[key]?._zod?.optout === "optional";
 			doc.write(`const ${id} = ${parseStr(key)};`);
 			if (isOptionalOut) doc.write(`
@@ -7593,6 +7641,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),
@@ -7608,7 +7677,20 @@ 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(),
+	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);
@@ -7657,7 +7739,7 @@ async function generateText(client, systemPrompt, userMessage, model = "claude-s
 	if (!content || content.type !== "text") throw new Error("Unexpected response type from Claude API");
 	return content.text;
 }
-const SOURCE_EXTENSIONS = new Set([
+const SOURCE_EXTENSIONS$1 = new Set([
 	".ts",
 	".tsx",
 	".js",
@@ -7675,16 +7757,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",
@@ -7695,15 +7781,19 @@ 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 {}
 	}
-	const allSource = walkDir(dir).filter((f) => SOURCE_EXTENSIONS.has(path.extname(f)) && !f.includes("node_modules") && !f.includes(".turbo") && !f.includes("dist/"));
+	const allSource = walkDir(dir).filter((f) => SOURCE_EXTENSIONS$1.has(path.extname(f)) && !f.includes("node_modules") && !f.includes(".turbo") && !f.includes("dist/"));
 	allSource.sort((a, b) => {
 		const aTest = /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(a);
 		return aTest === /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(b) ? 0 : aTest ? 1 : -1;
@@ -7712,16 +7802,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 = [];
@@ -7757,6 +7854,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) {
@@ -7764,7 +7862,7 @@ 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");
@@ -7849,13 +7947,64 @@ Return ONLY a valid JSON array — no other text:
 	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",
@@ -7864,7 +8013,13 @@ const ALL_FILLABLE_FIELDS = [
 	"knownLimitations",
 	"tags",
 	"successCriteria",
-	"domain"
+	"domain",
+	"componentFile",
+	"npmPackages",
+	"publicInterface",
+	"externalDependencies",
+	"lastVerifiedDate",
+	"codeSnippets"
 ];
 function getMissingFields(feature) {
 	return ALL_FILLABLE_FIELDS.filter((field) => {
@@ -7893,8 +8048,94 @@ const GEN_PROMPTS = {
 		userSuffix: "Generate user-facing documentation for this feature."
 	}
 };
+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");
+}
+/** 8-char sha256 prefix of a string — stable identifier for a prompt version. */
+function hashPrompt(prompt) {
+	return crypto.createHash("sha256").update(prompt).digest("hex").slice(0, 8);
+}
+const EXTRACT_SYSTEM = `You are a software engineering analyst. Given source code from a repository directory, generate a complete feature descriptor for this module or package.
+
+Return ONLY valid JSON with EXACTLY these fields — no markdown fences, no explanation:
+{
+  "title": "Short descriptive name (5-10 words)",
+  "problem": "What problem does this module solve? 1-2 sentences.",
+  "domain": "Single lowercase word or hyphenated phrase (e.g. auth, data-pipeline, payments)",
+  "tags": ["3-6 lowercase tags reflecting actual domain language"],
+  "analysis": "Architectural overview: what the code does, key patterns used, why they were chosen. Name actual functions/modules/techniques visible in the code. 150-300 words.",
+  "decisions": [
+    {
+      "decision": "what was decided (concrete, e.g. 'Use JWT for session tokens')",
+      "rationale": "why, based on code evidence",
+      "alternativesConsidered": ["alternative 1", "alternative 2"],
+      "date": null
+    }
+  ],
+  "implementation": "Main components and their roles, how data flows through the module, non-obvious patterns or constraints. 100-200 words.",
+  "knownLimitations": ["2-4 limitations, TODOs, or tech-debt items visible in the code"],
+  "successCriteria": "How do we know this module works correctly? 1-3 testable sentences."
+}
+
+Include 2-4 decisions. Be specific — generic observations are not useful.`;
+/**
+* Given a directory with source code (no feature.json required),
+* calls Claude in a single API request and returns all feature fields.
+*
+* This is designed for bulk extraction (lac extract-all) where
+* one API call per module is more efficient than field-by-field filling.
+*/
+async function extractFeature(options) {
+	const { dir, model = "claude-sonnet-4-6" } = options;
+	const client = createClient();
+	const ctx = buildContext(dir, {
+		featureKey: "feat-2026-000",
+		title: "(pending extraction)",
+		status: "draft",
+		problem: "(pending)"
+	});
+	if (ctx.sourceFiles.length === 0) throw new Error(`No source files found in "${dir}".`);
+	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("");
+	}
+	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 raw = await generateText(client, EXTRACT_SYSTEM, `Directory: ${dir}\n\nSource files:\n\n${parts.join("\n")}\n\nGenerate the feature descriptor JSON for this module.`, model);
+	const jsonStr = (raw.match(/```(?:json)?\s*([\s\S]*?)```/)?.[1] ?? raw).trim();
+	let parsed;
+	try {
+		parsed = JSON.parse(jsonStr);
+	} catch {
+		throw new Error(`Claude returned invalid JSON for "${dir}".\nRaw response:\n${raw.slice(0, 500)}`);
+	}
+	const result = parsed;
+	return {
+		title: String(result["title"] ?? "Untitled Module"),
+		problem: String(result["problem"] ?? "Problem statement not extracted."),
+		domain: String(result["domain"] ?? "general"),
+		tags: Array.isArray(result["tags"]) ? result["tags"] : [],
+		analysis: String(result["analysis"] ?? ""),
+		decisions: Array.isArray(result["decisions"]) ? result["decisions"] : [],
+		implementation: String(result["implementation"] ?? ""),
+		knownLimitations: Array.isArray(result["knownLimitations"]) ? result["knownLimitations"] : [],
+		successCriteria: String(result["successCriteria"] ?? "")
+	};
+}
 async function fillFeature(options) {
-	const { featureDir, dryRun = false, skipConfirm = false, model = "claude-sonnet-4-6" } = options;
+	const { featureDir, dryRun = false, skipConfirm = false, model = "claude-sonnet-4-6", defaultAuthor = "" } = options;
 	const featurePath = path.join(featureDir, "feature.json");
 	let raw;
 	try {
@@ -7928,12 +8169,17 @@ async function fillFeature(options) {
 	process$1.stdout.write(`Generating with ${model}...\n`);
 	const patch = {};
 	const diffs = [];
+	const rawResponses = /* @__PURE__ */ new Map();
 	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);
+			rawResponses.set(field, {
+				raw: rawValue,
+				systemPrompt: prompt.system
+			});
 			let value = rawValue.trim();
 			if (JSON_FIELDS.has(field)) try {
 				const jsonStr = rawValue.match(/```(?:json)?\s*([\s\S]*?)```/)?.[1] ?? rawValue;
@@ -7970,7 +8216,7 @@ async function fillFeature(options) {
 		};
 	}
 	if (!skipConfirm) {
-		const answer = await askUser("Apply? [Y]es / [n]o / [f]ield-by-field: ");
+		const answer = await askUser$1("Apply? [Y]es / [n]o / [f]ield-by-field: ");
 		if (answer.toLowerCase() === "n") {
 			process$1.stdout.write("  Cancelled.\n");
 			return {
@@ -7981,16 +8227,60 @@ async function fillFeature(options) {
 		}
 		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 [field, value] of Object.entries(patch)) if ((await askUser$1(`  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 INTENT_CRITICAL$1 = new Set([
+		"problem",
+		"analysis",
+		"implementation",
+		"decisions",
+		"successCriteria"
+	]);
+	const changedCritical = Object.keys(patch).filter((k) => {
+		if (!INTENT_CRITICAL$1.has(k)) return false;
+		const existing = feature[k];
+		if (existing === void 0 || existing === null) return false;
+		if (typeof existing === "string") return existing.trim().length > 0;
+		if (Array.isArray(existing)) return existing.length > 0;
+		return false;
+	});
+	const base = parsed;
+	let updatedRevisions = base.revisions ?? [];
+	if (!skipConfirm && changedCritical.length > 0) {
+		process$1.stdout.write(`\n  Intent-critical fields changed: ${changedCritical.join(", ")}\n`);
+		const author = await askUser$1(defaultAuthor ? `  Revision author [${defaultAuthor}]: ` : "  Revision author: ") || defaultAuthor;
+		const reason = await askUser$1("  Reason for change: ");
+		if (author && reason) {
+			const today$1 = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+			updatedRevisions = [...updatedRevisions, {
+				date: today$1,
+				author,
+				fields_changed: changedCritical,
+				reason
+			}];
+		}
+	}
 	const updated = {
-		...parsed,
-		...patch
+		...base,
+		...patch,
+		...updatedRevisions.length > 0 ? { revisions: updatedRevisions } : {}
 	};
 	fs.writeFileSync(featurePath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	appendPromptLog(featureDir, Object.keys(patch).map((field) => {
+		const captured = rawResponses.get(field);
+		return {
+			date: now,
+			field,
+			source: "lac fill",
+			model,
+			prompt_hash: captured ? hashPrompt(captured.systemPrompt) : void 0,
+			response_preview: captured ? captured.raw.slice(0, 120) : void 0
+		};
+	}));
 	const count = Object.keys(patch).length;
 	process$1.stdout.write(`\n  ✓ Updated ${feature.featureKey} — ${count} field${count === 1 ? "" : "s"} written.\n\n`);
 	return {
@@ -8036,7 +8326,7 @@ function typeToExt(type) {
 		docs: ".md"
 	}[type] ?? ".txt";
 }
-function askUser(question) {
+function askUser$1(question) {
 	return new Promise((resolve$1) => {
 		const rl = readline.createInterface({
 			input: process$1.stdin,
@@ -8049,6 +8339,463 @@ function askUser(question) {
 	});
 }
 
+//#endregion
+//#region src/lib/partitioner.ts
+/**
+* Files whose presence signals a module/package boundary.
+* Used by the 'module' strategy.
+*/
+const MODULE_SIGNAL_FILES = new Set([
+	"package.json",
+	"index.ts",
+	"index.js",
+	"index.tsx",
+	"index.mts",
+	"mod.ts",
+	"go.mod",
+	"main.go",
+	"Cargo.toml",
+	"lib.rs",
+	"main.rs",
+	"pyproject.toml",
+	"setup.py",
+	"setup.cfg",
+	"__init__.py",
+	"main.py",
+	"pom.xml",
+	"build.gradle",
+	"build.gradle.kts",
+	"*.csproj",
+	"Gemfile",
+	"composer.json"
+]);
+/** Source file extensions used to count files and determine if a dir has any code */
+const SOURCE_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".py",
+	".go",
+	".rs",
+	".java",
+	".kt",
+	".scala",
+	".cs",
+	".rb",
+	".php",
+	".vue",
+	".svelte",
+	".sql",
+	".c",
+	".cpp",
+	".h",
+	".hpp",
+	".swift"
+]);
+/**
+* Directory names that are always skipped.
+* These are either build artifacts, dependency trees, or known non-feature dirs.
+*/
+const BUILTIN_SKIP_DIRS = new Set([
+	"node_modules",
+	".git",
+	".svn",
+	".hg",
+	"dist",
+	"build",
+	"out",
+	"output",
+	"__pycache__",
+	".turbo",
+	"coverage",
+	".nyc_output",
+	"vendor",
+	"target",
+	".next",
+	".nuxt",
+	".cache",
+	".venv",
+	"venv",
+	"env",
+	".env",
+	"tmp",
+	"temp",
+	"_archive",
+	"migrations",
+	"fixtures",
+	"mocks",
+	"__mocks__",
+	"stubs",
+	".idea",
+	".vscode"
+]);
+/**
+* Walk a directory tree and return candidate directories for feature extraction.
+*
+* - Already-documented directories (those containing feature.json) are skipped
+*   and reported separately via the `alreadyDocumented` return value.
+* - Parent/child relationships are computed: each candidate's `parentDir` points
+*   to the nearest ancestor that is also a candidate.
+*/
+function findCandidates(rootDir, options) {
+	const root = path.resolve(rootDir);
+	const skipSet = new Set([...BUILTIN_SKIP_DIRS, ...options.ignore]);
+	const candidates = [];
+	const alreadyDocumented = [];
+	const skipped = [];
+	function walk(dir, depth) {
+		if (depth > options.maxDepth) return;
+		let entries;
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			skipped.push(dir);
+			return;
+		}
+		const names = new Set(entries.filter((e) => e.isFile()).map((e) => e.name));
+		if (names.has("feature.json")) alreadyDocumented.push(dir);
+		else if (depth > 0) {
+			const signals = getSignals(names, options.strategy);
+			const sourceFileCount = countSourceFiles(dir);
+			if (options.strategy === "module" ? signals.length > 0 : sourceFileCount > 0) candidates.push({
+				dir,
+				relativePath: path.relative(root, dir),
+				signals,
+				sourceFileCount,
+				parentDir: null
+			});
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			if (entry.name.startsWith(".") || skipSet.has(entry.name)) continue;
+			walk(path.join(dir, entry.name), depth + 1);
+		}
+	}
+	walk(root, 0);
+	candidates.sort((a, b) => a.dir.split(path.sep).length - b.dir.split(path.sep).length);
+	const candidateDirs = new Set(candidates.map((c) => c.dir));
+	for (const candidate of candidates) candidate.parentDir = findNearestCandidateAncestor(candidate.dir, root, candidateDirs);
+	return {
+		candidates,
+		alreadyDocumented,
+		skipped
+	};
+}
+function getSignals(names, strategy) {
+	if (strategy === "directory") return [...names].filter((n) => SOURCE_EXTENSIONS.has(path.extname(n)));
+	const signals = [];
+	for (const name of names) {
+		if (MODULE_SIGNAL_FILES.has(name)) signals.push(name);
+		if (name.endsWith(".csproj") || name.endsWith(".fsproj") || name.endsWith(".vbproj")) signals.push(name);
+	}
+	return signals;
+}
+function countSourceFiles(dir) {
+	let count = 0;
+	function walk(d) {
+		let entries;
+		try {
+			entries = fs.readdirSync(d, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const e of entries) if (e.isFile() && SOURCE_EXTENSIONS.has(path.extname(e.name))) count++;
+		else if (e.isDirectory() && !e.name.startsWith(".") && !BUILTIN_SKIP_DIRS.has(e.name)) walk(path.join(d, e.name));
+	}
+	walk(dir);
+	return count;
+}
+function findNearestCandidateAncestor(dir, root, candidateDirs) {
+	let current = path.dirname(dir);
+	while (current !== root && current !== path.dirname(current)) {
+		if (candidateDirs.has(current)) return current;
+		current = path.dirname(current);
+	}
+	return null;
+}
+/**
+* Given a raw directory name, produce a human-readable title.
+* e.g. "lac-mcp" → "Lac Mcp", "authService" → "Auth Service"
+*/
+function titleFromDirName(dirName) {
+	return dirName.replace(/[-_]/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/\b\w/g, (c) => c.toUpperCase()).trim() || "Unnamed Module";
+}
+
+//#endregion
+//#region src/commands/extract-all.ts
+function ensureLacDir(targetRoot) {
+	const lacDir = path.join(targetRoot, ".lac");
+	if (!fs.existsSync(lacDir)) {
+		fs.mkdirSync(lacDir, { recursive: true });
+		const year = (/* @__PURE__ */ new Date()).getFullYear();
+		fs.writeFileSync(path.join(lacDir, "counter"), `${year}\n0\n`, "utf-8");
+		process$1.stdout.write(`  ✓ Initialised .lac/ workspace at "${lacDir}"\n`);
+	}
+	return lacDir;
+}
+function findLacDir$2(fromDir) {
+	let current = path.resolve(fromDir);
+	while (true) {
+		const candidate = path.join(current, ".lac");
+		if (fs.existsSync(candidate)) return candidate;
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function writeDraftFeatureJson(featureDir, featureKey, title, problem) {
+	fs.mkdirSync(featureDir, { recursive: true });
+	const feature = {
+		featureKey,
+		title,
+		status: "draft",
+		problem,
+		schemaVersion: 1
+	};
+	fs.writeFileSync(path.join(featureDir, "feature.json"), JSON.stringify(feature, null, 2) + "\n", "utf-8");
+}
+function mergeExtractedFields(featureDir, fields) {
+	const featurePath = path.join(featureDir, "feature.json");
+	const updated = {
+		...JSON.parse(fs.readFileSync(featurePath, "utf-8")),
+		title: fields.title,
+		problem: fields.problem,
+		domain: fields.domain,
+		tags: fields.tags,
+		analysis: fields.analysis,
+		decisions: fields.decisions,
+		implementation: fields.implementation,
+		knownLimitations: fields.knownLimitations,
+		successCriteria: fields.successCriteria
+	};
+	fs.writeFileSync(featurePath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+}
+function scanNonFreshStatuses(dirs) {
+	const nonFresh = [];
+	for (const dir of dirs) {
+		const featurePath = path.join(dir, "feature.json");
+		if (!fs.existsSync(featurePath)) continue;
+		try {
+			const parsed = JSON.parse(fs.readFileSync(featurePath, "utf-8"));
+			const status = String(parsed["status"] ?? "draft");
+			if (status !== "draft" && status !== "active") nonFresh.push({
+				dir,
+				status
+			});
+		} catch {}
+	}
+	return nonFresh;
+}
+function applyStatusReset(snapshots, toStatus) {
+	let count = 0;
+	for (const { dir } of snapshots) {
+		const featurePath = path.join(dir, "feature.json");
+		try {
+			const parsed = JSON.parse(fs.readFileSync(featurePath, "utf-8"));
+			parsed["status"] = toStatus;
+			delete parsed["statusHistory"];
+			fs.writeFileSync(featurePath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+			count++;
+		} catch {}
+	}
+	return count;
+}
+function wireLineage(featureDir, featureKey, parentDir, dirToKey) {
+	if (!parentDir) return;
+	const parentKey = dirToKey.get(parentDir);
+	if (!parentKey) return;
+	const childPath = path.join(featureDir, "feature.json");
+	const child = JSON.parse(fs.readFileSync(childPath, "utf-8"));
+	child["lineage"] = {
+		...child["lineage"] ?? {},
+		parent: parentKey
+	};
+	fs.writeFileSync(childPath, JSON.stringify(child, null, 2) + "\n", "utf-8");
+	const parentPath = path.join(parentDir, "feature.json");
+	if (!fs.existsSync(parentPath)) return;
+	const parent = JSON.parse(fs.readFileSync(parentPath, "utf-8"));
+	const parentLineage = parent["lineage"] ?? {};
+	const children = parentLineage["children"] ?? [];
+	if (!children.includes(featureKey)) {
+		parentLineage["children"] = [...children, featureKey];
+		parent["lineage"] = parentLineage;
+		fs.writeFileSync(parentPath, JSON.stringify(parent, null, 2) + "\n", "utf-8");
+	}
+}
+const extractAllCommand = new Command("extract-all").description("Walk a repository and generate feature.json files for every module/directory").argument("[path]", "Root directory to scan (default: current directory)").option("--strategy <strategy>", "Partitioning strategy: \"module\" (package boundaries) or \"directory\" (all dirs with source)", "module").option("--depth <n>", "Max directory depth to descend (default: 4 for module, 2 for directory)").option("--fill", "Fill all fields with Claude API after creating draft feature.jsons").option("--model <model>", "Claude model to use with --fill (default: claude-sonnet-4-6)", "claude-sonnet-4-6").option("--dry-run", "Show what would be created without writing any files").option("--prefix <prefix>", "featureKey prefix (default: feat)", "feat").option("--ignore <patterns>", "Comma-separated directory names to skip (added to built-in skip list)", "").option("--init-workspace", "Create .lac/ directory in the target root if one is not found").option("--skip-confirm", "Skip interactive prompts (useful for CI or scripted use)").option("--concurrency <n>", "Number of parallel Claude API calls during --fill (default: 1)", "1").option("--reset-status", "Reset frozen/deprecated feature.json statuses to active (fresh-start for a new project). Prompts if not set.").action(async (targetArg, opts) => {
+	const targetRoot = path.resolve(targetArg ?? process$1.cwd());
+	const strategy = opts.strategy ?? "module";
+	const defaultDepth = strategy === "directory" ? 2 : 4;
+	const maxDepth = opts.depth !== void 0 ? Number(opts.depth) : defaultDepth;
+	const fill = opts.fill ?? false;
+	const model = opts.model ?? "claude-sonnet-4-6";
+	const dryRun = opts.dryRun ?? false;
+	const prefix = opts.prefix ?? "feat";
+	const ignore = (opts.ignore ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+	const initWorkspace = opts.initWorkspace ?? false;
+	const skipConfirm = opts.skipConfirm ?? fill;
+	const concurrency = Math.max(1, Number(opts.concurrency ?? 1));
+	const resetStatus = opts.resetStatus ?? false;
+	if (!fs.existsSync(targetRoot)) {
+		process$1.stderr.write(`Error: path "${targetRoot}" does not exist.\n`);
+		process$1.exit(1);
+	}
+	if (initWorkspace) ensureLacDir(targetRoot);
+	if (!findLacDir$2(targetRoot)) {
+		process$1.stderr.write(`Error: no .lac/ workspace found in "${targetRoot}" or any of its parents.\nRun "lac workspace init" inside the target directory first, or pass --init-workspace.\n`);
+		process$1.exit(1);
+	}
+	process$1.stdout.write(`\nScanning "${targetRoot}"...\n`);
+	process$1.stdout.write(`  Strategy : ${strategy}   Depth: ${maxDepth}\n`);
+	const { candidates, alreadyDocumented, skipped } = findCandidates(targetRoot, {
+		strategy,
+		maxDepth,
+		ignore
+	});
+	const resumable = [];
+	if (fill) for (const docDir of alreadyDocumented) {
+		const absDir = path.resolve(targetRoot, docDir);
+		try {
+			const raw = fs.readFileSync(path.join(absDir, "feature.json"), "utf-8");
+			const parsed = JSON.parse(raw);
+			const isEmpty = (v) => v === void 0 || v === null || typeof v === "string" && v.startsWith("TODO:") || Array.isArray(v) && v.length === 0;
+			if (isEmpty(parsed["analysis"]) && isEmpty(parsed["decisions"]) && isEmpty(parsed["implementation"])) resumable.push(absDir);
+		} catch {}
+	}
+	if (alreadyDocumented.length > 0) {
+		const skippedCount = alreadyDocumented.length - resumable.length;
+		if (skippedCount > 0) process$1.stdout.write(`  Skipping ${skippedCount} already-documented director${skippedCount === 1 ? "y" : "ies"}.\n`);
+		if (resumable.length > 0) process$1.stdout.write(`  Resuming ${resumable.length} incomplete fill${resumable.length === 1 ? "" : "s"} (draft with empty fields).\n`);
+	}
+	if (skipped.length > 0) process$1.stdout.write(`  Skipping ${skipped.length} unreadable director${skipped.length === 1 ? "y" : "ies"}.\n`);
+	const nonFreshSnapshots = scanNonFreshStatuses(alreadyDocumented.map((d) => path.resolve(targetRoot, d)));
+	if (nonFreshSnapshots.length > 0) {
+		const byStatus = nonFreshSnapshots.reduce((acc, { status }) => {
+			acc[status] = (acc[status] ?? 0) + 1;
+			return acc;
+		}, {});
+		const summary = Object.entries(byStatus).map(([s, n]) => `${n} ${s}`).join(", ");
+		if (resetStatus) {
+			const n = applyStatusReset(nonFreshSnapshots, "active");
+			process$1.stdout.write(`  ✓ Reset ${n} feature${n === 1 ? "" : "s"} (${summary}) → active.\n`);
+		} else if (!skipConfirm) {
+			process$1.stdout.write(`\n  Found ${nonFreshSnapshots.length} existing feature${nonFreshSnapshots.length === 1 ? "" : "s"} with non-fresh statuses (${summary}).\n  Reset to active for a fresh start? [y/N/skip]: `);
+			const answer = (await readLine$1()).toLowerCase();
+			if (answer === "y") {
+				const n = applyStatusReset(nonFreshSnapshots, "active");
+				process$1.stdout.write(`  ✓ Reset ${n} feature${n === 1 ? "" : "s"} → active.\n`);
+			} else if (answer !== "skip") process$1.stdout.write("  Statuses left unchanged.\n");
+		}
+	}
+	if (candidates.length === 0 && resumable.length === 0) {
+		process$1.stdout.write("\nNo undocumented modules found.\n");
+		if (strategy === "module") process$1.stdout.write("Tip: try --strategy directory to include all directories with source files.\n");
+		return;
+	}
+	process$1.stdout.write(`\nFound ${candidates.length} module${candidates.length === 1 ? "" : "s"} to document:\n\n`);
+	for (const c of candidates) {
+		const rel = c.relativePath || ".";
+		const indent = c.parentDir ? "  └─ " : "  ";
+		const hint = c.signals.length > 0 ? ` [${c.signals.slice(0, 2).join(", ")}]` : "";
+		process$1.stdout.write(`${indent}${rel.padEnd(40)} ${String(c.sourceFileCount).padStart(3)} src files${hint}\n`);
+	}
+	if (dryRun) {
+		process$1.stdout.write("\n[dry-run] No files written.\n\n");
+		return;
+	}
+	if (!skipConfirm) {
+		const suffix = fill ? " and fill all fields with Claude API" : "";
+		process$1.stdout.write(`\nCreate ${candidates.length} draft feature.json file${candidates.length === 1 ? "" : "s"}${suffix}? [Y/n]: `);
+		if ((await readLine$1()).toLowerCase() === "n") {
+			process$1.stdout.write("Aborted.\n");
+			return;
+		}
+	}
+	process$1.stdout.write("\n");
+	const dirToKey = /* @__PURE__ */ new Map();
+	const created = [];
+	const failed = [];
+	for (const candidate of candidates) {
+		const rel = candidate.relativePath || ".";
+		try {
+			const featureKey = generateFeatureKey(candidate.dir, prefix);
+			dirToKey.set(candidate.dir, featureKey);
+			const heuristicTitle = titleFromDirName(path.basename(candidate.dir));
+			writeDraftFeatureJson(candidate.dir, featureKey, heuristicTitle, `TODO: describe what problem the ${heuristicTitle} module solves.`);
+			created.push(featureKey);
+			process$1.stdout.write(`  ${rel} → ${featureKey} (draft)\n`);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			process$1.stdout.write(`  ${rel} ✗ ${msg}\n`);
+			failed.push(rel);
+		}
+	}
+	if (fill && (created.length > 0 || resumable.length > 0)) {
+		const resumableCandidates = resumable.map((dir) => ({
+			dir,
+			relativePath: path.relative(targetRoot, dir),
+			signals: [],
+			sourceFileCount: 0,
+			parentDir: null
+		}));
+		const toFill = [...candidates.filter((c) => dirToKey.has(c.dir)), ...resumableCandidates];
+		process$1.stdout.write(`\nFilling ${toFill.length} feature${toFill.length === 1 ? "" : "s"} with AI`);
+		if (concurrency > 1) process$1.stdout.write(` (concurrency: ${concurrency})`);
+		process$1.stdout.write("...\n");
+		let doneCount = 0;
+		let fillFailed = 0;
+		async function fillOne(candidate) {
+			const rel = candidate.relativePath || ".";
+			try {
+				const fields = await extractFeature({
+					dir: candidate.dir,
+					model
+				});
+				mergeExtractedFields(candidate.dir, fields);
+				doneCount++;
+				process$1.stdout.write(`  [${doneCount}/${toFill.length}] ${rel} ✓\n`);
+			} catch (err) {
+				fillFailed++;
+				const msg = err instanceof Error ? err.message.slice(0, 80) : String(err);
+				process$1.stdout.write(`  [${doneCount + fillFailed}/${toFill.length}] ${rel} ⚠ ${msg}\n`);
+			}
+		}
+		for (let i = 0; i < toFill.length; i += concurrency) {
+			const batch = toFill.slice(i, i + concurrency);
+			await Promise.all(batch.map(fillOne));
+		}
+		if (fillFailed > 0) process$1.stdout.write(`  ${fillFailed} fill${fillFailed === 1 ? "" : "s"} failed — drafts remain, run "lac fill <dir>" to retry.\n`);
+	}
+	let lineageCount = 0;
+	for (const candidate of candidates) if (candidate.parentDir && dirToKey.has(candidate.dir)) try {
+		wireLineage(candidate.dir, dirToKey.get(candidate.dir), candidate.parentDir, dirToKey);
+		lineageCount++;
+	} catch {}
+	process$1.stdout.write("\n");
+	process$1.stdout.write(`✓ Created ${created.length} feature.json file${created.length === 1 ? "" : "s"}`);
+	if (lineageCount > 0) process$1.stdout.write(`, wired ${lineageCount} parent/child link${lineageCount === 1 ? "" : "s"}`);
+	if (failed.length > 0) process$1.stdout.write(`, ${failed.length} failed`);
+	process$1.stdout.write("\n");
+	process$1.stdout.write(`\nNext steps:\n` + (fill ? "" : `  lac fill --all        Fill all features with AI\n`) + "  lac lint              Check for incomplete features\n  lac export --prompt . Bundle all features into a reconstruction prompt\n  lac export --site .   Generate a static HTML site\n\n");
+});
+function readLine$1() {
+	return new Promise((resolve$1) => {
+		const rl = readline.createInterface({
+			input: process$1.stdin,
+			output: process$1.stdout
+		});
+		rl.once("line", (answer) => {
+			rl.close();
+			resolve$1(answer.trim());
+		});
+	});
+}
+
 //#endregion
 //#region src/lib/walker.ts
 /**
@@ -8094,14 +8841,101 @@ function findLacConfig(startDir) {
 	}
 }
 
+//#endregion
+//#region src/lib/config.ts
+const DEFAULTS = {
+	version: 1,
+	requiredFields: ["problem"],
+	ciThreshold: 0,
+	lintStatuses: ["active", "draft"],
+	domain: "feat",
+	defaultAuthor: ""
+};
+function loadConfig(fromDir) {
+	const configPath = findLacConfig(fromDir ?? process$1.cwd());
+	if (!configPath) return { ...DEFAULTS };
+	try {
+		const raw = readFileSync(configPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		return {
+			version: parsed.version ?? DEFAULTS.version,
+			requiredFields: parsed.requiredFields ?? DEFAULTS.requiredFields,
+			ciThreshold: parsed.ciThreshold ?? DEFAULTS.ciThreshold,
+			lintStatuses: parsed.lintStatuses ?? DEFAULTS.lintStatuses,
+			domain: parsed.domain ?? DEFAULTS.domain,
+			defaultAuthor: parsed.defaultAuthor ?? DEFAULTS.defaultAuthor
+		};
+	} catch {
+		process$1.stderr.write(`Warning: could not parse lac.config.json at "${configPath}" — using defaults\n`);
+		return { ...DEFAULTS };
+	}
+}
+/** The 6 optional fields used to compute completeness score (0–100) */
+const OPTIONAL_FIELDS = [
+	"analysis",
+	"decisions",
+	"implementation",
+	"knownLimitations",
+	"tags",
+	"annotations"
+];
+function computeCompleteness(feature) {
+	const filled = OPTIONAL_FIELDS.filter((field) => {
+		const val = feature[field];
+		if (val === void 0 || val === null || val === "") return false;
+		if (Array.isArray(val)) return val.length > 0;
+		return typeof val === "string" && val.trim().length > 0;
+	}).length;
+	return Math.round(filled / OPTIONAL_FIELDS.length * 100);
+}
+
 //#endregion
 //#region src/commands/fill.ts
-const fillCommand = new Command("fill").description("Fill missing feature.json fields using AI analysis of your code").argument("[dir]", "Feature folder to fill (default: nearest feature.json from cwd)").option("--field <fields>", "Comma-separated fields to fill (default: all missing)").option("--dry-run", "Preview proposed changes without writing").option("--all", "Fill all features in the workspace below the completeness threshold").option("--threshold <n>", "Skip features above this completeness % (used with --all)", parseInt).option("--model <model>", "Claude model to use (default: claude-sonnet-4-6)").action(async (dir, options) => {
+const fillCommand = new Command("fill").description("Fill missing feature.json fields using AI analysis of your code").argument("[dir]", "Feature folder to fill (default: nearest feature.json from cwd)").option("--field <fields>", "Comma-separated fields to fill (default: all missing)").option("--dry-run", "Preview proposed changes without writing").option("--all", "Fill all features found under [dir] (or cwd) below the completeness threshold").option("--threshold <n>", "Completeness % ceiling for --all (default: 80 — skip features already above this)", parseInt).option("--model <model>", "Claude model to use (default: claude-sonnet-4-6)").action(async (dir, options) => {
 	const fields = options.field ? options.field.split(",").map((f) => f.trim()).filter(Boolean) : void 0;
 	if (options.all) {
-		process$1.stderr.write("--all flag coming soon. Run \"lac fill <dir>\" for a specific feature.\n");
-		process$1.exit(1);
-	}
+		const threshold = options.threshold ?? 80;
+		const scanDir = dir ? resolve(dir) : process$1.cwd();
+		let allFeatures;
+		try {
+			allFeatures = await scanFeatures(scanDir);
+		} catch (err) {
+			process$1.stderr.write(`Error scanning "${scanDir}": ${err instanceof Error ? err.message : String(err)}\n`);
+			process$1.exit(1);
+		}
+		const toFill = allFeatures.filter(({ feature }) => {
+			if (feature.status === "deprecated") return false;
+			return computeCompleteness(feature) < threshold;
+		});
+		if (toFill.length === 0) {
+			process$1.stdout.write(`All features are above ${threshold}% completeness. Nothing to fill.\n`);
+			return;
+		}
+		process$1.stdout.write(`\nFilling ${toFill.length} feature${toFill.length === 1 ? "" : "s"} below ${threshold}% completeness...\n\n`);
+		let filled = 0;
+		let failed = 0;
+		for (const { filePath } of toFill) {
+			const featureDir$1 = dirname(filePath);
+			const cfg = loadConfig(featureDir$1);
+			try {
+				if ((await fillFeature({
+					featureDir: featureDir$1,
+					fields,
+					dryRun: options.dryRun ?? false,
+					skipConfirm: true,
+					model: options.model,
+					defaultAuthor: cfg.defaultAuthor || void 0
+				})).applied) filled++;
+			} catch (err) {
+				process$1.stderr.write(`  Error filling "${featureDir$1}": ${err instanceof Error ? err.message : String(err)}\n`);
+				failed++;
+			}
+		}
+		process$1.stdout.write(`\n✓ Filled ${filled} feature${filled === 1 ? "" : "s"}`);
+		if (failed > 0) process$1.stdout.write(`, ${failed} failed`);
+		process$1.stdout.write("\n");
+		return;
+	}
 	let featureDir;
 	if (dir) featureDir = resolve(dir);
 	else {
@@ -8112,12 +8946,14 @@ const fillCommand = new Command("fill").description("Fill missing feature.json f
 		}
 		featureDir = dirname(found);
 	}
+	const config$2 = loadConfig(featureDir);
 	try {
 		await fillFeature({
 			featureDir,
 			fields,
 			dryRun: options.dryRun ?? false,
-			model: options.model
+			model: options.model,
+			defaultAuthor: config$2.defaultAuthor || void 0
 		});
 	} catch (err) {
 		process$1.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}\n`);
@@ -8164,50 +9000,259 @@ const genCommand = new Command("gen").description("Generate code artifacts from
 });
 
 //#endregion
-//#region src/lib/config.ts
-const DEFAULTS = {
-	version: 1,
-	requiredFields: ["problem"],
-	ciThreshold: 0,
-	lintStatuses: ["active", "draft"],
-	domain: "feat"
-};
-function loadConfig(fromDir) {
-	const configPath = findLacConfig(fromDir ?? process$1.cwd());
-	if (!configPath) return { ...DEFAULTS };
+//#region src/commands/log.ts
+const logCommand = new Command("log").description("Show the intent history of a feature: revisions, status transitions, and annotations").argument("[dir]", "Feature folder (default: nearest feature.json from cwd)").option("--json", "Output as JSON").action(async (dir, options) => {
+	let featureDir;
+	if (dir) featureDir = resolve(dir);
+	else {
+		const found = findNearestFeatureJson$1(process$1.cwd());
+		if (!found) {
+			process$1.stderr.write("No feature.json found from current directory.\n");
+			process$1.exit(1);
+		}
+		featureDir = dirname(found);
+	}
+	const featurePath = `${featureDir}/feature.json`;
+	let raw;
 	try {
-		const raw = readFileSync(configPath, "utf-8");
-		const parsed = JSON.parse(raw);
-		return {
-			version: parsed.version ?? DEFAULTS.version,
-			requiredFields: parsed.requiredFields ?? DEFAULTS.requiredFields,
-			ciThreshold: parsed.ciThreshold ?? DEFAULTS.ciThreshold,
-			lintStatuses: parsed.lintStatuses ?? DEFAULTS.lintStatuses,
-			domain: parsed.domain ?? DEFAULTS.domain
-		};
+		raw = await readFile(featurePath, "utf-8");
 	} catch {
-		process$1.stderr.write(`Warning: could not parse lac.config.json at "${configPath}" — using defaults\n`);
-		return { ...DEFAULTS };
+		process$1.stderr.write(`No feature.json found at "${featurePath}"\n`);
+		process$1.exit(1);
 	}
-}
-/** The 6 optional fields used to compute completeness score (0–100) */
-const OPTIONAL_FIELDS = [
+	const result = validateFeature$1(JSON.parse(raw));
+	if (!result.success) {
+		process$1.stderr.write(`Invalid feature.json: ${result.errors.join(", ")}\n`);
+		process$1.exit(1);
+	}
+	const feature = result.data;
+	const raw2 = feature;
+	const timeline = [];
+	for (const rev of raw2.revisions ?? []) timeline.push({
+		date: rev.date,
+		type: "revision",
+		label: `revised by ${rev.author}`,
+		detail: `${rev.reason}  [${rev.fields_changed.join(", ")}]`,
+		author: rev.author
+	});
+	for (const st of raw2.statusHistory ?? []) timeline.push({
+		date: st.date,
+		type: "status",
+		label: `status: ${st.from} → ${st.to}`,
+		detail: st.reason ?? ""
+	});
+	for (const ann of feature.annotations ?? []) timeline.push({
+		date: ann.date,
+		type: "annotation",
+		label: `[${ann.type}] by ${ann.author}`,
+		detail: ann.body,
+		author: ann.author
+	});
+	timeline.sort((a, b) => a.date.localeCompare(b.date));
+	if (options.json) {
+		process$1.stdout.write(JSON.stringify({
+			featureKey: feature.featureKey,
+			title: feature.title,
+			timeline
+		}, null, 2) + "\n");
+		return;
+	}
+	if (timeline.length === 0) {
+		process$1.stdout.write(`${feature.featureKey}  ${feature.title}\n\nNo history recorded yet.\n`);
+		return;
+	}
+	process$1.stdout.write(`${feature.featureKey}  ${feature.title}  [${feature.status}]\n`);
+	process$1.stdout.write("─".repeat(60) + "\n\n");
+	for (const entry of timeline) {
+		const icon = entry.type === "revision" ? "✎" : entry.type === "status" ? "⟳" : "◆";
+		process$1.stdout.write(`${icon}  ${entry.date}  ${entry.label}\n`);
+		if (entry.detail) process$1.stdout.write(`   ${entry.detail}\n`);
+		process$1.stdout.write("\n");
+	}
+});
+
+//#endregion
+//#region src/commands/merge.ts
+const mergeCommand = new Command("merge").description("Merge two or more features into a target feature, setting pointers on all sides").argument("<source-keys>", "Comma-separated featureKeys to merge (will be deprecated)").requiredOption("--into <target-key>", "featureKey of the target feature to merge into").option("-d, --dir <path>", "Directory to scan (default: cwd)").option("--dry-run", "Preview changes without writing").action(async (sourceKeysArg, options) => {
+	const scanDir = resolve(options.dir ?? process$1.cwd());
+	const sourceKeys = sourceKeysArg.split(",").map((k) => k.trim()).filter(Boolean);
+	const targetKey = options.into;
+	if (sourceKeys.length === 0) {
+		process$1.stderr.write("Error: at least one source key is required.\n");
+		process$1.exit(1);
+	}
+	const features = await scanFeatures(scanDir);
+	const byKey = new Map(features.map((f) => [f.feature.featureKey, f]));
+	for (const key of sourceKeys) if (!byKey.has(key)) {
+		process$1.stderr.write(`Error: feature "${key}" not found in "${scanDir}"\n`);
+		process$1.exit(1);
+	}
+	const targetEntry = byKey.get(targetKey);
+	if (!targetEntry) {
+		process$1.stderr.write(`Error: target feature "${targetKey}" not found in "${scanDir}"\n`);
+		process$1.exit(1);
+	}
+	process$1.stdout.write(`Merge: [${sourceKeys.join(", ")}] → ${targetKey}\n`);
+	for (const key of sourceKeys) process$1.stdout.write(`  ${key}: status → deprecated, merged_into = ${targetKey}\n`);
+	process$1.stdout.write(`  ${targetKey}: merged_from += [${sourceKeys.join(", ")}]\n`);
+	if (options.dryRun) {
+		process$1.stdout.write("[dry-run] No changes written.\n");
+		return;
+	}
+	for (const key of sourceKeys) {
+		const entry = byKey.get(key);
+		const raw = JSON.parse(await readFile(entry.filePath, "utf-8"));
+		raw.status = "deprecated";
+		raw.merged_into = targetKey;
+		const validation = validateFeature$1(raw);
+		if (!validation.success) {
+			process$1.stderr.write(`Validation error on "${key}": ${validation.errors.join(", ")}\n`);
+			process$1.exit(1);
+		}
+		await writeFile(entry.filePath, JSON.stringify(validation.data, null, 2) + "\n", "utf-8");
+	}
+	const targetRaw = JSON.parse(await readFile(targetEntry.filePath, "utf-8"));
+	const existingMergedFrom = targetRaw.merged_from ?? [];
+	const toAdd = sourceKeys.filter((k) => !existingMergedFrom.includes(k));
+	targetRaw.merged_from = [...existingMergedFrom, ...toAdd];
+	const targetValidation = validateFeature$1(targetRaw);
+	if (!targetValidation.success) {
+		process$1.stderr.write(`Validation error on "${targetKey}": ${targetValidation.errors.join(", ")}\n`);
+		process$1.exit(1);
+	}
+	await writeFile(targetEntry.filePath, JSON.stringify(targetValidation.data, null, 2) + "\n", "utf-8");
+	process$1.stdout.write(`✓ ${sourceKeys.join(", ")} merged into ${targetKey}\n`);
+});
+
+//#endregion
+//#region src/commands/revisions.ts
+const INTENT_CRITICAL = [
+	"problem",
 	"analysis",
-	"decisions",
 	"implementation",
-	"knownLimitations",
-	"tags",
-	"annotations"
+	"decisions",
+	"successCriteria"
 ];
-function computeCompleteness(feature) {
-	const filled = OPTIONAL_FIELDS.filter((field) => {
-		const val = feature[field];
-		if (val === void 0 || val === null || val === "") return false;
-		if (Array.isArray(val)) return val.length > 0;
-		return typeof val === "string" && val.trim().length > 0;
-	}).length;
-	return Math.round(filled / OPTIONAL_FIELDS.length * 100);
+function askUser(question) {
+	return new Promise((resolve$1) => {
+		const rl = readline.createInterface({
+			input: process$1.stdin,
+			output: process$1.stdout
+		});
+		rl.question(question, (answer) => {
+			rl.close();
+			resolve$1(answer.trim());
+		});
+	});
 }
+const baselineCommand = new Command("baseline").description("Add a first revision entry to all features that have intent-critical fields but no revisions").argument("[dir]", "Directory to scan (default: cwd)").option("--author <author>", "Author name for the baseline revision").option("--reason <reason>", "Reason text for the baseline revision (default: \"initial baseline\")").option("--dry-run", "Preview which features would be updated without writing").action(async (dir, options) => {
+	const scanDir = resolve(dir ?? process$1.cwd());
+	const config$2 = loadConfig(scanDir);
+	const needsBaseline = (await scanFeatures(scanDir)).filter(({ feature }) => {
+		const raw = feature;
+		if (Array.isArray(raw.revisions) && raw.revisions.length > 0) return false;
+		return INTENT_CRITICAL.some((field) => {
+			const val = raw[field];
+			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 (needsBaseline.length === 0) {
+		process$1.stdout.write("All features already have revision entries. Nothing to baseline.\n");
+		return;
+	}
+	process$1.stdout.write(`Found ${needsBaseline.length} feature(s) without revisions:\n`);
+	for (const { feature } of needsBaseline) process$1.stdout.write(`  ${feature.featureKey}  ${feature.title}\n`);
+	process$1.stdout.write("\n");
+	if (options.dryRun) {
+		process$1.stdout.write("[dry-run] No changes written.\n");
+		return;
+	}
+	const defaultAuthor = config$2.defaultAuthor;
+	let author = options.author ?? defaultAuthor ?? "";
+	if (!author) author = await askUser("Revision author (for all features): ");
+	if (!author) {
+		process$1.stderr.write("Error: author is required.\n");
+		process$1.exit(1);
+	}
+	const reason = options.reason ?? "initial baseline — revisions tracking added retroactively";
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	let updated = 0;
+	for (const { feature, filePath } of needsBaseline) {
+		const raw = feature;
+		const filledCritical = INTENT_CRITICAL.filter((field) => {
+			const val = raw[field];
+			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 revision = {
+			date: today,
+			author,
+			fields_changed: filledCritical,
+			reason
+		};
+		const content = JSON.parse(await readFile(filePath, "utf-8"));
+		content.revisions = [revision];
+		const validation = validateFeature$1(content);
+		if (!validation.success) {
+			process$1.stderr.write(`  ✗  ${feature.featureKey}  validation failed — skipping\n`);
+			continue;
+		}
+		await writeFile(filePath, JSON.stringify(validation.data, null, 2) + "\n", "utf-8");
+		process$1.stdout.write(`  ✓  ${feature.featureKey}  baselined (${filledCritical.join(", ")})\n`);
+		updated++;
+	}
+	process$1.stdout.write(`\n${updated} feature(s) baselined.\n`);
+});
+const revisionsCommand = new Command("revisions").description("Manage feature revision history").addCommand(baselineCommand);
+
+//#endregion
+//#region src/commands/supersede.ts
+const supersedeCommand = new Command("supersede").description("Mark one feature as superseded by another, setting pointers on both sides").argument("<old-key>", "featureKey being superseded (will be deprecated)").argument("<new-key>", "featureKey that supersedes it").option("-d, --dir <path>", "Directory to scan (default: cwd)").option("--dry-run", "Preview changes without writing").action(async (oldKey, newKey, options) => {
+	const scanDir = resolve(options.dir ?? process$1.cwd());
+	const features = await scanFeatures(scanDir);
+	const byKey = new Map(features.map((f) => [f.feature.featureKey, f]));
+	const oldEntry = byKey.get(oldKey);
+	if (!oldEntry) {
+		process$1.stderr.write(`Error: feature "${oldKey}" not found in "${scanDir}"\n`);
+		process$1.exit(1);
+	}
+	const newEntry = byKey.get(newKey);
+	if (!newEntry) {
+		process$1.stderr.write(`Error: feature "${newKey}" not found in "${scanDir}"\n`);
+		process$1.exit(1);
+	}
+	process$1.stdout.write(`Supersede: ${oldKey} → ${newKey}\n`);
+	process$1.stdout.write(`  ${oldKey}: status → deprecated, superseded_by = ${newKey}\n`);
+	process$1.stdout.write(`  ${newKey}: superseded_from += [${oldKey}]\n`);
+	if (options.dryRun) {
+		process$1.stdout.write("[dry-run] No changes written.\n");
+		return;
+	}
+	const oldRaw = JSON.parse(await readFile(oldEntry.filePath, "utf-8"));
+	oldRaw.status = "deprecated";
+	oldRaw.superseded_by = newKey;
+	const oldValidation = validateFeature$1(oldRaw);
+	if (!oldValidation.success) {
+		process$1.stderr.write(`Validation error on "${oldKey}": ${oldValidation.errors.join(", ")}\n`);
+		process$1.exit(1);
+	}
+	await writeFile(oldEntry.filePath, JSON.stringify(oldValidation.data, null, 2) + "\n", "utf-8");
+	const newRaw = JSON.parse(await readFile(newEntry.filePath, "utf-8"));
+	const existingSupersededFrom = newRaw.superseded_from ?? [];
+	if (!existingSupersededFrom.includes(oldKey)) newRaw.superseded_from = [...existingSupersededFrom, oldKey];
+	const newValidation = validateFeature$1(newRaw);
+	if (!newValidation.success) {
+		process$1.stderr.write(`Validation error on "${newKey}": ${newValidation.errors.join(", ")}\n`);
+		process$1.exit(1);
+	}
+	await writeFile(newEntry.filePath, JSON.stringify(newValidation.data, null, 2) + "\n", "utf-8");
+	process$1.stdout.write(`✓ ${oldKey} superseded by ${newKey}\n`);
+});
 
 //#endregion
 //#region src/commands/blame.ts
@@ -8538,748 +9583,906 @@ const doctorCommand = new Command("doctor").description("Check workspace health
 });
 
 //#endregion
-//#region src/templates/markdown.ts
-/**
-* Minimal markdown → HTML converter for use in the static site generator.
-* Handles the subset of markdown used in feature.json documentation fields:
-* headings, code blocks, inline code, bold, tables, lists, and paragraphs.
-*/
-function escapeHtml$2(s) {
-	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-function inlineMarkdown(text) {
-	return escapeHtml$2(text).replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>").replace(/`([^`]+)`/g, "<code>$1</code>").replace(/\[([^\]]+)\]\(((?:[^()]*|\([^()]*\))*)\)/g, "<a href=\"$2\">$1</a>");
-}
-function isTableRow(line) {
-	return line.trim().startsWith("|") && line.trim().endsWith("|");
-}
-function isTableSeparator(line) {
-	return /^\|[\s\-:|]+\|/.test(line.trim());
-}
-function renderTableRow(line, isHeader) {
-	const cells = line.trim().slice(1, -1).split("|").map((c) => c.trim());
-	const tag = isHeader ? "th" : "td";
-	return `<tr>${cells.map((c) => `<${tag}>${inlineMarkdown(c)}</${tag}>`).join("")}</tr>`;
-}
-function markdownToHtml(md) {
-	const lines = md.split("\n");
-	const out = [];
-	let i = 0;
-	while (i < lines.length) {
-		const line = lines[i] ?? "";
-		if (line.startsWith("```")) {
-			const lang = line.slice(3).trim();
-			const codeLines = [];
-			i++;
-			while (i < lines.length && !(lines[i] ?? "").startsWith("```")) {
-				codeLines.push(lines[i] ?? "");
-				i++;
-			}
-			if (i < lines.length) i++;
-			const langAttr = lang ? ` class="language-${escapeHtml$2(lang)}"` : "";
-			out.push(`<pre><code${langAttr}>${escapeHtml$2(codeLines.join("\n"))}</code></pre>`);
-			continue;
-		}
-		if (line.startsWith("### ")) {
-			out.push(`<h3>${inlineMarkdown(line.slice(4))}</h3>`);
-			i++;
-			continue;
-		}
-		if (line.startsWith("## ")) {
-			out.push(`<h2>${inlineMarkdown(line.slice(3))}</h2>`);
-			i++;
-			continue;
-		}
-		if (line.startsWith("# ")) {
-			out.push(`<h1>${inlineMarkdown(line.slice(2))}</h1>`);
-			i++;
-			continue;
-		}
-		if (/^(-{3,}|\*{3,}|_{3,})$/.test(line.trim())) {
-			out.push("<hr />");
-			i++;
-			continue;
-		}
-		if (isTableRow(line)) {
-			const tableRows = [];
-			let firstRow = true;
-			while (i < lines.length && isTableRow(lines[i] ?? "")) {
-				const current = lines[i] ?? "";
-				if (isTableSeparator(current)) {
-					i++;
-					continue;
-				}
-				tableRows.push(renderTableRow(current, firstRow));
-				if (firstRow) firstRow = false;
-				i++;
-			}
-			out.push(`<table class="md-table"><thead>${tableRows[0] ?? ""}</thead><tbody>${tableRows.slice(1).join("")}</tbody></table>`);
-			continue;
-		}
-		if (/^[-*] /.test(line)) {
-			const items = [];
-			while (i < lines.length && /^[-*] /.test(lines[i] ?? "")) {
-				items.push(`<li>${inlineMarkdown((lines[i] ?? "").slice(2))}</li>`);
-				i++;
-			}
-			out.push(`<ul>${items.join("")}</ul>`);
-			continue;
-		}
-		if (/^[1-9]\d*\. /.test(line)) {
-			const items = [];
-			while (i < lines.length && /^[1-9]\d*\. /.test(lines[i] ?? "")) {
-				items.push(`<li>${inlineMarkdown((lines[i] ?? "").replace(/^[1-9]\d*\. /, ""))}</li>`);
-				i++;
-			}
-			out.push(`<ol>${items.join("")}</ol>`);
-			continue;
-		}
-		if (line.trim() === "") {
-			i++;
-			continue;
-		}
-		const paraLines = [];
-		while (i < lines.length && (lines[i] ?? "").trim() !== "" && !(lines[i] ?? "").startsWith("#") && !(lines[i] ?? "").startsWith("```") && !/^[-*] /.test(lines[i] ?? "") && !/^[1-9]\d*\. /.test(lines[i] ?? "") && !isTableRow(lines[i] ?? "")) {
-			paraLines.push(lines[i] ?? "");
-			i++;
-		}
-		if (paraLines.length > 0) out.push(`<p>${inlineMarkdown(paraLines.join(" "))}</p>`);
-	}
-	return out.join("\n");
-}
+//#region src/lib/htmlGenerator.ts
+function esc(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function generateHtmlWiki(features, projectName) {
+	const dataJson = JSON.stringify(features).replace(/<\/script>/gi, "<\\/script>");
+	features.filter((f) => f.status === "active").length, features.filter((f) => f.status === "frozen").length, features.filter((f) => f.status === "draft").length, features.filter((f) => f.status === "deprecated").length;
+	const domains = [...new Set(features.map((f) => f.domain).filter(Boolean))].sort();
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>${esc(projectName)} — LAC Wiki</title>
+<style>
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
 
-//#endregion
-//#region src/templates/site-style.css.ts
-const css = `
 :root {
-  --color-bg: #ffffff;
-  --color-surface: #f8f9fa;
-  --color-border: #dee2e6;
-  --color-text: #212529;
-  --color-text-muted: #6c757d;
-  --color-link: #0d6efd;
-  --color-link-hover: #0a58ca;
-  --color-active: #198754;
-  --color-draft: #6c757d;
-  --color-frozen: #0d6efd;
-  --color-deprecated: #dc3545;
-}
-
-@media (prefers-color-scheme: dark) {
-  :root {
-    --color-bg: #1a1a2e;
-    --color-surface: #16213e;
-    --color-border: #374151;
-    --color-text: #e9ecef;
-    --color-text-muted: #9ca3af;
-    --color-link: #60a5fa;
-    --color-link-hover: #93c5fd;
-    --color-active: #4ade80;
-    --color-draft: #9ca3af;
-    --color-frozen: #60a5fa;
-    --color-deprecated: #f87171;
-  }
-}
+  --bg:          #12100e;
+  --bg-sidebar:  #0e0c0a;
+  --bg-card:     #1a1714;
+  --bg-hover:    #201d1a;
+  --bg-active:   #251f18;
+  --border:      #2a2420;
+  --border-soft: #221e1b;
+  --text:        #e8ddd4;
+  --text-mid:    #b0a49c;
+  --text-soft:   #7a6a5a;
+  --accent:      #c4a255;
+  --accent-warm: #e8b865;
+  --mono:        'Cascadia Code', 'Fira Code', 'JetBrains Mono', 'Consolas', monospace;
+  --sans:        -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
 
-*, *::before, *::after {
-  box-sizing: border-box;
-}
+  --status-active:     #4aad72;
+  --status-draft:      #c4a255;
+  --status-frozen:     #5b82cc;
+  --status-deprecated: #cc5b5b;
 
-html {
-  font-size: 16px;
-  line-height: 1.6;
+  --status-active-bg:     rgba(74,173,114,0.12);
+  --status-draft-bg:      rgba(196,162,85,0.12);
+  --status-frozen-bg:     rgba(91,130,204,0.12);
+  --status-deprecated-bg: rgba(204,91,91,0.12);
 }
 
-body {
-  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen,
-    Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
-  background-color: var(--color-bg);
-  color: var(--color-text);
-  margin: 0;
-  padding: 0;
-}
+html, body { height: 100%; }
+body { background: var(--bg); color: var(--text); font-family: var(--sans); font-size: 14px; line-height: 1.6; display: flex; flex-direction: column; }
 
-.container {
-  max-width: 800px;
-  margin: 0 auto;
-  padding: 2rem 1rem;
-}
+/* ── Shell ──────────────────────────────────────────────── */
 
-h1 {
-  font-size: 2rem;
-  font-weight: 700;
-  margin-top: 0;
-  margin-bottom: 0.5rem;
-}
+.shell { display: flex; flex-direction: column; height: 100vh; overflow: hidden; }
 
-h2 {
-  font-size: 1.25rem;
-  font-weight: 600;
-  margin-top: 2rem;
-  margin-bottom: 0.75rem;
-  border-bottom: 1px solid var(--color-border);
-  padding-bottom: 0.25rem;
-}
+.topbar {
+  flex-shrink: 0;
+  height: 44px;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 0 18px;
+  background: var(--bg-sidebar);
+  border-bottom: 1px solid var(--border);
+}
+.topbar-logo { font-family: var(--mono); font-size: 13px; color: var(--accent); letter-spacing: 0.05em; }
+.topbar-sep  { color: var(--border); }
+.topbar-project { font-family: var(--mono); font-size: 12px; color: var(--text-mid); }
+.topbar-count { margin-left: auto; font-family: var(--mono); font-size: 11px; color: var(--text-soft); }
 
-a {
-  color: var(--color-link);
-  text-decoration: none;
-}
+.body-row { display: flex; flex: 1; min-height: 0; }
+
+/* ── Sidebar ────────────────────────────────────────────── */
 
-a:hover {
-  color: var(--color-link-hover);
-  text-decoration: underline;
+.sidebar {
+  width: 264px;
+  flex-shrink: 0;
+  background: var(--bg-sidebar);
+  border-right: 1px solid var(--border);
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
 }
 
-p {
-  margin: 0 0 1rem;
+.sidebar-search {
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--border);
+  flex-shrink: 0;
 }
+.sidebar-search input {
+  width: 100%;
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  padding: 6px 10px;
+  font-family: var(--mono);
+  font-size: 12px;
+  color: var(--text);
+  outline: none;
+}
+.sidebar-search input:focus { border-color: var(--accent); }
+.sidebar-search input::placeholder { color: var(--text-soft); }
+
+.nav-tree {
+  flex: 1;
+  overflow-y: auto;
+  padding: 6px 0 24px;
+  scrollbar-width: thin;
+  scrollbar-color: var(--border) transparent;
+}
+.nav-tree::-webkit-scrollbar { width: 4px; }
+.nav-tree::-webkit-scrollbar-thumb { background: var(--border); border-radius: 2px; }
 
-.meta {
+/* Domain group */
+.nav-group { margin-bottom: 2px; }
+
+.nav-domain {
   display: flex;
   align-items: center;
-  gap: 0.75rem;
-  margin-bottom: 1.5rem;
-  color: var(--color-text-muted);
-  font-size: 0.875rem;
-}
+  gap: 6px;
+  padding: 6px 14px 4px;
+  font-family: var(--mono);
+  font-size: 10px;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: var(--text-soft);
+  cursor: pointer;
+  user-select: none;
+}
+.nav-domain:hover { color: var(--text-mid); }
+.nav-domain-arrow { transition: transform 0.15s; font-size: 8px; }
+.nav-domain.collapsed .nav-domain-arrow { transform: rotate(-90deg); }
+.nav-domain-count { margin-left: auto; font-size: 10px; opacity: 0.6; }
 
-.feature-key {
-  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas,
-    'Liberation Mono', 'Courier New', monospace;
-  font-size: 0.875rem;
-  color: var(--color-text-muted);
-}
+.nav-group-items { overflow: hidden; }
+.nav-group.collapsed .nav-group-items { display: none; }
 
-/* Status badges */
-.status-badge {
-  display: inline-block;
-  padding: 0.125rem 0.5rem;
-  border-radius: 9999px;
-  font-size: 0.75rem;
-  font-weight: 600;
-  text-transform: uppercase;
-  letter-spacing: 0.05em;
+/* Feature item */
+.nav-item {
+  display: flex;
+  align-items: baseline;
+  gap: 7px;
+  padding: 5px 14px 5px 18px;
+  cursor: pointer;
+  user-select: none;
+  border-left: 2px solid transparent;
+  transition: background 0.1s;
+  text-decoration: none;
 }
-
-.status-active {
-  color: var(--color-active);
-  background-color: color-mix(in srgb, var(--color-active) 15%, transparent);
-  border: 1px solid color-mix(in srgb, var(--color-active) 30%, transparent);
+.nav-item:hover { background: var(--bg-hover); }
+.nav-item.active {
+  background: var(--bg-active);
+  border-left-color: var(--accent);
 }
+.nav-item[data-depth="1"] { padding-left: 30px; }
+.nav-item[data-depth="2"] { padding-left: 42px; }
+.nav-item[data-depth="3"] { padding-left: 54px; }
 
-.status-draft {
-  color: var(--color-draft);
-  background-color: color-mix(in srgb, var(--color-draft) 15%, transparent);
-  border: 1px solid color-mix(in srgb, var(--color-draft) 30%, transparent);
+.nav-dot {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  flex-shrink: 0;
+  margin-top: 1px;
 }
+.nav-item[data-status="active"]     .nav-dot { background: var(--status-active); }
+.nav-item[data-status="draft"]      .nav-dot { background: var(--status-draft); }
+.nav-item[data-status="frozen"]     .nav-dot { background: var(--status-frozen); }
+.nav-item[data-status="deprecated"] .nav-dot { background: var(--status-deprecated); opacity: 0.5; }
 
-.status-frozen {
-  color: var(--color-frozen);
-  background-color: color-mix(in srgb, var(--color-frozen) 15%, transparent);
-  border: 1px solid color-mix(in srgb, var(--color-frozen) 30%, transparent);
-}
+.nav-item-key {
+  font-family: var(--mono);
+  font-size: 10px;
+  color: var(--text-soft);
+  flex-shrink: 0;
+}
+.nav-item-title {
+  font-size: 12px;
+  color: var(--text-mid);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  flex: 1;
+  min-width: 0;
+}
+.nav-item:hover .nav-item-title,
+.nav-item.active .nav-item-title { color: var(--text); }
+.nav-item.active .nav-item-key { color: var(--accent); }
 
-.status-deprecated {
-  color: var(--color-deprecated);
-  background-color: color-mix(in srgb, var(--color-deprecated) 15%, transparent);
-  border: 1px solid color-mix(in srgb, var(--color-deprecated) 30%, transparent);
+.nav-child-arrow {
+  font-size: 9px;
+  color: var(--text-soft);
+  flex-shrink: 0;
+  opacity: 0.5;
 }
 
-/* Search */
-.search-wrapper {
-  margin-bottom: 1.5rem;
-}
+/* ── Content ────────────────────────────────────────────── */
 
-.search-input {
-  width: 100%;
-  padding: 0.5rem 0.75rem;
-  border: 1px solid var(--color-border);
-  border-radius: 0.375rem;
-  background-color: var(--color-surface);
-  color: var(--color-text);
-  font-size: 1rem;
-  font-family: inherit;
-  outline: none;
-  transition: border-color 0.15s ease;
-}
+.content {
+  flex: 1;
+  min-width: 0;
+  overflow-y: auto;
+  scrollbar-width: thin;
+  scrollbar-color: var(--border) transparent;
+}
+.content::-webkit-scrollbar { width: 6px; }
+.content::-webkit-scrollbar-thumb { background: var(--border); border-radius: 3px; }
 
-.search-input:focus {
-  border-color: var(--color-link);
+/* Home / welcome */
+.home-page {
+  max-width: 680px;
+  margin: 0 auto;
+  padding: 56px 40px 80px;
+}
+.home-eyebrow {
+  font-family: var(--mono);
+  font-size: 10px;
+  letter-spacing: 0.18em;
+  text-transform: uppercase;
+  color: var(--accent);
+  margin-bottom: 16px;
+}
+.home-title {
+  font-size: 32px;
+  font-weight: 700;
+  color: var(--text);
+  margin-bottom: 8px;
+  line-height: 1.2;
+}
+.home-subtitle {
+  font-size: 14px;
+  color: var(--text-mid);
+  margin-bottom: 40px;
 }
 
-/* Feature table */
-.feature-table {
-  width: 100%;
-  border-collapse: collapse;
-  font-size: 0.9375rem;
+.stat-row {
+  display: flex;
+  gap: 16px;
+  flex-wrap: wrap;
+  margin-bottom: 40px;
 }
+.stat-pill {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 8px 14px;
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  font-family: var(--mono);
+  font-size: 12px;
+}
+.stat-pill-dot { width: 8px; height: 8px; border-radius: 50%; }
+.stat-pill-num { font-size: 18px; font-weight: 700; color: var(--text); }
+.stat-pill-label { color: var(--text-soft); }
 
-.feature-table th {
-  text-align: left;
-  padding: 0.5rem 0.75rem;
-  border-bottom: 2px solid var(--color-border);
-  color: var(--color-text-muted);
-  font-size: 0.75rem;
-  font-weight: 600;
+.home-section-title {
+  font-family: var(--mono);
+  font-size: 10px;
+  letter-spacing: 0.14em;
   text-transform: uppercase;
-  letter-spacing: 0.05em;
+  color: var(--text-soft);
+  margin-bottom: 12px;
+  padding-bottom: 6px;
+  border-bottom: 1px solid var(--border);
 }
 
-.feature-table td {
-  padding: 0.625rem 0.75rem;
-  border-bottom: 1px solid var(--color-border);
-  vertical-align: top;
-}
+.domain-chips {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-bottom: 40px;
+}
+.domain-chip {
+  padding: 4px 10px;
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: 100px;
+  font-family: var(--mono);
+  font-size: 11px;
+  color: var(--text-mid);
+  cursor: pointer;
+  transition: border-color 0.15s, color 0.15s;
+}
+.domain-chip:hover { border-color: var(--accent); color: var(--accent); }
 
-.feature-table tr:last-child td {
-  border-bottom: none;
+/* Feature page */
+.feature-page {
+  max-width: 760px;
+  margin: 0 auto;
+  padding: 48px 40px 80px;
 }
 
-.feature-table tr:hover td {
-  background-color: var(--color-surface);
+.feature-meta {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+  margin-bottom: 20px;
 }
-
-.problem-excerpt {
-  color: var(--color-text-muted);
-  font-size: 0.875rem;
+.feature-key {
+  font-family: var(--mono);
+  font-size: 11px;
+  color: var(--text-soft);
 }
 
-/* Sections */
-section {
-  margin-bottom: 2rem;
+.badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  padding: 3px 8px;
+  border-radius: 4px;
+  font-family: var(--mono);
+  font-size: 11px;
+  font-weight: 500;
 }
+.badge-dot { width: 6px; height: 6px; border-radius: 50%; }
+.badge-active     { color: var(--status-active);     background: var(--status-active-bg);     border: 1px solid rgba(74,173,114,0.25); }
+.badge-draft      { color: var(--status-draft);      background: var(--status-draft-bg);      border: 1px solid rgba(196,162,85,0.25); }
+.badge-frozen     { color: var(--status-frozen);     background: var(--status-frozen-bg);     border: 1px solid rgba(91,130,204,0.25); }
+.badge-deprecated { color: var(--status-deprecated); background: var(--status-deprecated-bg); border: 1px solid rgba(204,91,91,0.25); }
 
-.problem-text {
-  background-color: var(--color-surface);
-  border-left: 3px solid var(--color-link);
-  padding: 1rem 1.25rem;
-  border-radius: 0 0.375rem 0.375rem 0;
-  margin: 0;
+.badge-domain {
+  color: var(--text-mid);
+  background: var(--bg-card);
+  border: 1px solid var(--border);
 }
 
-/* Decisions timeline */
-ol.decisions {
-  list-style: none;
-  padding: 0;
-  margin: 0;
+.feature-title {
+  font-size: 26px;
+  font-weight: 700;
+  color: var(--text);
+  line-height: 1.25;
+  margin-bottom: 6px;
 }
-
-ol.decisions li {
+.feature-completeness {
+  font-family: var(--mono);
+  font-size: 11px;
+  color: var(--text-soft);
+  margin-bottom: 32px;
+}
+.completeness-bar {
+  display: inline-block;
+  width: 80px;
+  height: 4px;
+  background: var(--border);
+  border-radius: 2px;
+  vertical-align: middle;
+  margin-right: 6px;
   position: relative;
-  padding: 1rem 1rem 1rem 1.5rem;
-  border-left: 2px solid var(--color-border);
-  margin-bottom: 1rem;
+  top: -1px;
+  overflow: hidden;
 }
-
-ol.decisions li:last-child {
-  margin-bottom: 0;
+.completeness-fill {
+  height: 100%;
+  border-radius: 2px;
+  background: var(--accent);
 }
 
-ol.decisions li::before {
-  content: '';
-  position: absolute;
-  left: -0.375rem;
-  top: 1.25rem;
-  width: 0.625rem;
-  height: 0.625rem;
-  border-radius: 50%;
-  background-color: var(--color-link);
-}
+/* Sections */
+.section { margin-bottom: 36px; }
 
-.decision-date {
-  font-size: 0.75rem;
-  color: var(--color-text-muted);
-  margin-bottom: 0.25rem;
+.section-header {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 14px;
+  padding-bottom: 8px;
+  border-bottom: 1px solid var(--border);
+}
+.section-label {
+  font-family: var(--mono);
+  font-size: 10px;
+  letter-spacing: 0.14em;
+  text-transform: uppercase;
+  color: var(--text-soft);
 }
-
-.decision-text {
-  font-weight: 600;
-  margin-bottom: 0.375rem;
+.section-count {
+  font-family: var(--mono);
+  font-size: 10px;
+  color: var(--border);
 }
 
-.decision-rationale {
-  color: var(--color-text-muted);
-  font-size: 0.9375rem;
-  margin-bottom: 0.375rem;
-}
+.section-body p { color: var(--text-mid); line-height: 1.75; margin-bottom: 10px; }
+.section-body p:last-child { margin-bottom: 0; }
+.section-body strong { color: var(--text); }
+.section-body code {
+  font-family: var(--mono);
+  font-size: 12px;
+  color: var(--accent);
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: 3px;
+  padding: 1px 5px;
+}
+.section-body ul { padding-left: 20px; color: var(--text-mid); }
+.section-body li { margin-bottom: 4px; line-height: 1.6; }
 
-.alternatives {
-  font-size: 0.875rem;
-  color: var(--color-text-muted);
-}
+/* Decision cards */
+.decisions-list { display: flex; flex-direction: column; gap: 12px; }
 
-.alternatives span {
-  font-weight: 500;
+.decision-card {
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-left: 3px solid var(--accent);
+  border-radius: 4px;
+  padding: 14px 16px;
+}
+.decision-title {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text);
+  margin-bottom: 6px;
+  line-height: 1.4;
 }
-
-/* Implementation / limitation sections */
-.implementation-text {
-  white-space: pre-wrap;
-  font-size: 0.9375rem;
-  line-height: 1.7;
+.decision-rationale {
+  font-size: 13px;
+  color: var(--text-mid);
+  line-height: 1.65;
+  margin-bottom: 8px;
 }
-
-ul.limitations {
-  padding-left: 1.5rem;
-  margin: 0;
+.decision-meta {
+  display: flex;
+  gap: 12px;
+  flex-wrap: wrap;
 }
-
-ul.limitations li {
-  margin-bottom: 0.375rem;
-  color: var(--color-text-muted);
+.decision-date {
+  font-family: var(--mono);
+  font-size: 10px;
+  color: var(--text-soft);
 }
-
-/* Lineage */
-.lineage-info {
-  background-color: var(--color-surface);
-  border: 1px solid var(--color-border);
-  border-radius: 0.375rem;
-  padding: 1rem 1.25rem;
+.decision-alts {
+  font-family: var(--mono);
+  font-size: 10px;
+  color: var(--text-soft);
 }
 
-.lineage-info p {
-  margin-bottom: 0.5rem;
-}
+/* Limitations list */
+.limitations-list { display: flex; flex-direction: column; gap: 6px; }
+.limitation-item {
+  display: flex;
+  gap: 10px;
+  padding: 8px 12px;
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  font-size: 13px;
+  color: var(--text-mid);
+  line-height: 1.55;
+}
+.limitation-bullet { color: var(--text-soft); flex-shrink: 0; margin-top: 1px; }
 
-.lineage-info p:last-child {
-  margin-bottom: 0;
+/* Tags row */
+.tags-row { display: flex; flex-wrap: wrap; gap: 6px; }
+.tag {
+  padding: 3px 9px;
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: 100px;
+  font-family: var(--mono);
+  font-size: 11px;
+  color: var(--text-soft);
 }
 
-/* Back link */
-.back-link {
+/* Lineage */
+.lineage-row { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
+.lineage-link {
   display: inline-flex;
   align-items: center;
-  gap: 0.25rem;
-  margin-bottom: 2rem;
-  font-size: 0.875rem;
+  gap: 6px;
+  padding: 5px 10px;
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  font-family: var(--mono);
+  font-size: 11px;
+  color: var(--text-mid);
+  cursor: pointer;
+  transition: border-color 0.15s, color 0.15s;
+  text-decoration: none;
 }
+.lineage-link:hover { border-color: var(--accent); color: var(--accent); }
+.lineage-arrow { color: var(--text-soft); font-size: 10px; }
+
+/* Empty states */
+.empty { color: var(--text-soft); font-size: 13px; font-style: italic; }
 
-/* Empty state */
-.empty-state {
+/* No results */
+.no-results {
+  padding: 24px 18px;
+  font-size: 12px;
+  color: var(--text-soft);
   text-align: center;
-  padding: 3rem 1rem;
-  color: var(--color-text-muted);
+  font-family: var(--mono);
 }
+</style>
+</head>
+<body>
+<div class="shell">
+  <div class="topbar">
+    <span class="topbar-logo">◈ lac</span>
+    <span class="topbar-sep">|</span>
+    <span class="topbar-project">${esc(projectName)}</span>
+    <span class="topbar-count">${features.length} features · ${domains.length} domains</span>
+  </div>
+  <div class="body-row">
+    <aside class="sidebar">
+      <div class="sidebar-search">
+        <input type="text" id="filter-input" placeholder="Filter features…" autocomplete="off" spellcheck="false">
+      </div>
+      <nav class="nav-tree" id="nav-tree"></nav>
+    </aside>
+    <main class="content" id="content"></main>
+  </div>
+</div>
 
-/* No results row */
-.no-results {
-  display: none;
-  padding: 1.5rem 0.75rem;
-  color: var(--color-text-muted);
-  font-style: italic;
+<script>
+const FEATURES = ${dataJson};
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function esc(s) {
+  return String(s)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
 }
 
-/* Markdown-rendered content */
-.implementation-text h2,
-.analysis-text h2 {
-  font-size: 1.125rem;
-  font-weight: 600;
-  margin-top: 1.75rem;
-  margin-bottom: 0.5rem;
-  border-bottom: 1px solid var(--color-border);
-  padding-bottom: 0.25rem;
+function md(text) {
+  if (!text) return '';
+  const lines = esc(text).split('\\n');
+  const out = [];
+  let inList = false;
+  for (const line of lines) {
+    const t = line.trim();
+    if (t.match(/^[-*] /)) {
+      if (!inList) { out.push('<ul>'); inList = true; }
+      out.push('<li>' + inline(t.slice(2)) + '</li>');
+    } else {
+      if (inList) { out.push('</ul>'); inList = false; }
+      out.push(line);
+    }
+  }
+  if (inList) out.push('</ul>');
+  return out.join('\\n').split(/\\n{2,}/).map(block => {
+    const b = block.trim();
+    if (!b) return '';
+    if (b.startsWith('<ul>') || b.startsWith('<li>')) return b;
+    return '<p>' + inline(b.replace(/\\n/g, '<br>')) + '</p>';
+  }).filter(Boolean).join('\\n');
 }
 
-.implementation-text h3,
-.analysis-text h3 {
-  font-size: 1rem;
-  font-weight: 600;
-  margin-top: 1.25rem;
-  margin-bottom: 0.375rem;
-  color: var(--color-text-muted);
+function inline(s) {
+  return s
+    .replace(/\\*\\*(.+?)\\*\\*/g, '<strong>$1</strong>')
+    .replace(/\`([^\`\\n]+)\`/g, '<code>$1</code>');
 }
 
-.implementation-text pre,
-.analysis-text pre {
-  background-color: var(--color-surface);
-  border: 1px solid var(--color-border);
-  border-radius: 0.375rem;
-  padding: 1rem 1.25rem;
-  overflow-x: auto;
-  margin: 1rem 0;
+function completeness(f) {
+  const checks = [
+    !!f.analysis, !!f.implementation,
+    !!(f.decisions && f.decisions.length),
+    !!f.successCriteria,
+    !!(f.knownLimitations && f.knownLimitations.length),
+    !!(f.tags && f.tags.length),
+    !!f.domain,
+  ];
+  return Math.round(checks.filter(Boolean).length / checks.length * 100);
 }
 
-.implementation-text code,
-.analysis-text code {
-  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
-  font-size: 0.875em;
+function statusColor(s) {
+  return { active: '#4aad72', draft: '#c4a255', frozen: '#5b82cc', deprecated: '#cc5b5b' }[s] || '#c4a255';
 }
 
-.implementation-text pre code,
-.analysis-text pre code {
-  background: none;
-  padding: 0;
-  border-radius: 0;
-  font-size: 0.875rem;
+// ── Tree building ────────────────────────────────────────────────────────────
+
+const byKey = new Map(FEATURES.map(f => [f.featureKey, f]));
+
+function getChildren(key) {
+  return FEATURES.filter(f => f.lineage && f.lineage.parent === key);
 }
 
-.implementation-text :not(pre) > code,
-.analysis-text :not(pre) > code {
-  background-color: var(--color-surface);
-  border: 1px solid var(--color-border);
-  border-radius: 0.25rem;
-  padding: 0.1em 0.35em;
+function isRoot(f) {
+  const p = f.lineage && f.lineage.parent;
+  return !p || !byKey.has(p);
 }
 
-.implementation-text ul,
-.analysis-text ul,
-.implementation-text ol,
-.analysis-text ol {
-  padding-left: 1.5rem;
-  margin: 0.5rem 0 1rem;
+/** Flatten feature + its descendants with depth info */
+function flatten(f, depth) {
+  const result = [{ feature: f, depth }];
+  for (const child of getChildren(f.featureKey)) {
+    result.push(...flatten(child, depth + 1));
+  }
+  return result;
 }
 
-.implementation-text li,
-.analysis-text li {
-  margin-bottom: 0.25rem;
+// Group root features by domain
+function buildGroups(features) {
+  const roots = features.filter(isRoot);
+  const groups = new Map();
+
+  for (const f of roots) {
+    const domain = f.domain || '(no domain)';
+    if (!groups.has(domain)) groups.set(domain, []);
+    groups.get(domain).push(...flatten(f, 0));
+  }
+  return groups;
 }
 
-/* Markdown tables */
-.md-table {
-  width: 100%;
-  border-collapse: collapse;
-  margin: 1rem 0;
-  font-size: 0.9rem;
+// ── Nav rendering ────────────────────────────────────────────────────────────
+
+let activeKey = null;
+const collapsedDomains = new Set();
+
+function renderNav(filterText) {
+  const nav = document.getElementById('nav-tree');
+  const q = (filterText || '').toLowerCase().trim();
+
+  const features = q
+    ? FEATURES.filter(f =>
+        f.featureKey.toLowerCase().includes(q) ||
+        f.title.toLowerCase().includes(q) ||
+        (f.domain && f.domain.toLowerCase().includes(q)) ||
+        (f.tags && f.tags.some(t => t.toLowerCase().includes(q)))
+      )
+    : FEATURES;
+
+  if (features.length === 0) {
+    nav.innerHTML = '<div class="no-results">No features match</div>';
+    return;
+  }
+
+  const groups = q
+    ? (() => {
+        // Flat list when searching
+        const m = new Map([['results', features.map(f => ({ feature: f, depth: 0 }))]]);
+        return m;
+      })()
+    : buildGroups(FEATURES);
+
+  const sortedDomains = [...groups.keys()].sort((a, b) => {
+    if (a === '(no domain)') return 1;
+    if (b === '(no domain)') return -1;
+    return a.localeCompare(b);
+  });
+
+  let html = '';
+  for (const domain of sortedDomains) {
+    const items = groups.get(domain);
+    const visible = q ? items.filter(({ feature: f }) =>
+      f.featureKey.toLowerCase().includes(q) ||
+      f.title.toLowerCase().includes(q) ||
+      (f.tags && f.tags.some(t => t.toLowerCase().includes(q)))
+    ) : items;
+    if (visible.length === 0) continue;
+
+    const isCollapsed = !q && collapsedDomains.has(domain);
+    const label = domain === 'results' ? 'results' : domain;
+
+    html += \`<div class="nav-group\${isCollapsed ? ' collapsed' : ''}" data-domain="\${esc(domain)}">
+  <div class="nav-domain\${isCollapsed ? ' collapsed' : ''}" onclick="toggleDomain(this)">
+    <span class="nav-domain-arrow">▾</span>
+    <span>\${esc(label)}</span>
+    <span class="nav-domain-count">\${visible.length}</span>
+  </div>
+  <div class="nav-group-items">\`;
+
+    for (const { feature: f, depth } of visible) {
+      const isChild = depth > 0;
+      const hasChildren = getChildren(f.featureKey).length > 0;
+      html += \`<div class="nav-item\${f.featureKey === activeKey ? ' active' : ''}"
+        data-key="\${esc(f.featureKey)}"
+        data-status="\${esc(f.status)}"
+        data-depth="\${depth}"
+        onclick="navigate('\${esc(f.featureKey)}')">
+        \${isChild ? '<span class="nav-child-arrow">↳</span>' : '<span class="nav-dot"></span>'}
+        <span class="nav-item-key">\${esc(f.featureKey)}</span>
+        <span class="nav-item-title">\${esc(f.title)}</span>
+        \${hasChildren ? '<span class="nav-child-arrow" style="margin-left:auto;opacity:0.4">⊕</span>' : ''}
+      </div>\`;
+    }
+
+    html += '</div></div>';
+  }
+
+  nav.innerHTML = html;
 }
 
-.md-table th {
-  text-align: left;
-  padding: 0.5rem 0.75rem;
-  border-bottom: 2px solid var(--color-border);
-  font-size: 0.75rem;
-  font-weight: 600;
-  text-transform: uppercase;
-  letter-spacing: 0.05em;
-  color: var(--color-text-muted);
+function toggleDomain(el) {
+  const group = el.closest('.nav-group');
+  const domain = group.dataset.domain;
+  if (collapsedDomains.has(domain)) {
+    collapsedDomains.delete(domain);
+    group.classList.remove('collapsed');
+    el.classList.remove('collapsed');
+  } else {
+    collapsedDomains.add(domain);
+    group.classList.add('collapsed');
+    el.classList.add('collapsed');
+  }
 }
 
-.md-table td {
-  padding: 0.5rem 0.75rem;
-  border-bottom: 1px solid var(--color-border);
-  vertical-align: top;
+// ── Content rendering ────────────────────────────────────────────────────────
+
+function renderHome() {
+  const content = document.getElementById('content');
+  const total = FEATURES.length;
+  const frozen = FEATURES.filter(f => f.status === 'frozen').length;
+  const active = FEATURES.filter(f => f.status === 'active').length;
+  const draft  = FEATURES.filter(f => f.status === 'draft').length;
+  const depr   = FEATURES.filter(f => f.status === 'deprecated').length;
+
+  const domains = [...new Set(FEATURES.map(f => f.domain).filter(Boolean))].sort();
+
+  const avgCompleteness = FEATURES.length
+    ? Math.round(FEATURES.reduce((s, f) => s + completeness(f), 0) / FEATURES.length)
+    : 0;
+
+  content.innerHTML = \`<div class="home-page">
+  <div class="home-eyebrow">◈ life-as-code wiki</div>
+  <div class="home-title">\${esc(document.title.replace(' — LAC Wiki', ''))}</div>
+  <div class="home-subtitle">\${total} feature\${total === 1 ? '' : 's'} · avg \${avgCompleteness}% complete</div>
+
+  <div class="stat-row">
+    \${active ? \`<div class="stat-pill"><span class="stat-pill-dot" style="background:#4aad72"></span><span class="stat-pill-num">\${active}</span><span class="stat-pill-label">active</span></div>\` : ''}
+    \${frozen ? \`<div class="stat-pill"><span class="stat-pill-dot" style="background:#5b82cc"></span><span class="stat-pill-num">\${frozen}</span><span class="stat-pill-label">frozen</span></div>\` : ''}
+    \${draft  ? \`<div class="stat-pill"><span class="stat-pill-dot" style="background:#c4a255"></span><span class="stat-pill-num">\${draft}</span><span class="stat-pill-label">draft</span></div>\` : ''}
+    \${depr   ? \`<div class="stat-pill"><span class="stat-pill-dot" style="background:#cc5b5b"></span><span class="stat-pill-num">\${depr}</span><span class="stat-pill-label">deprecated</span></div>\` : ''}
+  </div>
+
+  \${domains.length ? \`<div class="home-section-title">Domains</div>
+  <div class="domain-chips">
+    \${domains.map(d => \`<span class="domain-chip" onclick="filterByDomain('\${esc(d)}')">\${esc(d)}</span>\`).join('')}
+  </div>\` : ''}
+
+  <div class="home-section-title">All features</div>
+  <div style="display:flex;flex-direction:column;gap:2px;">
+    \${FEATURES.map(f => \`<div class="nav-item" data-key="\${esc(f.featureKey)}" data-status="\${esc(f.status)}" data-depth="0" onclick="navigate('\${esc(f.featureKey)}')" style="border-radius:4px;border:1px solid var(--border-soft);margin-bottom:2px;">
+      <span class="nav-dot"></span>
+      <span class="nav-item-key">\${esc(f.featureKey)}</span>
+      <span class="nav-item-title">\${esc(f.title)}</span>
+      <span style="margin-left:auto;font-family:var(--mono);font-size:10px;color:var(--text-soft);">\${completeness(f)}%</span>
+    </div>\`).join('')}
+  </div>
+</div>\`;
 }
 
-.md-table tr:last-child td {
-  border-bottom: none;
+function renderFeature(key) {
+  const f = byKey.get(key);
+  if (!f) { renderHome(); return; }
+
+  const pct = completeness(f);
+  const barFill = \`<span class="completeness-bar"><span class="completeness-fill" style="width:\${pct}%"></span></span>\`;
+
+  const children = getChildren(f.featureKey);
+  const parent = f.lineage && f.lineage.parent && byKey.get(f.lineage.parent);
+
+  let html = \`<div class="feature-page">
+  <div class="feature-meta">
+    <span class="feature-key">\${esc(f.featureKey)}</span>
+    <span class="badge badge-\${esc(f.status)}"><span class="badge-dot" style="background:\${statusColor(f.status)}"></span>\${esc(f.status)}</span>
+    \${f.domain ? \`<span class="badge badge-domain">\${esc(f.domain)}</span>\` : ''}
+  </div>
+  <div class="feature-title">\${esc(f.title)}</div>
+  <div class="feature-completeness">\${barFill}\${pct}% complete</div>\`;
+
+  // Problem
+  html += section('Problem', f.problem ? \`<div class="section-body">\${md(f.problem)}</div>\` : '<span class="empty">Not documented.</span>');
+
+  // Analysis
+  if (f.analysis)
+    html += section('Analysis', \`<div class="section-body">\${md(f.analysis)}</div>\`);
+
+  // Implementation
+  if (f.implementation)
+    html += section('Implementation', \`<div class="section-body">\${md(f.implementation)}</div>\`);
+
+  // Success Criteria
+  if (f.successCriteria)
+    html += section('Success Criteria', \`<div class="section-body">\${md(f.successCriteria)}</div>\`);
+
+  // Decisions
+  if (f.decisions && f.decisions.length) {
+    const cards = f.decisions.map(d => \`<div class="decision-card">
+      <div class="decision-title">\${esc(d.decision)}</div>
+      <div class="decision-rationale">\${md(d.rationale)}</div>
+      \${d.date || (d.alternativesConsidered && d.alternativesConsidered.length) ? \`<div class="decision-meta">
+        \${d.date ? \`<span class="decision-date">📅 \${esc(d.date)}</span>\` : ''}
+        \${d.alternativesConsidered && d.alternativesConsidered.length ? \`<span class="decision-alts">Considered: \${d.alternativesConsidered.map(esc).join(', ')}</span>\` : ''}
+      </div>\` : ''}
+    </div>\`).join('');
+    html += section('Decisions', \`<div class="decisions-list">\${cards}</div>\`, f.decisions.length);
+  }
+
+  // Known Limitations
+  if (f.knownLimitations && f.knownLimitations.length) {
+    const items = f.knownLimitations.map(l =>
+      \`<div class="limitation-item"><span class="limitation-bullet">—</span><span>\${md(l)}</span></div>\`
+    ).join('');
+    html += section('Known Limitations', \`<div class="limitations-list">\${items}</div>\`, f.knownLimitations.length);
+  }
+
+  // Tags
+  if (f.tags && f.tags.length) {
+    const chips = f.tags.map(t => \`<span class="tag">\${esc(t)}</span>\`).join('');
+    html += section('Tags', \`<div class="tags-row">\${chips}</div>\`);
+  }
+
+  // Lineage
+  if (parent || children.length) {
+    let lineage = '<div class="lineage-row">';
+    if (parent) {
+      lineage += \`<span class="lineage-arrow">parent ↑</span>
+        <a class="lineage-link" onclick="navigate('\${esc(parent.featureKey)}')">
+          \${esc(parent.featureKey)} — \${esc(parent.title)}
+        </a>\`;
+    }
+    if (parent && children.length) lineage += '<span class="lineage-arrow" style="margin:0 6px;">·</span>';
+    if (children.length) {
+      lineage += '<span class="lineage-arrow">children ↓</span>';
+      for (const c of children) {
+        lineage += \`<a class="lineage-link" onclick="navigate('\${esc(c.featureKey)}')">
+          \${esc(c.featureKey)} — \${esc(c.title)}
+        </a>\`;
+      }
+    }
+    lineage += '</div>';
+    html += section('Lineage', lineage);
+  }
+
+  html += '</div>';
+  document.getElementById('content').innerHTML = html;
+  document.getElementById('content').scrollTop = 0;
 }
 
-.md-table tr:hover td {
-  background-color: var(--color-surface);
+function section(label, body, count) {
+  const countHtml = count != null ? \`<span class="section-count">(\${count})</span>\` : '';
+  return \`<div class="section">
+  <div class="section-header">
+    <span class="section-label">\${label}</span>\${countHtml}
+  </div>
+  \${body}
+</div>\`;
 }
 
-/* Analysis section */
-.analysis-text {
-  font-size: 0.9375rem;
-  line-height: 1.7;
+// ── Navigation ───────────────────────────────────────────────────────────────
+
+function navigate(key) {
+  activeKey = key;
+  location.hash = key ? '#' + key : '';
+  renderNav(document.getElementById('filter-input').value);
+  if (key) {
+    renderFeature(key);
+    // Scroll nav item into view
+    const el = document.querySelector(\`.nav-item[data-key="\${key}"]\`);
+    if (el) el.scrollIntoView({ block: 'nearest' });
+  } else {
+    renderHome();
+  }
 }
-`;
 
-//#endregion
-//#region src/templates/site-feature.html.ts
-function escapeHtml$1(str) {
-	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-function statusBadge$1(status) {
-	return `<span class="status-badge status-${escapeHtml$1(status)}">${escapeHtml$1(status)}</span>`;
-}
-function renderDecisions(decisions) {
-	if (decisions.length === 0) return "";
-	return `
-  <section class="decisions">
-    <h2>Decisions</h2>
-    <ol class="decisions">
-      ${decisions.map((d) => {
-		const date$4 = d.date ? `<div class="decision-date">${escapeHtml$1(d.date)}</div>` : "";
-		const alts = d.alternativesConsidered && d.alternativesConsidered.length > 0 ? `<div class="alternatives"><span>Alternatives considered:</span> ${d.alternativesConsidered.map(escapeHtml$1).join(", ")}</div>` : "";
-		return `
-      <li>
-        ${date$4}
-        <div class="decision-text">${escapeHtml$1(d.decision)}</div>
-        <div class="decision-rationale">${escapeHtml$1(d.rationale)}</div>
-        ${alts}
-      </li>`;
-	}).join("\n")}
-    </ol>
-  </section>`;
-}
-function renderLineage(lineage) {
-	const parts = [];
-	if (lineage.parent) parts.push(`<p><strong>Parent:</strong> <a href="${escapeHtml$1(lineage.parent)}.html">${escapeHtml$1(lineage.parent)}</a></p>`);
-	if (lineage.children && lineage.children.length > 0) {
-		const childLinks = lineage.children.map((c) => `<a href="${escapeHtml$1(c)}.html">${escapeHtml$1(c)}</a>`).join(", ");
-		parts.push(`<p><strong>Children:</strong> ${childLinks}</p>`);
-	}
-	if (lineage.spawnReason) parts.push(`<p><strong>Spawn reason:</strong> ${escapeHtml$1(lineage.spawnReason)}</p>`);
-	if (parts.length === 0) return "";
-	return `
-  <section class="lineage">
-    <h2>Lineage</h2>
-    <div class="lineage-info">
-      ${parts.join("\n      ")}
-    </div>
-  </section>`;
-}
-function renderFeature(feature) {
-	const decisionsSection = feature.decisions && feature.decisions.length > 0 ? renderDecisions(feature.decisions) : "";
-	const implementationSection = feature.implementation ? `
-  <section class="implementation">
-    <h2>How it works</h2>
-    <div class="implementation-text">${markdownToHtml(feature.implementation)}</div>
-  </section>` : "";
-	const analysisSection = feature["analysis"] ? `
-  <section class="analysis">
-    <h2>Background &amp; Context</h2>
-    <div class="analysis-text">${markdownToHtml(feature["analysis"])}</div>
-  </section>` : "";
-	const limitationsSection = feature.knownLimitations && feature.knownLimitations.length > 0 ? `
-  <section class="limitations">
-    <h2>Known Limitations</h2>
-    <ul class="limitations">
-      ${feature.knownLimitations.map((l) => `<li>${escapeHtml$1(l)}</li>`).join("\n      ")}
-    </ul>
-  </section>` : "";
-	const lineageSection = feature.lineage && (feature.lineage.parent || feature.lineage.children && feature.lineage.children.length > 0 || feature.lineage.spawnReason) ? renderLineage(feature.lineage) : "";
-	const tagsSection = feature.tags && feature.tags.length > 0 ? `<div class="meta" style="margin-top:0.5rem;flex-wrap:wrap">${feature.tags.map((t) => `<span style="font-size:0.75rem;padding:0.125rem 0.5rem;border-radius:9999px;background-color:var(--color-surface);border:1px solid var(--color-border)">${escapeHtml$1(t)}</span>`).join("")}</div>` : "";
-	return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>${escapeHtml$1(feature.title)} — Feature Provenance</title>
-  <style>${css}</style>
-</head>
-<body>
-  <div class="container">
-    <a href="index.html" class="back-link">&#8592; All features</a>
-
-    <h1>${escapeHtml$1(feature.title)}</h1>
-    <div class="meta">
-      ${statusBadge$1(feature.status)}
-      <span class="feature-key">${escapeHtml$1(feature.featureKey)}</span>
-    </div>
-    ${tagsSection}
-
-    <section class="problem">
-      <h2>Problem</h2>
-      <p class="problem-text">${escapeHtml$1(feature.problem)}</p>
-    </section>
-
-    ${analysisSection}
-    ${decisionsSection}
-    ${implementationSection}
-    ${limitationsSection}
-    ${lineageSection}
-  </div>
-</body>
-</html>`;
+function filterByDomain(domain) {
+  const input = document.getElementById('filter-input');
+  input.value = domain;
+  renderNav(domain);
 }
 
-//#endregion
-//#region src/templates/site-index.html.ts
-function escapeHtml(str) {
-	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-function statusBadge(status) {
-	return `<span class="status-badge status-${escapeHtml(status)}">${escapeHtml(status)}</span>`;
-}
-function renderIndex(features, generatedAt) {
-	const timestamp = (generatedAt ?? /* @__PURE__ */ new Date()).toISOString();
-	const rows = features.length === 0 ? `<tr><td colspan="4" class="no-results" style="display:table-cell">No features found.</td></tr>` : features.map((f) => `
-    <tr class="feature-row" data-search="${escapeHtml((f.featureKey + " " + f.title).toLowerCase())}">
-      <td><a href="${escapeHtml(f.featureKey)}.html" class="feature-key">${escapeHtml(f.featureKey)}</a></td>
-      <td><a href="${escapeHtml(f.featureKey)}.html">${escapeHtml(f.title)}</a></td>
-      <td>${statusBadge(f.status)}</td>
-      <td class="problem-excerpt">${escapeHtml(f.problem.slice(0, 100))}${f.problem.length > 100 ? "…" : ""}</td>
-    </tr>`).join("\n");
-	return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>Feature Provenance</title>
-  <style>${css}</style>
-</head>
-<body>
-  <div class="container">
-    <h1>Feature Provenance</h1>
-    <p style="color:var(--color-text-muted);margin-bottom:1.5rem">${features.length} feature${features.length === 1 ? "" : "s"} tracked</p>
-
-    <div class="search-wrapper">
-      <input
-        type="search"
-        id="search"
-        class="search-input"
-        placeholder="Search by key or title…"
-        aria-label="Search features"
-      />
-    </div>
-
-    <table class="feature-table" id="feature-table">
-      <thead>
-        <tr>
-          <th>Key</th>
-          <th>Title</th>
-          <th>Status</th>
-          <th>Problem</th>
-        </tr>
-      </thead>
-      <tbody id="feature-tbody">
-        ${rows}
-        <tr id="no-results-row" style="display:none">
-          <td colspan="4" class="no-results" style="display:table-cell;color:var(--color-text-muted);font-style:italic;padding:1.5rem 0.75rem">No features match your search.</td>
-        </tr>
-      </tbody>
-    </table>
-  </div>
+// Filter input
+document.getElementById('filter-input').addEventListener('input', e => {
+  renderNav(e.target.value);
+});
 
-  <footer style="margin-top:2rem;padding-top:1rem;border-top:1px solid var(--color-border);color:var(--color-text-muted);font-size:0.75rem;text-align:right">
-    Generated ${escapeHtml(timestamp)}
-  </footer>
-
-  <script>
-    (function () {
-      var input = document.getElementById('search');
-      var noResults = document.getElementById('no-results-row');
-      if (!input) return;
-      input.addEventListener('input', function () {
-        var query = input.value.trim().toLowerCase();
-        var rows = document.querySelectorAll('#feature-tbody .feature-row');
-        var visible = 0;
-        rows.forEach(function (row) {
-          var search = row.getAttribute('data-search') || '';
-          var match = query === '' || search.indexOf(query) !== -1;
-          row.style.display = match ? '' : 'none';
-          if (match) visible++;
-        });
-        if (noResults) {
-          noResults.style.display = (visible === 0 && query !== '') ? '' : 'none';
-        }
-      });
-    })();
-  <\/script>
+// ── Boot ─────────────────────────────────────────────────────────────────────
+
+const hashKey = location.hash.slice(1);
+if (hashKey && byKey.has(hashKey)) {
+  activeKey = hashKey;
+  renderNav('');
+  renderFeature(hashKey);
+  setTimeout(() => {
+    const el = document.querySelector(\`.nav-item[data-key="\${hashKey}"]\`);
+    if (el) el.scrollIntoView({ block: 'nearest' });
+  }, 0);
+} else {
+  renderNav('');
+  renderHome();
+}
+
+window.navigate = navigate;
+window.toggleDomain = toggleDomain;
+window.filterByDomain = filterByDomain;
+<\/script>
 </body>
 </html>`;
 }
 
 //#endregion
 //#region src/lib/siteGenerator.ts
-/**
-* Generates a static HTML site for the given features.
-* Creates:
-*   outDir/index.html         — searchable feature list
-*   outDir/{featureKey}.html  — one page per feature
-*   outDir/style.css          — shared stylesheet
-*/
 async function generateSite(features, outDir) {
 	await mkdir(outDir, { recursive: true });
-	await writeFile(join(outDir, "style.css"), css.trim(), "utf-8");
-	const allFeatures = features.map((f) => f.feature);
-	await writeFile(join(outDir, "index.html"), renderIndex(allFeatures), "utf-8");
-	for (const { feature } of features) {
-		const pageHtml = renderFeature(feature);
-		await writeFile(join(outDir, `${feature.featureKey}.html`), pageHtml, "utf-8");
-	}
+	const projectName = basename(outDir.replace(/[/\\]+$/, "")) || "project";
+	const html = generateHtmlWiki(features.map((f) => f.feature), projectName);
+	await writeFile(join(outDir, "index.html"), html, "utf-8");
 }
 
 //#endregion
@@ -9358,7 +10561,199 @@ function featureToMarkdown(feature) {
 	}
 	return lines.join("\n");
 }
-const exportCommand = new Command("export").description("Export feature.json as JSON, Markdown, or generate a static HTML site").option("--out <path>", "Output file or directory path").option("--site <dir>", "Scan <dir> for feature.json files and generate a static HTML site").option("--markdown", "Output feature as a Markdown document instead of JSON").action(async (options) => {
+/**
+* Topological sort: parents before children. Features with no lineage come first.
+* Cycles are broken by key order (shouldn't happen in a valid workspace).
+*/
+function topoSort(features) {
+	const keyToFeature = new Map(features.map((f) => [f.feature.featureKey, f]));
+	const visited = /* @__PURE__ */ new Set();
+	const result = [];
+	function visit(key) {
+		if (visited.has(key)) return;
+		visited.add(key);
+		const f = keyToFeature.get(key);
+		if (!f) return;
+		const parent = f.feature.lineage?.parent;
+		if (parent && keyToFeature.has(parent)) visit(parent);
+		result.push(f);
+	}
+	for (const f of features) visit(f.feature.featureKey);
+	return result;
+}
+/**
+* Render a compact ASCII tree of the parent→child hierarchy.
+*/
+function renderLineageTree(features) {
+	const childrenOf = /* @__PURE__ */ new Map();
+	const roots = [];
+	for (const f of features) {
+		const parent = f.feature.lineage?.parent;
+		if (parent) {
+			const list = childrenOf.get(parent) ?? [];
+			list.push(f.feature.featureKey);
+			childrenOf.set(parent, list);
+		} else roots.push(f.feature.featureKey);
+	}
+	const keyToTitle = new Map(features.map((f) => [f.feature.featureKey, f.feature.title]));
+	const treeLines = [];
+	function renderNode(key, prefix, isLast) {
+		const connector = isLast ? "└── " : "├── ";
+		treeLines.push(`${prefix}${connector}${key} — ${keyToTitle.get(key) ?? ""}`);
+		const children = childrenOf.get(key) ?? [];
+		const childPrefix = prefix + (isLast ? "    " : "│   ");
+		children.forEach((child, i) => renderNode(child, childPrefix, i === children.length - 1));
+	}
+	roots.forEach((root, i) => renderNode(root, "", i === roots.length - 1));
+	return treeLines.join("\n");
+}
+/**
+* Build a reconstruction prompt from all feature.jsons under a directory.
+* The output is a single Markdown document a fresh AI can consume to
+* re-implement the system from its documented intent alone.
+*/
+function buildReconstructionPrompt(features, projectName, promptDir) {
+	const lines = [];
+	lines.push(`# Reconstruction Spec — ${projectName}`);
+	lines.push("");
+	lines.push("> This document fully describes a software system through its feature documentation.", "> Your task is to implement this system from scratch.", "> Do not reproduce the original source — implement cleanly to satisfy each feature's", "> problem statement, decisions, and success criteria.", "> Features are listed in dependency order (parents before children).");
+	lines.push("");
+	const total = features.length;
+	const frozen = features.filter((f) => f.feature.status === "frozen").length;
+	const domains = [...new Set(features.map((f) => f.feature.domain).filter(Boolean))];
+	lines.push(`**${total} features** · ${frozen} frozen · ${domains.length} domains: ${domains.join(", ")}`);
+	lines.push("");
+	const tree = renderLineageTree(features);
+	if (tree) {
+		lines.push("## Feature Tree");
+		lines.push("");
+		lines.push("```");
+		lines.push(tree);
+		lines.push("```");
+		lines.push("");
+	}
+	const sorted = topoSort(features);
+	const renderFeature = (f) => {
+		const feat = f.feature;
+		const parts = [];
+		const featureDir = dirname(f.filePath);
+		const relDir = featureDir === promptDir ? "." : featureDir.slice(promptDir.length).replace(/^[\\/]/, "").replace(/\\/g, "/");
+		parts.push(`### ${feat.featureKey} — ${feat.title}`);
+		parts.push("");
+		parts.push(`**Status:** ${feat.status}`);
+		parts.push(`**Path:** \`${relDir}/\``);
+		if (feat.lineage?.parent) parts.push(`**Parent:** ${feat.lineage.parent}`);
+		if (feat.lineage?.children?.length) parts.push(`**Children:** ${feat.lineage.children.join(", ")}`);
+		parts.push("");
+		parts.push(`**Problem:** ${feat.problem}`);
+		parts.push("");
+		if (feat.analysis) {
+			parts.push("**Analysis:**");
+			parts.push(feat.analysis);
+			parts.push("");
+		}
+		if (feat.implementation) {
+			parts.push("**Implementation:**");
+			parts.push(feat.implementation);
+			parts.push("");
+		}
+		if (feat.decisions?.length) {
+			parts.push("**Decisions:**");
+			for (const d of feat.decisions) {
+				parts.push(`- **${d.decision}** — ${d.rationale}`);
+				if (d.alternativesConsidered?.length) parts.push(`  Alternatives considered: ${d.alternativesConsidered.join(", ")}`);
+			}
+			parts.push("");
+		}
+		if (feat.knownLimitations?.length) {
+			parts.push("**Known Limitations:**");
+			for (const lim of feat.knownLimitations) parts.push(`- ${lim}`);
+			parts.push("");
+		}
+		if (feat.successCriteria) {
+			parts.push(`**Success Criteria:** ${feat.successCriteria}`);
+			parts.push("");
+		}
+		if (feat.tags?.length) {
+			parts.push(`**Tags:** ${feat.tags.join(", ")}`);
+			parts.push("");
+		}
+		return parts.join("\n");
+	};
+	lines.push("## Features");
+	lines.push("");
+	for (const f of sorted) {
+		lines.push(renderFeature(f));
+		lines.push("---");
+		lines.push("");
+	}
+	lines.push("## Reconstruction Instructions");
+	lines.push("");
+	lines.push("Using only the feature specs above (no original source code):", "", "1. Identify the tech stack implied by the decisions and tags", "2. Implement each feature in the order listed above (parents are always listed before children)", "3. Place each feature's code in the directory indicated by its **Path** field", "4. For each feature, satisfy its Problem, Success Criteria, and honour its Decisions", "5. Respect Known Limitations — do not over-engineer around them unless specified", "6. The result should pass all Success Criteria when run");
+	lines.push("");
+	return lines.join("\n");
+}
+const exportCommand = new Command("export").description("Export feature.json as JSON, Markdown, or generate a static HTML wiki").option("--out <path>", "Output file or directory path").option("--html [dir]", "Scan <dir> (default: cwd) and emit a single self-contained HTML wiki file").option("--site <dir>", "Scan <dir> for feature.json files and generate a static HTML site (outputs index.html in --out dir)").option("--prompt [dir]", "Scan <dir> for all feature.json files and emit a single reconstruction prompt (default: cwd)").option("--markdown", "Output feature as a Markdown document instead of JSON").option("--tags <tags>", "Comma-separated tags to filter by in --site/--html mode — only features with at least one matching tag are exported (OR logic)").action(async (options) => {
+	if (options.prompt !== void 0) {
+		const promptDir = typeof options.prompt === "string" ? resolve(options.prompt) : resolve(process$1.cwd());
+		let features;
+		try {
+			features = await scanFeatures(promptDir);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			process$1.stderr.write(`Error scanning "${promptDir}": ${message}\n`);
+			process$1.exit(1);
+		}
+		if (features.length === 0) {
+			process$1.stdout.write(`No valid feature.json files found in "${promptDir}".\n`);
+			process$1.exit(0);
+		}
+		const projectName = basename(promptDir);
+		const prompt = buildReconstructionPrompt(features, projectName, promptDir);
+		if (options.out) {
+			const outPath = resolve(options.out);
+			try {
+				await writeFile(outPath, prompt, "utf-8");
+				process$1.stdout.write(`✓ Reconstruction prompt (${features.length} features) → ${options.out}\n`);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				process$1.stderr.write(`Error writing to "${options.out}": ${message}\n`);
+				process$1.exit(1);
+			}
+		} else process$1.stdout.write(prompt);
+		return;
+	}
+	if (options.html !== void 0) {
+		const htmlDir = typeof options.html === "string" ? resolve(options.html) : resolve(process$1.cwd());
+		let features;
+		try {
+			features = await scanFeatures(htmlDir);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			process$1.stderr.write(`Error scanning "${htmlDir}": ${message}\n`);
+			process$1.exit(1);
+		}
+		if (options.tags) {
+			const tagsToMatch = options.tags.split(",").map((t) => t.trim()).filter(Boolean);
+			features = features.filter(({ feature }) => tagsToMatch.some((tag) => feature.tags?.includes(tag)));
+		}
+		if (features.length === 0) {
+			process$1.stdout.write(`No valid feature.json files found in "${htmlDir}".\n`);
+			process$1.exit(0);
+		}
+		const projectName = basename(htmlDir);
+		const html = generateHtmlWiki(features.map((f) => f.feature), projectName);
+		const outFile = options.out ? resolve(options.out) : resolve(process$1.cwd(), "lac-wiki.html");
+		try {
+			await writeFile(outFile, html, "utf-8");
+			process$1.stdout.write(`✓ HTML wiki (${features.length} features) → ${options.out ?? "lac-wiki.html"}\n`);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			process$1.stderr.write(`Error writing "${outFile}": ${message}\n`);
+			process$1.exit(1);
+		}
+		return;
+	}
 	if (options.site !== void 0) {
 		const scanDir = resolve(options.site);
 		const outDir = resolve(options.out ?? "./lac-site");
@@ -9370,6 +10765,10 @@ const exportCommand = new Command("export").description("Export feature.json as
 			process$1.stderr.write(`Error scanning "${scanDir}": ${message}\n`);
 			process$1.exit(1);
 		}
+		if (options.tags) {
+			const tagsToMatch = options.tags.split(",").map((t) => t.trim()).filter(Boolean);
+			features = features.filter(({ feature }) => tagsToMatch.some((tag) => feature.tags?.includes(tag)));
+		}
 		if (features.length === 0) {
 			process$1.stdout.write(`No valid feature.json files found in "${scanDir}".\n`);
 			process$1.exit(0);
@@ -9627,10 +11026,12 @@ function buildTree(key, byKey, childrenOf, visited = /* @__PURE__ */ new Set())
 	const childKeys = childrenOf.get(key) ?? [];
 	const children = [];
 	for (const ck of childKeys) if (!visited.has(ck)) children.push(buildTree(ck, byKey, childrenOf, visited));
+	children.sort((a, b) => (a.priority ?? 9999) - (b.priority ?? 9999));
 	return {
 		key,
 		status: feature?.status ?? "unknown",
 		title: feature?.title ?? "(unknown)",
+		priority: feature?.priority,
 		children
 	};
 }
@@ -9688,7 +11089,15 @@ const lineageCommand = new Command("lineage").description("Show the lineage tree
 
 //#endregion
 //#region src/commands/lint.ts
-function checkFeature(feature, filePath, requiredFields, threshold) {
+/** Intent-critical fields that should have a revision entry when non-empty */
+const INTENT_CRITICAL_FIELDS = [
+	"problem",
+	"analysis",
+	"implementation",
+	"decisions",
+	"successCriteria"
+];
+function checkFeature(feature, filePath, requiredFields, threshold, revisionWarnings = true) {
 	const raw = feature;
 	const completeness = computeCompleteness(raw);
 	const missingRequired = requiredFields.filter((field) => {
@@ -9698,6 +11107,20 @@ function checkFeature(feature, filePath, requiredFields, threshold) {
 		return typeof val === "string" && val.trim().length === 0;
 	});
 	const belowThreshold = threshold > 0 && completeness < threshold;
+	const warnings = [];
+	const hasRevisions = Array.isArray(raw.revisions) && raw.revisions.length > 0;
+	if (revisionWarnings && !hasRevisions) {
+		const filledCritical = INTENT_CRITICAL_FIELDS.filter((field) => {
+			const val = raw[field];
+			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 — consider adding a revision entry for: ${filledCritical.join(", ")}`);
+	}
+	if (raw.superseded_by && feature.status !== "deprecated") warnings.push(`superseded_by is set but status is "${feature.status}" — consider deprecating`);
+	if (raw.merged_into && feature.status !== "deprecated") warnings.push(`merged_into is set but status is "${feature.status}" — consider deprecating`);
 	return {
 		featureKey: feature.featureKey,
 		filePath,
@@ -9705,7 +11128,8 @@ function checkFeature(feature, filePath, requiredFields, threshold) {
 		completeness,
 		missingRequired,
 		belowThreshold,
-		pass: missingRequired.length === 0 && !belowThreshold
+		pass: missingRequired.length === 0 && !belowThreshold,
+		warnings
 	};
 }
 /** Default placeholder values for auto-fix of missing required fields */
@@ -9746,15 +11170,17 @@ async function fixFeature(filePath, missingFields) {
 	await writeFile(filePath, JSON.stringify(validation.data, null, 2) + "\n", "utf-8");
 	return fixed;
 }
-const lintCommand = new Command("lint").description("Check feature.json files for completeness and required fields").argument("[dir]", "Directory to scan (default: current directory)").option("--require <fields>", "Comma-separated required fields (overrides lac.config.json)").option("--threshold <n>", "Minimum completeness % required (overrides lac.config.json)", parseInt).option("--quiet", "Only print failures, suppress passing results").option("--json", "Output results as JSON").option("--watch", "Re-run lint on every feature.json change").option("--fix", "Auto-insert default values for missing required fields").action(async (dir, options) => {
+const lintCommand = new Command("lint").description("Check feature.json files for completeness and required fields").argument("[dir]", "Directory to scan (default: current directory)").option("--require <fields>", "Comma-separated required fields (overrides lac.config.json)").option("--threshold <n>", "Minimum completeness % required (overrides lac.config.json)", parseInt).option("--quiet", "Only print failures, suppress passing results").option("--json", "Output results as JSON").option("--watch", "Re-run lint on every feature.json change").option("--fix", "Auto-insert default values for missing required fields").option("--include-archived", "Include features inside _archive/ directories").option("--no-revision-warnings", "Suppress \"no revisions recorded\" warnings (useful during migration)").option("--tags <tags>", "Comma-separated tags to filter by — only lint features with at least one matching tag (OR logic)").action(async (dir, options) => {
 	const scanDir = resolve(dir ?? process$1.cwd());
 	const config$2 = loadConfig(scanDir);
 	const requiredFields = options.require ? options.require.split(",").map((f) => f.trim()).filter(Boolean) : config$2.requiredFields;
 	const threshold = options.threshold !== void 0 ? options.threshold : config$2.ciThreshold;
+	const scanOpts = { includeArchived: options.includeArchived ?? false };
+	const revisionWarnings = options.revisionWarnings ?? true;
 	async function runLint() {
 		let scanned;
 		try {
-			scanned = await scanFeatures(scanDir);
+			scanned = await scanFeatures(scanDir, scanOpts);
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
 			process$1.stderr.write(`Error scanning "${scanDir}": ${message}\n`);
@@ -9764,7 +11190,33 @@ const lintCommand = new Command("lint").description("Check feature.json files fo
 			process$1.stdout.write(`No feature.json files found in "${scanDir}".\n`);
 			return 0;
 		}
-		const results = scanned.filter(({ feature }) => config$2.lintStatuses.includes(feature.status)).map(({ feature, filePath }) => checkFeature(feature, filePath, requiredFields, threshold));
+		let toCheck = scanned.filter(({ feature }) => config$2.lintStatuses.includes(feature.status));
+		if (options.tags) {
+			const tagsToMatch = options.tags.split(",").map((t) => t.trim()).filter(Boolean);
+			toCheck = toCheck.filter(({ feature }) => tagsToMatch.some((tag) => feature.tags?.includes(tag)));
+		}
+		const results = toCheck.map(({ feature, filePath }) => checkFeature(feature, filePath, requiredFields, threshold, revisionWarnings));
+		const featureByKey = new Map(scanned.map(({ feature }) => [feature.featureKey, feature]));
+		for (const result of results) {
+			const raw = featureByKey.get(result.featureKey);
+			if (!raw) continue;
+			if (raw.merged_into) {
+				const target = featureByKey.get(String(raw.merged_into));
+				if (target) {
+					if (!(target.merged_from ?? []).includes(result.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.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.featureKey)) result.warnings.push(`superseded_by "${raw.superseded_by}" but that feature does not list this key in superseded_from`);
+				}
+			}
+		}
 		if (options.fix) {
 			const toFix = results.filter((r) => !r.pass && r.missingRequired.length > 0);
 			let totalFixed = 0;
@@ -9785,12 +11237,12 @@ const lintCommand = new Command("lint").description("Check feature.json files fo
 			}
 			let rescanned;
 			try {
-				rescanned = await scanFeatures(scanDir);
+				rescanned = await scanFeatures(scanDir, scanOpts);
 			} catch {
 				process$1.stdout.write(`\n✓ Fixed ${totalFixed} field${totalFixed === 1 ? "" : "s"}. Could not re-validate — run "lac lint" to confirm.\n`);
 				return 0;
 			}
-			const stillFailing = rescanned.filter(({ feature }) => config$2.lintStatuses.includes(feature.status)).map(({ feature, filePath }) => checkFeature(feature, filePath, requiredFields, threshold)).filter((r) => !r.pass);
+			const stillFailing = rescanned.filter(({ feature }) => config$2.lintStatuses.includes(feature.status)).map(({ feature, filePath }) => checkFeature(feature, filePath, requiredFields, threshold, revisionWarnings)).filter((r) => !r.pass);
 			if (stillFailing.length === 0) {
 				process$1.stdout.write(`\n✓ Fixed ${totalFixed} field${totalFixed === 1 ? "" : "s"} — all features now pass lint.\n`);
 				return 0;
@@ -9801,11 +11253,13 @@ const lintCommand = new Command("lint").description("Check feature.json files fo
 		}
 		const failures = results.filter((r) => !r.pass);
 		const passes = results.filter((r) => r.pass);
+		const warnings = results.filter((r) => r.warnings.length > 0);
 		if (options.json) {
 			process$1.stdout.write(JSON.stringify({
 				results,
 				failures: failures.length,
-				passes: passes.length
+				passes: passes.length,
+				warningCount: warnings.length
 			}, null, 2) + "\n");
 			return failures.length > 0 ? 1 : 0;
 		}
@@ -9818,7 +11272,11 @@ const lintCommand = new Command("lint").description("Check feature.json files fo
 			for (const field of r.missingRequired) process$1.stdout.write(`       missing required field: ${field}\n`);
 			if (r.belowThreshold) process$1.stdout.write(`       completeness ${r.completeness}% is below threshold ${threshold}%\n`);
 		}
-		process$1.stdout.write(`\n${passes.length} passed, ${failures.length} failed — ${results.length} features checked\n`);
+		if (!options.quiet && warnings.length > 0) {
+			process$1.stdout.write("\nWarnings:\n");
+			for (const r of warnings) for (const w of r.warnings) process$1.stdout.write(`  ⚠  ${col(r.featureKey, 18)}  ${w}\n`);
+		}
+		process$1.stdout.write(`\n${passes.length} passed, ${failures.length} failed, ${warnings.length} warned — ${results.length} features checked\n`);
 		if (failures.length > 0) {
 			if (!options.quiet) {
 				process$1.stdout.write(`\nFailing features:\n`);
@@ -10049,8 +11507,12 @@ const renameCommand = new Command("rename").description("Rename a featureKey —
 
 //#endregion
 //#region src/commands/search.ts
-const searchCommand = new Command("search").description("Search features by keyword across key, title, problem, tags, and analysis").argument("<query>", "Search query (case-insensitive)").option("-d, --dir <path>", "Directory to scan (default: cwd)").option("--json", "Output results as JSON").option("--field <fields>", "Comma-separated fields to search (default: all)").action(async (query, options) => {
-	const features = await scanFeatures(options.dir ?? process$1.cwd());
+const searchCommand = new Command("search").description("Search features by keyword across key, title, problem, tags, and analysis").argument("<query>", "Search query (case-insensitive)").option("-d, --dir <path>", "Directory to scan (default: cwd)").option("--json", "Output results as JSON").option("--field <fields>", "Comma-separated fields to search (default: all)").option("--tags <tags>", "Comma-separated tags to filter by — only features with at least one matching tag are searched (OR logic)").action(async (query, options) => {
+	let features = await scanFeatures(options.dir ?? process$1.cwd());
+	if (options.tags) {
+		const tagsToMatch = options.tags.split(",").map((t) => t.trim()).filter(Boolean);
+		features = features.filter(({ feature }) => tagsToMatch.some((tag) => feature.tags?.includes(tag)));
+	}
 	const searchFields = options.field ? options.field.split(",").map((f) => f.trim()) : [
 		"featureKey",
 		"title",
@@ -10332,7 +11794,7 @@ const spawnCommand = new Command("spawn").description("Spawn a child feature fro
 
 //#endregion
 //#region src/commands/stat.ts
-const statCommand = new Command("stat").description("Show workspace statistics: feature counts, status breakdown, completeness, top tags").option("-d, --dir <path>", "Directory to scan (default: cwd)").action(async (options) => {
+const statCommand = new Command("stat").description("Show workspace statistics: feature counts, status breakdown, completeness, top tags").option("-d, --dir <path>", "Directory to scan (default: cwd)").option("--tags <tags>", "Comma-separated tags to filter by — scope stats to features with at least one matching tag (OR logic)").option("--by-tag", "Group output by tag — show per-tag feature counts and status breakdown").action(async (options) => {
 	const scanDir = options.dir ?? process$1.cwd();
 	let features;
 	try {
@@ -10342,6 +11804,10 @@ const statCommand = new Command("stat").description("Show workspace statistics:
 		process$1.stderr.write(`Error scanning "${scanDir}": ${message}\n`);
 		process$1.exit(1);
 	}
+	if (options.tags) {
+		const tagsToMatch = options.tags.split(",").map((t) => t.trim()).filter(Boolean);
+		features = features.filter(({ feature }) => tagsToMatch.some((tag) => feature.tags?.includes(tag)));
+	}
 	const total = features.length;
 	if (total === 0) {
 		process$1.stdout.write(`No features found in "${scanDir}".\n`);
@@ -10382,9 +11848,170 @@ const statCommand = new Command("stat").description("Show workspace statistics:
 		lines.push("Top 5 tags:");
 		for (const [tag, count] of topTags) lines.push(`  ${tag.padEnd(20)}: ${count}`);
 	}
+	if (options.byTag) {
+		lines.push("");
+		lines.push("By tag:");
+		const allTags = Array.from(tagCounts.keys()).sort();
+		for (const tag of allTags) {
+			const tagged = features.filter(({ feature }) => feature.tags?.includes(tag));
+			const byStatus = {};
+			for (const { feature } of tagged) byStatus[feature.status] = (byStatus[feature.status] ?? 0) + 1;
+			const statusSummary = Object.entries(byStatus).map(([s, n]) => `${s}:${n}`).join("  ");
+			lines.push(`  ${tag.padEnd(22)} ${tagged.length.toString().padStart(3)} features  (${statusSummary})`);
+		}
+		const untagged = features.filter(({ feature }) => !feature.tags || feature.tags.length === 0);
+		if (untagged.length > 0) lines.push(`  ${"(untagged)".padEnd(22)} ${untagged.length.toString().padStart(3)} features`);
+	}
 	process$1.stdout.write(lines.join("\n") + "\n");
 });
 
+//#endregion
+//#region src/commands/strip.ts
+const DEFAULT_KEEP = new Set([
+	"feature.json",
+	"package.json",
+	"package-lock.json",
+	"bun.lock",
+	"yarn.lock",
+	"pnpm-lock.yaml",
+	"tsconfig.json",
+	"tsconfig.base.json",
+	"vite.config.ts",
+	"vite.config.js",
+	"vitest.config.ts",
+	"vitest.config.js",
+	"next.config.ts",
+	"next.config.js",
+	"tailwind.config.ts",
+	"tailwind.config.js",
+	"postcss.config.js",
+	"postcss.config.ts",
+	".gitignore",
+	".gitattributes",
+	"README.md",
+	"LICENSE",
+	"Makefile",
+	".env.example",
+	"turbo.json"
+]);
+const SKIP_DIRS = new Set([
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	"out",
+	".turbo",
+	".next",
+	".nuxt",
+	"__pycache__",
+	".venv",
+	"venv",
+	"target",
+	"vendor",
+	"coverage"
+]);
+function collectDeletable(dir, keepNames) {
+	const deletable = [];
+	function walk(current) {
+		let entries;
+		try {
+			entries = fs.readdirSync(current, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const fullPath = path.join(current, entry.name);
+			if (entry.isDirectory()) {
+				if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+				walk(fullPath);
+			} else if (entry.isFile()) {
+				if (!keepNames.has(entry.name)) deletable.push({
+					absolutePath: fullPath,
+					relativePath: path.relative(dir, fullPath).replace(/\\/g, "/")
+				});
+			}
+		}
+	}
+	walk(dir);
+	return deletable;
+}
+function readLine(prompt) {
+	return new Promise((resolve$1) => {
+		const rl = readline.createInterface({
+			input: process$1.stdin,
+			output: process$1.stdout
+		});
+		rl.question(prompt, (answer) => {
+			rl.close();
+			resolve$1(answer.trim());
+		});
+	});
+}
+const stripCommand = new Command("strip").description("Export a reconstruction prompt then delete all non-feature source files.\nUseful for reducing a documented repo to its spec only.\nRuns export --prompt first, shows a dry-run, then asks for confirmation.").argument("[path]", "Root directory to strip (default: current directory)").option("--out <file>", "Write the reconstruction prompt to <file> before deleting").option("--keep <names>", "Comma-separated extra file names to preserve (added to built-in keep-list)", "").option("--dry-run", "Show what would be deleted without removing anything").option("--yes", "Skip the confirmation prompt").action(async (targetArg, opts) => {
+	const targetDir = path.resolve(targetArg ?? process$1.cwd());
+	if (!fs.existsSync(targetDir)) {
+		process$1.stderr.write(`Error: path "${targetDir}" does not exist.\n`);
+		process$1.exit(1);
+	}
+	process$1.stdout.write(`\nScanning "${targetDir}" for feature.json files...\n`);
+	let features;
+	try {
+		features = await scanFeatures(targetDir);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process$1.stderr.write(`Error scanning features: ${message}\n`);
+		process$1.exit(1);
+	}
+	if (features.length === 0) {
+		process$1.stderr.write(`Error: no valid feature.json files found in "${targetDir}". Run "lac extract-all" first.\n`);
+		process$1.exit(1);
+	}
+	process$1.stdout.write(`  Found ${features.length} feature${features.length === 1 ? "" : "s"}.\n`);
+	if (opts.out) {
+		const outPath = path.resolve(opts.out);
+		const prompt = buildReconstructionPrompt(features, basename(targetDir), targetDir);
+		try {
+			await writeFile(outPath, prompt, "utf-8");
+			process$1.stdout.write(`  ✓ Reconstruction prompt (${features.length} features) → ${opts.out}\n`);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			process$1.stderr.write(`Warning: could not write reconstruction prompt to "${opts.out}": ${message}\n`);
+		}
+	} else process$1.stdout.write(`\nTip: run "lac export --prompt ${targetArg ?? "."} --out spec.md" to save the reconstruction prompt before stripping.\n`);
+	const extraKeep = (opts.keep ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+	const deletable = collectDeletable(targetDir, new Set([...DEFAULT_KEEP, ...extraKeep]));
+	if (deletable.length === 0) {
+		process$1.stdout.write("\nNothing to delete — all source files are already in the keep-list.\n");
+		return;
+	}
+	process$1.stdout.write(`\nThe following ${deletable.length} file${deletable.length === 1 ? "" : "s"} would be deleted:\n\n`);
+	for (const f of deletable) process$1.stdout.write(`  - ${f.relativePath}\n`);
+	if (opts.dryRun) {
+		process$1.stdout.write("\n[dry-run] No files deleted.\n");
+		return;
+	}
+	if (!opts.yes) {
+		if ((await readLine(`\nDelete ${deletable.length} file${deletable.length === 1 ? "" : "s"}? [y/N]: `)).toLowerCase() !== "y") {
+			process$1.stdout.write("Aborted.\n");
+			return;
+		}
+	}
+	let deleted = 0;
+	let failed = 0;
+	for (const f of deletable) try {
+		fs.unlinkSync(f.absolutePath);
+		deleted++;
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process$1.stderr.write(`  Warning: could not delete "${f.relativePath}": ${message}\n`);
+		failed++;
+	}
+	process$1.stdout.write(`\n✓ Deleted ${deleted} file${deleted === 1 ? "" : "s"}`);
+	if (failed > 0) process$1.stdout.write(` (${failed} failed)`);
+	process$1.stdout.write("\n");
+	if (!opts.out) process$1.stdout.write("\nNext: run \"lac export --prompt . --out spec.md\" to generate the reconstruction prompt from the remaining feature.json files.\n");
+});
+
 //#endregion
 //#region src/commands/tag.ts
 const tagCommand = new Command("tag").description("Add or remove tags on a feature").argument("<key>", "featureKey to tag (e.g. feat-2026-001)").argument("<tags>", "Comma-separated tags to add (prefix with - to remove, e.g. \"auth,-legacy,api\")").option("-d, --dir <path>", "Directory to scan for features (default: cwd)").action(async (key, tags, options) => {
@@ -10498,7 +12125,13 @@ program.addCommand(diffCommand);
 program.addCommand(renameCommand);
 program.addCommand(importCommand);
 program.addCommand(fillCommand);
+program.addCommand(extractAllCommand);
 program.addCommand(genCommand);
+program.addCommand(logCommand);
+program.addCommand(mergeCommand);
+program.addCommand(revisionsCommand);
+program.addCommand(supersedeCommand);
+program.addCommand(stripCommand);
 program.parse();
 
 //#endregion