@marver-design/marver 0.20.0 → 0.22.0

package/dist/context-DUAENlJ6.mjs

@@ -0,0 +1,600 @@
+import { r as NAME } from "./cli.mjs";
+import { C as tables, S as proseLines, _ as isRecordTable, b as looseTables, c as CITED_FILE, d as LEVEL, f as availableLevels, g as hasGlob, h as globRe, k as checkRealDirs, l as EVIDENCE_COLUMN, m as frontMatter, p as capabilityTable, s as CITATION, tt as readStatusWord, u as GENERATED, v as levelsIn, w as wordCount, x as parseMap, y as lf } from "./board-status-CWGHIdo_.mjs";
+import { pkgDir } from "./managed-HwHVNI3h.mjs";
+import { t as writeManaged } from "./managed-write-Bo-oPc-i.mjs";
+import { r as scanFrames } from "./manifest-BqBcMJcd.mjs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, normalize, relative, sep } from "node:path";
+import { execFileSync } from "node:child_process";
+//#region src/server/publish-graph.ts
+/**
+* What a canvas build carries, as repository paths - the same selection the build makes, so a
+* check against it judges what actually ships: the published boards' frames (every frame when
+* `all-scenes` ships), each frame's `_layout` chain, `design/providers`, and everything they import -
+* relative paths, `design/tsconfig.json` aliases, `?raw` and asset strings. An import that looks
+* local and does not resolve is reported, never silently skipped.
+*/
+const IMPORT = /(?:import|export)\s[^'"]*?from\s*['"]([^'"]+)['"]|import\(\s*['"]([^'"]+)['"]\s*\)|require\(\s*['"]([^'"]+)['"]\s*\)|['"]((?:\.{1,2}\/|\/)[^'"\s]+\.[a-z0-9]{1,5})(?:\?[a-z]+)?['"]/g;
+const CODE = /\.(tsx?|jsx?|mjs|cjs|mdx?)$/;
+/** The published board names, straight from design/publish.json (an unreadable policy ships nothing). */
+function publishedBoards(root) {
+	try {
+		return Object.keys(JSON.parse(readFileSync(join(root, "design", "publish.json"), "utf8")).boards ?? {});
+	} catch {
+		return [];
+	}
+}
+/** JSON with comments and trailing commas, as tsconfig allows - comments stripped outside strings only
+*  (a "$schema": "https://..." is a string, not a comment). */
+function parseJsonc(text) {
+	let out = "", i = 0, str = false;
+	const t = text.replace(/^\uFEFF/, "");
+	while (i < t.length) {
+		const c = t[i];
+		if (str) {
+			out += c;
+			if (c === "\\") {
+				out += t[i + 1] ?? "";
+				i += 2;
+				continue;
+			}
+			if (c === "\"") str = false;
+			i++;
+			continue;
+		}
+		if (c === "\"") {
+			str = true;
+			out += c;
+			i++;
+			continue;
+		}
+		if (c === "/" && t[i + 1] === "/") {
+			while (i < t.length && t[i] !== "\n") i++;
+			continue;
+		}
+		if (c === "/" && t[i + 1] === "*") {
+			i += 2;
+			while (i < t.length && !(t[i] === "*" && t[i + 1] === "/")) i++;
+			i += 2;
+			continue;
+		}
+		out += c;
+		i++;
+	}
+	return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+/** design/tsconfig.json's path aliases, resolved against the config that declares them - its own,
+*  or one it `extends` (the host's tsconfig), as TypeScript and Vite would. */
+function aliases(root) {
+	const read = (rel, depth) => {
+		if (depth > 4) return [];
+		let cfg;
+		try {
+			cfg = parseJsonc(readFileSync(join(root, rel), "utf8"));
+		} catch {
+			return [];
+		}
+		const dir = dirname(rel);
+		const base = typeof cfg.compilerOptions?.baseUrl === "string" ? normalize(join(dir, cfg.compilerOptions.baseUrl)) : dir;
+		const own = Object.entries(cfg.compilerOptions?.paths ?? {}).flatMap(([k, v]) => Array.isArray(v) ? [{
+			prefix: k.replace(/\*$/, ""),
+			targets: v.map((t) => normalize(join(base, t.replace(/\*$/, ""))))
+		}] : []);
+		const ext = (Array.isArray(cfg.extends) ? cfg.extends : [cfg.extends]).filter((e) => typeof e === "string" && e.startsWith("."));
+		let inherited = [];
+		for (const e of ext) {
+			const got = read(normalize(join(dir, e.endsWith(".json") ? e : `${e}.json`)), depth + 1);
+			inherited = [...got, ...inherited.filter((p) => !got.some((g) => g.prefix === p.prefix))];
+		}
+		return [...own, ...inherited.filter((p) => !own.some((o) => o.prefix === p.prefix))];
+	};
+	return read("design/tsconfig.json", 0);
+}
+function publishGraph(root) {
+	const files = /* @__PURE__ */ new Set();
+	const unresolved = [];
+	const boards = publishedBoards(root);
+	if (!boards.length) return {
+		files,
+		unresolved
+	};
+	const rel = (abs) => relative(root, abs).split(sep).join("/");
+	const isFile = (p) => {
+		try {
+			return statSync(join(root, p)).isFile();
+		} catch {
+			return false;
+		}
+	};
+	const manifest = scanFrames(root);
+	let wanted = /* @__PURE__ */ new Set();
+	for (const b of boards) {
+		if (b === "all-scenes") {
+			wanted = null;
+			break;
+		}
+		try {
+			const j = JSON.parse(readFileSync(join(root, "design", "boards", `${b}.json`), "utf8"));
+			for (const n of Array.isArray(j?.nodes) ? j.nodes : []) if (typeof n?.frame === "string") wanted.add(n.frame);
+		} catch {}
+	}
+	const entries = manifest.frames.filter((f) => !wanted || wanted.has(f.id));
+	const frames = entries.map((f) => rel(join(root, f.file)));
+	const queue = [...frames];
+	for (const [i, f] of frames.entries()) {
+		const scene = entries[i].scene;
+		for (const dir of /* @__PURE__ */ new Set([scene ? `design/scenes/${scene}` : dirname(f), dirname(f)])) for (const n of ["_brief.md", "_note.md"]) if (isFile(`${dir}/${n}`)) queue.push(`${dir}/${n}`);
+		const note = f.replace(/\.(tsx|jsx|html)$/, ".note.md");
+		if (isFile(note)) queue.push(note);
+	}
+	for (const f of frames) {
+		const base = f.startsWith("design/components/") ? "design/components" : "design/scenes";
+		let dir = dirname(f);
+		while (dir.length >= base.length) {
+			for (const ext of ["tsx", "jsx"]) if (isFile(`${dir}/_layout.${ext}`)) queue.push(`${dir}/_layout.${ext}`);
+			if (dir === base) break;
+			dir = dirname(dir);
+		}
+	}
+	for (const ext of ["tsx", "jsx"]) if (isFile(`design/providers.${ext}`)) queue.push(`design/providers.${ext}`);
+	const al = aliases(root);
+	const resolve = (from, spec) => {
+		const bare = spec.replace(/\?[a-z]+$/, "");
+		let bases = [];
+		if (bare.startsWith(".")) bases = [normalize(join(dirname(from), bare))];
+		else if (bare.startsWith("/")) bases = [normalize(bare.slice(1))];
+		else {
+			const a = al.find((x) => bare.startsWith(x.prefix) && x.prefix);
+			if (!a) return "";
+			bases = a.targets.map((t) => normalize(join(t, bare.slice(a.prefix.length))));
+		}
+		for (const b of bases) for (const cand of [
+			b,
+			`${b}.ts`,
+			`${b}.tsx`,
+			`${b}.js`,
+			`${b}.jsx`,
+			`${b}/index.ts`,
+			`${b}/index.tsx`
+		]) if (!cand.startsWith("..") && isFile(cand)) return cand.split(sep).join("/");
+		return null;
+	};
+	while (queue.length) {
+		const p = queue.pop();
+		if (files.has(p)) continue;
+		files.add(p);
+		if (!CODE.test(p)) continue;
+		let text = "";
+		try {
+			text = readFileSync(join(root, p), "utf8");
+		} catch {
+			continue;
+		}
+		for (const m of text.matchAll(IMPORT)) {
+			const spec = m[1] || m[2] || m[3] || m[4] || "";
+			if (!spec) continue;
+			const r = resolve(p, spec);
+			if (r === "") continue;
+			if (r === null) {
+				if (spec.startsWith(".") || spec.startsWith("/") || al.some((x) => x.prefix && spec.startsWith(x.prefix))) unresolved.push({
+					from: p,
+					spec
+				});
+				continue;
+			}
+			queue.push(r);
+		}
+	}
+	return {
+		files,
+		unresolved
+	};
+}
+//#endregion
+//#region src/cli/context.ts
+/**
+* `marver context` (spec 19) - the conventions P0 proved, for any repository:
+*   init   create context/ (the index, the shipped record, the map, the playbooks Marver maintains)
+*   check  keep it true - deterministic, run in ci; exit 0 pass, 1 fail, 2 cannot determine
+*   index  rewrite the index's generated capability table from the map
+* The parsing is shared with the dev server (shared/context.ts), so the canvas's statuses and the
+* check read the files one way.
+*/
+const INDEX_BUDGET = 800;
+const CONTEXT = "context";
+/** Create context/ - never overwriting. The playbooks are managed: pristine ones take Marver's
+*  updates on a re-run, edited ones are kept and the new version staged for a merge. */
+function contextInit(root, kind = "product") {
+	const created = [];
+	const templates = join(pkgDir(), "templates");
+	const name = projectName(root);
+	const bad = checkRealDirs(root, [[join(root, CONTEXT), `${CONTEXT}/`], [join(root, CONTEXT, "playbooks"), `${CONTEXT}/playbooks/`]]);
+	if (bad) throw new Error(bad);
+	const plain = (rel, body) => {
+		const file = join(root, CONTEXT, rel);
+		mkdirFor(file);
+		try {
+			writeFileSync(file, body, { flag: "wx" });
+			created.push(`${CONTEXT}/${rel}`);
+		} catch (e) {
+			if (e.code !== "EEXIST") throw e;
+		}
+	};
+	plain("INDEX.md", readFileSync(join(templates, "context", "INDEX.md"), "utf8").replaceAll("{{NAME}}", name).replace("{{RECORD_QUESTION}}", kind === "knowledge" ? "Was it delivered, to whom, and when?" : "Is it available, where, for whom, since when?"));
+	plain("shipped.md", readFileSync(join(templates, "context", kind === "knowledge" ? "shipped-knowledge.md" : "shipped.md"), "utf8"));
+	plain("map.json", readFileSync(join(templates, "context", "map.json"), "utf8"));
+	const pbRoot = join(templates, "playbooks");
+	for (const pb of readdirSync(pbRoot)) for (const f of readdirSync(join(pbRoot, pb)).filter((x) => x.endsWith(".md"))) {
+		const rel = `playbooks/${pb}/${f}`;
+		writeManaged({
+			base: join(root, CONTEXT),
+			rel,
+			body: readFileSync(join(pbRoot, pb, f), "utf8"),
+			shown: `${CONTEXT}/${rel}`,
+			stageDir: join(root, "design", ".local", "latest", CONTEXT),
+			created,
+			rerun: `\`npx ${NAME} context init\``
+		});
+	}
+	if (!existsSync(join(root, "design", "instructions", "context.md"))) writeManaged({
+		base: join(root, CONTEXT),
+		rel: "README.md",
+		body: readFileSync(join(templates, "instructions", "context.md"), "utf8"),
+		shown: `${CONTEXT}/README.md`,
+		stageDir: join(root, "design", ".local", "latest", CONTEXT),
+		created,
+		rerun: `\`npx ${NAME} context init\``
+	});
+	const agents = join(root, "AGENTS.md");
+	const route = "Any question about the product - what is available, how it works, why, what is next: start at context/INDEX.md.";
+	for (let attempt = 0; attempt < 5; attempt++) {
+		const cur = existsSync(agents) ? readFileSync(agents, "utf8") : null;
+		if (cur !== null && cur.includes("context/INDEX.md")) break;
+		if (cur === null) try {
+			writeFileSync(agents, `# ${name}\n\n${route}\n`, { flag: "wx" });
+			created.push("AGENTS.md");
+			break;
+		} catch (e) {
+			if (e.code === "EEXIST") continue;
+			throw e;
+		}
+		const tmp = `${agents}.${process.pid}.${attempt}.tmp`;
+		writeFileSync(tmp, cur.replace(/\n*$/, "") + `\n\n${route}\n`, { flag: "wx" });
+		if (readFileSync(agents, "utf8") !== cur) {
+			rmSync(tmp, { force: true });
+			continue;
+		}
+		renameSync(tmp, agents);
+		created.push("AGENTS.md (updated)");
+		break;
+	}
+	return created;
+}
+function projectName(root) {
+	try {
+		const n = JSON.parse(readFileSync(join(root, "package.json"), "utf8")).name;
+		if (typeof n === "string" && n) return n.replace(/^@[^/]+\//, "");
+	} catch {}
+	return basename(root);
+}
+const mkdirFor = (file) => mkdirSync(dirname(file), { recursive: true });
+/** Rewrite the index's generated table from the map. Returns the words now in the index. */
+function contextIndex(root) {
+	const indexFile = join(root, CONTEXT, "INDEX.md");
+	const mapFile = join(root, CONTEXT, "map.json");
+	if (!existsSync(indexFile)) throw new Error(`${CONTEXT}/INDEX.md is missing - run \`npx ${NAME} context init\``);
+	if (!existsSync(mapFile)) throw new Error(`${CONTEXT}/map.json is missing - run \`npx ${NAME} context init\``);
+	const map = parseMap(readFileSync(mapFile, "utf8"));
+	if (typeof map === "string") throw new Error(map);
+	const text = readFileSync(indexFile, "utf8");
+	const m = GENERATED.exec(text);
+	if (!m) throw new Error(`${CONTEXT}/INDEX.md has no <!-- generated --> ... <!-- /generated --> fences for the capability table`);
+	const opening = text.slice(m.index, m.index + m[0].indexOf("-->") + 3);
+	const next = text.slice(0, m.index) + `${opening}\n${capabilityTable(map)}\n<!-- /generated -->` + text.slice(m.index + m[0].length);
+	if (next !== text) writeFileSync(indexFile, next);
+	return {
+		words: wordCount(next),
+		changed: next !== text
+	};
+}
+/** The supersession smells a current document never carries. */
+const SUPERSEDED = /wins where it differs|wins over sections?|overrides (section|§)|section \d+ wins|supersedes section|amended by section/i;
+/** Availability is the shipped record's alone - a contract saying what is live is the smell. */
+const AVAILABILITY = /\b(on production|on staging|in production since|live since|went live|deployed to|released to|rolled out to|shipped (on|to|in|since)|(was|were|been) delivered (to|on)|delivered on \d|handed over (to|on))\b/i;
+const CONTRACT_STATES = [
+	"current",
+	"proposed",
+	"historical"
+];
+const FEEDBACK_STATES = [
+	"new",
+	"triaged",
+	"proposed",
+	"planned",
+	"shipped",
+	"declined"
+];
+const LINK = /\[[^\]]*\]\(([^)\s]+)\)/g;
+/** A `path:line` citation - a path from the root, or a bare name the resolver looks up by basename
+*  (`run.ts:12` when one tracked file is run.ts; shorthand for the file named before it when several are). */
+const CITE = /`((?:\.{0,2}[\w@.-]+\/)*[\w@.$-]+\.[a-z]{1,5}):(\d+)(?:-(\d+))?`/g;
+function contextCheck(root, opts = {}) {
+	const failures = [], unsure = [], notes = [];
+	const fail = (rule, where, what) => failures.push({
+		rule,
+		where,
+		what
+	});
+	const cannot = (rule, what) => unsure.push({
+		rule,
+		where: "",
+		what
+	});
+	const note = (rule, what) => notes.push({
+		rule,
+		where: "",
+		what
+	});
+	const exists = (p) => existsSync(join(root, p));
+	const read = (p) => readFileSync(join(root, p), "utf8");
+	const git = (...args) => execFileSync("git", args, {
+		cwd: root,
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		maxBuffer: 536870912
+	});
+	if (!exists(CONTEXT)) {
+		fail("context", `${CONTEXT}/`, `missing - run \`npx ${NAME} context init\``);
+		return {
+			exit: 1,
+			failures,
+			unsure,
+			notes
+		};
+	}
+	const walk = (dir) => {
+		if (!exists(dir)) return [];
+		const out = [];
+		for (const n of readdirSync(join(root, dir))) {
+			const p = `${dir}/${n}`;
+			const st = lstatSync(join(root, p));
+			if (st.isSymbolicLink()) continue;
+			if (st.isDirectory()) out.push(...walk(p));
+			else out.push(p);
+		}
+		return out;
+	};
+	const docs = walk(CONTEXT).filter((p) => p.endsWith(".md")).map((path) => {
+		const text = read(path);
+		return {
+			path,
+			text,
+			...frontMatter(text)
+		};
+	});
+	for (const d of docs) if (d.error) fail("front-matter", d.path, d.error);
+	const isContract = (d) => d.data?.state === "current" && /^context\/(product|system)\//.test(d.path);
+	for (const d of docs.filter(isContract)) for (const [n, line] of proseLines(d.body, d.offset)) {
+		if (/^\s*\**status\**\s*:/i.test(line)) fail("status-line", `${d.path}:${n}`, `a status line in a current contract - status lives in ${CONTEXT}/shipped.md`);
+		const a = line.match(AVAILABILITY);
+		if (a) fail("availability", `${d.path}:${n}`, `"${a[0]}" - availability lives in ${CONTEXT}/shipped.md`);
+	}
+	for (const d of docs.filter((x) => x.data?.state === "current")) for (const [n, line] of proseLines(d.body, d.offset)) {
+		const m = line.match(SUPERSEDED);
+		if (m) fail("supersession", `${d.path}:${n}`, `"${m[0]}" - fold the amendment in; one answer per rule`);
+	}
+	let tracked = null;
+	try {
+		tracked = new Set(git("ls-files", "-z").split("\0").filter(Boolean));
+	} catch {
+		cannot("git", "git ls-files failed - not a repository?");
+	}
+	/** A cited file, resolved: a path from the root, or a bare name (`run.test.ts`) that one tracked
+	*  file carries - several mean the citation is shorthand for the one named before it. Returns the
+	*  path, 'ambiguous', or null when nothing carries it. */
+	const byBase = /* @__PURE__ */ new Map();
+	if (tracked) for (const t of tracked) {
+		const b = t.slice(t.lastIndexOf("/") + 1);
+		byBase.set(b, [...byBase.get(b) ?? [], t]);
+	}
+	const resolveCited = (f) => {
+		if (exists(f)) return statSync(join(root, f)).isFile() ? f : null;
+		if (f.includes("/")) return null;
+		const hits = byBase.get(f) ?? [];
+		return hits.length === 1 ? hits[0] : hits.length > 1 ? "ambiguous" : null;
+	};
+	const lines = /* @__PURE__ */ new Map();
+	const linesOf = (p) => {
+		if (!lines.has(p)) lines.set(p, read(p).split("\n").length);
+		return lines.get(p);
+	};
+	/** What is wrong with a citation - a file nothing carries, a line past its end, a range backwards - or null. */
+	const citationProblem = (file, from, to) => {
+		const f = file.replace(/^\.\//, "");
+		const r = resolveCited(f);
+		if (r === null) return `${f} does not exist`;
+		const a = Number(from), z = Number(to ?? from);
+		if (from && z < a) return `${f}:${from}-${to} runs backwards`;
+		if (r === "ambiguous" || !from) return null;
+		if (z > linesOf(r)) return `${f}:${from}${to ? `-${to}` : ""} is past the end of ${r} (${linesOf(r)} lines)`;
+		return null;
+	};
+	const shippedPath = `${CONTEXT}/shipped.md`;
+	if (!exists(shippedPath)) fail("shipped", shippedPath, "missing");
+	else {
+		const text = read(shippedPath);
+		if (!tables(text).some(isRecordTable)) fail("shipped-shape", shippedPath, "no Capability (or Project) table with an Available (or Delivered) column - the canvas cannot read a status from it");
+		for (const n of looseTables(text)) fail("table-format", `${shippedPath}:${n}`, "a table without outer pipes - start and end every row with |");
+		for (const t of tables(text)) for (const r of t.rows) {
+			const where = `${shippedPath}:${r.line}`;
+			if (!r.cells.some((c) => levelsIn(c).length)) fail("shipped-level", where, "a row with no evidence level");
+			r.cells.forEach((c, i) => {
+				if (EVIDENCE_COLUMN.test(t.header[i] ?? "") && !/^nowhere\b/i.test(c) && !levelsIn(c).length) fail("shipped-level", where, `the ${t.header[i]} cell has no evidence level`);
+				for (const m of c.matchAll(LEVEL)) if (m[1] !== "unknown" && !CITATION.test(c)) fail("shipped-citation", where, `\`${m[1]}\` with no citation in its cell`);
+				if (levelsIn(c).length) for (const m of c.matchAll(CITED_FILE)) {
+					const problem = citationProblem(m[1], m[2], m[3]);
+					if (problem) fail("dead-citation", where, problem);
+				}
+			});
+		}
+	}
+	for (const d of docs) for (const [n, line] of proseLines(d.body, d.offset)) {
+		for (const m of line.matchAll(LINK)) {
+			const href = m[1].split("#")[0];
+			if (!href || /^[a-z]+:/i.test(href)) continue;
+			if (!exists(normalize(join(dirname(d.path), href)))) fail("dead-link", `${d.path}:${n}`, `${m[1]} does not exist`);
+		}
+		if (d.data?.state === "historical") continue;
+		for (const m of line.matchAll(CITE)) {
+			const problem = citationProblem(m[1], m[2], m[3]);
+			if (problem) fail("dead-citation", `${d.path}:${n}`, problem);
+		}
+	}
+	let map = null;
+	const mapPath = `${CONTEXT}/map.json`;
+	if (!exists(mapPath)) fail("map", mapPath, "missing");
+	else {
+		const m = parseMap(read(mapPath));
+		if (typeof m === "string") fail("map", mapPath, m);
+		else map = m;
+	}
+	const indexPath = `${CONTEXT}/INDEX.md`;
+	if (!exists(indexPath)) fail("index", indexPath, "missing");
+	else {
+		const text = read(indexPath);
+		const words = wordCount(text);
+		if (words > 800) fail("index-budget", indexPath, `${words} words, budget 800`);
+		else note("index", `${words} / 800 words`);
+		if (map) {
+			const fenced = GENERATED.exec(text)?.[1];
+			if (fenced === void 0) fail("index-table", indexPath, "no <!-- generated --> fences around the capability table");
+			else if (capabilityTable(map).trim() !== lf(fenced).trim()) fail("index-table", indexPath, `the capability table differs from ${mapPath} - run \`npx ${NAME} context index\``);
+		}
+	}
+	if (tracked) {
+		for (const d of docs) if (d.data?.audience === "restricted" && tracked.has(d.path)) fail("audience", d.path, "restricted, yet tracked by git");
+	}
+	const graph = publishGraph(root);
+	let inContext = 0;
+	for (const p of graph.files) {
+		const declared = /\.mdx?$/.test(p) ? frontMatter(read(p)).data?.audience : void 0;
+		if (p.startsWith(`${CONTEXT}/`)) {
+			inContext++;
+			const audience = typeof declared === "string" ? declared : "team";
+			if (audience !== "publishable") fail("audience", p, `${audience} material reachable from design/publish.json`);
+		} else if (typeof declared === "string" && declared !== "publishable") fail("audience", p, `${declared} material reachable from design/publish.json`);
+	}
+	for (const u of graph.unresolved) if (/context\//.test(u.spec)) cannot("audience", `${u.from} imports ${u.spec}, which does not resolve - cannot tell what it would publish`);
+	note("audience", `${graph.files.size} files reachable from design/publish.json; ${inContext} under ${CONTEXT}/`);
+	for (const d of docs) {
+		if (d.path.startsWith(`${CONTEXT}/product/`) && d.data && !CONTRACT_STATES.includes(String(d.data.state))) fail("state", d.path, `state "${String(d.data.state)}" is not a contract state (${CONTRACT_STATES.join(", ")})`);
+		if (!d.path.startsWith(`${CONTEXT}/feedback/`)) continue;
+		for (const n of looseTables(d.text)) fail("table-format", `${d.path}:${n}`, "a table without outer pipes - start and end every row with |");
+		for (const t of tables(d.text)) {
+			const si = t.header.findIndex((h) => /^state$/i.test(h));
+			if (si < 0) continue;
+			let ri = t.header.findIndex((h) => /resolv/i.test(h));
+			if (ri < 0) ri = t.header.length - 1;
+			for (const r of t.rows) {
+				const state = (r.cells[si] ?? "").replace(/`/g, "").trim();
+				const where = `${d.path}:${r.line}`;
+				if (!FEEDBACK_STATES.includes(state)) fail("state", where, `"${state}" is not a feedback state (${FEEDBACK_STATES.join(", ")})`);
+				const resolution = r.cells[ri] ?? "";
+				if (state !== "shipped") continue;
+				const claims = resolution.split(";").filter((c) => !/\b(implement(ed|ation)|built|merged|coded|tested|test suite|ci)\b/i.test(c) || /\b(available|availability|production|live|delivered)\b/i.test(c)).join(";");
+				if (ri === si || !availableLevels(claims).includes("confirmed") || !CITATION.test(resolution) || /availab\w*[^;]*`unknown`/i.test(resolution)) fail("feedback-closed", where, "shipped without a cited `confirmed` availability in its resolution");
+				for (const m of resolution.matchAll(CITED_FILE)) {
+					const problem = citationProblem(m[1], m[2], m[3]);
+					if (problem) fail("dead-citation", where, problem);
+				}
+			}
+		}
+	}
+	if (map) {
+		for (const [cap, c] of Object.entries(map.capabilities)) {
+			if (c.contract && !exists(c.contract)) fail("map", mapPath, `${cap}: contract ${c.contract} does not exist`);
+			for (const t of c.tests ?? []) if (!(hasGlob(t) ? tracked ? [...tracked].some((f) => globRe(t).test(f)) : true : exists(t))) fail("map", mapPath, `${cap}: test ${t} ${hasGlob(t) ? "matches no tracked file" : "does not exist"}`);
+		}
+		if (tracked && map.source?.length) {
+			const inSource = map.source.map(globRe);
+			const covered = [...Object.values(map.capabilities).flatMap((c) => [...c.paths, ...c.tests ?? []]), ...map.excluded.map((e) => e.path)].map(globRe);
+			const loose = [...tracked].filter((p) => inSource.some((r) => r.test(p)) && !covered.some((r) => r.test(p)));
+			note("map", loose.length ? `${loose.length} source files neither mapped nor excluded, e.g. ${loose.slice(0, 5).join(", ")}` : "every source file is mapped or excluded");
+		}
+	}
+	const boardsDir = join(root, "design", "boards");
+	if (existsSync(boardsDir)) for (const f of readdirSync(boardsDir).filter((x) => x.endsWith(".json") && !x.startsWith("_"))) try {
+		const j = JSON.parse(readFileSync(join(boardsDir, f), "utf8"));
+		if (readStatusWord(j?.status) === "done") fail("board-status", `design/boards/${f}`, "\"status\": \"done\" - Done comes only from the shipped record; remove it");
+	} catch {}
+	for (const d of docs.filter((x) => /\/playbooks\/[^/]+\/PLAYBOOK\.md$/.test(x.path))) {
+		const ls = d.data?.last_success;
+		const rev = typeof ls === "object" && ls ? ls.revision : void 0;
+		const all = [].concat(d.data?.depends_on ?? []).filter((x) => typeof x === "string");
+		const deps = all.filter((x) => !/^(service|account)\s*:/.test(x));
+		const outside = all.length - deps.length;
+		if (typeof rev !== "string") {
+			note("playbook", `${d.path}: unknown - no last_success.revision`);
+			continue;
+		}
+		try {
+			git("cat-file", "-e", `${rev}^{commit}`);
+			const changed = deps.length ? git("diff", "--name-only", rev, "--", ...deps).trim() : "";
+			note("playbook", `${d.path}: ${changed ? `stale - ${changed.split("\n").length} dependencies changed since ${rev}` : outside ? `unknown - its files are unchanged since ${rev}, ${outside} dependenc${outside === 1 ? "y" : "ies"} outside git (a service, an account) cannot be checked` : `current since ${rev} (working tree included)`}`);
+		} catch {
+			note("playbook", `${d.path}: unknown - ${rev} is not in this clone's history`);
+		}
+	}
+	if (opts.prError) cannot("pr", opts.prError);
+	if (opts.base && map) {
+		let changed = null;
+		try {
+			changed = git("diff", "--name-only", "-z", `${opts.base}...${opts.head ?? "HEAD"}`).split("\0").filter(Boolean);
+		} catch {
+			cannot("pr", `no merge base between ${opts.base} and ${opts.head ?? "HEAD"} - fetch full history (fetch-depth: 0)`);
+		}
+		if (changed) for (const [cap, c] of Object.entries(map.capabilities)) {
+			if (!c.contract) continue;
+			const res = c.paths.map(globRe);
+			const hit = changed.filter((p) => res.some((r) => r.test(p)));
+			if (!hit.length || changed.includes(c.contract)) continue;
+			if (!new RegExp(`no-contract-change:\\s*${cap}\\s*-\\s*\\S`, "i").test(opts.body ?? "")) fail("pr", cap, `changes ${hit.length} mapped file(s) (${hit.slice(0, 3).join(", ")}) without ${c.contract} - update it, or write "no-contract-change: ${cap} - <why>" in the pull request`);
+		}
+	}
+	return {
+		exit: failures.length ? 1 : unsure.length ? 2 : 0,
+		failures,
+		unsure,
+		notes
+	};
+}
+/** The pull request this ci run checks, from GitHub's event payload: base, head and body. */
+function pullRequestFromEnv(env = process.env) {
+	if (!/^pull_request(_target)?$/.test(env.GITHUB_EVENT_NAME ?? "")) return null;
+	try {
+		const pr = JSON.parse(readFileSync(env.GITHUB_EVENT_PATH ?? "", "utf8")).pull_request;
+		if (typeof pr?.base?.sha !== "string" || typeof pr?.head?.sha !== "string") throw new Error("no base and head in the event");
+		return {
+			base: pr.base.sha,
+			head: pr.head.sha,
+			body: typeof pr.body === "string" ? pr.body : ""
+		};
+	} catch (e) {
+		return { prError: `the pull request event (GITHUB_EVENT_PATH) could not be read: ${e.message}` };
+	}
+}
+/** The human report. */
+function printCheck(r) {
+	for (const n of r.notes) console.log(`  ${n.rule}  ${n.what}`);
+	for (const u of r.unsure) console.log(`? ${u.rule}  cannot determine: ${u.what}`);
+	for (const f of r.failures) console.log(`✗ ${f.rule}  ${f.where}  ${f.what}`);
+	console.log(`\ncontext check: ${r.exit === 0 ? "pass" : r.exit === 1 ? `${r.failures.length} failing` : "cannot determine"}`);
+}
+/** Where this repository's context conventions live - the canvas's instruction, else context/README.md. */
+const conventionsPath = (root) => existsSync(join(root, "design", "instructions", "context.md")) ? "design/instructions/context.md" : `${CONTEXT}/README.md`;
+//#endregion
+export { INDEX_BUDGET, contextCheck, contextIndex, contextInit, conventionsPath, printCheck, pullRequestFromEnv };

package/dist/{daemon-DbHvLQUL.mjs → daemon-BmkwErpC.mjs}

@@ -1,7 +1,7 @@
 import { n as replay } from "./events-B3LBn74P.mjs";
 import { i as readLog, r as listBoards, t as appendEvents } from "./comments-DZyobpxG.mjs";
 import { n as localProfile } from "./profile-BjAPAJSb.mjs";
-import { a as toFrameId } from "./manifest-B01PSyDc.mjs";
+import { a as toFrameId } from "./manifest-BqBcMJcd.mjs";
 import { workActivity } from "./work-CLrmY-vQ.mjs";
 import { r as deviceId, t as has } from "./ledger-Bu0BjqIe.mjs";
 import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, watch, writeFileSync, writeSync } from "node:fs";

package/dist/{dev-BjdDP69b.mjs → dev-BW7a5kDF.mjs}

@@ -1,6 +1,6 @@
 import { i as PKG, r as NAME } from "./cli.mjs";
-import { c as loadConfig, u as detectHost } from "./manifest-B01PSyDc.mjs";
-import { n as tailwind3Css, r as tailwind4Plugin, t as marverPlugin } from "./plugin-y4Ch7o_A.mjs";
+import { i as detectHost, n as loadConfig } from "./config-DJxMRVD8.mjs";
+import { n as tailwind3Css, r as tailwind4Plugin, t as marverPlugin } from "./plugin-8XntSCx_.mjs";
 import { readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -413,7 +413,9 @@ async function dev(root, portFlag) {
 				"**/coverage/**",
 				"**/.gstack/**",
 				"**/.git/**",
-				"**/.playwright-mcp/**"
+				"**/.playwright-mcp/**",
+				"**/context/map.json",
+				"**/context/sync/**"
 			] },
 			warmup: { clientFiles: [
 				join(clientDir, "frame-host", "main.tsx"),
@@ -452,12 +454,12 @@ async function dev(root, portFlag) {
 	console.log(`\n  ${NAME} · ${projectName} → http://localhost:${port}/\n`);
 	setTimeout(async () => {
 		try {
-			await (await import("./shot-iw3SEcpn.mjs")).sweepGhosts((m) => console.log(`  ${m}`));
+			await (await import("./shot-C22Ues04.mjs")).sweepGhosts((m) => console.log(`  ${m}`));
 		} catch {}
 	}, 0);
 	try {
 		const { staleManagedInstructions } = await import("./managed-HwHVNI3h.mjs");
-		const { installedVersion } = await import("./plugin-y4Ch7o_A.mjs").then((n) => n.i);
+		const { installedVersion } = await import("./plugin-8XntSCx_.mjs").then((n) => n.i);
 		const stale = staleManagedInstructions(root);
 		if (stale.length) {
 			const shown = stale.slice(0, 4).join(", ") + (stale.length > 4 ? `, +${stale.length - 4} more` : "");
@@ -495,7 +497,7 @@ async function dev(root, portFlag) {
 		});
 	}
 	if (config.jam) {
-		const { startJam } = await import("./daemon-DbHvLQUL.mjs");
+		const { startJam } = await import("./daemon-BmkwErpC.mjs");
 		const jam = startJam(root, config.jam, (m) => console.log(m), (board) => server.ws.send("sh:jam-comment", { board }));
 		if (jam) {
 			const close = server.close.bind(server);