lazycodex-ai 5.1.45 → 5.1.46

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

@@ -0,0 +1,193 @@
+// md-lite.mjs - a light Markdown block model for md/post deliverables.
+//
+// parseMarkdown(text) returns { blocks } in document order, each block one of heading,
+// paragraph, list_item, table_row, code, blockquote, with start/end offsets into the raw text
+// so text.slice(start, end) === block.text (table cells carry their own offsets). Headings carry
+// level 1-6. Code blocks are fenced (``` or ~~~); an unterminated fence runs to the end of the
+// text and is reported in problems as unterminated_fence, which a caller must refuse rather than
+// skip. Callers skip kind 'code' when they look for numbers. sectionKindsMd(blocks) classifies
+// sections with the gates-static classifier itself (sectionKind, closingTest). It never renders
+// HTML. Plain Node ESM, sibling imports only.
+
+import { closingTest, sectionKind } from "./gates-static.mjs"
+
+export { closingTest, sectionKind }
+
+/** A fence opener: a backtick fence's info string holds no backtick (else it is an inline span). */
+const FENCE = /^ {0,3}(?:(`{3,})[^`]*|(~{3,}).*)$/
+const HEADING = /^ {0,3}(#{1,6})(?=[ \t]|$)/
+const BLOCKQUOTE = /^ {0,3}> ?/
+/** A bullet or an ordered marker (digits, then . or ), then a space); group 1 is the number. */
+const LIST_ITEM = /^[ \t]*(?:[-*+]|(\d{1,9})[.)])[ \t]+/
+const TABLE_SEPARATOR = /^[ \t]*\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/
+const CLOSING_HASHES = /[ \t]+#+[ \t]*$|^#+[ \t]*$/
+const THEMATIC_BREAK = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/
+
+/** The Markdown block grammar, one named pattern per syntax. */
+export const MD_BLOCK_PATTERNS = Object.freeze({ FENCE, HEADING, BLOCKQUOTE, LIST_ITEM, TABLE_SEPARATOR, CLOSING_HASHES, THEMATIC_BREAK })
+
+/** Split into lines with offsets; end excludes the newline and a trailing carriage return. */
+function linesOf(text) {
+	const lines = []
+	let start = 0
+	while (start <= text.length) {
+		const newline = text.indexOf("\n", start)
+		const next = newline === -1 ? text.length + 1 : newline + 1
+		let end = newline === -1 ? text.length : newline
+		if (end > start && text[end - 1] === "\r") end--
+		lines.push({ start, end, next, raw: text.slice(start, end) })
+		start = next
+	}
+	return lines
+}
+
+/** Narrow [start, end) to its non-whitespace core. */
+function trimRange(text, start, end) {
+	let from = start
+	let to = end
+	while (from < to && /\s/.test(text[from])) from++
+	while (to > from && /\s/.test(text[to - 1])) to--
+	return { start: from, end: to }
+}
+
+function block(text, kind, range, extra = {}) {
+	return { kind, ...extra, text: text.slice(range.start, range.end), start: range.start, end: range.end }
+}
+
+function isSeparator(line) {
+	return line !== undefined && line.raw.includes("-") && TABLE_SEPARATOR.test(line.raw)
+}
+
+/** Cells split on unescaped pipes, outer pipes dropped, each cell trimmed with offsets. */
+function tableCells(text, range) {
+	const bounds = []
+	for (let k = range.start; k < range.end; k++) {
+		let slashes = 0
+		while (k - slashes - 1 >= range.start && text[k - slashes - 1] === "\\") slashes++
+		if (text[k] === "|" && slashes % 2 === 0) bounds.push(k)
+	}
+	const edges = [range.start - 1, ...bounds, range.end]
+	if (bounds[0] === range.start) edges.shift()
+	if (bounds.at(-1) === range.end - 1 && bounds.length > 0) edges.pop()
+	const cells = []
+	for (let k = 0; k + 1 < edges.length; k++) {
+		const cell = trimRange(text, edges[k] + 1, edges[k + 1])
+		cells.push({ text: text.slice(cell.start, cell.end), start: cell.start, end: cell.end })
+	}
+	return cells
+}
+
+function headingBlock(text, line, marker) {
+	const after = line.start + line.raw.indexOf(marker) + marker.length
+	const range = trimRange(text, after, line.end)
+	const closing = text.slice(range.start, range.end).match(CLOSING_HASHES)
+	if (closing) range.end = trimRange(text, range.start, range.start + (closing.index ?? 0)).end
+	return block(text, "heading", range, { level: marker.length })
+}
+
+/**
+ * Parse Markdown into a flat block list.
+ * @param {string} text
+ * @returns {{ blocks: { kind: string, level?: number, text: string, start: number, end: number,
+ *   cells?: { text: string, start: number, end: number }[] }[],
+ *   problems: { code: "unterminated_fence", line: number, start: number }[] }}
+ */
+export function parseMarkdown(text) {
+	const source = String(text ?? "")
+	const lines = linesOf(source)
+	const blocks = []
+	const problems = []
+	let paragraph = null
+	let inTable = false
+	const flush = () => {
+		if (paragraph) blocks.push(block(source, "paragraph", paragraph))
+		paragraph = null
+	}
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i]
+		const fence = line.raw.match(FENCE)
+		if (fence) {
+			flush()
+			inTable = false
+			const open = fence[1] ?? fence[2]
+			const codeStart = Math.min(line.next, source.length)
+			let close = lines.length
+			for (let k = i + 1; k < lines.length; k++) {
+				const candidate = lines[k].raw.trim()
+				if (candidate.startsWith(open[0].repeat(open.length)) && /^(`+|~+)$/.test(candidate)) {
+					close = k
+					break
+				}
+			}
+			let codeEnd = source.length
+			if (close === lines.length) problems.push({ code: "unterminated_fence", line: i + 1, start: line.start })
+			else {
+				codeEnd = Math.max(codeStart, lines[close].start - 1)
+				if (codeEnd > codeStart && source[codeEnd - 1] === "\r") codeEnd--
+			}
+			blocks.push(block(source, "code", { start: codeStart, end: codeEnd }))
+			i = close
+			continue
+		}
+		if (line.raw.trim() === "") {
+			flush()
+			inTable = false
+			continue
+		}
+		const range = trimRange(source, line.start, line.end)
+		if (!inTable && line.raw.includes("|") && isSeparator(lines[i + 1])) inTable = true
+		if (inTable && line.raw.includes("|")) {
+			flush()
+			if (!isSeparator(line)) blocks.push(block(source, "table_row", range, { cells: tableCells(source, range) }))
+			continue
+		}
+		inTable = false
+		const heading = line.raw.match(HEADING)
+		if (heading) {
+			flush()
+			blocks.push(headingBlock(source, line, heading[1]))
+			continue
+		}
+		if (THEMATIC_BREAK.test(line.raw)) {
+			flush()
+			continue
+		}
+		const marker = line.raw.match(BLOCKQUOTE) ?? line.raw.match(LIST_ITEM)
+		// Only an ordered marker numbered 1 may interrupt a paragraph (CommonMark); else it is text.
+		const continues = paragraph !== null && marker?.[1] !== undefined && Number(marker[1]) !== 1
+		if (marker && !continues) {
+			flush()
+			const kind = BLOCKQUOTE.test(line.raw) ? "blockquote" : "list_item"
+			const content = trimRange(source, line.start + marker[0].length, line.end)
+			if (content.end > content.start) blocks.push(block(source, kind, content))
+			continue
+		}
+		if (paragraph) paragraph.end = range.end
+		else paragraph = { start: range.start, end: range.end }
+	}
+	flush()
+	return { blocks, problems }
+}
+
+/**
+ * Section kind of every block, parallel to blocks: an h2 opens a section whose kind comes from
+ * its heading text (sources, closing, toc, appendix, glossary, or null for findings); an h3 that
+ * reads as a closing heading marks its blocks closing until the next h2 or h3, as in gates-static.
+ * @param {{ kind: string, level?: number, text: string }[]} blocks
+ * @param {{ closingPattern?: RegExp|string }} [options] extra closing heading pattern (the spec's)
+ * @returns {(string|null)[]}
+ */
+export function sectionKindsMd(blocks, options = {}) {
+	const isClosing = closingTest(options.closingPattern)
+	let section = null
+	let closingH3 = false
+	return blocks.map((entry) => {
+		if (entry.kind === "heading" && entry.level === 2) {
+			section = sectionKind(entry.text, isClosing)
+			closingH3 = false
+		} else if (entry.kind === "heading" && entry.level === 3) {
+			closingH3 = isClosing(entry.text)
+		}
+		return closingH3 ? "closing" : section
+	})
+}

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

@@ -0,0 +1,196 @@
+// meaning-check.mjs - ingest the meaning readers' verdicts over fact-pairs output.
+//
+// ingestVerdicts reads verdict files written by separate reader lanes (cheap and strong tiers),
+// keeps a drift verdict only when its pair exists, its tier and drift_kind are in the closed sets,
+// and both its fragment (from the sentence) and source_fragment (from the quote or statement) are
+// non-empty substrings after whitespace normalization; every other verdict is dropped and logged.
+// Both tiers naming the same drift_kind (not "other") on a pair is meaning_drift_confirmed (major,
+// never integrity); one tier is meaning_drift_warn (minor). Each flagged pair yields one
+// calibration line; a dispute is recorded there and never removes the defect. Coverage is
+// fail-closed: every pair no reader judged, and every force_strong pair no strong reader judged,
+// is listed in `unverified`, so a gate can tell a clean check apart from a pair nobody read.
+// No model, no fetch.
+
+import { appendFileSync, readFileSync } from "node:fs"
+
+import { DEFECT_CODES } from "./contracts.mjs"
+
+export const DRIFT_KINDS = Object.freeze([
+	"subject_changed", "scope_widened", "hedge_dropped", "certainty_added", "causality_added",
+	"direction_flipped", "population_changed", "evidence_grade_raised", "other",
+])
+export const MODEL_TIERS = Object.freeze(["cheap", "strong"])
+export const VERDICTS = Object.freeze(["drift", "ok"])
+export const isDriftKind = (kind) => DRIFT_KINDS.includes(kind)
+/** The machine-read verdict contract a reader lane receives with pairs.json; built from the registries above. */
+export const VERDICT_SCHEMA = Object.freeze({
+	model_tier: MODEL_TIERS,
+	verdict: VERDICTS,
+	drift_kind: DRIFT_KINDS,
+	required: Object.freeze(["pair_id", "verdict"]),
+	drift_required: Object.freeze(["drift_kind", "fragment", "source_fragment"]),
+})
+
+/** NFC, every whitespace run collapsed to one space, trimmed. */
+const squash = (text) => String(text ?? "").normalize("NFC").replace(/\s+/gu, " ").trim()
+
+/** Read a verdict file, mapping an unreadable path or invalid JSON to a short typed error. */
+function parseFile(path) {
+	let text
+	try {
+		text = readFileSync(path, "utf8")
+	} catch {
+		throw new TypeError(`${path}: cannot read the verdict file`)
+	}
+	try {
+		return JSON.parse(text)
+	} catch {
+		throw new TypeError(`${path}: the verdict file is not valid JSON`)
+	}
+}
+
+function verdictsOf(input) {
+	const label = typeof input === "string" ? input : "<inline>"
+	const parsed = typeof input === "string" ? parseFile(input) : input
+	const list = Array.isArray(parsed) ? parsed : parsed?.verdicts
+	if (!Array.isArray(list)) throw new TypeError(`${label}: a verdict file is an array of verdicts or { verdicts: [...] }`)
+	const tier = Array.isArray(parsed) ? undefined : parsed.model_tier
+	return list.map((verdict) => ({ verdict: tier === undefined || verdict?.model_tier !== undefined ? verdict : { ...verdict, model_tier: tier }, file: label }))
+}
+
+/** The reason a verdict is dropped, or null when it is accepted. */
+function dropReason(verdict, pair) {
+	if (verdict === null || typeof verdict !== "object") return "malformed_verdict"
+	if (!pair) return "unknown_pair"
+	if (!VERDICTS.includes(verdict.verdict)) return "invalid_verdict"
+	if (!MODEL_TIERS.includes(verdict.model_tier)) return "invalid_model_tier"
+	if (verdict.verdict === "ok") return null
+	if (!isDriftKind(verdict.drift_kind)) return "unknown_drift_kind"
+	const [fragment, sourceFragment] = [squash(verdict.fragment), squash(verdict.source_fragment)]
+	if (fragment === "" || sourceFragment === "") return "empty_fragment"
+	if (!squash(pair.sentence).includes(fragment)) return "fragment_not_found"
+	const source = pair.kind === "claim" ? pair.statement : pair.quote
+	if (!squash(source).includes(sourceFragment)) return "source_fragment_not_found"
+	return null
+}
+
+function defect(code, pair, driftKind, tiers, verdicts) {
+	const entry = DEFECT_CODES[code]
+	// The fragment must come from the verdict whose drift_kind is being reported, not from whichever
+	// verdict happened to arrive first on the pair.
+	const first = verdicts.find((verdict) => verdict.drift_kind === driftKind) ?? verdicts[0]
+	return {
+		code,
+		severity: entry.severity,
+		integrity: entry.integrity,
+		pair_id: pair.pair_id,
+		sentence_key: pair.sentence_key ?? null,
+		drift_kind: driftKind,
+		tiers,
+		fragment: first.fragment,
+		source_fragment: first.source_fragment,
+		selector: null,
+		line: null,
+		message: `${pair.pair_id}: ${tiers.join(" and ")} reader${tiers.length > 1 ? "s" : ""} found ${driftKind} at "${squash(first.fragment)}"`,
+		hint: entry.hint,
+	}
+}
+
+/** One meaning_unverified defect per coverage gap, so blocksDelivery sees an unread pair through the registry. */
+export function unverifiedDefects(unverified) {
+	const entry = DEFECT_CODES.meaning_unverified
+	return unverified.map((gap) => ({
+		code: "meaning_unverified",
+		severity: entry.severity,
+		integrity: entry.integrity,
+		pair_id: gap.pair_id,
+		reason: gap.reason,
+		selector: null,
+		line: null,
+		message: `${gap.pair_id}: ${gap.reason === "no_strong_verdict" ? "no strong reader judged this force_strong pair" : "no reader judged this pair"}`,
+		hint: entry.hint,
+	}))
+}
+
+/** Pairs with no accepted verdict, and force_strong pairs with no accepted strong verdict, in pair order. */
+function coverageGaps(list, accepted) {
+	const tiersByPair = new Map()
+	for (const verdict of accepted) {
+		tiersByPair.set(verdict.pair_id, (tiersByPair.get(verdict.pair_id) ?? new Set()).add(verdict.model_tier))
+	}
+	const gaps = []
+	for (const pair of list) {
+		const tiers = tiersByPair.get(pair.pair_id)
+		if (tiers === undefined || tiers.size === 0) gaps.push({ pair_id: pair.pair_id, reason: "no_verdict" })
+		else if (pair.force_strong === true && !tiers.has("strong")) gaps.push({ pair_id: pair.pair_id, reason: "no_strong_verdict" })
+	}
+	return gaps
+}
+
+/** Group accepted drift verdicts per pair, then per tier. */
+function flaggedPairs(accepted) {
+	const byPair = new Map()
+	for (const verdict of accepted) {
+		if (verdict.verdict !== "drift") continue
+		const tiers = byPair.get(verdict.pair_id) ?? new Map()
+		tiers.set(verdict.model_tier, [...(tiers.get(verdict.model_tier) ?? []), verdict])
+		byPair.set(verdict.pair_id, tiers)
+	}
+	return byPair
+}
+
+/** The drift_kind both tiers named (never "other"), or null. */
+function agreedKind(tiers) {
+	const [cheap, strong] = MODEL_TIERS.map((tier) => tiers.get(tier) ?? [])
+	return cheap.map((verdict) => verdict.drift_kind).find((kind) => kind !== "other" && strong.some((verdict) => verdict.drift_kind === kind)) ?? null
+}
+
+/**
+ * @param {object[] | { pairs: object[] }} pairs extractPairs(...) output
+ * @param {(string | object[] | { verdicts: object[], model_tier?: string })[]} verdictFiles paths, or parsed verdict lists
+ * @param {{ dispute?: { pair_id: string, reason: string }, calibrationPath?: string }} [options]
+ *   calibrationPath: append each calibration line to this JSONL file (fidelity-calibration.jsonl)
+ * @returns {{ defects: object[], dropped: object[], unverified: { pair_id: string, reason: string }[], calibrationLines: string[] }}
+ *   unverified lists, in pair order, every pair no reader judged (`no_verdict`) and every
+ *   force_strong pair no strong reader judged (`no_strong_verdict`); a verdict that was dropped
+ *   does not count as read. A consumer MUST treat a non-empty list as blocking: the pairs were
+ *   never checked, so an empty `defects` list does not mean the report is clean.
+ * @throws {TypeError} when pairs is neither an array nor `{ pairs: [...] }` (fail closed: a missing
+ *   pairs input never reads as a fully verified report)
+ */
+export function ingestVerdicts(pairs, verdictFiles, options = {}) {
+	const list = Array.isArray(pairs) ? pairs : pairs?.pairs
+	if (!Array.isArray(list)) throw new TypeError("pairs: expected an array of pairs or { pairs: [...] }")
+	const byId = new Map(list.map((pair) => [pair.pair_id, pair]))
+	const accepted = []
+	const dropped = []
+	for (const input of verdictFiles) {
+		for (const { verdict, file } of verdictsOf(input)) {
+			const reason = dropReason(verdict, byId.get(verdict?.pair_id))
+			if (reason === null) accepted.push(verdict)
+			else dropped.push({ file, pair_id: verdict?.pair_id ?? null, model_tier: verdict?.model_tier ?? null, reason })
+		}
+	}
+	const dispute = options.dispute ?? null
+	const defects = []
+	const calibrationLines = []
+	const flagged = flaggedPairs(accepted)
+	for (const pair of list) {
+		const tiers = flagged.get(pair.pair_id)
+		if (!tiers) continue
+		const tierNames = MODEL_TIERS.filter((tier) => tiers.has(tier))
+		const agreed = agreedKind(tiers)
+		const verdicts = MODEL_TIERS.flatMap((tier) => tiers.get(tier) ?? [])
+		const kind = agreed ?? verdicts[0].drift_kind
+		const confirmed = agreed !== null
+		defects.push(defect(confirmed ? "meaning_drift_confirmed" : "meaning_drift_warn", pair, kind, tierNames, verdicts))
+		const disputed = dispute !== null && dispute.pair_id === pair.pair_id
+		calibrationLines.push(JSON.stringify({ kind: pair.kind, pair_id: pair.pair_id, tiers: tierNames, drift_kind: kind, confirmed, disputed, reason: disputed ? String(dispute.reason ?? "") : null }))
+	}
+	const unverified = coverageGaps(list, accepted)
+	if (dispute !== null && !flagged.has(dispute.pair_id)) {
+		dropped.push({ file: "<dispute>", pair_id: dispute.pair_id, model_tier: null, reason: "dispute_not_flagged" })
+	}
+	if (options.calibrationPath && calibrationLines.length > 0) appendFileSync(options.calibrationPath, `${calibrationLines.join("\n")}\n`)
+	return { defects, dropped, unverified, calibrationLines }
+}

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

@@ -1,6 +1,5 @@
-// 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.
+// 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"
@@ -86,7 +85,7 @@ export function setDeliverable(manifest, format, status, detail = {}) {
 	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"]) {
+	for (const key of ["path", "reason", "pages", "bytes", "verifiedBy", "renderedFrom"]) {
 		if (detail[key] !== undefined) row[key] = detail[key]
 	}
 	if (index >= 0) next.deliverables[index] = row
@@ -94,11 +93,13 @@ export function setDeliverable(manifest, format, status, detail = {}) {
 	return next
 }
 
-export function setGate(manifest, gate, status) {
+export function setGate(manifest, gate, status, detail = {}) {
 	assertOneOf("unknown_gate", "gate", gate, GATE_NAMES)
 	assertOneOf("unknown_gate_status", "gate status", status, GATE_STATUSES)
+	if (gate === "fidelity" && status === "not_run" && (typeof detail.reason !== "string" || !detail.reason.trim())) throw new OutcomeError("gate_reason_required", "fidelity not_run requires a non-empty --reason")
 	const next = clone(manifest)
 	next.gates[gate] = status
+	next.gateHistory = [...(next.gateHistory ?? []), { gate, status, ...(detail.reason !== undefined ? { reason: detail.reason.trim() } : {}), at: stamp(detail.now) }]
 	return next
 }
 

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

@@ -0,0 +1,184 @@
+// placeholder.mjs - the fact pointer grammar of the fill step and its render helpers.
+// Value pointers: {{F12:label}}, {{F12:label:value}}, {{F12:label:unit}}, {{F12:label:q}}.
+// Quote pointers: {{Q7:label}}, {{Q7:label:lead=18}}, {{Q7:label:from="x":to="y"}} (anchors are
+// JSON strings, so they may hold a colon or an escaped quote). Labels are compared exactly by the
+// caller; this module never guesses an id. Pure functions; node: builtins only.
+
+import { parseNumeral } from "./numerals.mjs"
+
+export const ELLIPSIS = "\u2026"
+
+const ID = /^([FQ])\d+$/
+const LABEL = /^[^\s:{}"]+$/
+const VALUE_MODES = new Set(["value", "unit", "q"])
+const LEAD = /^lead=([1-9]\d*)$/
+const LINEAGE = Object.freeze({ measured: "MEASURED", assumed: "ASSUMED", derived: "DERIVED", converted: "DERIVED" })
+
+/** End index (exclusive) of a JSON string starting at `at`, or -1 when it is not closed on its line. */
+function jsonStringEnd(text, at) {
+	let i = at + 1
+	while (i < text.length && text[i] !== '"' && text[i] !== "\n") i += text[i] === "\\" ? 2 : 1
+	return text[i] === '"' ? i + 1 : -1
+}
+
+function readJsonString(text, at) {
+	if (text[at] !== '"') return null
+	const end = jsonStringEnd(text, at)
+	if (end === -1) return null
+	try {
+		return { value: JSON.parse(text.slice(at, end)), end }
+	} catch {
+		return null
+	}
+}
+
+function parseAnchors(tail) {
+	if (!tail.startsWith("from=")) return null
+	const from = readJsonString(tail, 5)
+	if (from === null || !tail.startsWith(":to=", from.end)) return null
+	const to = readJsonString(tail, from.end + 4)
+	if (to === null || to.end !== tail.length || from.value === "" || to.value === "") return null
+	return { from: from.value, to: to.value }
+}
+
+/** @returns the parsed pointer, or { error } for a malformed one. */
+export function parsePlaceholder(token) {
+	if (!token.startsWith("{{") || !token.endsWith("}}")) return { error: "a placeholder is {{ID:label...}}" }
+	const body = token.slice(2, -2)
+	const colon = body.indexOf(":")
+	const id = colon === -1 ? body : body.slice(0, colon)
+	const idMatch = ID.exec(id)
+	if (idMatch === null) return { error: `"${id}" is not an F<n> or Q<n> id` }
+	if (colon === -1) return { error: `${id} has no label; write {{${id}:label}}` }
+	const rest = body.slice(colon + 1)
+	const second = rest.indexOf(":")
+	const label = second === -1 ? rest : rest.slice(0, second)
+	if (!LABEL.test(label)) return { error: `"${label}" is not a label` }
+	const tail = second === -1 ? null : rest.slice(second + 1)
+	const base = { id, kind: idMatch[1], label }
+	if (idMatch[1] === "F") {
+		if (tail === null) return { ...base, mode: "full" }
+		return VALUE_MODES.has(tail) ? { ...base, mode: tail } : { error: `"${tail}" is not a value mode (value, unit, q)` }
+	}
+	if (tail === null) return { ...base, mode: "full", selector: "full" }
+	const lead = LEAD.exec(tail)
+	if (lead !== null) return { ...base, mode: "lead", lead: Number(lead[1]), selector: `lead=${lead[1]}` }
+	const anchors = parseAnchors(tail)
+	if (anchors === null) return { error: `"${tail}" is not a quote selector (lead=N or from="..":to="..")` }
+	return { ...base, mode: "span", ...anchors, selector: `from=${anchors.from};to=${anchors.to}` }
+}
+
+/** End index (exclusive) of the pointer opened at `at`, or -1 when it is not closed on its line. */
+function placeholderEnd(text, at) {
+	let i = at + 2
+	while (i < text.length && text[i] !== "\n") {
+		if (text[i] === '"') {
+			const end = jsonStringEnd(text, i)
+			if (end === -1) return -1
+			i = end
+		} else if (text.startsWith("}}", i)) return i + 2
+		else i++
+	}
+	return -1
+}
+
+/** Every `{{...}}` pointer in source order: [{ token, start, end, parsed }]. */
+export function findPlaceholders(text) {
+	const found = []
+	let at = text.indexOf("{{")
+	while (at !== -1) {
+		const end = placeholderEnd(text, at)
+		if (end === -1) {
+			found.push({ token: text.slice(at, text.indexOf("\n", at) === -1 ? text.length : text.indexOf("\n", at)), start: at, end: at + 2, parsed: { error: "the placeholder is not closed on its line" } })
+			at = text.indexOf("{{", at + 2)
+			continue
+		}
+		const token = text.slice(at, end)
+		found.push({ token, start: at, end, parsed: parsePlaceholder(token) })
+		at = text.indexOf("{{", end)
+	}
+	return found
+}
+
+function occurrences(text, needle) {
+	let count = 0
+	for (let at = text.indexOf(needle); at !== -1; at = text.indexOf(needle, at + 1)) count++
+	return count
+}
+
+function cut(quote, start, end) {
+	return { text: `${start > 0 ? ELLIPSIS : ""}${quote.slice(start, end)}${end < quote.length ? ELLIPSIS : ""}`, start, end }
+}
+
+/** The contiguous span from `from` through `to`; each anchor must occur exactly once, in order. */
+export function subSpan(quote, from, to) {
+	if (occurrences(quote, from) !== 1 || occurrences(quote, to) !== 1) return null
+	const start = quote.indexOf(from)
+	const toAt = quote.indexOf(to)
+	if (toAt < start || toAt + to.length < start + from.length) return null
+	return cut(quote, start, toAt + to.length)
+}
+
+/** The first `n` whitespace-delimited words, with an ellipsis when words were cut. */
+export function lead(quote, n) {
+	const words = [...quote.matchAll(/\S+/g)]
+	if (words.length <= n) return { text: quote, start: 0, end: quote.length }
+	const last = words[n - 1]
+	return cut(quote, 0, last.index + last[0].length)
+}
+
+/** The value and unit parts of a row's raw text ("4.2 eok won" -> value "4.2 eok", unit "won"). */
+export function valueParts(row) {
+	const unitText = parseNumeral(row.raw)?.unitRaw ?? row.unit
+	const valueText = unitText && row.raw.endsWith(unitText) ? row.raw.slice(0, -unitText.length).trimEnd() : (row.value ?? row.raw)
+	return { valueText, unitText: unitText ?? "" }
+}
+
+/** The quote interval holding the row's qualifier and its raw quantity, or null if absent. */
+export function qualifiedText(row) {
+	if (row.qualifier === null) return row.raw
+	for (let numeral = parseNumeral(row.quote); numeral !== null; numeral = parseNumeral(row.quote, numeral.span[1])) {
+		if (numeral.raw !== row.raw || numeral.qualifierRaw === null) continue
+		const [start, end] = numeral.span
+		const before = row.quote.lastIndexOf(numeral.qualifierRaw, start)
+		const between = before === -1 ? [] : row.quote.slice(before + numeral.qualifierRaw.length, start).split(/\s+/u).filter(Boolean)
+		if (before !== -1 && between.length <= 1) return row.quote.slice(before, end)
+		const after = row.quote.indexOf(numeral.qualifierRaw, end)
+		if (after !== -1) return row.quote.slice(start, after + numeral.qualifierRaw.length)
+	}
+	return null
+}
+
+export function escapeHtml(text) {
+	return String(text).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;")
+}
+
+/** The elements the renderers below emit as fact spans; recognizers build their patterns from this. */
+export const FACT_ELEMENT_TAGS = Object.freeze(["data", "q", "blockquote"])
+
+export function renderValueHtml(row, text) {
+	const unit = row.unit === null ? "" : ` data-unit="${escapeHtml(row.unit)}"`
+	return `<data class="fact" value="${escapeHtml(row.value)}" data-fact="${row.fact_id}"${unit} data-lineage="${LINEAGE[row.kind]}">${escapeHtml(text)}</data>`
+}
+
+export function renderQuote(row, selector, text, format) {
+	const marker = `[${row.source_id}]`
+	if (format === "md") return `"${text}" ${marker}`
+	return `<q data-fact="${row.fact_id}" data-quote-sel="${escapeHtml(selector)}">${escapeHtml(text)}</q> ${marker}`
+}
+
+const RENDERED_MD_QUOTE = /^"([\s\S]*)" (\[S\d+\])$/u
+
+/** The quote text and source marker of bytes renderQuote wrote for md, or null for any other layout. */
+export function parseRenderedQuote(body) {
+	const match = RENDERED_MD_QUOTE.exec(body)
+	return match ? { text: match[1], marker: match[2] } : null
+}
+
+/** The attributed block that replaces a twice-failed sentence; entity and valid_at stay outside the quote. */
+export function renderBlockquote(row, key, format) {
+	const attribution = row.entity === null ? "" : `, on ${row.entity}${row.valid_at === null ? "" : ` (${row.valid_at})`}`
+	const footer = `[${row.source_id}]${attribution}`
+	if (format === "md") return `> "${row.quote}"\n> ${footer}`
+	return `<blockquote data-fact="${row.fact_id}" data-replaced="${escapeHtml(key)}">"${escapeHtml(row.quote)}" <footer>${escapeHtml(footer)}</footer></blockquote>`
+}