@majeanson/lac 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2465 @@
+import { Command } from "commander";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import process$1 from "node:process";
+import { FEATURE_KEY_PATTERN, generateFeatureKey, validateFeature } from "@life-as-code/feature-schema";
+import path, { dirname, join, resolve } from "node:path";
+import fs, { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import prompts from "prompts";
+import http from "node:http";
+
+//#region src/lib/scanner.ts
+/**
+* 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.
+*/
+async function scanFeatures(dir) {
+	const results = [];
+	async function walk(currentDir) {
+		let entries;
+		let rawEntries;
+		try {
+			rawEntries = await readdir(currentDir, { withFileTypes: true });
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`Warning: could not read directory "${currentDir}": ${message}\n`);
+			return;
+		}
+		entries = rawEntries.map((e) => ({
+			name: String(e.name),
+			isDirectory: () => e.isDirectory(),
+			isFile: () => e.isFile()
+		}));
+		for (const entry of entries) {
+			const fullPath = join(currentDir, entry.name);
+			if (entry.isDirectory()) {
+				if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+				await walk(fullPath);
+			} else if (entry.isFile() && entry.name === "feature.json") {
+				let raw;
+				try {
+					raw = await readFile(fullPath, "utf-8");
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					process.stderr.write(`Warning: could not read "${fullPath}": ${message}\n`);
+					continue;
+				}
+				let parsed;
+				try {
+					parsed = JSON.parse(raw);
+				} catch {
+					process.stderr.write(`Warning: invalid JSON in "${fullPath}" — skipping\n`);
+					continue;
+				}
+				const result = validateFeature(parsed);
+				if (!result.success) {
+					process.stderr.write(`Warning: "${fullPath}" failed validation — skipping\n  ${result.errors.join("\n  ")}\n`);
+					continue;
+				}
+				results.push({
+					filePath: fullPath,
+					feature: result.data
+				});
+			}
+		}
+	}
+	await walk(dir);
+	return results;
+}
+
+//#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 scanDir = options.dir ?? process$1.cwd();
+	const found = (await scanFeatures(scanDir)).find((f) => f.feature.featureKey === key);
+	if (!found) {
+		process$1.stderr.write(`Error: feature "${key}" not found in "${scanDir}"\n`);
+		process$1.exit(1);
+	}
+	if (found.feature.status === "deprecated") {
+		process$1.stdout.write(`Already deprecated: ${key}\n`);
+		process$1.exit(0);
+	}
+	const raw = await readFile(found.filePath, "utf-8");
+	const parsed = JSON.parse(raw);
+	parsed["status"] = "deprecated";
+	const validation = validateFeature(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`);
+});
+
+//#endregion
+//#region src/lib/walker.ts
+/**
+* Walks up the directory tree from startDir to find the nearest feature.json.
+* Returns the absolute path or null if not found before reaching the filesystem root.
+*/
+function findNearestFeatureJson$1(startDir) {
+	let current = resolve(startDir);
+	while (true) {
+		const candidate = join(current, "feature.json");
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+/**
+* Walks up the directory tree from startDir to find the nearest .git directory.
+* Returns the absolute path to .git or null if not found.
+*/
+function findGitDir(startDir) {
+	let current = resolve(startDir);
+	while (true) {
+		const candidate = join(current, ".git");
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+/**
+* Walks up the directory tree from startDir to find the nearest lac.config.json.
+* Returns the absolute path or null if not found.
+*/
+function findLacConfig(startDir) {
+	let current = resolve(startDir);
+	while (true) {
+		const candidate = join(current, "lac.config.json");
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+
+//#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 };
+	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
+		};
+	} 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/blame.ts
+const blameCommand = new Command("blame").description("Show which feature owns a file or path").argument("<path>", "File path to trace (supports path:line format, line is ignored)").action((rawPath) => {
+	const filePath = rawPath.replace(/:\d+$/, "");
+	const featureJsonPath = findNearestFeatureJson$1(dirname(resolve(filePath)));
+	if (!featureJsonPath) {
+		process$1.stderr.write(`No feature.json found for "${filePath}".\nRun "lac init" in the feature folder to create one.\n`);
+		process$1.exit(1);
+	}
+	let raw;
+	try {
+		raw = readFileSync(featureJsonPath, "utf-8");
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process$1.stderr.write(`Error reading "${featureJsonPath}": ${message}\n`);
+		process$1.exit(1);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		process$1.stderr.write(`Error: "${featureJsonPath}" contains invalid JSON.\n`);
+		process$1.exit(1);
+	}
+	const result = validateFeature(parsed);
+	if (!result.success) {
+		process$1.stderr.write(`Error: "${featureJsonPath}" failed validation:\n  ${result.errors.join("\n  ")}\n`);
+		process$1.exit(1);
+	}
+	const f = result.data;
+	const icon = {
+		active: "⊙",
+		draft: "◌",
+		frozen: "❄",
+		deprecated: "⊘"
+	}[f.status] ?? "?";
+	const completeness = computeCompleteness(f);
+	const bar = "█".repeat(Math.round(completeness / 10)) + "░".repeat(10 - Math.round(completeness / 10));
+	process$1.stdout.write("\n");
+	process$1.stdout.write(`  Feature   : ${f.featureKey}\n`);
+	process$1.stdout.write(`  Title     : ${f.title}\n`);
+	process$1.stdout.write(`  Status    : ${icon}  ${f.status}\n`);
+	process$1.stdout.write(`  Complete  : [${bar}] ${completeness}%\n`);
+	process$1.stdout.write(`  Path      : ${featureJsonPath}\n`);
+	process$1.stdout.write("\n");
+	process$1.stdout.write(`  Problem:\n    ${f.problem}\n`);
+	if (f.analysis) {
+		const excerpt = f.analysis.length > 120 ? f.analysis.slice(0, 120) + "…" : f.analysis;
+		process$1.stdout.write(`\n  Analysis:\n    ${excerpt}\n`);
+	}
+	if (f.decisions && f.decisions.length > 0) {
+		process$1.stdout.write(`\n  Decisions (${f.decisions.length}):\n`);
+		for (const d of f.decisions) process$1.stdout.write(`    • ${d.decision}\n      Rationale: ${d.rationale}\n`);
+	}
+	if (f.knownLimitations && f.knownLimitations.length > 0) {
+		process$1.stdout.write(`\n  Known Limitations:\n`);
+		for (const lim of f.knownLimitations) process$1.stdout.write(`    - ${lim}\n`);
+	}
+	if (f.lineage?.parent) process$1.stdout.write(`\n  Lineage   : parent → ${f.lineage.parent}\n`);
+	process$1.stdout.write("\n");
+});
+
+//#endregion
+//#region src/commands/diff.ts
+/**
+* Stable JSON serialisation that sorts object keys recursively so that two
+* objects with the same content but different insertion order compare equal.
+*/
+function stableStringify(val) {
+	if (val === null || typeof val !== "object") return JSON.stringify(val);
+	if (Array.isArray(val)) return `[${val.map(stableStringify).join(",")}]`;
+	return `{${Object.keys(val).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(val[k])}`).join(",")}}`;
+}
+function formatValue(val) {
+	if (val === void 0 || val === null) return "(empty)";
+	if (typeof val === "string") return val.length > 80 ? val.slice(0, 77) + "..." : val;
+	return JSON.stringify(val);
+}
+const diffCommand = new Command("diff").description("Compare two features field-by-field").argument("<key1>", "First featureKey").argument("<key2>", "Second featureKey").option("-d, --dir <path>", "Directory to scan (default: cwd)").action(async (key1, key2, options) => {
+	const scanDir = options.dir ?? process$1.cwd();
+	let features;
+	try {
+		features = await scanFeatures(scanDir);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process$1.stderr.write(`Error scanning "${scanDir}": ${message}\n`);
+		process$1.exit(1);
+	}
+	const f1 = features.find((f) => f.feature.featureKey === key1);
+	const f2 = features.find((f) => f.feature.featureKey === key2);
+	if (!f1) {
+		process$1.stderr.write(`Error: feature "${key1}" not found in "${scanDir}"\n`);
+		process$1.exit(1);
+	}
+	if (!f2) {
+		process$1.stderr.write(`Error: feature "${key2}" not found in "${scanDir}"\n`);
+		process$1.exit(1);
+	}
+	const obj1 = f1.feature;
+	const obj2 = f2.feature;
+	const allKeys = new Set([...Object.keys(obj1), ...Object.keys(obj2)]);
+	const lines = [];
+	lines.push(`diff ${key1} → ${key2}`);
+	lines.push("─".repeat(60));
+	let hasDiffs = false;
+	for (const field of allKeys) {
+		const v1 = obj1[field];
+		const v2 = obj2[field];
+		if (stableStringify(v1) === stableStringify(v2)) continue;
+		hasDiffs = true;
+		if (v1 === void 0) lines.push(`+ ${field}: ${formatValue(v2)}`);
+		else if (v2 === void 0) lines.push(`- ${field}: ${formatValue(v1)}`);
+		else {
+			lines.push(`~ ${field}:`);
+			lines.push(`    OLD: ${formatValue(v1)}`);
+			lines.push(`    NEW: ${formatValue(v2)}`);
+		}
+	}
+	if (!hasDiffs) lines.push("(no differences)");
+	process$1.stdout.write(lines.join("\n") + "\n");
+});
+
+//#endregion
+//#region src/commands/doctor.ts
+/** Mirrors the findLacDir logic from keygen.ts */
+function findLacDir$1(fromDir) {
+	let current = path.resolve(fromDir);
+	while (true) {
+		const candidate = path.join(current, ".lac");
+		try {
+			if (statSync(candidate).isDirectory()) return candidate;
+		} catch {}
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+/** Walk a directory tree collecting all feature.json paths with validation info. */
+async function walkFeatureFiles(currentDir) {
+	let validCount = 0;
+	const invalidFiles = [];
+	async function walk(dir) {
+		let rawEntries;
+		try {
+			rawEntries = await readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		const entries = rawEntries.map((e) => ({
+			name: String(e.name),
+			isDirectory: () => e.isDirectory(),
+			isFile: () => e.isFile()
+		}));
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+			if (entry.isDirectory()) {
+				if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+				await walk(fullPath);
+			} else if (entry.isFile() && entry.name === "feature.json") {
+				let raw;
+				try {
+					raw = await readFile(fullPath, "utf-8");
+				} catch {
+					invalidFiles.push({
+						filePath: fullPath,
+						errors: ["could not read file"]
+					});
+					continue;
+				}
+				let parsed;
+				try {
+					parsed = JSON.parse(raw);
+				} catch {
+					invalidFiles.push({
+						filePath: fullPath,
+						errors: ["invalid JSON"]
+					});
+					continue;
+				}
+				const result = validateFeature(parsed);
+				if (!result.success) invalidFiles.push({
+					filePath: fullPath,
+					errors: result.errors
+				});
+				else validCount++;
+			}
+		}
+	}
+	await walk(currentDir);
+	return {
+		valid: validCount,
+		invalid: invalidFiles
+	};
+}
+const doctorCommand = new Command("doctor").description("Check workspace health and report any issues").argument("[dir]", "Directory to check (default: cwd)").action(async (dir) => {
+	const checkDir = dir ? path.resolve(dir) : process$1.cwd();
+	let passed = 0;
+	let warned = 0;
+	let failed = 0;
+	const output = [];
+	output.push("lac doctor — workspace diagnostics");
+	output.push("===================================");
+	output.push("");
+	let lacDir = null;
+	try {
+		lacDir = findLacDir$1(checkDir);
+	} catch {}
+	if (lacDir) {
+		output.push(`✓ Workspace found at ${lacDir}`);
+		passed++;
+	} else {
+		output.push("✗ No .lac/ workspace — run: lac workspace init");
+		failed++;
+	}
+	if (lacDir) {
+		const counterPath = join(lacDir, "counter");
+		let counterOk = false;
+		let counterYear = null;
+		let nextKey = "";
+		try {
+			const parts = readFileSync(counterPath, "utf-8").trim().split("\n").map((l) => l.trim());
+			const yr = parseInt(parts[0] ?? "", 10);
+			const cnt = parseInt(parts[1] ?? "", 10);
+			if (!isNaN(yr) && !isNaN(cnt)) {
+				counterOk = true;
+				counterYear = yr;
+				nextKey = `feat-${yr}-${String(cnt + 1).padStart(3, "0")}`;
+			}
+		} catch {}
+		if (counterOk && counterYear !== null) {
+			output.push(`✓ Counter valid — next key preview: ${nextKey}`);
+			passed++;
+			const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+			if (counterYear !== currentYear) {
+				output.push(`⚠ Counter year is stale (${counterYear}) — will reset on next lac init`);
+				warned++;
+			}
+		} else {
+			output.push("✗ Counter file missing or corrupt — run: lac workspace init --force");
+			failed++;
+		}
+	}
+	try {
+		const { valid, invalid } = await walkFeatureFiles(checkDir);
+		const total = valid + invalid.length;
+		output.push(`✓ Found ${total} feature.json file${total === 1 ? "" : "s"}`);
+		passed++;
+		for (const inv of invalid) {
+			output.push(`  ✗ Invalid: ${inv.filePath} — ${inv.errors.join("; ")}`);
+			failed++;
+		}
+	} catch {
+		output.push("✗ Could not scan feature.json files");
+		failed++;
+	}
+	try {
+		const configPath = findLacConfig(checkDir);
+		if (!configPath) output.push("  (no lac.config.json — using defaults)");
+		else try {
+			const raw = readFileSync(configPath, "utf-8");
+			const parsed = JSON.parse(raw);
+			const domain = typeof parsed.domain === "string" ? parsed.domain : "feat";
+			const threshold = typeof parsed.ciThreshold === "number" ? parsed.ciThreshold : 0;
+			output.push(`✓ lac.config.json valid (domain: ${domain}, threshold: ${threshold})`);
+			passed++;
+		} catch {
+			output.push("✗ lac.config.json is invalid JSON — fix or delete it");
+			failed++;
+		}
+	} catch {
+		output.push("  (no lac.config.json — using defaults)");
+	}
+	try {
+		const result = spawnSync("lac-lsp", ["--help"], {
+			timeout: 2e3,
+			stdio: "ignore"
+		});
+		if (result.error || result.status === null) {
+			output.push("✗ lac-lsp not found — install: npm i -g @life-as-code/lac-lsp");
+			failed++;
+		} else {
+			output.push("✓ lac-lsp found in PATH");
+			passed++;
+		}
+	} catch {
+		output.push("✗ lac-lsp not found — install: npm i -g @life-as-code/lac-lsp");
+		failed++;
+	}
+	try {
+		const config = loadConfig(checkDir);
+		const toCheck = (await scanFeatures(checkDir)).filter(({ feature }) => config.lintStatuses.includes(feature.status));
+		let lintWarnCount = 0;
+		for (const { feature } of toCheck) {
+			const raw = feature;
+			const completeness = computeCompleteness(raw);
+			const missingRequired = config.requiredFields.filter((field) => {
+				const val = raw[field];
+				if (val === void 0 || val === null || val === "") return true;
+				if (Array.isArray(val)) return val.length === 0;
+				return typeof val === "string" && val.trim().length === 0;
+			});
+			const belowThreshold = config.ciThreshold > 0 && completeness < config.ciThreshold;
+			if (missingRequired.length > 0 || belowThreshold) lintWarnCount++;
+		}
+		if (lintWarnCount === 0) {
+			output.push("✓ All features pass lint");
+			passed++;
+		} else {
+			output.push(`⚠ ${lintWarnCount} feature${lintWarnCount === 1 ? "" : "s"} have lint warnings`);
+			warned++;
+		}
+	} catch {
+		output.push("⚠ Could not run lint check");
+		warned++;
+	}
+	output.push("");
+	output.push(`Overall: ${passed} check${passed === 1 ? "" : "s"} passed, ${warned} warning${warned === 1 ? "" : "s"}, ${failed} failure${failed === 1 ? "" : "s"}`);
+	if (failed === 0) {
+		output.push("");
+		output.push("Next steps:");
+		output.push("  lac serve          → open dashboard at http://127.0.0.1:7474");
+		output.push("  lac hooks install  → lint on every commit");
+		output.push("  lac init           → create your first feature");
+	}
+	process$1.stdout.write(output.join("\n") + "\n");
+	process$1.exit(failed > 0 ? 1 : 0);
+});
+
+//#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");
+}
+
+//#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;
+  }
+}
+
+*, *::before, *::after {
+  box-sizing: border-box;
+}
+
+html {
+  font-size: 16px;
+  line-height: 1.6;
+}
+
+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;
+}
+
+.container {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 2rem 1rem;
+}
+
+h1 {
+  font-size: 2rem;
+  font-weight: 700;
+  margin-top: 0;
+  margin-bottom: 0.5rem;
+}
+
+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;
+}
+
+a {
+  color: var(--color-link);
+  text-decoration: none;
+}
+
+a:hover {
+  color: var(--color-link-hover);
+  text-decoration: underline;
+}
+
+p {
+  margin: 0 0 1rem;
+}
+
+.meta {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  margin-bottom: 1.5rem;
+  color: var(--color-text-muted);
+  font-size: 0.875rem;
+}
+
+.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);
+}
+
+/* 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;
+}
+
+.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);
+}
+
+.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);
+}
+
+.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);
+}
+
+.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);
+}
+
+/* Search */
+.search-wrapper {
+  margin-bottom: 1.5rem;
+}
+
+.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;
+}
+
+.search-input:focus {
+  border-color: var(--color-link);
+}
+
+/* Feature table */
+.feature-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 0.9375rem;
+}
+
+.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;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.feature-table td {
+  padding: 0.625rem 0.75rem;
+  border-bottom: 1px solid var(--color-border);
+  vertical-align: top;
+}
+
+.feature-table tr:last-child td {
+  border-bottom: none;
+}
+
+.feature-table tr:hover td {
+  background-color: var(--color-surface);
+}
+
+.problem-excerpt {
+  color: var(--color-text-muted);
+  font-size: 0.875rem;
+}
+
+/* Sections */
+section {
+  margin-bottom: 2rem;
+}
+
+.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;
+}
+
+/* Decisions timeline */
+ol.decisions {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+
+ol.decisions li {
+  position: relative;
+  padding: 1rem 1rem 1rem 1.5rem;
+  border-left: 2px solid var(--color-border);
+  margin-bottom: 1rem;
+}
+
+ol.decisions li:last-child {
+  margin-bottom: 0;
+}
+
+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);
+}
+
+.decision-date {
+  font-size: 0.75rem;
+  color: var(--color-text-muted);
+  margin-bottom: 0.25rem;
+}
+
+.decision-text {
+  font-weight: 600;
+  margin-bottom: 0.375rem;
+}
+
+.decision-rationale {
+  color: var(--color-text-muted);
+  font-size: 0.9375rem;
+  margin-bottom: 0.375rem;
+}
+
+.alternatives {
+  font-size: 0.875rem;
+  color: var(--color-text-muted);
+}
+
+.alternatives span {
+  font-weight: 500;
+}
+
+/* Implementation / limitation sections */
+.implementation-text {
+  white-space: pre-wrap;
+  font-size: 0.9375rem;
+  line-height: 1.7;
+}
+
+ul.limitations {
+  padding-left: 1.5rem;
+  margin: 0;
+}
+
+ul.limitations li {
+  margin-bottom: 0.375rem;
+  color: var(--color-text-muted);
+}
+
+/* Lineage */
+.lineage-info {
+  background-color: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: 0.375rem;
+  padding: 1rem 1.25rem;
+}
+
+.lineage-info p {
+  margin-bottom: 0.5rem;
+}
+
+.lineage-info p:last-child {
+  margin-bottom: 0;
+}
+
+/* Back link */
+.back-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  margin-bottom: 2rem;
+  font-size: 0.875rem;
+}
+
+/* Empty state */
+.empty-state {
+  text-align: center;
+  padding: 3rem 1rem;
+  color: var(--color-text-muted);
+}
+
+/* No results row */
+.no-results {
+  display: none;
+  padding: 1.5rem 0.75rem;
+  color: var(--color-text-muted);
+  font-style: italic;
+}
+
+/* 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;
+}
+
+.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);
+}
+
+.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;
+}
+
+.implementation-text code,
+.analysis-text code {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 0.875em;
+}
+
+.implementation-text pre code,
+.analysis-text pre code {
+  background: none;
+  padding: 0;
+  border-radius: 0;
+  font-size: 0.875rem;
+}
+
+.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;
+}
+
+.implementation-text ul,
+.analysis-text ul,
+.implementation-text ol,
+.analysis-text ol {
+  padding-left: 1.5rem;
+  margin: 0.5rem 0 1rem;
+}
+
+.implementation-text li,
+.analysis-text li {
+  margin-bottom: 0.25rem;
+}
+
+/* Markdown tables */
+.md-table {
+  width: 100%;
+  border-collapse: collapse;
+  margin: 1rem 0;
+  font-size: 0.9rem;
+}
+
+.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);
+}
+
+.md-table td {
+  padding: 0.5rem 0.75rem;
+  border-bottom: 1px solid var(--color-border);
+  vertical-align: top;
+}
+
+.md-table tr:last-child td {
+  border-bottom: none;
+}
+
+.md-table tr:hover td {
+  background-color: var(--color-surface);
+}
+
+/* Analysis section */
+.analysis-text {
+  font-size: 0.9375rem;
+  line-height: 1.7;
+}
+`;
+
+//#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 = 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}
+        <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>`;
+}
+
+//#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>
+
+  <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>
+</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");
+	}
+}
+
+//#endregion
+//#region src/commands/export.ts
+/**
+* Walks up the directory tree from `startDir` to find the nearest feature.json.
+* Returns the absolute path or null if not found.
+*/
+function findNearestFeatureJson(startDir) {
+	let current = resolve(startDir);
+	while (true) {
+		const candidate = join(current, "feature.json");
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+/** Render a feature as a Markdown document */
+function featureToMarkdown(feature) {
+	const f = feature;
+	const lines = [];
+	lines.push(`# ${f["title"]}`);
+	lines.push("");
+	lines.push(`**Key:** \`${f["featureKey"]}\`  `);
+	lines.push(`**Status:** ${f["status"]}`);
+	lines.push("");
+	if (f["problem"]) {
+		lines.push("## Problem");
+		lines.push("");
+		lines.push(f["problem"]);
+		lines.push("");
+	}
+	if (f["analysis"]) {
+		lines.push("## Analysis");
+		lines.push("");
+		lines.push(f["analysis"]);
+		lines.push("");
+	}
+	if (f["implementation"]) {
+		lines.push("## Implementation");
+		lines.push("");
+		lines.push(f["implementation"]);
+		lines.push("");
+	}
+	const limitations = f["knownLimitations"];
+	if (limitations && limitations.length > 0) {
+		lines.push("## Known Limitations");
+		lines.push("");
+		for (const lim of limitations) lines.push(`- ${lim}`);
+		lines.push("");
+	}
+	const decisions = f["decisions"];
+	if (decisions && decisions.length > 0) {
+		lines.push("## Decisions");
+		lines.push("");
+		for (const d of decisions) {
+			lines.push(`### ${d["decision"]}`);
+			lines.push("");
+			lines.push(`**Rationale:** ${d["rationale"]}`);
+			if (d["date"]) lines.push(`**Date:** ${d["date"]}`);
+			lines.push("");
+		}
+	}
+	const annotations = f["annotations"];
+	if (annotations && annotations.length > 0) {
+		lines.push("## Annotations");
+		lines.push("");
+		for (const a of annotations) lines.push(`- **[${a["type"]}]** ${a["body"]} _(${a["author"]}, ${a["date"]})_`);
+		lines.push("");
+	}
+	const tags = f["tags"];
+	if (tags && tags.length > 0) {
+		lines.push(`**Tags:** ${tags.join(", ")}`);
+		lines.push("");
+	}
+	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) => {
+	if (options.site !== void 0) {
+		const scanDir = resolve(options.site);
+		const outDir = resolve(options.out ?? "./lac-site");
+		let features;
+		try {
+			features = await scanFeatures(scanDir);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			process$1.stderr.write(`Error scanning "${scanDir}": ${message}\n`);
+			process$1.exit(1);
+		}
+		if (features.length === 0) {
+			process$1.stdout.write(`No valid feature.json files found in "${scanDir}".\n`);
+			process$1.exit(0);
+		}
+		try {
+			await generateSite(features, outDir);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			process$1.stderr.write(`Error generating site: ${message}\n`);
+			process$1.exit(1);
+		}
+		const displayOut = options.out ?? "./lac-site";
+		process$1.stdout.write(`✓ Generated ${features.length} page${features.length === 1 ? "" : "s"} → ${displayOut}\n`);
+		return;
+	}
+	const featureJsonPath = findNearestFeatureJson(process$1.cwd());
+	if (!featureJsonPath) {
+		process$1.stderr.write(`Error: no feature.json found in the current directory or any of its parents.\n`);
+		process$1.exit(1);
+	}
+	let raw;
+	try {
+		raw = await readFile(featureJsonPath, "utf-8");
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process$1.stderr.write(`Error reading "${featureJsonPath}": ${message}\n`);
+		process$1.exit(1);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		process$1.stderr.write(`Error: "${featureJsonPath}" contains invalid JSON.\n`);
+		process$1.exit(1);
+	}
+	const result = validateFeature(parsed);
+	if (!result.success) {
+		process$1.stderr.write(`Error: "${featureJsonPath}" failed validation:\n  ${result.errors.join("\n  ")}\n`);
+		process$1.exit(1);
+	}
+	if (options.markdown) {
+		const mdOutput = featureToMarkdown(result.data);
+		if (options.out) {
+			const outPath = resolve(options.out);
+			try {
+				await writeFile(outPath, mdOutput, "utf-8");
+				process$1.stdout.write(`Exported to ${outPath}\n`);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				process$1.stderr.write(`Error writing to "${outPath}": ${message}\n`);
+				process$1.exit(1);
+			}
+		} else process$1.stdout.write(mdOutput);
+		return;
+	}
+	const output = JSON.stringify(result.data, null, 2) + "\n";
+	if (options.out) {
+		const outPath = resolve(options.out);
+		try {
+			await writeFile(outPath, output, "utf-8");
+			process$1.stdout.write(`Exported to ${outPath}\n`);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			process$1.stderr.write(`Error writing to "${outPath}": ${message}\n`);
+			process$1.exit(1);
+		}
+	} else process$1.stdout.write(output);
+});
+
+//#endregion
+//#region src/commands/hooks.ts
+const LAC_MARKER = "# managed-by-lac";
+const HOOK_SCRIPT = `#!/bin/sh
+${LAC_MARKER}
+# Provenance lint — runs lac lint before every commit.
+# To remove: run "lac hooks uninstall"
+
+# Find lac in PATH, or try npx as fallback
+if command -v lac >/dev/null 2>&1; then
+  LAC_CMD="lac"
+else
+  LAC_CMD="npx --yes lac"
+fi
+
+if ! $LAC_CMD lint --quiet 2>/tmp/lac-lint-output; then
+  echo ""
+  echo "lac pre-commit: lint failed — commit blocked"
+  # Show failing feature keys from lint output
+  if [ -s /tmp/lac-lint-output ]; then
+    grep -o 'feat-[a-z0-9]*-[0-9]*\\|[a-z][a-z0-9]*-[0-9]\\{4\\}-[0-9]*' /tmp/lac-lint-output | sort -u | while read key; do
+      echo "  ✗ $key"
+    done
+  fi
+  echo ""
+  echo "  Run \\"lac lint\\" for details."
+  echo ""
+  rm -f /tmp/lac-lint-output
+  exit 1
+fi
+rm -f /tmp/lac-lint-output
+`;
+const hooksCommand = new Command("hooks").description("Manage git hooks for provenance linting");
+hooksCommand.command("install").description("Install a pre-commit hook that runs \"lac lint\" before each commit").option("--force", "Overwrite existing pre-commit hook even if not managed by lac").action((options) => {
+	const gitDir = findGitDir(process$1.cwd());
+	if (!gitDir) {
+		process$1.stderr.write(`Error: no .git directory found. Are you inside a git repository?\n`);
+		process$1.exit(1);
+	}
+	const hooksDir = join(gitDir, "hooks");
+	const hookPath = join(hooksDir, "pre-commit");
+	if (!existsSync(hooksDir)) mkdirSync(hooksDir, { recursive: true });
+	if (existsSync(hookPath) && !options.force) {
+		if (!readFileSync(hookPath, "utf-8").includes(LAC_MARKER)) {
+			process$1.stderr.write(`Error: a pre-commit hook already exists at "${hookPath}" and was not installed by lac.\nUse --force to overwrite it.\n`);
+			process$1.exit(1);
+		}
+	}
+	writeFileSync(hookPath, HOOK_SCRIPT, "utf-8");
+	chmodSync(hookPath, 493);
+	process$1.stdout.write(`✓ Installed pre-commit hook at ${hookPath}\n`);
+	process$1.stdout.write(`  "lac lint" will run before every commit.\n`);
+	process$1.stdout.write(`  To remove: run "lac hooks uninstall"\n`);
+});
+hooksCommand.command("uninstall").description("Remove the lac-managed pre-commit hook").action(() => {
+	const gitDir = findGitDir(process$1.cwd());
+	if (!gitDir) {
+		process$1.stderr.write(`Error: no .git directory found.\n`);
+		process$1.exit(1);
+	}
+	const hookPath = join(gitDir, "hooks", "pre-commit");
+	if (!existsSync(hookPath)) {
+		process$1.stdout.write(`No pre-commit hook found at "${hookPath}".\n`);
+		return;
+	}
+	if (!readFileSync(hookPath, "utf-8").includes(LAC_MARKER)) {
+		process$1.stderr.write(`Error: the pre-commit hook at "${hookPath}" was not installed by lac.\nRemove it manually if you want to uninstall it.\n`);
+		process$1.exit(1);
+	}
+	rmSync(hookPath);
+	process$1.stdout.write(`✓ Removed lac pre-commit hook from ${hookPath}\n`);
+});
+hooksCommand.command("status").description("Show whether the lac pre-commit hook is installed").action(() => {
+	const gitDir = findGitDir(process$1.cwd());
+	if (!gitDir) {
+		process$1.stdout.write(`Not inside a git repository.\n`);
+		return;
+	}
+	const hookPath = join(gitDir, "hooks", "pre-commit");
+	if (!existsSync(hookPath)) {
+		process$1.stdout.write(`pre-commit hook: not installed\n`);
+		return;
+	}
+	if (readFileSync(hookPath, "utf-8").includes(LAC_MARKER)) process$1.stdout.write(`pre-commit hook: ✓ installed (managed by lac)\n`);
+	else process$1.stdout.write(`pre-commit hook: installed (NOT managed by lac — foreign hook)\n`);
+});
+
+//#endregion
+//#region src/lib/featureKey.ts
+/**
+* Generates a new featureKey for the given directory, honouring the `domain`
+* field from the nearest `lac.config.json`.
+*
+* @throws {Error} If no `.lac/` directory can be found in fromDir or its parents.
+*/
+function nextFeatureKey(fromDir) {
+	return generateFeatureKey(fromDir, loadConfig(fromDir).domain);
+}
+
+//#endregion
+//#region src/commands/init.ts
+/**
+* Derives a short title from a problem statement by taking the first 6 words
+* and appending "..." when truncated.
+*/
+function titleFromProblem$1(problem) {
+	const words = problem.trim().split(/\s+/);
+	if (words.length <= 6) return problem.trim();
+	return words.slice(0, 6).join(" ") + "...";
+}
+const initCommand = new Command("init").description("Scaffold a feature.json in the current directory").option("-f, --force", "Overwrite existing feature.json", false).action(async (options) => {
+	const cwd = process$1.cwd();
+	const featureJsonPath = join(cwd, "feature.json");
+	if (existsSync(featureJsonPath) && !options.force) {
+		process$1.stderr.write(`Error: feature.json already exists in this directory.\nUse --force to overwrite.\n`);
+		process$1.exit(1);
+	}
+	const answers = await prompts([{
+		type: "text",
+		name: "problem",
+		message: "What problem does this feature solve?",
+		initial: "e.g. Users cannot reset their password without contacting support",
+		validate: (value) => value.trim().length > 0 ? true : "Problem statement is required"
+	}, {
+		type: "select",
+		name: "status",
+		message: "Status?",
+		choices: [{
+			title: "draft",
+			value: "draft"
+		}, {
+			title: "active",
+			value: "active"
+		}],
+		initial: 0
+	}], { onCancel: () => {
+		process$1.stderr.write("Aborted.\n");
+		process$1.exit(1);
+	} });
+	const problem = answers.problem.trim();
+	const status = answers.status;
+	let featureKey;
+	try {
+		featureKey = nextFeatureKey(cwd);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process$1.stderr.write(`Error: ${message}\n\nTip: run "lac workspace init" first to create the .lac/ workspace.\n`);
+		process$1.exit(1);
+	}
+	const title = titleFromProblem$1(problem);
+	const wasTruncated = problem.trim().split(/\s+/).length > 6;
+	let finalTitle = title;
+	if (wasTruncated) {
+		process$1.stdout.write(`\nTitle will be: "${title}"\n`);
+		const titleAnswer = await prompts({
+			type: "text",
+			name: "customTitle",
+			message: "Custom title? (leave blank to use the above)",
+			initial: ""
+		});
+		if (titleAnswer.customTitle && titleAnswer.customTitle.trim().length > 0) finalTitle = titleAnswer.customTitle.trim();
+	}
+	const validation = validateFeature({
+		featureKey,
+		title: finalTitle,
+		status,
+		problem
+	});
+	if (!validation.success) {
+		process$1.stderr.write(`Internal error: generated feature did not pass validation:\n  ${validation.errors.join("\n  ")}\n`);
+		process$1.exit(1);
+	}
+	await writeFile(featureJsonPath, JSON.stringify(validation.data, null, 2) + "\n", "utf-8");
+	process$1.stdout.write(`✓ Created feature.json — ${featureKey}\n`);
+});
+
+//#endregion
+//#region src/commands/lineage.ts
+/**
+* Build a lineage tree rooted at the given featureKey.
+* Children are features that list this key as their lineage.parent.
+*/
+function buildTree(key, byKey, childrenOf, visited = /* @__PURE__ */ new Set()) {
+	visited.add(key);
+	const feature = byKey.get(key);
+	const childKeys = childrenOf.get(key) ?? [];
+	const children = [];
+	for (const ck of childKeys) if (!visited.has(ck)) children.push(buildTree(ck, byKey, childrenOf, visited));
+	return {
+		key,
+		status: feature?.status ?? "unknown",
+		title: feature?.title ?? "(unknown)",
+		children
+	};
+}
+/**
+* Render a FeatureNode tree as ASCII art.
+*/
+function renderTree(node, prefix = "", isLast = true) {
+	const lines = [`${prefix}${prefix === "" ? "" : isLast ? "└── " : "├── "}${node.key} (${node.status}) — ${node.title}`];
+	const childPrefix = prefix + (isLast ? "    " : "│   ");
+	for (let i = 0; i < node.children.length; i++) {
+		const child = node.children[i];
+		if (child) {
+			const childLines = renderTree(child, childPrefix, i === node.children.length - 1);
+			lines.push(...childLines);
+		}
+	}
+	return lines;
+}
+const lineageCommand = new Command("lineage").description("Show the lineage tree (parent → key → children) for a feature").argument("<key>", "featureKey to inspect (e.g. feat-2026-001)").option("-d, --dir <path>", "Directory to scan (default: cwd)").action(async (key, options) => {
+	const scanDir = options.dir ?? process$1.cwd();
+	let features;
+	try {
+		features = await scanFeatures(scanDir);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process$1.stderr.write(`Error scanning "${scanDir}": ${message}\n`);
+		process$1.exit(1);
+	}
+	const byKey = /* @__PURE__ */ new Map();
+	const childrenOf = /* @__PURE__ */ new Map();
+	for (const { feature } of features) {
+		byKey.set(feature.featureKey, feature);
+		const parent = feature.lineage?.parent;
+		if (parent) {
+			const existing = childrenOf.get(parent) ?? [];
+			existing.push(feature.featureKey);
+			childrenOf.set(parent, existing);
+		}
+	}
+	if (!byKey.has(key)) {
+		process$1.stderr.write(`Error: feature "${key}" not found in "${scanDir}"\n`);
+		process$1.exit(1);
+	}
+	let rootKey = key;
+	const seen = /* @__PURE__ */ new Set();
+	while (true) {
+		seen.add(rootKey);
+		const parent = byKey.get(rootKey)?.lineage?.parent;
+		if (!parent || !byKey.has(parent) || seen.has(parent)) break;
+		rootKey = parent;
+	}
+	const lines = renderTree(buildTree(rootKey, byKey, childrenOf));
+	process$1.stdout.write(lines.join("\n") + "\n");
+});
+
+//#endregion
+//#region src/commands/lint.ts
+function checkFeature(feature, filePath, requiredFields, threshold) {
+	const raw = feature;
+	const completeness = computeCompleteness(raw);
+	const missingRequired = requiredFields.filter((field) => {
+		const val = raw[field];
+		if (val === void 0 || val === null || val === "") return true;
+		if (Array.isArray(val)) return val.length === 0;
+		return typeof val === "string" && val.trim().length === 0;
+	});
+	const belowThreshold = threshold > 0 && completeness < threshold;
+	return {
+		featureKey: feature.featureKey,
+		filePath,
+		status: feature.status,
+		completeness,
+		missingRequired,
+		belowThreshold,
+		pass: missingRequired.length === 0 && !belowThreshold
+	};
+}
+/** Default placeholder values for auto-fix of missing required fields */
+const FIELD_DEFAULTS = {
+	problem: "TODO: describe the problem this feature solves.",
+	analysis: "",
+	decisions: [],
+	implementation: "",
+	knownLimitations: [],
+	tags: []
+};
+/**
+* Auto-repair a feature file by inserting default values for missing required fields.
+* Returns the number of fields fixed, or 0 if nothing was changed.
+*/
+async function fixFeature(filePath, missingFields) {
+	if (missingFields.length === 0) return 0;
+	let raw;
+	try {
+		raw = await readFile(filePath, "utf-8");
+	} catch {
+		return 0;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return 0;
+	}
+	let fixed = 0;
+	for (const field of missingFields) if (field in FIELD_DEFAULTS) {
+		parsed[field] = FIELD_DEFAULTS[field];
+		fixed++;
+	}
+	if (fixed === 0) return 0;
+	const validation = validateFeature(parsed);
+	if (!validation.success) return 0;
+	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 scanDir = resolve(dir ?? process$1.cwd());
+	const config = loadConfig(scanDir);
+	const requiredFields = options.require ? options.require.split(",").map((f) => f.trim()).filter(Boolean) : config.requiredFields;
+	const threshold = options.threshold !== void 0 ? options.threshold : config.ciThreshold;
+	async function runLint() {
+		let scanned;
+		try {
+			scanned = await scanFeatures(scanDir);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			process$1.stderr.write(`Error scanning "${scanDir}": ${message}\n`);
+			return 1;
+		}
+		if (scanned.length === 0) {
+			process$1.stdout.write(`No feature.json files found in "${scanDir}".\n`);
+			return 0;
+		}
+		const results = scanned.filter(({ feature }) => config.lintStatuses.includes(feature.status)).map(({ feature, filePath }) => checkFeature(feature, filePath, requiredFields, threshold));
+		if (options.fix) {
+			const toFix = results.filter((r) => !r.pass && r.missingRequired.length > 0);
+			let totalFixed = 0;
+			for (const r of toFix) {
+				const count = await fixFeature(r.filePath, r.missingRequired);
+				if (count > 0) {
+					totalFixed += count;
+					process$1.stdout.write(`  🔧  ${r.featureKey}  fixed ${count} field${count === 1 ? "" : "s"} (${r.missingRequired.join(", ")})\n`);
+				}
+			}
+			if (totalFixed === 0 && toFix.length > 0) {
+				process$1.stdout.write(`  No fields could be auto-fixed (fields may not have default values).\n`);
+				return 1;
+			}
+			if (toFix.length === 0) {
+				process$1.stdout.write(`  Nothing to fix — all required fields present.\n`);
+				return 0;
+			}
+			let rescanned;
+			try {
+				rescanned = await scanFeatures(scanDir);
+			} 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.lintStatuses.includes(feature.status)).map(({ feature, filePath }) => checkFeature(feature, filePath, requiredFields, threshold)).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;
+			}
+			process$1.stdout.write(`\n⚠ Fixed ${totalFixed} field${totalFixed === 1 ? "" : "s"} but ${stillFailing.length} feature${stillFailing.length === 1 ? "" : "s"} still fail lint:\n`);
+			for (const r of stillFailing) process$1.stdout.write(`  ✗  ${r.featureKey}  missing: ${r.missingRequired.join(", ")}\n`);
+			return 1;
+		}
+		const failures = results.filter((r) => !r.pass);
+		const passes = results.filter((r) => r.pass);
+		if (options.json) {
+			process$1.stdout.write(JSON.stringify({
+				results,
+				failures: failures.length,
+				passes: passes.length
+			}, null, 2) + "\n");
+			return failures.length > 0 ? 1 : 0;
+		}
+		const col = (s, width) => s.slice(0, width).padEnd(width);
+		if (!options.quiet || passes.length > 0) {
+			if (!options.quiet) for (const r of passes) process$1.stdout.write(`  ✓  ${col(r.featureKey, 18)} ${r.completeness.toString().padStart(3)}%  ${r.status}\n`);
+		}
+		for (const r of failures) {
+			process$1.stdout.write(`  ✗  ${col(r.featureKey, 18)} ${r.completeness.toString().padStart(3)}%  ${r.status}\n`);
+			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 (failures.length > 0) {
+			if (!options.quiet) {
+				process$1.stdout.write(`\nFailing features:\n`);
+				for (const r of failures) process$1.stdout.write(`  ${r.featureKey}  →  ${r.filePath}\n`);
+			}
+			return 1;
+		}
+		return 0;
+	}
+	if (options.watch) {
+		process$1.stdout.write(`Watching "${scanDir}"...\n\n`);
+		await runLint();
+		let debounce = null;
+		fs.watch(scanDir, { recursive: true }, (_event, filename) => {
+			if (!filename || !filename.toString().endsWith("feature.json")) return;
+			if (debounce) clearTimeout(debounce);
+			debounce = setTimeout(async () => {
+				process$1.stdout.write("\x1Bc");
+				await runLint();
+				process$1.stdout.write("\nWatching for changes...\n");
+			}, 300);
+		});
+		process$1.stdin.resume();
+		process$1.on("SIGINT", () => {
+			process$1.stdout.write("\nStopping watch.\n");
+			process$1.exit(0);
+		});
+	} else {
+		const exitCode = await runLint();
+		process$1.exit(exitCode);
+	}
+});
+
+//#endregion
+//#region src/commands/import.ts
+const importCommand = new Command("import").description("Import features from a JSON file (array of feature objects)").argument("<file>", "Path to a JSON file containing an array of feature objects").option("-d, --dir <path>", "Directory to create feature subdirectories in (default: cwd)").option("--dry-run", "Preview what would be created without writing files").option("--skip-invalid", "Skip invalid features instead of aborting").action(async (file, options) => {
+	const filePath = resolve(file);
+	const outDir = resolve(options.dir ?? process$1.cwd());
+	const dryRun = options.dryRun ?? false;
+	const skipInvalid = options.skipInvalid ?? false;
+	let raw;
+	try {
+		raw = await readFile(filePath, "utf-8");
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process$1.stderr.write(`Error reading "${filePath}": ${message}\n`);
+		process$1.exit(1);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		process$1.stderr.write(`Error: "${filePath}" contains invalid JSON.\n`);
+		process$1.exit(1);
+	}
+	if (!Array.isArray(parsed)) {
+		process$1.stderr.write(`Error: expected a JSON array of feature objects, got ${typeof parsed}.\n`);
+		process$1.exit(1);
+	}
+	const features = parsed;
+	if (features.length === 0) {
+		process$1.stdout.write(`No features in "${filePath}" — nothing to import.\n`);
+		process$1.exit(0);
+	}
+	process$1.stdout.write(`Found ${features.length} feature${features.length === 1 ? "" : "s"} in "${file}".\n`);
+	if (dryRun) process$1.stdout.write(`Dry run — no files will be written.\n\n`);
+	let imported = 0;
+	let skipped = 0;
+	for (const item of features) {
+		const result = validateFeature(item);
+		if (!result.success) {
+			const key = item?.["featureKey"] ?? "(unknown)";
+			if (skipInvalid) {
+				process$1.stderr.write(`  ⚠  ${key} — skipped (invalid): ${result.errors.join(", ")}\n`);
+				skipped++;
+				continue;
+			} else {
+				process$1.stderr.write(`  ✗  ${key} — validation failed:\n` + result.errors.map((e) => `       ${e}`).join("\n") + "\n\nAbort. Use --skip-invalid to continue past errors.\n");
+				process$1.exit(1);
+			}
+		}
+		const feature = result.data;
+		const featureDirName = feature.featureKey;
+		const featureDir = join(outDir, featureDirName);
+		const featureFilePath = join(featureDir, "feature.json");
+		if (existsSync(featureDir) && !statSync(featureDir).isDirectory()) {
+			process$1.stderr.write(`  ✗  ${feature.featureKey} — path "${featureDirName}" already exists as a file, not a directory.\n`);
+			process$1.exit(1);
+		}
+		const alreadyExists = existsSync(featureFilePath);
+		if (dryRun) {
+			process$1.stdout.write(`  Would ${alreadyExists ? "overwrite" : "create"}: ${featureDirName}/feature.json\n`);
+			imported++;
+			continue;
+		}
+		if (alreadyExists) process$1.stderr.write(`  ⚠  ${feature.featureKey} — ${featureDirName}/feature.json already exists, overwriting\n`);
+		try {
+			await mkdir(featureDir, { recursive: true });
+			await writeFile(featureFilePath, JSON.stringify(feature, null, 2) + "\n", "utf-8");
+			process$1.stdout.write(`  ✓  ${feature.featureKey} → ${featureDirName}/feature.json\n`);
+			imported++;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			process$1.stderr.write(`  ✗  ${feature.featureKey} — write failed: ${message}\n`);
+			process$1.exit(1);
+		}
+	}
+	process$1.stdout.write(`\n`);
+	if (dryRun) process$1.stdout.write(`Would import ${imported} feature${imported === 1 ? "" : "s"}.\n`);
+	else {
+		const parts = [];
+		if (imported > 0) parts.push(`${imported} imported`);
+		if (skipped > 0) parts.push(`${skipped} skipped`);
+		process$1.stdout.write(`Done: ${parts.join(", ")}.\n`);
+	}
+});
+
+//#endregion
+//#region src/commands/rename.ts
+/**
+* Patches all featureJson files that reference oldKey in their lineage.parent
+* or lineage.children to use newKey instead.
+*/
+async function patchLineageRefs(features, oldKey, newKey) {
+	let patched = 0;
+	for (const { feature, filePath } of features) {
+		let changed = false;
+		const data = { ...feature };
+		const lineage = data["lineage"];
+		if (!lineage) continue;
+		const updatedLineage = { ...lineage };
+		if (updatedLineage.parent === oldKey) {
+			updatedLineage.parent = newKey;
+			changed = true;
+		}
+		if (Array.isArray(updatedLineage.children) && updatedLineage.children.includes(oldKey)) {
+			updatedLineage.children = updatedLineage.children.map((c) => c === oldKey ? newKey : c);
+			changed = true;
+		}
+		if (changed) {
+			data["lineage"] = updatedLineage;
+			const validation = validateFeature(data);
+			if (validation.success) {
+				await writeFile(filePath, JSON.stringify(validation.data, null, 2) + "\n", "utf-8");
+				patched++;
+			}
+		}
+	}
+	return patched;
+}
+const renameCommand = new Command("rename").description("Rename a featureKey — updates the feature.json and patches all lineage references").argument("<old-key>", "Current featureKey (e.g. feat-2026-001)").argument("<new-key>", "New featureKey (e.g. feat-2026-099)").option("-d, --dir <path>", "Directory to scan for features (default: cwd)").option("--dry-run", "Preview changes without writing files").action(async (oldKey, newKey, options) => {
+	if (!FEATURE_KEY_PATTERN.test(newKey)) {
+		process$1.stderr.write(`Error: "${newKey}" is not a valid featureKey.\nKeys must match the pattern <domain>-YYYY-NNN (e.g. feat-2026-099).\n`);
+		process$1.exit(1);
+	}
+	if (oldKey === newKey) {
+		process$1.stderr.write(`Error: old and new keys are identical ("${oldKey}").\n`);
+		process$1.exit(1);
+	}
+	const scanDir = options.dir ?? process$1.cwd();
+	const dryRun = options.dryRun ?? false;
+	let features;
+	try {
+		features = await scanFeatures(scanDir);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process$1.stderr.write(`Error scanning "${scanDir}": ${message}\n`);
+		process$1.exit(1);
+	}
+	const target = features.find((f) => f.feature.featureKey === oldKey);
+	if (!target) {
+		process$1.stderr.write(`Error: feature "${oldKey}" not found in "${scanDir}".\n`);
+		process$1.exit(1);
+	}
+	const conflict = features.find((f) => f.feature.featureKey === newKey);
+	if (conflict) {
+		process$1.stderr.write(`Error: "${newKey}" is already used by "${path.relative(scanDir, conflict.filePath)}".\n`);
+		process$1.exit(1);
+	}
+	const lineageRefs = features.filter(({ feature }) => {
+		const lineage = feature.lineage;
+		return lineage?.parent === oldKey || Array.isArray(lineage?.children) && lineage.children.includes(oldKey);
+	});
+	if (dryRun) {
+		process$1.stdout.write(`Dry run — no files will be written.\n\n`);
+		process$1.stdout.write(`Would rename: ${oldKey} → ${newKey}\n`);
+		process$1.stdout.write(`  File: ${path.relative(scanDir, target.filePath)}\n`);
+		if (lineageRefs.length > 0) {
+			process$1.stdout.write(`\nWould patch ${lineageRefs.length} lineage reference(s):\n`);
+			for (const ref of lineageRefs) process$1.stdout.write(`  ${path.relative(scanDir, ref.filePath)}\n`);
+		}
+		return;
+	}
+	const raw = await readFile(target.filePath, "utf-8");
+	const parsed = JSON.parse(raw);
+	parsed["featureKey"] = newKey;
+	const validation = validateFeature(parsed);
+	if (!validation.success) {
+		process$1.stderr.write(`Internal error: renamed feature failed validation:\n  ${validation.errors.join("\n  ")}\n`);
+		process$1.exit(1);
+	}
+	await writeFile(target.filePath, JSON.stringify(validation.data, null, 2) + "\n", "utf-8");
+	process$1.stdout.write(`✓ Renamed ${oldKey} → ${newKey}\n`);
+	const patched = await patchLineageRefs(features, oldKey, newKey);
+	if (patched > 0) process$1.stdout.write(`✓ Patched ${patched} lineage reference${patched === 1 ? "" : "s"}\n`);
+	let lacDir = null;
+	let cur = path.resolve(scanDir);
+	while (true) {
+		const candidate = path.join(cur, ".lac");
+		if (existsSync(candidate)) {
+			lacDir = candidate;
+			break;
+		}
+		const parent = path.dirname(cur);
+		if (parent === cur) break;
+		cur = parent;
+	}
+	if (lacDir) {
+		const keysPath = path.join(lacDir, "keys");
+		if (existsSync(keysPath)) {
+			const updated = readFileSync(keysPath, "utf-8").trim().split("\n").filter(Boolean).map((k) => k === oldKey ? newKey : k);
+			if (!updated.includes(newKey)) updated.push(newKey);
+			writeFileSync(keysPath, updated.join("\n") + "\n", "utf-8");
+			process$1.stdout.write(`✓ Updated .lac/keys registry\n`);
+		}
+	}
+});
+
+//#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 searchFields = options.field ? options.field.split(",").map((f) => f.trim()) : [
+		"featureKey",
+		"title",
+		"problem",
+		"tags",
+		"analysis",
+		"implementation"
+	];
+	const q = query.toLowerCase();
+	const matches = features.filter(({ feature }) => {
+		for (const field of searchFields) {
+			const val = feature[field];
+			if (val === void 0 || val === null) continue;
+			if (typeof val === "string" && val.toLowerCase().includes(q)) return true;
+			if (Array.isArray(val) && val.some((v) => typeof v === "string" && v.toLowerCase().includes(q))) return true;
+		}
+		return false;
+	});
+	if (options.json) {
+		process$1.stdout.write(JSON.stringify(matches.map((m) => m.feature), null, 2) + "\n");
+		return;
+	}
+	if (matches.length === 0) {
+		process$1.stdout.write(`No features found matching "${query}"\n`);
+		return;
+	}
+	process$1.stdout.write(`Found ${matches.length} feature(s) matching "${query}":\n\n`);
+	for (const { feature, filePath } of matches) {
+		const statusIcon = {
+			active: "⊙",
+			draft: "◌",
+			frozen: "❄",
+			deprecated: "⊘"
+		}[feature.status] ?? "?";
+		process$1.stdout.write(`  ${statusIcon}  ${feature.featureKey.padEnd(18)} ${feature.title}\n`);
+		process$1.stdout.write(`     ${feature.problem.slice(0, 80)}${feature.problem.length > 80 ? "..." : ""}\n`);
+		process$1.stdout.write(`     ${filePath}\n\n`);
+	}
+});
+
+//#endregion
+//#region src/commands/serve.ts
+function openBrowser(url) {
+	if (process$1.platform === "darwin") spawn("open", [url], {
+		detached: true,
+		stdio: "ignore"
+	}).unref();
+	else if (process$1.platform === "win32") spawn("cmd", [
+		"/c",
+		"start",
+		"",
+		url
+	], {
+		detached: true,
+		stdio: "ignore"
+	}).unref();
+	else spawn("xdg-open", [url], {
+		detached: true,
+		stdio: "ignore"
+	}).unref();
+}
+function waitForServer(port, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	return new Promise((res) => {
+		function attempt() {
+			const req = http.get(`http://127.0.0.1:${port}/health`, (response) => {
+				res(response.statusCode === 200);
+			});
+			req.on("error", () => {
+				if (Date.now() < deadline) setTimeout(attempt, 250);
+				else res(false);
+			});
+			req.end();
+		}
+		attempt();
+	});
+}
+function spawnServer(workspaceDir, port) {
+	return spawn("lac-lsp", [
+		"--http-only",
+		"--workspace",
+		workspaceDir,
+		"--port",
+		String(port)
+	], { stdio: [
+		"ignore",
+		"inherit",
+		"inherit"
+	] });
+}
+const serveCommand = new Command("serve").description("Start the life-as-code HTTP server and open the dashboard in your browser").argument("[dir]", "Workspace root to index (default: current directory)").option("-p, --port <n>", "HTTP port (default: 7474)", "7474").option("--no-open", "Skip opening the browser automatically").action(async (dir, options) => {
+	const workspaceDir = resolve(dir ?? process$1.cwd());
+	const port = parseInt(options.port, 10);
+	const url = `http://127.0.0.1:${port}`;
+	process$1.stdout.write(`Starting lac-lsp HTTP server for workspace "${workspaceDir}" on port ${port}...\n`);
+	let child = spawnServer(workspaceDir, port);
+	let shuttingDown = false;
+	child.on("error", (err) => {
+		process$1.stderr.write(`Error: could not start lac-lsp — ${err.message}\n`);
+		process$1.stderr.write(`Make sure lac-lsp is installed: npm i -g @life-as-code/lac-lsp\n`);
+		process$1.exit(1);
+	});
+	child.on("exit", (code) => {
+		if (!shuttingDown) process$1.stderr.write(`lac-lsp exited with code ${code ?? 0}\n`);
+	});
+	if (await waitForServer(port, 6e3)) {
+		process$1.stdout.write(`\nReady — ${url}\n\n`);
+		process$1.stdout.write(`  GET ${url}/features     all indexed features\n`);
+		process$1.stdout.write(`  GET ${url}/lint         run lint against all features\n`);
+		process$1.stdout.write(`  GET ${url}/events       SSE stream of changes\n\n`);
+		process$1.stdout.write(`Press Ctrl+C to stop.\n`);
+		if (options.open) openBrowser(url);
+	} else process$1.stderr.write(`Warning: server on port ${port} did not respond within 6 s — it may still be starting up.\n`);
+	let failCount = 0;
+	const healthInterval = setInterval(async () => {
+		if (shuttingDown) {
+			clearInterval(healthInterval);
+			return;
+		}
+		if (await waitForServer(port, 2e3)) {
+			failCount = 0;
+			return;
+		}
+		failCount++;
+		if (failCount >= 3) {
+			process$1.stderr.write(`\nWarning: lac-lsp appears to have crashed. Restarting...\n`);
+			try {
+				child.kill();
+			} catch {}
+			child = spawnServer(workspaceDir, port);
+			failCount = 0;
+			child.on("error", (err) => {
+				process$1.stderr.write(`Error restarting lac-lsp — ${err.message}\n`);
+			});
+			if (await waitForServer(port, 6e3)) {
+				process$1.stdout.write(`lac-lsp restarted successfully.\n`);
+				if (options.open) openBrowser(url);
+			} else process$1.stderr.write(`Warning: lac-lsp did not come back up after restart.\n`);
+		}
+	}, 15e3);
+	process$1.on("SIGINT", () => {
+		shuttingDown = true;
+		clearInterval(healthInterval);
+		process$1.stdout.write("\nShutting down...\n");
+		child.kill("SIGTERM");
+		process$1.exit(0);
+	});
+});
+
+//#endregion
+//#region src/commands/spawn.ts
+const LAC_DIR$1 = ".lac";
+/**
+* Walk up from startDir looking for a .lac/ directory.
+* Returns the absolute path to the workspace root (the dir containing .lac/) or null.
+*/
+function findWorkspaceRoot(startDir) {
+	let current = resolve(startDir);
+	while (true) {
+		if (existsSync(join(current, LAC_DIR$1))) return current;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+/**
+* Derives a short title from a problem statement by taking the first 6 words
+* and appending "..." when truncated.
+*/
+function titleFromProblem(problem) {
+	const words = problem.trim().split(/\s+/);
+	if (words.length <= 6) return problem.trim();
+	return words.slice(0, 6).join(" ") + "...";
+}
+/**
+* Slugifies the first 3 words of a string into kebab-case for use as a
+* default subdirectory name.
+*/
+function slugifyProblem(problem) {
+	return problem.trim().split(/\s+/).slice(0, 3).join("-").toLowerCase().replace(/[^a-z0-9-]/g, "");
+}
+const spawnCommand = new Command("spawn").description("Spawn a child feature from an existing parent feature").argument("<parent-key>", "featureKey of the parent feature (e.g. feat-2026-001)").option("--reason <text>", "Reason for spawning (default: empty)").option("--dir <name>", "Subdirectory name under parent dir (default: slug of problem)").action(async (parentKey, options) => {
+	const workspaceRoot = findWorkspaceRoot(process$1.cwd());
+	if (!workspaceRoot) {
+		process$1.stderr.write("Error: No .lac/ workspace found in current directory or any parent.\nRun \"lac workspace init\" to create one.\n");
+		process$1.exit(1);
+	}
+	let scanned;
+	try {
+		scanned = await scanFeatures(workspaceRoot);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process$1.stderr.write(`Error scanning workspace "${workspaceRoot}": ${message}\n`);
+		process$1.exit(1);
+	}
+	const parentEntry = scanned.find((s) => s.feature.featureKey === parentKey);
+	if (!parentEntry) {
+		process$1.stderr.write(`Error: parent feature "${parentKey}" not found in workspace.\nRun "lac blame" or check your .lac/keys file to see available feature keys.\n`);
+		process$1.exit(1);
+	}
+	const parentDir = dirname(parentEntry.filePath);
+	const answers = await prompts([{
+		type: "text",
+		name: "problem",
+		message: "What problem does this new feature solve?",
+		validate: (value) => value.trim().length > 0 ? true : "Problem statement is required"
+	}, {
+		type: "select",
+		name: "status",
+		message: "Status?",
+		choices: [{
+			title: "draft",
+			value: "draft"
+		}, {
+			title: "active",
+			value: "active"
+		}],
+		initial: 0
+	}], { onCancel: () => {
+		process$1.stderr.write("Aborted.\n");
+		process$1.exit(1);
+	} });
+	const reason = options.reason ?? "";
+	const problem = answers.problem.trim();
+	const status = answers.status;
+	let subdirName;
+	if (options.dir) subdirName = options.dir;
+	else {
+		const baseSlug = slugifyProblem(problem);
+		subdirName = baseSlug;
+		let suffix = 1;
+		while (existsSync(join(parentDir, subdirName))) {
+			suffix++;
+			subdirName = `${baseSlug}-${suffix}`;
+		}
+	}
+	const newFeatureDir = join(parentDir, subdirName);
+	await mkdir(newFeatureDir, { recursive: true });
+	let featureKey;
+	try {
+		featureKey = nextFeatureKey(newFeatureDir);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process$1.stderr.write(`Error: ${message}\n\nTip: run "lac workspace init" first to create the .lac/ workspace.\n`);
+		process$1.exit(1);
+	}
+	const title = titleFromProblem(problem);
+	const validation = validateFeature({
+		featureKey,
+		title,
+		status,
+		problem,
+		lineage: {
+			parent: parentKey,
+			...reason ? { spawnReason: reason } : {}
+		}
+	});
+	if (!validation.success) {
+		process$1.stderr.write(`Internal error: generated feature did not pass validation:\n  ${validation.errors.join("\n  ")}\n`);
+		process$1.exit(1);
+	}
+	await writeFile(join(newFeatureDir, "feature.json"), JSON.stringify(validation.data, null, 2) + "\n", "utf-8");
+	process$1.stdout.write(`✓ Spawned ${featureKey} from ${parentKey} in ${newFeatureDir}\n`);
+});
+
+//#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 scanDir = options.dir ?? process$1.cwd();
+	let features;
+	try {
+		features = await scanFeatures(scanDir);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process$1.stderr.write(`Error scanning "${scanDir}": ${message}\n`);
+		process$1.exit(1);
+	}
+	const total = features.length;
+	if (total === 0) {
+		process$1.stdout.write(`No features found in "${scanDir}".\n`);
+		process$1.stdout.write(`Run "lac init" in a subdirectory to create your first feature.\n`);
+		return;
+	}
+	const statusBreakdown = {
+		active: 0,
+		draft: 0,
+		frozen: 0,
+		deprecated: 0
+	};
+	for (const { feature } of features) {
+		const s = feature.status;
+		statusBreakdown[s] = (statusBreakdown[s] ?? 0) + 1;
+	}
+	const completenessValues = features.map(({ feature }) => computeCompleteness(feature));
+	const avgCompleteness = completenessValues.length > 0 ? Math.round(completenessValues.reduce((a, b) => a + b, 0) / completenessValues.length) : 0;
+	const zeroDecisions = features.filter(({ feature }) => !feature.decisions || feature.decisions.length === 0).length;
+	const zeroTags = features.filter(({ feature }) => !feature.tags || feature.tags.length === 0).length;
+	const tagCounts = /* @__PURE__ */ new Map();
+	for (const { feature } of features) for (const tag of feature.tags ?? []) tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+	const topTags = Array.from(tagCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5);
+	const lines = [];
+	lines.push("lac stat — workspace statistics");
+	lines.push("================================");
+	lines.push("");
+	lines.push(`Total features : ${total}`);
+	lines.push("");
+	lines.push("By status:");
+	for (const [status, count] of Object.entries(statusBreakdown)) if (count > 0) lines.push(`  ${status.padEnd(12)}: ${count}`);
+	lines.push("");
+	lines.push(`Avg completeness  : ${avgCompleteness}%`);
+	lines.push(`No decisions      : ${zeroDecisions}`);
+	lines.push(`No tags           : ${zeroTags}`);
+	if (topTags.length > 0) {
+		lines.push("");
+		lines.push("Top 5 tags:");
+		for (const [tag, count] of topTags) lines.push(`  ${tag.padEnd(20)}: ${count}`);
+	}
+	process$1.stdout.write(lines.join("\n") + "\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) => {
+	const scanDir = options.dir ?? process$1.cwd();
+	const found = (await scanFeatures(scanDir)).find((f) => f.feature.featureKey === key);
+	if (!found) {
+		process$1.stderr.write(`Error: feature "${key}" not found in "${scanDir}"\n`);
+		process$1.exit(1);
+	}
+	const tagList = tags.split(",").map((t) => t.trim()).filter(Boolean);
+	const toAdd = tagList.filter((t) => !t.startsWith("-"));
+	const toRemove = tagList.filter((t) => t.startsWith("-")).map((t) => t.slice(1));
+	const current = found.feature.tags ?? [];
+	for (const tag of toAdd) if (current.includes(tag)) process$1.stdout.write(`Note: tag "${tag}" already present\n`);
+	for (const tag of toRemove) if (!current.includes(tag)) process$1.stdout.write(`Note: tag "${tag}" was not present\n`);
+	const updated = [...new Set([...current.filter((t) => !toRemove.includes(t)), ...toAdd])];
+	const raw = await readFile(found.filePath, "utf-8");
+	const parsed = JSON.parse(raw);
+	parsed["tags"] = updated;
+	const validation = validateFeature(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} tags: [${updated.join(", ")}]\n`);
+});
+
+//#endregion
+//#region src/commands/workspace.ts
+const LAC_DIR = ".lac";
+const COUNTER_FILE = "counter";
+/**
+* Walk up from startDir looking for a .lac/ directory.
+* Returns the absolute path to .lac/ or null if not found.
+*/
+function findLacDir(startDir) {
+	let current = resolve(startDir);
+	while (true) {
+		const candidate = join(current, LAC_DIR);
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+const workspaceCommand = new Command("workspace").description("Manage the lac workspace (.lac/ directory)");
+workspaceCommand.command("init").description("Initialise a lac workspace in the current directory").argument("[dir]", "Directory to initialise (default: current directory)").option("--force", "Re-initialise even if a .lac/ directory already exists").action((dir, options) => {
+	const lacDir = join(resolve(dir ?? process$1.cwd()), LAC_DIR);
+	const counterPath = join(lacDir, COUNTER_FILE);
+	if (existsSync(lacDir) && !options.force) {
+		process$1.stdout.write(`lac workspace already initialised at "${lacDir}".\nRun "lac workspace init --force" to reinitialise.\n`);
+		return;
+	}
+	mkdirSync(lacDir, { recursive: true });
+	if (!existsSync(counterPath) || options.force) writeFileSync(counterPath, `${(/* @__PURE__ */ new Date()).getFullYear()}\n0\n`, "utf-8");
+	process$1.stdout.write(`✓ Initialised lac workspace at "${lacDir}"\n`);
+	process$1.stdout.write(`  Run "lac init" inside a feature folder to create a feature.json.\n`);
+});
+workspaceCommand.command("status").description("Show workspace info (location, counter, next key, feature stats)").action(async () => {
+	const lacDir = findLacDir(process$1.cwd());
+	if (!lacDir) {
+		process$1.stdout.write("No .lac/ workspace found in current directory or any parent.\nRun \"lac workspace init\" to create one.\n");
+		return;
+	}
+	const counterPath = join(lacDir, COUNTER_FILE);
+	if (!existsSync(counterPath)) {
+		process$1.stdout.write(`Workspace : ${lacDir}\nCounter   : not initialised\n`);
+		return;
+	}
+	const lines = readFileSync(counterPath, "utf-8").trim().split("\n").map((l) => l.trim());
+	const year = lines[0] ?? "?";
+	const counterStr = lines[1] ?? "0";
+	const counter = parseInt(counterStr, 10);
+	const next = isNaN(counter) ? "001" : String(counter + 1).padStart(3, "0");
+	process$1.stdout.write(`Workspace : ${lacDir}\n`);
+	process$1.stdout.write(`Counter   : ${year}/${counterStr}\n`);
+	process$1.stdout.write(`Next key  : feat-${year}-${next}\n`);
+	const workspaceRoot = resolve(lacDir, "..");
+	try {
+		const features = await scanFeatures(workspaceRoot);
+		process$1.stdout.write(`Features  : ${features.length}\n`);
+		if (features.length === 0) process$1.stdout.write(`\nNo features found. Run "lac init" in a subdirectory to create your first feature.\n`);
+		else {
+			const completenessValues = features.map(({ feature }) => computeCompleteness(feature));
+			const avg = Math.round(completenessValues.reduce((a, b) => a + b, 0) / completenessValues.length);
+			process$1.stdout.write(`Avg compl.: ${avg}%\n`);
+		}
+	} catch {}
+});
+
+//#endregion
+//#region src/index.ts
+const program = new Command();
+program.name("lac").description("life-as-code CLI — provenance for your features").version("0.1.0");
+program.addCommand(workspaceCommand);
+program.addCommand(spawnCommand);
+program.addCommand(initCommand);
+program.addCommand(exportCommand);
+program.addCommand(lintCommand);
+program.addCommand(blameCommand);
+program.addCommand(hooksCommand);
+program.addCommand(serveCommand);
+program.addCommand(tagCommand);
+program.addCommand(archiveCommand);
+program.addCommand(doctorCommand);
+program.addCommand(searchCommand);
+program.addCommand(statCommand);
+program.addCommand(lineageCommand);
+program.addCommand(diffCommand);
+program.addCommand(renameCommand);
+program.addCommand(importCommand);
+program.parse();
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.mjs.map