lazycodex-ai 5.0.0-beta.89 → 5.0.0-beta.90

package/packages/omo-codex/plugin/skills/ulw-research/scripts/html-lite.mjs

@@ -0,0 +1,239 @@
+// html-lite.mjs - a dependency-free HTML tokenizer for report checks.
+//
+// Single forward scan with indexOf (no whole-document regex, no backtracking). Produces a
+// LiteNode tree: { tag, attrs, children, parent, line, text, raw }. Text nodes carry
+// tag "#text"; <style>/<script>/<svg> keep their inner source in `raw` and have no parsed
+// children. The "#document" root also carries `ids` (id -> occurrence count) so
+// selectorPath can tell whether an id is unique. Plain Node ESM, no dependencies.
+
+import { decodeEntities } from "./entities.mjs"
+
+export { decodeEntities }
+
+const VOID_TAGS = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"])
+const RAW_TAGS = new Set(["style", "script", "svg"])
+const HEADINGS = ["h1", "h2", "h3", "h4", "h5", "h6"]
+const P_CLOSERS = new Set([
+	"address", "article", "blockquote", "details", "div", "dl", "fieldset", "figcaption", "figure", "footer",
+	"form", "header", "hr", "main", "menu", "nav", "ol", "p", "pre", "section", "table", "ul", ...HEADINGS,
+])
+const P_SCOPE = new Set(["td", "th", "caption", "button", "body", "html"])
+const LI_SCOPE = new Set(["ul", "ol", "menu", "body", "html"])
+const PROSE_SKIP = new Set(["code", "pre", "kbd", "samp", "script", "style", "svg"])
+const SAFE_ID = /^[A-Za-z_][\w-]*$/
+
+export const PROSE_TAGS = new Set(["p", "li", ...HEADINGS, "td", "th", "figcaption", "blockquote", "dd", "dt"])
+const PROSE_BREAKS = new Set([...P_CLOSERS, ...PROSE_TAGS, "br", "tr"])
+
+function makeNode(tag, attrs, parent, line) {
+	return { tag, attrs, children: [], parent, line, text: "", raw: null }
+}
+
+function lineStarts(source) {
+	const starts = [0]
+	for (let at = source.indexOf("\n"); at !== -1; at = source.indexOf("\n", at + 1)) starts.push(at + 1)
+	return starts
+}
+
+function lineAt(starts, offset) {
+	let lo = 0
+	let hi = starts.length - 1
+	while (lo < hi) {
+		const mid = (lo + hi + 1) >> 1
+		if (starts[mid] <= offset) lo = mid
+		else hi = mid - 1
+	}
+	return lo + 1
+}
+
+const isSpace = (ch) => ch === " " || ch === "\n" || ch === "\t" || ch === "\r" || ch === "\f"
+const isLetter = (ch) => (ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z")
+
+function skipSpaces(source, at) {
+	while (at < source.length && isSpace(source[at])) at++
+	return at
+}
+
+/** Read `<name attrs...>` starting just after `<`. */
+function readTag(source, start) {
+	const end = source.length
+	let at = start
+	while (at < end && !isSpace(source[at]) && source[at] !== ">" && source[at] !== "/") at++
+	const name = source.slice(start, at).toLowerCase()
+	const attrs = {}
+	let selfClosing = false
+	while (at < end) {
+		const ch = source[at]
+		if (isSpace(ch)) { at++; continue }
+		if (ch === ">") return { name, attrs, end: at + 1, selfClosing }
+		selfClosing = ch === "/" && source[at + 1] === ">"
+		if (ch === "/") { at++; continue }
+		let stop = at + 1
+		while (stop < end && !isSpace(source[stop]) && source[stop] !== "/" && source[stop] !== ">" && source[stop] !== "=") stop++
+		const key = source.slice(at, stop).toLowerCase()
+		at = skipSpaces(source, stop)
+		let value = ""
+		if (source[at] === "=") {
+			at = skipSpaces(source, at + 1)
+			const quote = source[at]
+			if (quote === '"' || quote === "'") {
+				const close = source.indexOf(quote, at + 1)
+				const valueEnd = close === -1 ? end : close
+				value = source.slice(at + 1, valueEnd)
+				at = valueEnd + 1
+			} else {
+				let valueEnd = at
+				while (valueEnd < end && !isSpace(source[valueEnd]) && source[valueEnd] !== ">") valueEnd++
+				value = source.slice(at, valueEnd)
+				at = valueEnd
+			}
+		}
+		if (key !== "__proto__" && !Object.hasOwn(attrs, key)) attrs[key] = decodeEntities(value)
+	}
+	return { name, attrs, end, selfClosing }
+}
+
+function tagNameAt(source, at, tag) {
+	if (source.slice(at, at + tag.length).toLowerCase() !== tag) return false
+	const next = source[at + tag.length] ?? ">"
+	return isSpace(next) || next === ">" || next === "/"
+}
+
+/** Find the close of a raw element; nested <svg> is depth-counted. Returns [innerEnd, resumeAt]. */
+function findRawClose(source, from, tag) {
+	let depth = 0
+	for (let lt = source.indexOf("<", from); lt !== -1; lt = source.indexOf("<", lt + 1)) {
+		if (source[lt + 1] === "/" && tagNameAt(source, lt + 2, tag)) {
+			if (depth === 0) {
+				const gt = source.indexOf(">", lt)
+				return [lt, gt === -1 ? source.length : gt + 1]
+			}
+			depth--
+		} else if (tag === "svg" && tagNameAt(source, lt + 1, tag)) {
+			depth++
+		}
+	}
+	return [source.length, source.length]
+}
+
+/** Parse an HTML string into a LiteNode tree rooted at "#document"; never throws on malformed input. */
+export function parseHtml(source) {
+	const src = String(source)
+	const starts = lineStarts(src)
+	const root = makeNode("#document", {}, null, 1)
+	root.ids = new Map()
+	const stack = [root]
+	let sawBody = false
+	let textStart = 0
+	let at = 0
+	const top = () => stack[stack.length - 1]
+	const flushText = (to) => {
+		if (to > textStart) {
+			const node = makeNode("#text", {}, top(), lineAt(starts, textStart))
+			node.text = decodeEntities(src.slice(textStart, to))
+			top().children.push(node)
+		}
+	}
+	const closeWithin = (tag, scope) => {
+		for (let k = stack.length - 1; k > 0; k--) {
+			if (stack[k].tag === tag) { stack.length = k; return }
+			if (scope.has(stack[k].tag)) return
+		}
+	}
+	while (at < src.length) {
+		const lt = src.indexOf("<", at)
+		if (lt === -1) break
+		const next = src[lt + 1] ?? ""
+		if (src.startsWith("<!--", lt)) {
+			flushText(lt)
+			const close = src.indexOf("-->", lt + 4)
+			at = textStart = close === -1 ? src.length : close + 3
+		} else if (next === "!" || next === "?") {
+			flushText(lt)
+			const close = src.indexOf(">", lt)
+			at = textStart = close === -1 ? src.length : close + 1
+		} else if (next === "/" && isLetter(src[lt + 2] ?? "")) {
+			flushText(lt)
+			const tag = readTag(src, lt + 2)
+			if (tag.name !== "body" && tag.name !== "html") {
+				for (let k = stack.length - 1; k > 0; k--) {
+					if (stack[k].tag === tag.name) { stack.length = k; break }
+				}
+			}
+			at = textStart = tag.end
+		} else if (isLetter(next)) {
+			flushText(lt)
+			const tag = readTag(src, lt + 1)
+			at = textStart = tag.end
+			if ((tag.name === "html" || tag.name === "body" || tag.name === "head") && stack.some((n) => n.tag === tag.name)) continue
+			if (P_CLOSERS.has(tag.name)) closeWithin("p", P_SCOPE)
+			if (tag.name === "li") closeWithin("li", LI_SCOPE)
+			const node = makeNode(tag.name, tag.attrs, top(), lineAt(starts, lt))
+			top().children.push(node)
+			if (tag.name === "body") sawBody = true
+			if (tag.attrs.id) root.ids.set(tag.attrs.id, (root.ids.get(tag.attrs.id) ?? 0) + 1)
+			if (RAW_TAGS.has(tag.name)) {
+				node.raw = ""
+				if (!tag.selfClosing) {
+					const [innerEnd, resume] = findRawClose(src, tag.end, tag.name)
+					node.raw = src.slice(tag.end, innerEnd)
+					at = textStart = resume
+				}
+			} else if (!VOID_TAGS.has(tag.name)) {
+				stack.push(node)
+			}
+		} else {
+			at = lt + 1
+		}
+	}
+	flushText(src.length)
+	if (!sawBody) wrapInBody(root)
+	return root
+}
+
+/** Fragments without <body>: move everything except <head> under a synthesized body. */
+function wrapInBody(root) {
+	const host = root.children.find((child) => child.tag === "html") ?? root
+	const kept = host.children.filter((child) => child.tag === "head")
+	const moved = host.children.filter((child) => child.tag !== "head")
+	const body = makeNode("body", {}, host, moved[0]?.line ?? 1)
+	for (const child of moved) child.parent = body
+	body.children = moved
+	host.children = [...kept, body]
+}
+
+function segment(node) {
+	const same = node.parent.children.filter((child) => child.tag === node.tag)
+	return same.length > 1 ? `${node.tag}:nth-of-type(${same.indexOf(node) + 1})` : node.tag
+}
+
+/** CSS selector for a node: nearest unique-id anchor, else `body > tag:nth-of-type(k) > ...`. */
+export function selectorPath(node) {
+	let root = node
+	while (root.parent) root = root.parent
+	const ids = root.ids ?? new Map()
+	const segments = []
+	for (let cur = node.tag === "#text" ? node.parent : node; cur?.parent; cur = cur.parent) {
+		const id = cur.attrs.id
+		if (id && SAFE_ID.test(id) && ids.get(id) === 1) return [`#${id}`, ...segments].join(" > ")
+		if (cur.tag === "body") return ["body", ...segments].join(" > ")
+		if (cur.tag === "html") break
+		segments.unshift(segment(cur))
+	}
+	return segments.join(" > ")
+}
+
+/** Descendant text minus code/pre/kbd/samp/script/style/svg, whitespace collapsed. */
+export function proseText(node) {
+	const parts = []
+	const walk = (cur) => {
+		if (cur.tag === "#text") { parts.push(cur.text); return }
+		if (PROSE_SKIP.has(cur.tag)) return
+		const breaks = PROSE_BREAKS.has(cur.tag)
+		if (breaks) parts.push(" ")
+		for (const child of cur.children) walk(child)
+		if (breaks) parts.push(" ")
+	}
+	for (const child of node.children) walk(child)
+	return parts.join("").replace(/\s+/g, " ").trim()
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/layout-probe.mjs

@@ -0,0 +1,83 @@
+// layout-probe.mjs - the in-page probe the layout gates consume.
+//
+// buildProbeSource() returns ONE async IIFE expression (the engine's evaluate awaits it): it first
+// forces lazy images to load eagerly and awaits their decode (bounded), so natural sizes are real. The orchestrator evaluates it in the rendered
+// report through the browser skill's owned headless engine and writes the result to boxes.json;
+// gates-layout.mjs reads that file. This module never launches a browser.
+//
+// Selector paths use the SAME rule as html-lite.selectorPath (a unique safe #id anchors the path,
+// otherwise tag segments with :nth-of-type(k) only when the parent has more than one child of that
+// tag, prefixed "body"), so a layout defect can be mapped back to the static tree. The rule lives in
+// PATH_FUNCTION_SOURCE, embedded verbatim in the probe and exercised by the parity test.
+
+export const PROBE_VERSION = 1
+export const SAMPLED_SELECTOR = "figure, .fig, img, svg, table, h1, h2, h3, p, pre"
+export const EXCLUDED_ANCESTORS = Object.freeze(["svg", "nav", "header", "footer"])
+
+/** In-page path rule. idCount(id) returns how many elements carry that id. */
+export const PATH_FUNCTION_SOURCE = `function ulwSelectorPath(el, idCount) {
+	const SAFE_ID = /^[A-Za-z_][\\w-]*$/;
+	const segments = [];
+	for (let cur = el; cur && cur.parentElement; cur = cur.parentElement) {
+		const tag = cur.tagName.toLowerCase();
+		const id = cur.id;
+		if (id && SAFE_ID.test(id) && idCount(id) === 1) return ["#" + id].concat(segments).join(" > ");
+		if (tag === "body") return ["body"].concat(segments).join(" > ");
+		if (tag === "html") break;
+		const same = Array.from(cur.parentElement.children).filter((c) => c.tagName === cur.tagName);
+		segments.unshift(same.length > 1 ? tag + ":nth-of-type(" + (same.indexOf(cur) + 1) + ")" : tag);
+	}
+	return segments.join(" > ");
+}`
+
+export class ProbeError extends Error {
+	constructor(code, message) {
+		super(message)
+		this.name = "ProbeError"
+		this.code = code
+	}
+}
+
+/** @param {{ cap?: number, root?: string }} [options] */
+export function buildProbeSource({ cap = 400, root = "main, article" } = {}) {
+	if (!Number.isInteger(cap) || cap <= 0) throw new ProbeError("invalid_cap", `--cap requires a positive integer, got ${cap}`)
+	if (typeof root !== "string" || root.trim().length === 0) throw new ProbeError("invalid_root", "--root requires a non-empty CSS selector")
+	return `(async () => {
+	const CAP = ${cap};
+	const IMAGE_WAIT_MS = 5000;
+	const ROOT = document.querySelector(${JSON.stringify(root)}) || document.body;
+	const EXCLUDED = ${JSON.stringify(EXCLUDED_ANCESTORS)};
+	const images = Array.from(document.images);
+	for (const img of images) if (img.loading === "lazy") img.loading = "eager";
+	const settle = Promise.all(images.map((img) => (img.complete && img.naturalWidth > 0 ? null : img.decode().catch(() => null))));
+	await Promise.race([settle, new Promise((resolve) => setTimeout(resolve, IMAGE_WAIT_MS))]);
+	${PATH_FUNCTION_SOURCE}
+	const idCount = (id) => document.querySelectorAll("#" + CSS.escape(id)).length;
+	const path = (el) => ulwSelectorPath(el, idCount);
+	const r1 = (n) => Math.round(n * 10) / 10;
+	const rect = (el) => { const b = el.getBoundingClientRect(); return { x: r1(b.left + scrollX), y: r1(b.top + scrollY), w: r1(b.width), h: r1(b.height) }; };
+	const excluded = (el) => { for (let p = el.parentElement; p; p = p.parentElement) if (EXCLUDED.includes(p.tagName.toLowerCase())) return true; return false; };
+	const all = Array.from(ROOT.querySelectorAll(${JSON.stringify(SAMPLED_SELECTOR)})).filter((el) => {
+		if (excluded(el)) return false;
+		const b = el.getBoundingClientRect();
+		return b.width > 0 || b.height > 0;
+	});
+	const boxes = all.slice(0, CAP).map((el) => {
+		const cs = getComputedStyle(el);
+		const parent = el.parentElement;
+		const box = {
+			selector: path(el), tag: el.tagName.toLowerCase(), rect: rect(el),
+			parentSelector: parent ? path(parent) : null, parentRect: parent ? rect(parent) : null,
+			parentOverflow: parent ? { x: getComputedStyle(parent).overflowX, y: getComputedStyle(parent).overflowY } : null,
+			scroll: { sw: el.scrollWidth, cw: el.clientWidth, sh: el.scrollHeight, ch: el.clientHeight },
+			overflow: { x: cs.overflowX, y: cs.overflowY }, position: cs.position,
+			textLen: (el.textContent || "").trim().length,
+		};
+		if (el.tagName === "IMG") { box.objectFit = cs.objectFit; box.natural = { w: el.naturalWidth, h: el.naturalHeight }; }
+		return box;
+	});
+	return { probe_version: ${PROBE_VERSION}, viewport: { w: innerWidth, h: innerHeight },
+		document: { w: document.documentElement.scrollWidth, h: document.documentElement.scrollHeight },
+		count: all.length, truncated: all.length > CAP, boxes };
+})()`
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/outcome.mjs

@@ -0,0 +1,250 @@
+// outcome.mjs - the per-run outcome manifest (`outcome.json`) and the closing briefing.
+// Manifest functions are pure (they return a new manifest); the briefing reads only the
+// manifest, the sources-ledger text, and an injected `now`. node: builtins only.
+
+import * as nodeFs from "node:fs"
+import { basename, dirname, join } from "node:path"
+
+import { DELIVERABLE_FORMATS, DELIVERABLE_STATUSES, GATE_NAMES, GATE_STATUSES, LANES } from "./contracts.mjs"
+import { MANIFEST_CODES, SCHEMA_VERSION, validateOutcomeManifest } from "./contracts.mjs"
+
+export const MANIFEST_FILENAME = "outcome.json"
+const MISSING = MANIFEST_CODES[0]
+const SESSION_STAMP = /^(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})$/
+const SOURCE_LINE = /^\[(S|Source )\d+\]/
+const URL_PATTERN = /https?:\/\/[^\s)<>\]"'`]+/g
+const DRAFT_MARKER = "STATUS: draft"
+const DRAFT_SCAN_LINES = 5
+const REASON_REQUIRED = new Set(["blocked_capability", "skipped", "failed"])
+
+export class OutcomeError extends Error {
+	/** @param {string} code @param {string} message @param {readonly string[]} [allowed] */
+	constructor(code, message, allowed) {
+		super(message)
+		this.name = "OutcomeError"
+		this.code = code
+		if (allowed) this.allowed = [...allowed]
+	}
+}
+
+function assertOneOf(code, label, value, allowed) {
+	if (!allowed.includes(value)) {
+		throw new OutcomeError(code, `unknown ${label} ${JSON.stringify(value)}; allowed: ${allowed.join(", ")}`, allowed)
+	}
+}
+
+const clone = (manifest) => structuredClone(manifest)
+const isMissing = (error) => error?.code === "ENOENT" || error?.code === "ENOTDIR"
+
+function stamp(now) {
+	return (now ?? new Date()).toISOString()
+}
+
+/** Local wall-clock start time from a `YYYYMMDD-HHMMSS` session dir basename. */
+export function parseSessionStart(sessionDir) {
+	const match = SESSION_STAMP.exec(basename(sessionDir))
+	if (!match) throw new OutcomeError("invalid_session_dir", `session dir basename must be YYYYMMDD-HHMMSS: ${sessionDir}`)
+	const [y, mo, d, h, mi, s] = match.slice(1).map(Number)
+	const date = new Date(y, mo - 1, d, h, mi, s)
+	if (date.getMonth() !== mo - 1 || date.getDate() !== d || date.getHours() !== h) {
+		throw new OutcomeError("invalid_session_dir", `session dir basename is not a real local time: ${sessionDir}`)
+	}
+	return date
+}
+
+/** @param {{ sessionDir: string, promised: string[], lane: string|null, interview?: object|null, now?: Date }} input */
+export function initManifest({ sessionDir, promised, lane, interview = null, now }) {
+	const startedAt = parseSessionStart(sessionDir).toISOString()
+	if (lane !== null && lane !== undefined) assertOneOf("unknown_lane", "lane", lane, LANES)
+	const formats = [...new Set(promised)]
+	for (const format of formats) assertOneOf("unknown_format", "deliverable format", format, DELIVERABLE_FORMATS)
+	const updatedAt = stamp(now)
+	return {
+		schemaVersion: SCHEMA_VERSION,
+		sessionDir,
+		startedAt,
+		finishedAt: null,
+		elapsedMinutes: null,
+		lane: lane ?? null,
+		interview,
+		deliverables: formats.map((format) => ({ format, status: "pending", promised: true, updatedAt })),
+		renders: [],
+		gates: Object.fromEntries(GATE_NAMES.map((gate) => [gate, "not_run"])),
+		residualDefects: [],
+		repair: null,
+		sources: null,
+	}
+}
+
+/**
+ * Set one format's row; every other row is kept as is. An unpromised format gets a new
+ * row with promised=false. The row's detail fields are replaced by the ones given.
+ * @param {{ path?: string, reason?: string, pages?: number, bytes?: number, now?: Date }} [detail]
+ */
+export function setDeliverable(manifest, format, status, detail = {}) {
+	assertOneOf("unknown_format", "deliverable format", format, DELIVERABLE_FORMATS)
+	assertOneOf("unknown_status", "deliverable status", status, DELIVERABLE_STATUSES)
+	const next = clone(manifest)
+	const index = next.deliverables.findIndex((row) => row.format === format)
+	const row = { format, status, promised: index >= 0 ? next.deliverables[index].promised : false, updatedAt: stamp(detail.now) }
+	for (const key of ["path", "reason", "pages", "bytes"]) {
+		if (detail[key] !== undefined) row[key] = detail[key]
+	}
+	if (index >= 0) next.deliverables[index] = row
+	else next.deliverables.push(row)
+	return next
+}
+
+export function setGate(manifest, gate, status) {
+	assertOneOf("unknown_gate", "gate", gate, GATE_NAMES)
+	assertOneOf("unknown_gate_status", "gate status", status, GATE_STATUSES)
+	const next = clone(manifest)
+	next.gates[gate] = status
+	return next
+}
+
+export function addRender(manifest, path, page) {
+	if (typeof path !== "string" || path.length === 0) throw new OutcomeError("invalid_render", "render path must be a non-empty string")
+	if (!Number.isInteger(page) || page < 1) throw new OutcomeError("invalid_render", `render page must be an integer >= 1, got ${page}`)
+	const next = clone(manifest)
+	if (!next.renders.some((render) => render.path === path && render.page === page)) next.renders.push({ path, page })
+	return next
+}
+
+function fileSize(fs, path) {
+	try {
+		const stat = fs.statSync(path)
+		return stat.isFile() ? stat.size : null
+	} catch (error) {
+		if (isMissing(error)) return null
+		throw error
+	}
+}
+
+/**
+ * @param {object} manifest
+ * @param {{ statSync: typeof nodeFs.statSync }} [fs]
+ * @returns {{ ok: boolean, problems: { code: string, format: string, message: string, path?: string }[] }}
+ */
+export function verifyManifest(manifest, fs = nodeFs) {
+	const problems = []
+	for (const row of manifest.deliverables) {
+		const problem = (message, path) => problems.push({ code: MISSING, format: row.format, message, ...(path ? { path } : {}) })
+		if (row.status === "pending") problem(`${row.format} is still pending`)
+		else if (row.status === "delivered") {
+			if (!row.path) problem(`${row.format} is delivered without a path`)
+			else {
+				const size = fileSize(fs, row.path)
+				if (size === null) problem(`${row.format} delivered file is missing: ${row.path}`, row.path)
+				else if (size === 0) problem(`${row.format} delivered file is empty: ${row.path}`, row.path)
+			}
+		} else if (REASON_REQUIRED.has(row.status) && !row.reason) problem(`${row.format} is ${row.status} without a reason`)
+	}
+	return { ok: problems.length === 0, problems }
+}
+
+/**
+ * none = missing or empty file; partial = `STATUS: draft` in the first 5 lines, or the
+ * manifest (given, else a sibling outcome.json) still has a pending row; else complete.
+ * @returns {"none"|"partial"|"complete"}
+ */
+export function deliverableState(deliverablePath, manifestOrNull) {
+	let text
+	try {
+		text = nodeFs.readFileSync(deliverablePath, "utf8")
+	} catch (error) {
+		if (isMissing(error)) return "none"
+		throw error
+	}
+	if (text.trim() === "") return "none"
+	if (text.split(/\r?\n/, DRAFT_SCAN_LINES).some((line) => line.includes(DRAFT_MARKER))) return "partial"
+	const sibling = join(dirname(deliverablePath), MANIFEST_FILENAME)
+	const manifest = manifestOrNull ?? (nodeFs.existsSync(sibling) ? readManifest(sibling) : null)
+	if (manifest && manifest.deliverables.some((row) => row.status === "pending")) return "partial"
+	return "complete"
+}
+
+/** Hostname without a leading `www.`; null for a string URL cannot parse (not a source host). */
+function hostOf(url) {
+	return URL.canParse(url) ? new URL(url).hostname.toLowerCase().replace(/^www\./, "") : null
+}
+
+function repairSummary(repair) {
+	if (!repair) return null
+	const attempts = Array.isArray(repair.attempts) ? repair.attempts.length : repair.attempts ?? null
+	return { attempts, action: repair.decision?.action ?? repair.action ?? null, reason: repair.decision?.reason ?? repair.reason ?? null }
+}
+
+/** The briefing numbers, from the manifest + ledger text + injected `now` only. */
+export function briefingFacts(manifest, sourcesLedgerText, now) {
+	const sourceLines = String(sourcesLedgerText ?? "").split(/\r?\n/).filter((line) => SOURCE_LINE.test(line))
+	const hosts = new Set()
+	for (const line of sourceLines) {
+		for (const url of line.match(URL_PATTERN) ?? []) {
+			const host = hostOf(url)
+			if (host) hosts.add(host)
+		}
+	}
+	const elapsedMs = now.getTime() - new Date(manifest.startedAt).getTime()
+	return {
+		sources: sourceLines.length,
+		domains: hosts.size,
+		hosts: [...hosts].sort(),
+		minutes: Math.max(0, Math.round(elapsedMs / 60000)),
+		deliverables: manifest.deliverables.map((row) => ({ format: row.format, status: row.status, reason: row.reason ?? null, path: row.path ?? null })),
+		gates: { ...manifest.gates },
+		residualDefects: manifest.residualDefects.length,
+		repair: repairSummary(manifest.repair),
+	}
+}
+
+/** The closing briefing block as plain text. */
+export function buildBriefing(manifest, sourcesLedgerText, now) {
+	const facts = briefingFacts(manifest, sourcesLedgerText, now)
+	const repair = facts.repair
+		? `${facts.repair.attempts ?? "?"} attempt(s), last decision ${facts.repair.action ?? "?"} (${facts.repair.reason ?? "?"})`
+		: "not run"
+	return [
+		"Closing briefing",
+		`- Sources: ${facts.sources} from ${facts.domains} distinct domain(s), counted from the sources ledger.`,
+		`- Elapsed: ${facts.minutes} minute(s) since ${manifest.startedAt}.`,
+		"- Deliverables:",
+		"  | format | status | detail |",
+		"  |---|---|---|",
+		...facts.deliverables.map((row) => `  | ${row.format} | ${row.status} | ${row.reason ?? row.path ?? ""} |`),
+		`- Gates: ${GATE_NAMES.map((gate) => `${gate} ${facts.gates[gate]}`).join(", ")}.`,
+		`- Residual defects: ${facts.residualDefects}.`,
+		`- Repair: ${repair}.`,
+	].join("\n")
+}
+
+function assertValid(manifest, where) {
+	const { ok, errors } = validateOutcomeManifest(manifest)
+	if (!ok) throw new OutcomeError("invalid_manifest", `${where}: ${errors.join("; ")}`)
+}
+
+export function readManifest(file) {
+	let manifest
+	try {
+		manifest = JSON.parse(nodeFs.readFileSync(file, "utf8"))
+	} catch (error) {
+		if (error instanceof SyntaxError) throw new OutcomeError("invalid_manifest", `${file}: not valid JSON (${error.message})`)
+		throw error
+	}
+	assertValid(manifest, file)
+	return manifest
+}
+
+/** Validate, then write atomically (temp file in the same dir + rename). */
+export function writeManifest(file, manifest) {
+	assertValid(manifest, file)
+	const temp = join(dirname(file), `.${basename(file)}.${process.pid}.${Date.now()}.tmp`)
+	try {
+		nodeFs.writeFileSync(temp, `${JSON.stringify(manifest, null, "\t")}\n`, "utf8")
+		nodeFs.renameSync(temp, file)
+	} catch (error) {
+		nodeFs.rmSync(temp, { force: true })
+		throw error
+	}
+	return file
+}