@dall337/lore 0.0.0-stage → 0.1.0

package/hud/dist/server/main.js

@@ -0,0 +1,1287 @@
+import { existsSync, mkdirSync, promises, readFileSync, readdirSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash, randomUUID } from "node:crypto";
+import { execFile, execFileSync } from "node:child_process";
+import { createServer, get } from "node:http";
+//#region hud/shared/boardOps.ts
+/**
+* Move a card to `index` within `column` (index counts only that column's
+* cards). Card order lives in the flat `cards` array. Shared so the page's
+* optimistic move and the server's write can never disagree.
+*/
+function applyMove(board, id, column, index, today) {
+	const card = board.cards.find((c) => c.id === id);
+	if (!card) throw new Error(`no card with id "${id}"`);
+	if (!board.columns.some((c) => c.id === column)) throw new Error(`unknown column "${column}"`);
+	board.cards.splice(board.cards.indexOf(card), 1);
+	const target = board.cards.filter((c) => c.column === column);
+	const at = Math.max(0, Math.min(Number.isFinite(index) ? index : target.length, target.length));
+	if (card.column !== column) card.updated = today;
+	card.column = column;
+	if (at < target.length) board.cards.splice(board.cards.indexOf(target[at]), 0, card);
+	else if (target.length > 0) board.cards.splice(board.cards.indexOf(target[target.length - 1]) + 1, 0, card);
+	else board.cards.push(card);
+}
+/** The column carrying a role, if the board assigns it. */
+var columnWithRole = (board, role) => board.columns.find((c) => c.role === role);
+var shiftDays = (date, days) => new Date(Date.parse(date) + days * 864e5).toISOString().slice(0, 10);
+/**
+* The PRs a journal's text points at that belong to ITS work: opened from the
+* day before the journal started to three weeks after. Older numbers in the
+* text are citations of earlier work, not this journal's PRs.
+*/
+function ownPrs(j, prs) {
+	const from = shiftDays(j.date, -1);
+	const to = shiftDays(j.date, 21);
+	const out = [];
+	for (const n of j.prRefs) {
+		const p = prs.get(n);
+		const opened = p?.createdAt?.slice(0, 10);
+		if (p && opened && opened >= from && opened <= to) out.push(p);
+	}
+	return out;
+}
+/** "fix(scaffold): yarn installs…" → "Yarn installs…" */
+function cleanPrTitle(title) {
+	const t = title.replace(/^[a-z]+(\([^)]*\))?!?:\s*/i, "").trim() || title;
+	return t.charAt(0).toUpperCase() + t.slice(1);
+}
+/** "2026-10-01 — P4: `x`" / "Review (2026-10-05)" / "X — 2026-10-07" → the bare name. */
+function cleanJournalTitle(title) {
+	return title.replace(/^\d{4}-\d{2}-\d{2}\s*[—–-]\s*/, "").replace(/\s*[—–-]\s*\(?\d{4}-\d{2}-\d{2}\)?\s*$/, "").replace(/\s*\(\d{4}-\d{2}-\d{2}\)\s*$/, "").replace(/`/g, "").trim() || title;
+}
+var INBOX_KEY = /^(pr|issue):\d+$|^journal:[\w.-]+\.md$/;
+/** Where an Inbox kind lands: the first role the board assigns, else the first column. */
+function landing(board, roles) {
+	for (const role of roles) {
+		const col = columnWithRole(board, role);
+		if (col) return col.id;
+	}
+	return board.columns[0].id;
+}
+function inboxItems(board, journals, prs, issues) {
+	const prMap = new Map(prs.map((p) => [p.number, p]));
+	const dismissed = new Set(board.inboxDismissed ?? []);
+	const linkedPrs = /* @__PURE__ */ new Set();
+	const linkedIssues = /* @__PURE__ */ new Set();
+	const linkedJournals = /* @__PURE__ */ new Set();
+	for (const c of board.cards) {
+		c.links?.prs?.forEach((n) => linkedPrs.add(n));
+		c.links?.issues?.forEach((n) => linkedIssues.add(n));
+		c.links?.journals?.forEach((f) => linkedJournals.add(f));
+	}
+	const own = new Map(journals.map((j) => [j.file, ownPrs(j, prMap)]));
+	for (const f of linkedJournals) own.get(f)?.forEach((p) => linkedPrs.add(p.number));
+	const prColumn = landing(board, ["review", "active"]);
+	const journalColumn = landing(board, ["active"]);
+	const issueColumn = landing(board, ["intake"]);
+	const active = journals.filter((j) => j.status === "open");
+	const items = [];
+	const prItems = /* @__PURE__ */ new Set();
+	for (const p of prs) {
+		if (p.state !== "OPEN" || linkedPrs.has(p.number) || dismissed.has(`pr:${p.number}`)) continue;
+		const withJournals = active.filter((j) => own.get(j.file)?.some((x) => x.number === p.number)).map((j) => j.file);
+		prItems.add(p.number);
+		items.push({
+			key: `pr:${p.number}`,
+			kind: "pr",
+			label: `#${p.number}`,
+			title: p.title,
+			when: p.updatedAt,
+			url: p.url,
+			suggest: {
+				title: cleanPrTitle(p.title),
+				column: prColumn,
+				links: {
+					prs: [p.number],
+					...withJournals.length ? { journals: withJournals } : {}
+				}
+			}
+		});
+	}
+	for (const j of active) {
+		if (linkedJournals.has(j.file) || dismissed.has(`journal:${j.file}`)) continue;
+		const mine = own.get(j.file) ?? [];
+		if (mine.some((p) => linkedPrs.has(p.number) || prItems.has(p.number))) continue;
+		items.push({
+			key: `journal:${j.file}`,
+			kind: "journal",
+			label: j.date,
+			title: j.title,
+			when: j.modified,
+			file: j.file,
+			suggest: {
+				title: cleanJournalTitle(j.title),
+				column: journalColumn,
+				links: {
+					journals: [j.file],
+					...mine.length ? { prs: mine.map((p) => p.number) } : {}
+				}
+			}
+		});
+	}
+	for (const i of issues) {
+		if (i.state !== "OPEN" || linkedIssues.has(i.number) || dismissed.has(`issue:${i.number}`)) continue;
+		items.push({
+			key: `issue:${i.number}`,
+			kind: "issue",
+			label: `#${i.number}`,
+			title: i.title,
+			when: i.updatedAt,
+			url: i.url,
+			suggest: {
+				title: i.title,
+				column: issueColumn,
+				links: { issues: [i.number] }
+			}
+		});
+	}
+	return items.sort((a, b) => b.when.localeCompare(a.when));
+}
+//#endregion
+//#region hud/shared/types.ts
+var COLUMN_ROLES = [
+	"intake",
+	"active",
+	"review",
+	"blocked",
+	"done"
+];
+//#endregion
+//#region hud/server/board.ts
+var BoardError = class extends Error {
+	status;
+	constructor(message, status = 400) {
+		super(message);
+		this.status = status;
+	}
+};
+var today = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+var DEFAULT_COLUMNS = [
+	{
+		id: "backlog",
+		title: "Backlog",
+		led: "empty",
+		hint: "Captured, not sequenced",
+		role: "intake"
+	},
+	{
+		id: "next",
+		title: "Next",
+		led: "blue",
+		hint: "Sequenced, ready to start"
+	},
+	{
+		id: "doing",
+		title: "In progress",
+		led: "pulse",
+		hint: "Active now",
+		role: "active"
+	},
+	{
+		id: "review",
+		title: "Waiting on owner",
+		led: "amber",
+		hint: "Reviews, rulings, merges",
+		role: "review"
+	},
+	{
+		id: "blocked",
+		title: "Blocked",
+		led: "red",
+		hint: "External dependency",
+		role: "blocked"
+	},
+	{
+		id: "done",
+		title: "Done",
+		led: "green",
+		hint: "Merged or shipped",
+		role: "done"
+	}
+];
+var LEDS = /* @__PURE__ */ new Set([
+	"empty",
+	"blue",
+	"pulse",
+	"amber",
+	"red",
+	"green"
+]);
+var emptyBoard = () => ({
+	version: 1,
+	columns: structuredClone(DEFAULT_COLUMNS),
+	cards: [],
+	areas: {},
+	journals: {}
+});
+function validate(raw) {
+	const fail = (message) => {
+		throw new BoardError(`board.json: ${message}`, 500);
+	};
+	if (!raw || typeof raw !== "object") fail("not an object");
+	const b = raw;
+	if (!Array.isArray(b.columns) || b.columns.length === 0) fail("\"columns\" must be a non-empty array");
+	if (!Array.isArray(b.cards)) fail("\"cards\" must be an array");
+	const columnIds = /* @__PURE__ */ new Set();
+	const roles = /* @__PURE__ */ new Set();
+	for (const col of b.columns) {
+		if (!col || typeof col.id !== "string" || typeof col.title !== "string") fail("every column needs a string \"id\" and \"title\"");
+		if (columnIds.has(col.id)) fail(`duplicate column id "${col.id}"`);
+		columnIds.add(col.id);
+		if (!LEDS.has(col.led)) fail(`column "${col.id}" has unknown led "${String(col.led)}"`);
+		if (col.role !== void 0) {
+			if (!COLUMN_ROLES.includes(col.role)) fail(`column "${col.id}" has unknown role "${String(col.role)}" (${COLUMN_ROLES.join(", ")})`);
+			if (roles.has(col.role)) fail(`role "${col.role}" is on more than one column`);
+			roles.add(col.role);
+		}
+	}
+	if (b.areas !== void 0 && (!b.areas || typeof b.areas !== "object" || Array.isArray(b.areas) || Object.values(b.areas).some((v) => typeof v !== "string"))) fail("\"areas\" must map area keys to descriptions");
+	const seen = /* @__PURE__ */ new Set();
+	for (const card of b.cards) {
+		if (!card || typeof card.id !== "string" || typeof card.title !== "string") fail("every card needs a string \"id\" and \"title\"");
+		if (seen.has(card.id)) fail(`duplicate card id "${card.id}"`);
+		seen.add(card.id);
+		if (!columnIds.has(card.column)) fail(`card "${card.id}" is in unknown column "${card.column}"`);
+		if (card.area !== void 0 && !(Array.isArray(card.area) && card.area.every((a) => typeof a === "string"))) fail(`card "${card.id}": "area" must be an array of area keys`);
+	}
+	if (b.inboxDismissed !== void 0 && !(Array.isArray(b.inboxDismissed) && b.inboxDismissed.every((k) => typeof k === "string"))) fail("\"inboxDismissed\" must be an array of strings");
+	return {
+		...b,
+		version: 1,
+		columns: b.columns,
+		cards: b.cards,
+		journals: b.journals ?? {}
+	};
+}
+function createBoardStore(boardPath) {
+	let queue = Promise.resolve();
+	/** Text of our own last write — lets the file watcher ignore self-writes. */
+	let lastWritten = "";
+	/** `create: false` reports a missing board as null instead of seeding one. */
+	async function load(create) {
+		let text;
+		try {
+			text = await promises.readFile(boardPath, "utf8");
+		} catch (err) {
+			if (err.code !== "ENOENT") throw err;
+			if (!create) return null;
+			const fresh = emptyBoard();
+			await write(fresh);
+			return fresh;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(text.replace(/^/, ""));
+		} catch (err) {
+			throw new BoardError(`board.json is not valid JSON: ${err.message}`, 500);
+		}
+		return validate(parsed);
+	}
+	const read = async () => await load(true);
+	async function write(board) {
+		const text = JSON.stringify(board, null, 2) + "\n";
+		const tmp = `${boardPath}.tmp`;
+		await promises.mkdir(path.dirname(boardPath), { recursive: true });
+		await promises.writeFile(tmp, text, "utf8");
+		lastWritten = text;
+		for (let attempt = 0;; attempt++) try {
+			await promises.rename(tmp, boardPath);
+			return;
+		} catch (err) {
+			if (attempt >= 4) throw err;
+			await new Promise((r) => setTimeout(r, 60 * (attempt + 1)));
+		}
+	}
+	/** Serialize read-modify-write operations. */
+	function mutate(op) {
+		const run = queue.then(async () => {
+			const board = await read();
+			op(board);
+			validate(board);
+			await write(board);
+			return board;
+		});
+		queue = run.catch(() => void 0);
+		return run;
+	}
+	function findCard(board, id) {
+		const card = board.cards.find((c) => c.id === id);
+		if (!card) throw new BoardError(`no card with id "${id}"`, 404);
+		return card;
+	}
+	return {
+		read,
+		peek: () => load(false),
+		isOwnWrite: (text) => text === lastWritten,
+		move(id, column, index) {
+			return mutate((board) => {
+				if (!board.columns.some((c) => c.id === column)) throw new BoardError(`unknown column "${column}"`);
+				findCard(board, id);
+				applyMove(board, id, column, index, today());
+			});
+		},
+		/**
+		* Create or merge-update a card. A field left out keeps the card's value
+		* (title and column included); a `null` field clears it.
+		*/
+		upsert(input) {
+			return mutate((board) => {
+				const existing = input.id ? board.cards.find((c) => c.id === input.id) : void 0;
+				const title = (input.title ?? existing?.title ?? "").trim();
+				if (!title) throw new BoardError("a card needs a title");
+				const column = input.column ?? existing?.column ?? board.columns[0].id;
+				if (!board.columns.some((c) => c.id === column)) throw new BoardError(`unknown column "${column}"`);
+				const card = existing ?? {
+					id: input.id || randomUUID(),
+					created: today()
+				};
+				Object.assign(card, input, {
+					id: card.id,
+					title,
+					column,
+					updated: today()
+				});
+				for (const key of Object.keys(card)) if (card[key] === null) delete card[key];
+				if (!existing) board.cards.push(card);
+			});
+		},
+		remove(id) {
+			return mutate((board) => {
+				const card = findCard(board, id);
+				board.cards.splice(board.cards.indexOf(card), 1);
+			});
+		},
+		/** Dismiss (or restore) one Inbox item; `key === '*'` with dismissed=false restores all. */
+		setInboxDismissed(key, dismissed) {
+			if (key !== "*" && !INBOX_KEY.test(key)) return Promise.reject(new BoardError(`not an inbox key: ${key}`));
+			return mutate((board) => {
+				const set = new Set(board.inboxDismissed ?? []);
+				if (key === "*") set.clear();
+				else if (dismissed) set.add(key);
+				else set.delete(key);
+				board.inboxDismissed = [...set].sort();
+			});
+		},
+		setJournal(file, override) {
+			return mutate((board) => {
+				board.journals ??= {};
+				if (override) board.journals[file] = {
+					...override,
+					at: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				else delete board.journals[file];
+			});
+		}
+	};
+}
+//#endregion
+//#region hud/server/config.ts
+var POLICY_DIRS = [
+	"lore/policies",
+	"policies",
+	"suite/policies"
+];
+var slashes = (p) => p.split(path.sep).join("/");
+var inside = (root, full) => {
+	const r = path.relative(root, full);
+	return r === "" || !r.startsWith("..") && !path.isAbsolute(r);
+};
+/** Forward-slash path relative to the main checkout. */
+var rel = (config, full) => slashes(path.relative(config.mainRoot, full));
+/** A path as the owner should read it: relative inside the main checkout, absolute outside it. */
+var display = (config, full) => inside(config.mainRoot, full) ? rel(config, full) : slashes(path.resolve(full));
+/** Read-only git: never takes the index lock or refreshes it. */
+function git(cwd, args) {
+	try {
+		return execFileSync("git", args, {
+			cwd,
+			encoding: "utf8",
+			windowsHide: true,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			env: {
+				...process.env,
+				GIT_OPTIONAL_LOCKS: "0"
+			}
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+/** The main checkout of a repository: the first worktree git lists, unless that one is bare. */
+function mainWorktree(repoRoot) {
+	const first = git(repoRoot, [
+		"worktree",
+		"list",
+		"--porcelain"
+	])?.split(/\r?\n\r?\n/)[0] ?? "";
+	const dir = /^worktree (.+)$/m.exec(first)?.[1];
+	return dir && !/^bare$/m.test(first) ? path.resolve(dir) : repoRoot;
+}
+/** "https://github.com/acme/widgets.git" or "git@github.com:acme/widgets.git" → "widgets". */
+function repoNameFromUrl(url) {
+	return url.trim().replace(/[\\/]+$/, "").split(/[\\/:]/).pop()?.replace(/\.git$/i, "") || null;
+}
+function remoteName(repoRoot) {
+	const remotes = git(repoRoot, ["remote"])?.split(/\r?\n/).filter(Boolean) ?? [];
+	const remote = remotes.includes("origin") ? "origin" : remotes[0];
+	const url = remote ? git(repoRoot, [
+		"remote",
+		"get-url",
+		remote
+	]) : null;
+	return url ? repoNameFromUrl(url) : null;
+}
+function readConfigFile(dataDir) {
+	const file = path.join(dataDir, "config.json");
+	if (!existsSync(file)) return {};
+	try {
+		const value = JSON.parse(readFileSync(file, "utf8").replace(/^/, ""));
+		return value && typeof value === "object" ? value : {};
+	} catch (err) {
+		throw new Error(`${file} is not valid JSON: ${err.message}`);
+	}
+}
+function resolveConfig(repo, data) {
+	const start = path.resolve(repo);
+	if (!existsSync(start) || !statSync(start).isDirectory()) throw new Error(`not a directory: ${start}`);
+	const top = git(start, ["rev-parse", "--show-toplevel"]);
+	const repoRoot = path.resolve(top || start);
+	const mainRoot = top ? mainWorktree(repoRoot) : repoRoot;
+	const dataDir = data ? path.resolve(data) : path.join(mainRoot, ".lore");
+	const file = readConfigFile(dataDir);
+	const text = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+	const pick = (value) => text(value) ? path.resolve(mainRoot, text(value)) : null;
+	const policiesDir = pick(file.policies) ?? POLICY_DIRS.map((d) => path.join(mainRoot, d)).find((d) => existsSync(d) && statSync(d).isDirectory()) ?? null;
+	const port = Number.isInteger(file.port) && file.port > 0 && file.port < 65536 ? file.port : null;
+	return {
+		repoRoot,
+		mainRoot,
+		repoName: text(file.name) ?? (top ? remoteName(repoRoot) : null) ?? path.basename(mainRoot),
+		dataDir,
+		boardPath: path.join(dataDir, "board.json"),
+		journalsDir: pick(file.journals) ?? path.join(mainRoot, ".research"),
+		policiesDir,
+		port
+	};
+}
+/**
+* A stable default port for one repository, so its address can be
+* bookmarked: derived from the main checkout's path, in 5200–5999.
+*/
+function defaultPortFor(mainRoot) {
+	const key = path.resolve(mainRoot).toLowerCase();
+	return 5200 + parseInt(createHash("sha1").update(key).digest("hex").slice(0, 8), 16) % 800;
+}
+/**
+* A policy's name from its file: `research.md` → `research`, and a
+* `-policy` suffix (`persistent-research-policy.md`) is dropped too.
+*/
+var policyName = (file) => path.basename(file, ".md").replace(/-policy$/i, "");
+/** The repository's policies, reserved scopes included, from the policies folder. */
+function listPolicies(config) {
+	const dir = config.policiesDir;
+	if (!dir) return [];
+	const out = [];
+	for (const [sub, reserved] of [[dir, false], [path.join(dir, "reserved"), true]]) {
+		if (!existsSync(sub)) continue;
+		for (const f of readdirSync(sub).sort()) {
+			const full = path.join(sub, f);
+			if (f.endsWith(".md") && statSync(full).isFile()) out.push({
+				name: policyName(f),
+				path: display(config, full),
+				reserved
+			});
+		}
+	}
+	return out;
+}
+/**
+* Would git leave the board file out of commits? true = ignored, false = it
+* would show as untracked, null = not a git repository (or git missing), or
+* the board lives outside the main checkout, where git never sees it.
+*/
+function boardIgnored(config) {
+	if (!inside(config.mainRoot, config.boardPath)) return null;
+	try {
+		execFileSync("git", [
+			"check-ignore",
+			"-q",
+			rel(config, config.boardPath)
+		], {
+			cwd: config.mainRoot,
+			windowsHide: true,
+			stdio: "ignore",
+			env: {
+				...process.env,
+				GIT_OPTIONAL_LOCKS: "0"
+			}
+		});
+		return true;
+	} catch (err) {
+		return err.status === 1 ? false : null;
+	}
+}
+//#endregion
+//#region hud/server/http.ts
+var MIME = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".ico": "image/x-icon",
+	".woff2": "font/woff2",
+	".woff": "font/woff",
+	".txt": "text/plain; charset=utf-8"
+};
+function send(res, status, body) {
+	res.statusCode = status;
+	res.setHeader("Content-Type", "application/json; charset=utf-8");
+	res.setHeader("Cache-Control", "no-store");
+	res.end(JSON.stringify(body));
+}
+async function readJson(req) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		size += chunk.length;
+		if (size > 1e6) throw new BoardError("request body too large", 413);
+		chunks.push(chunk);
+	}
+	try {
+		const value = JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+		if (!value || typeof value !== "object") throw new Error("not an object");
+		return value;
+	} catch {
+		throw new BoardError("request body must be a JSON object");
+	}
+}
+/** Names, mtimes and sizes of the watched files: what counts as a change. */
+async function snapshot(dir, accept) {
+	const names = (await promises.readdir(dir).catch(() => [])).filter(accept).sort();
+	return (await Promise.all(names.map(async (f) => {
+		const s = await promises.stat(path.join(dir, f)).catch(() => null);
+		return s ? `${f}:${s.mtimeMs}:${s.size}` : "";
+	}))).join("|");
+}
+/**
+* Debounced fs.watch on one directory that fires only when a watched file's
+* name, mtime or size changed. Windows also reports access-time updates, so
+* merely reading an old journal would otherwise count as an edit. A missing
+* directory (no journals yet) or a dropped watcher is retried, so a folder
+* created later still goes live.
+*/
+function watchDir(dir, accept, fire) {
+	let watcher = null;
+	let timer;
+	let last = snapshot(dir, accept);
+	const settle = async () => {
+		const [before, now] = [await last, await snapshot(dir, accept)];
+		last = Promise.resolve(now);
+		if (now !== before) fire();
+	};
+	const arm = () => {
+		if (watcher) return;
+		try {
+			watcher = watch(dir, (_event, file) => {
+				if (file && !accept(file.toString())) return;
+				clearTimeout(timer);
+				timer = setTimeout(() => void settle(), 200);
+			});
+			watcher.on("error", () => {
+				watcher?.close();
+				watcher = null;
+			});
+		} catch {
+			watcher = null;
+		}
+	};
+	arm();
+	const retry = setInterval(arm, 3e3);
+	retry.unref();
+	return () => {
+		clearInterval(retry);
+		clearTimeout(timer);
+		watcher?.close();
+	};
+}
+var LOOPBACK = (host, port) => host === `127.0.0.1:${port}` || host === `localhost:${port}` || host === `[::1]:${port}`;
+async function serveStatic(req, res, clientDir) {
+	let pathname;
+	try {
+		pathname = decodeURIComponent(new URL(req.url ?? "/", "http://local").pathname);
+	} catch {
+		return send(res, 400, { error: "bad path" });
+	}
+	if (pathname === "/") pathname = "/index.html";
+	const root = path.resolve(clientDir);
+	const full = path.resolve(root, `.${pathname}`);
+	if (!full.startsWith(root + path.sep)) return send(res, 404, { error: "not found" });
+	try {
+		if (!(await promises.stat(full)).isFile()) return send(res, 404, { error: "not found" });
+		res.statusCode = 200;
+		res.setHeader("Content-Type", MIME[path.extname(full).toLowerCase()] ?? "application/octet-stream");
+		res.setHeader("Cache-Control", pathname.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "no-store");
+		res.setHeader("X-Content-Type-Options", "nosniff");
+		if (req.method === "HEAD") return res.end();
+		res.end(await promises.readFile(full));
+	} catch {
+		send(res, 404, { error: "not found" });
+	}
+}
+function createHudServer(ctx) {
+	const clients = /* @__PURE__ */ new Set();
+	const push = (event) => {
+		for (const res of clients) res.write(`event: ${event}\ndata: {}\n\n`);
+	};
+	const stopBoard = watchDir(path.dirname(ctx.watch.boardPath), (f) => f === path.basename(ctx.watch.boardPath), async () => {
+		const text = await promises.readFile(ctx.watch.boardPath, "utf8").catch(() => "");
+		if (!ctx.board.isOwnWrite(text)) push("board");
+	});
+	const stopJournals = watchDir(ctx.watch.journalsDir, (f) => f.endsWith(".md"), () => push("journals"));
+	const heartbeat = setInterval(() => {
+		for (const res of clients) res.write(": ping\n\n");
+	}, 25e3);
+	heartbeat.unref();
+	async function api(req, res, url) {
+		const route = `${req.method} ${url.pathname.slice(4)}`;
+		const origin = req.headers.origin;
+		if (origin && (origin === "null" || new URL(origin).host !== req.headers.host)) throw new BoardError("cross-origin request refused", 403);
+		if (req.method === "POST" && !String(req.headers["content-type"]).startsWith("application/json")) throw new BoardError("POST bodies must be application/json", 415);
+		switch (route) {
+			case "GET /meta": return send(res, 200, ctx.meta());
+			case "GET /events":
+				res.writeHead(200, {
+					"Content-Type": "text/event-stream",
+					"Cache-Control": "no-store",
+					Connection: "keep-alive"
+				});
+				res.write(": connected\n\n");
+				clients.add(res);
+				req.on("close", () => clients.delete(res));
+				return;
+			case "GET /board": return send(res, 200, await ctx.board.read());
+			case "POST /board/move": {
+				const b = await readJson(req);
+				return send(res, 200, await ctx.board.move(String(b.id), String(b.column), Number(b.index)));
+			}
+			case "POST /board/card": {
+				const b = await readJson(req);
+				return send(res, 200, await ctx.board.upsert(b.card ?? {}));
+			}
+			case "POST /board/delete": {
+				const b = await readJson(req);
+				return send(res, 200, await ctx.board.remove(String(b.id)));
+			}
+			case "POST /board/journal": {
+				const b = await readJson(req);
+				const override = b.state === "closed" ? {
+					state: "closed",
+					note: b.note ? String(b.note) : void 0
+				} : null;
+				return send(res, 200, await ctx.board.setJournal(String(b.file), override));
+			}
+			case "POST /board/inbox": {
+				const b = await readJson(req);
+				return send(res, 200, await ctx.board.setInboxDismissed(String(b.key), b.dismissed !== false));
+			}
+			case "GET /journals": {
+				const overrides = (await ctx.board.read().catch(() => null))?.journals ?? {};
+				return send(res, 200, await ctx.journals.list(overrides));
+			}
+			case "GET /journal": {
+				const file = url.searchParams.get("file") ?? "";
+				return send(res, 200, {
+					file,
+					text: await ctx.journals.read(file)
+				});
+			}
+			case "GET /repo": return send(res, 200, await ctx.repo.get(url.searchParams.has("force")));
+			default: return send(res, 404, { error: `no route ${route}` });
+		}
+	}
+	const server = createServer(async (req, res) => {
+		const address = server.address();
+		const port = typeof address === "object" && address ? address.port : 0;
+		if (!LOOPBACK(req.headers.host, port)) return send(res, 403, { error: "this server answers loopback requests only" });
+		const url = new URL(req.url ?? "/", "http://local");
+		try {
+			if (url.pathname.startsWith("/api/")) return await api(req, res, url);
+			if ((req.method === "GET" || req.method === "HEAD") && ctx.clientDir) return await serveStatic(req, res, ctx.clientDir);
+			return send(res, 404, { error: "not found" });
+		} catch (err) {
+			const status = err instanceof BoardError ? err.status : 500;
+			if (!res.headersSent) send(res, status, { error: err.message });
+			else res.end();
+		}
+	});
+	return {
+		server,
+		close: () => new Promise((resolve) => {
+			stopBoard();
+			stopJournals();
+			clearInterval(heartbeat);
+			for (const res of clients) res.end();
+			clients.clear();
+			server.close(() => resolve());
+			server.closeAllConnections?.();
+		})
+	};
+}
+//#endregion
+//#region hud/server/instance.ts
+/**
+* GET a small JSON document from the local HUD. Plain node:http with no
+* keep-alive: a pooled fetch socket left open makes a short-lived CLI
+* process linger, and on Windows exiting around one can abort Node.
+*/
+function getJson(url, timeoutMs = 1500) {
+	return new Promise((resolve, reject) => {
+		const req = get(url, {
+			agent: false,
+			timeout: timeoutMs
+		}, (res) => {
+			let body = "";
+			res.setEncoding("utf8");
+			res.on("data", (chunk) => body += chunk);
+			res.on("end", () => {
+				try {
+					resolve(JSON.parse(body));
+				} catch (err) {
+					reject(err);
+				}
+			});
+		});
+		req.on("timeout", () => req.destroy(/* @__PURE__ */ new Error(`no answer from ${url}`)));
+		req.on("error", reject);
+	});
+}
+var instanceFile = (config) => path.join(config.dataDir, "hud.json");
+function readInstance(config) {
+	try {
+		const value = JSON.parse(readFileSync(instanceFile(config), "utf8"));
+		return Number.isInteger(value.pid) && Number.isInteger(value.port) && typeof value.url === "string" ? value : null;
+	} catch {
+		return null;
+	}
+}
+function writeInstance(config, instance) {
+	mkdirSync(config.dataDir, { recursive: true });
+	writeFileSync(instanceFile(config), JSON.stringify(instance, null, 2) + "\n");
+}
+/** Remove the entry; with a pid, only if the entry is that process's (a newer HUD may have replaced it). */
+function clearInstance(config, pid) {
+	const file = instanceFile(config);
+	if (!existsSync(file)) return;
+	if (pid !== void 0 && readInstance(config)?.pid !== pid) return;
+	rmSync(file, { force: true });
+}
+function processAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		return err.code === "EPERM";
+	}
+}
+/** The HUD this repository has running, confirmed by asking it; null if none. */
+async function liveInstance(config) {
+	const instance = readInstance(config);
+	if (!instance || !processAlive(instance.pid)) return null;
+	try {
+		return (await getJson(`${instance.url}/api/meta`)).pid === instance.pid ? instance : null;
+	} catch {
+		return null;
+	}
+}
+/** Stop the repository's running HUD. Returns what was stopped, or null; a stale entry is cleared either way. */
+async function stopInstance(config) {
+	const instance = await liveInstance(config);
+	if (!instance) {
+		clearInstance(config);
+		return null;
+	}
+	process.kill(instance.pid);
+	for (let i = 0; i < 50 && processAlive(instance.pid); i++) await new Promise((r) => setTimeout(r, 100));
+	clearInstance(config, instance.pid);
+	return instance;
+}
+var DAY_MS = 864e5;
+var SAFE_NAME = /^[\w.-]+\.md$/;
+/** `## Next Actions (updated)` → `next actions`. */
+function sectionKey(heading) {
+	return heading.replace(/\(.*?\)/g, "").replace(/[*_`:]/g, "").trim().toLowerCase();
+}
+function splitSections(text) {
+	const sections = /* @__PURE__ */ new Map();
+	const prose = [];
+	let title = null;
+	let current = null;
+	let inFence = false;
+	for (const line of text.split(/\r?\n/)) {
+		if (/^\s*```/.test(line)) inFence = !inFence;
+		if (!inFence) {
+			prose.push(line);
+			const h1 = /^#\s+(.+)/.exec(line);
+			if (h1 && title === null) {
+				title = h1[1].trim();
+				continue;
+			}
+			const h2 = /^##\s+(.+)/.exec(line);
+			if (h2) {
+				current = [];
+				sections.set(sectionKey(h2[1]), current);
+				continue;
+			}
+		}
+		current?.push(line);
+	}
+	return {
+		title,
+		sections,
+		prose
+	};
+}
+/** Markdown → one plain line for summaries. */
+function collapse(lines, max) {
+	if (!lines) return "";
+	const text = lines.join("\n").replace(/```[\s\S]*?```/g, " ").replace(/^>\s?/gm, "").replace(/^\s*(?:[-*+]|\d+[.)])\s+/gm, "· ").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/(\*\*|__|~~|`)/g, "").replace(/\s+/g, " ").replace(/^· /, "").trim();
+	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+var LIST_ITEM = /^( ?)(?:[-*+]|\d+[.)])\s+(.*)$/;
+function topLevelItems(lines) {
+	if (!lines) return [];
+	const items = [];
+	for (const line of lines) {
+		const m = LIST_ITEM.exec(line);
+		if (!m) continue;
+		const body = m[2].trim();
+		if (/^\[[xX]\]/.test(body) || /^~~/.test(body)) continue;
+		items.push(body.replace(/^\[ \]\s*/, ""));
+	}
+	return items;
+}
+var EMPTYISH = /^[\s(_*~—–-]*(pending|tbd|todo|none yet|not yet|n\/a|to be written|tbd\.)?[\s)_*.~—–-]*$/i;
+/** A Next Actions list that only says the work is over ("None.", "Closed."). */
+var NOTHING_NEXT = /^[*_~\s]*(none|closed|done|nothing|n\/a|complete|completed|shipped|merged|fixed)\b/i;
+var COMPLETE = /^\s*[*_]*status[*_]*\s*:\s*[*_]*\s*(complete|completed|done|closed|shipped|merged|fixed)\b/im;
+var PR_REF = /(?<![\w&/])#(\d{2,4})\b/g;
+/** `Policies: research, implementation` / `**Policies:** research` / `- Policies: …` */
+var POLICIES_LINE = /^\s*(?:[-*]\s+)?[*_]{0,2}policies[*_]{0,2}\s*:[*_]{0,2}\s*(.+)$/i;
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Names on the first `Policies:` line, normalized (`policies/research.md` → `research`). */
+function declaredPolicies(prose) {
+	for (const line of prose) {
+		const m = POLICIES_LINE.exec(line);
+		if (!m) continue;
+		const names = m[1].replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").split(/[\s,;·|]+/).map((t) => t.replace(/[`*_[\]()]/g, "").replace(/^(?:\.\.\/)*(?:lore\/)?(?:policies\/)?(?:reserved\/)?/i, "").replace(/\.md$/i, "").replace(/-policy$/i, "").toLowerCase()).filter((t) => /^[a-z0-9][a-z0-9-]*$/.test(t) && t !== "policy" && t !== "and");
+		return [...new Set(names)];
+	}
+	return [];
+}
+/**
+* Known policies the text refers to — by file (`research.md`,
+* `persistent-research-policy.md`) or by name ("research policy") — minus
+* the declared ones.
+*/
+function mentionedPolicies(text, policies, declared) {
+	const out = [];
+	for (const p of policies) {
+		const { name, stem } = typeof p === "string" ? {
+			name: p,
+			stem: void 0
+		} : p;
+		if (declared.includes(name) || out.includes(name)) continue;
+		const files = [.../* @__PURE__ */ new Set([name, stem ?? name])].map(escapeRe).join("|");
+		const e = escapeRe(name);
+		if (new RegExp(`(?:^|[^\\w-])(?:${files})\\.md\\b|(?:^|[^\\w-])${e}[ -]polic(?:y|ies)\\b`, "i").test(text)) out.push(name);
+	}
+	return out;
+}
+function parseJournal(text, fallbackTitle, policyNames = []) {
+	const { title, sections, prose } = splitSections(text);
+	const conclusionText = collapse(sections.get("final conclusions") ?? sections.get("final conclusion"), 360);
+	const prRefs = [...new Set([...text.matchAll(PR_REF)].map((m) => Number(m[1])))].sort((a, b) => b - a);
+	const nextLines = sections.get("next actions");
+	const next = topLevelItems(nextLines);
+	const nothingNext = next.length ? next.every((item) => NOTHING_NEXT.test(item)) : NOTHING_NEXT.test(collapse(nextLines, 80));
+	const declared = declaredPolicies(prose);
+	return {
+		title: title ?? fallbackTitle,
+		objective: collapse(sections.get("objective") ?? sections.get("current objective") ?? sections.get("original request"), 320),
+		conclusion: EMPTYISH.test(conclusionText) ? null : conclusionText,
+		completeMarker: COMPLETE.test(text) || nothingNext,
+		nextActions: next.slice(0, 8).map((s) => s.length > 220 ? `${s.slice(0, 219)}…` : s),
+		openQuestions: topLevelItems(sections.get("remaining questions")).filter((q) => !/✅|resolved|answered/i.test(q)).length,
+		prRefs,
+		policies: {
+			declared,
+			mentioned: mentionedPolicies(text, policyNames, declared)
+		}
+	};
+}
+/**
+* Was the journal written after it was closed? A close never touches the file,
+* so a later mtime means someone picked the work back up. A bare YYYY-MM-DD
+* close (hand-written) compares at day precision: only a later day counts.
+*/
+function writtenAfter(mtime, closedAt) {
+	if (/^\d{4}-\d{2}-\d{2}$/.test(closedAt)) return mtime.toISOString().slice(0, 10) > closedAt;
+	const at = Date.parse(closedAt);
+	return Number.isFinite(at) && mtime.getTime() > at;
+}
+function createJournalIndex(journalsDir, policyNames = () => []) {
+	const cache = /* @__PURE__ */ new Map();
+	function resolve(file) {
+		if (!SAFE_NAME.test(file)) throw new Error(`not a journal name: ${file}`);
+		const full = path.join(journalsDir, file);
+		if (path.dirname(full) !== path.resolve(journalsDir)) throw new Error(`outside the journals folder: ${file}`);
+		return full;
+	}
+	async function list(overrides = {}) {
+		let names;
+		try {
+			names = (await promises.readdir(journalsDir, { withFileTypes: true })).filter((d) => d.isFile() && d.name.endsWith(".md")).map((d) => d.name);
+		} catch (err) {
+			if (err.code === "ENOENT") return [];
+			throw err;
+		}
+		const known = policyNames();
+		const knownKey = JSON.stringify(known);
+		const now = Date.now();
+		const out = await Promise.all(names.map(async (file) => {
+			const full = path.join(journalsDir, file);
+			const stat = await promises.stat(full);
+			const key = `${stat.mtimeMs}:${stat.size}:${knownKey}`;
+			let hit = cache.get(file);
+			if (!hit || hit.key !== key) {
+				const slug = file.replace(/\.md$/, "").replace(/^\d{4}-\d{2}-\d{2}-/, "").replace(/[-_]/g, " ");
+				hit = {
+					key,
+					parsed: parseJournal(await promises.readFile(full, "utf8"), slug, known)
+				};
+				cache.set(file, hit);
+			}
+			const p = hit.parsed;
+			const ageDays = Math.floor((now - stat.mtimeMs) / DAY_MS);
+			const override = overrides[file];
+			const closed = override?.state === "closed";
+			const editedAfterClose = closed && writtenAfter(stat.mtime, override.at);
+			let status;
+			if (closed && !editedAfterClose) status = "closed";
+			else if (p.conclusion !== null || p.completeMarker) status = "concluded";
+			else status = ageDays > 7 ? "stale" : "open";
+			return {
+				file,
+				date: /^\d{4}-\d{2}-\d{2}/.exec(file)?.[0] ?? stat.mtime.toISOString().slice(0, 10),
+				title: p.title,
+				objective: p.objective,
+				status,
+				conclusion: p.conclusion,
+				nextActions: p.nextActions,
+				openQuestions: p.openQuestions,
+				modified: stat.mtime.toISOString(),
+				ageDays,
+				prRefs: p.prRefs,
+				policies: p.policies,
+				override,
+				editedAfterClose
+			};
+		}));
+		for (const name of cache.keys()) if (!names.includes(name)) cache.delete(name);
+		return out.sort((a, b) => b.modified.localeCompare(a.modified));
+	}
+	async function read(file) {
+		return promises.readFile(resolve(file), "utf8");
+	}
+	return {
+		list,
+		read
+	};
+}
+//#endregion
+//#region hud/server/repo.ts
+var GH_TTL_MS = 6e4;
+var READ_ONLY_GIT = {
+	...process.env,
+	GIT_OPTIONAL_LOCKS: "0"
+};
+function run(cmd, args, cwd) {
+	return new Promise((resolve, reject) => {
+		execFile(cmd, args, {
+			cwd,
+			timeout: 3e4,
+			maxBuffer: 16777216,
+			windowsHide: true,
+			env: READ_ONLY_GIT
+		}, (err, stdout, stderr) => {
+			if (err?.code === "ENOENT") reject(/* @__PURE__ */ new Error(`${cmd} is not installed`));
+			else if (err) reject(/* @__PURE__ */ new Error(`${cmd} ${args[0]} ${args[1] ?? ""}: ${(stderr || err.message).trim()}`));
+			else resolve(stdout);
+		});
+	});
+}
+/** gh's failure, in the words the owner needs. */
+function explainGhError(message) {
+	if (/gh is not installed/.test(message)) return "the gh CLI is not installed";
+	if (/not a git repository/i.test(message)) return "this folder is not a git repository";
+	if (/no git remotes|none of the git remotes|could not determine (base )?repo/i.test(message)) return "this repository has no GitHub remote";
+	if (/gh auth login|not logged in|authentication|HTTP 401/i.test(message)) return "gh is not logged in (run `gh auth login`)";
+	return message;
+}
+function createRepoState(repoRoot) {
+	let cached = null;
+	let cachedAt = 0;
+	let inflight = null;
+	async function fetchGitHub() {
+		const [prs, issues, release] = await Promise.all([
+			run("gh", [
+				"pr",
+				"list",
+				"--state",
+				"all",
+				"--limit",
+				"400",
+				"--json",
+				"number,title,state,url,createdAt,updatedAt,mergedAt,closedAt,headRefName,isDraft"
+			], repoRoot),
+			run("gh", [
+				"issue",
+				"list",
+				"--state",
+				"all",
+				"--limit",
+				"400",
+				"--json",
+				"number,title,state,url,createdAt,updatedAt,closedAt,labels"
+			], repoRoot),
+			run("gh", [
+				"release",
+				"view",
+				"--json",
+				"tagName,publishedAt,url"
+			], repoRoot).catch(() => "null")
+		]);
+		const rel = JSON.parse(release);
+		return {
+			fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			prs: JSON.parse(prs),
+			issues: JSON.parse(issues).map((i) => ({
+				...i,
+				labels: (i.labels ?? []).map((l) => l.name)
+			})),
+			release: rel ? {
+				tag: rel.tagName,
+				publishedAt: rel.publishedAt,
+				url: rel.url
+			} : null
+		};
+	}
+	async function github(force) {
+		if (!force && cached && Date.now() - cachedAt < GH_TTL_MS) return cached;
+		inflight ??= fetchGitHub().then((fresh) => {
+			cached = fresh;
+			cachedAt = Date.now();
+			return fresh;
+		}).catch((err) => ({
+			...cached ?? {
+				prs: [],
+				issues: [],
+				release: null
+			},
+			fetchedAt: cached?.fetchedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+			error: explainGhError(err.message),
+			lastGood: cached !== null
+		})).finally(() => {
+			inflight = null;
+		});
+		return inflight;
+	}
+	async function git() {
+		try {
+			const [branch, log, status] = await Promise.all([
+				run("git", [
+					"rev-parse",
+					"--abbrev-ref",
+					"HEAD"
+				], repoRoot),
+				run("git", [
+					"log",
+					"-1",
+					"--format=%h%x09%s"
+				], repoRoot),
+				run("git", ["status", "--porcelain"], repoRoot)
+			]);
+			const [head, ...subject] = log.trim().split("	");
+			return {
+				branch: branch.trim(),
+				head,
+				subject: subject.join("	"),
+				dirty: status.split("\n").filter(Boolean).length
+			};
+		} catch {
+			return null;
+		}
+	}
+	return { async get(force = false) {
+		const [gh, g] = await Promise.all([github(force), git()]);
+		return {
+			...gh,
+			git: g
+		};
+	} };
+}
+//#endregion
+//#region hud/server/main.ts
+var PORT_TRIES = 10;
+/** The repository's running HUD, if any (confirmed by asking it). */
+async function findHud(options) {
+	const config = resolveConfig(options.repo, options.data);
+	return {
+		config,
+		live: await liveInstance(config)
+	};
+}
+/** Stop the repository's running HUD; null when none was running. */
+async function stopHud(options) {
+	return stopInstance(resolveConfig(options.repo, options.data));
+}
+function defaultClientDir() {
+	const here = path.dirname(fileURLToPath(import.meta.url));
+	for (const candidate of [path.join(here, "..", "client"), path.join(here, "..", "dist", "client")]) if (existsSync(path.join(candidate, "index.html"))) return candidate;
+	return null;
+}
+function services(config, version) {
+	const board = createBoardStore(config.boardPath);
+	const policyNames = () => listPolicies(config).map((p) => ({
+		name: p.name,
+		stem: path.basename(p.path, ".md")
+	}));
+	const journals = createJournalIndex(config.journalsDir, policyNames);
+	const meta = () => ({
+		repo: config.repoName,
+		journals: display(config, config.journalsDir),
+		boardFile: display(config, config.boardPath),
+		policies: listPolicies(config),
+		boardIgnored: boardIgnored(config),
+		version,
+		pid: process.pid
+	});
+	return {
+		board,
+		journals,
+		meta
+	};
+}
+async function startHud(options) {
+	const config = resolveConfig(options.repo, options.data);
+	const { board, journals, meta } = services(config, options.version ?? "dev");
+	const hud = createHudServer({
+		board,
+		journals,
+		repo: createRepoState(config.repoRoot),
+		meta,
+		clientDir: options.clientDir === void 0 ? defaultClientDir() : options.clientDir,
+		watch: {
+			boardPath: config.boardPath,
+			journalsDir: config.journalsDir
+		}
+	});
+	const first = options.port ?? config.port ?? defaultPortFor(config.mainRoot);
+	const tries = options.port === void 0 ? PORT_TRIES : 1;
+	let port = first;
+	for (let i = 0;; i++) try {
+		await new Promise((resolve, reject) => {
+			hud.server.once("error", reject);
+			hud.server.listen(port, "127.0.0.1", () => {
+				hud.server.off("error", reject);
+				resolve();
+			});
+		});
+		break;
+	} catch (err) {
+		if (err.code !== "EADDRINUSE" || i + 1 >= tries) throw err;
+		port += 1;
+	}
+	const address = hud.server.address();
+	const actual = typeof address === "object" && address ? address.port : port;
+	const url = `http://127.0.0.1:${actual}`;
+	const version = options.version ?? "dev";
+	if (options.register) writeInstance(config, {
+		pid: process.pid,
+		port: actual,
+		url,
+		version,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		repo: config.repoName
+	});
+	return {
+		url,
+		config,
+		meta: meta(),
+		close: async () => {
+			if (options.register) clearInstance(config, process.pid);
+			await hud.close();
+		}
+	};
+}
+var MAX_TITLES = 6;
+var clip = (s, n = 52) => s.length > n ? `${s.slice(0, n - 1)}…` : s;
+/**
+* The board in a few lines, for an agent's session start. Offline and
+* read-only: it never creates the board and never calls GitHub.
+*/
+async function brief(options) {
+	const config = resolveConfig(options.repo, options.data);
+	const { board: store, journals, meta } = services(config, "brief");
+	const m = meta();
+	const out = [`=== LORE board · ${m.repo} (${m.boardFile} · \`lore hud\` to open it) ===`];
+	let board = null;
+	try {
+		board = await store.peek();
+		if (!board) out.push(`No board yet. Ask the owner whether to bootstrap one, or run \`lore hud\` to start an empty board.`);
+		else if (board.cards.length === 0) out.push(`The board is empty: bootstrap it with the owner (read the repository, propose areas and cards, write what they approve).`);
+		else {
+			const quiet = /* @__PURE__ */ new Set([columnWithRole(board, "intake")?.id, columnWithRole(board, "done")?.id]);
+			for (const col of board.columns) {
+				const cards = board.cards.filter((c) => c.column === col.id);
+				if (quiet.has(col.id) || !cards.length) continue;
+				const titles = cards.slice(0, MAX_TITLES).map((c) => clip(c.title));
+				const more = cards.length > MAX_TITLES ? ` · +${cards.length - MAX_TITLES}` : "";
+				out.push(`${col.title} (${cards.length}): ${titles.join(" · ")}${more}`);
+			}
+			const intake = columnWithRole(board, "intake");
+			const done = columnWithRole(board, "done");
+			const count = (id) => board.cards.filter((c) => c.column === id).length;
+			const top = done && board.cards.find((c) => c.column === done.id);
+			const tail = [intake ? `${intake.title} ${count(intake.id)}` : null, done ? `${done.title} ${count(done.id)}${top ? ` (top: ${clip(top.title, 44)})` : ""}` : null].filter(Boolean);
+			if (tail.length) out.push(tail.join(" · "));
+		}
+	} catch (err) {
+		out.push(`${m.boardFile} unreadable: ${err.message} — fix it before relying on the board.`);
+	}
+	try {
+		const list = await journals.list(board?.journals ?? {});
+		const by = (s) => list.filter((j) => j.status === s);
+		const open = by("open");
+		if (list.length) out.push(`Journals (${m.journals}): ${open.length} open · ${by("stale").length} stale · ${by("concluded").length} concluded` + (open.length ? ` — newest open: ${open.slice(0, 3).map((j) => clip(j.file.replace(/\.md$/, ""), 40)).join(", ")}` : ""));
+		if (board && board.cards.length) {
+			const untracked = inboxItems(board, list, [], []);
+			if (untracked.length) out.push(`Inbox — active journals no card links (add or link a card if this is your work): ` + untracked.slice(0, 4).map((i) => clip((i.file ?? i.label).replace(/\.md$/, ""), 44)).join(", ") + (untracked.length > 4 ? ` · +${untracked.length - 4}` : ""));
+		}
+	} catch {}
+	const live = await liveInstance(config);
+	out.push(live ? `HUD: ${live.url} (running)` : "HUD: not running — `lore hud` starts it and opens the browser.");
+	const policy = m.policies.find((p) => p.name === "board");
+	out.push(`Keep the board current: when work moves — it starts, a PR opens or merges, a ruling is owed — update ${m.boardFile} in the same session` + (policy ? ` (${policy.path}).` : "."));
+	return out.join("\n");
+}
+//#endregion
+export { brief, findHud, getJson, resolveConfig, startHud, stopHud };