oh-my-opencode 5.1.45 → 5.1.47

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

@@ -18,14 +18,19 @@ import { PROSE_TAGS, proseText, selectorPath } from "./html-lite.mjs"
 const CITATION_MARKER = /\[S\d+\]|\[Source\s*\d+\]|\[\uCD9C\uCC98[^\]]*\]|\[\^\d+\]/i
 const ANCHOR_HREF = /^#(?:s|src|source|ref|fn)/i
 const ANCHOR_TEXT = /^\[(?:\uCD9C\uCC98|Source\s*\d+|S\d+)\]$/i
-/** Closing ("how this report was made") heading; Korean alternates cover the same register. */
-export const CLOSING_HEADING = /\b(?:method(?:ology)?|how)\b|\uB4B7\uBA74|\uBC29\uBC95|\uC5B4\uB5BB\uAC8C|\uB9CC\uB4E4\uC5B4/i
+/**
+ * Closing ("how this report was made") heading; Korean alternates cover the same register. A
+ * heading that is exactly "Closing" (or the Korean word for it) also counts; a heading that only
+ * starts with it ("Closing the gap") does not.
+ */
+export const CLOSING_HEADING = /\b(?:method(?:ology)?|how)\b|\uB4B7\uBA74|\uBC29\uBC95|\uC5B4\uB5BB\uAC8C|\uB9CC\uB4E4\uC5B4|^\s*(?:closing|\uB9C8\uBB34\uB9AC)\s*$/i
 export const SOURCES_HEADING = /references|sources|bibliography|\uCD9C\uCC98|\uCC38\uACE0\s*(?:\uBB38\uD5CC|\uC790\uB8CC)/i
-const OTHER_KINDS = [
+/** Section kinds after sources and closing, in match order; HTML and Markdown share this table. */
+export const OTHER_KINDS = Object.freeze([
 	["toc", /\b(?:contents|toc)\b|\uBAA9\uCC28/i],
 	["appendix", /appendix|\uBD80\uB85D/i],
 	["glossary", /glossary|\uC6A9\uC5B4/i],
-]
+])
 const TEXT_SKIP = new Set(["code", "pre", "kbd", "samp", "script", "style", "svg", "template", "noscript"])
 const HEADING_TAG = /^h[1-6]$/
 /** The one sanctioned severity override: section-level lineage demotes unsourced_number. */
@@ -75,9 +80,25 @@ function findBody(doc) {
 	return doc
 }
 
-function sectionKind(text, closingTest) {
+/**
+ * Closing-heading test for both editions: CLOSING_HEADING plus the spec's optional pattern.
+ * @param {RegExp|string|null} [pattern]
+ * @returns {(text: string) => boolean}
+ */
+export function closingTest(pattern) {
+	const extra = pattern ? toRegExp(pattern) : null
+	return (text) => CLOSING_HEADING.test(text) || Boolean(extra?.test(text))
+}
+
+/**
+ * Section kind of an h2 heading text: sources, closing, toc, appendix, glossary, or null.
+ * @param {string} text
+ * @param {(text: string) => boolean} isClosing
+ * @returns {string|null}
+ */
+export function sectionKind(text, isClosing) {
 	if (SOURCES_HEADING.test(text)) return "sources"
-	if (closingTest(text)) return "closing"
+	if (isClosing(text)) return "closing"
 	return OTHER_KINDS.find(([, re]) => re.test(text))?.[0] ?? null
 }
 
@@ -111,7 +132,6 @@ function walkBody(ctx, node, state) {
 export function buildContext(doc, options) {
 	const lineageMode = options.lineageMode ?? "inline"
 	if (!LINEAGE_MODES.includes(lineageMode)) throw new TypeError(`lineageMode must be one of ${LINEAGE_MODES.join(", ")}`)
-	const closingPattern = options.closingPattern ? toRegExp(options.closingPattern) : null
 	const all = descendants(doc)
 	const styleBlocks = all.filter((node) => node.tag === "style").map((node) => ({ node, css: node.raw ?? "" }))
 	const styleAttrs = all.filter((node) => node.attrs.style).map((node) => ({ node, css: node.attrs.style }))
@@ -130,7 +150,7 @@ export function buildContext(doc, options) {
 		requireSections: (options.requireSections ?? []).map(toRegExp),
 		baseDir: options.baseDir ?? null,
 		fs: options.fs ?? nodeFs,
-		isClosing: (text) => CLOSING_HEADING.test(text) || Boolean(closingPattern?.test(text)),
+		isClosing: closingTest(options.closingPattern),
 		util: { classTokens, closest, descendants, hasCitation, citationMarker: CITATION_MARKER },
 		kindOf: (scope) => (scope.closingH3 ? "closing" : (scope.section?.kind ?? null)),
 		defect(code, node, message) {

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

@@ -54,8 +54,8 @@ function skipSpaces(source, at) {
 	return at
 }
 
-/** Read `<name attrs...>` starting just after `<`. */
-function readTag(source, start) {
+/** Read `<name attrs...>` starting just after `<`; the one attribute parser (any quoting). */
+export function readTag(source, start) {
 	const end = source.length
 	let at = start
 	while (at < end && !isSpace(source[at]) && source[at] !== ">" && source[at] !== "/") at++

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

@@ -0,0 +1,182 @@
+// Byte-preserving HTML boundaries for polish. No CSS or visibility inference.
+import { readTag } from "./html-lite.mjs"
+
+const RAW = new Set(["script", "style"])
+const FROZEN = new Set([...RAW, "template"])
+const VOID = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"])
+const isLetter = (ch) => /[a-z]/i.test(ch ?? "")
+
+function scan(src, at, visit) {
+	while (at < src.length) {
+		const start = src.indexOf("<", at)
+		if (start === -1) return
+		const next = src[start + 1]
+		let kind
+		let end
+		let tag = null
+		if (src.startsWith("<!--", start)) {
+			// From start + 2 so the abrupt closes <!--> and <!---> end where the HTML tokenizer ends them.
+			kind = "skip"
+			const stop = src.indexOf("-->", start + 2)
+			end = stop === -1 ? src.length : stop + 3
+		} else if (next === "!" || next === "?" || (next === "/" && !isLetter(src[start + 2]))) {
+			// Declarations, <?...> and </ + non-letter (</> included) are bogus comments up to the next ">".
+			kind = "skip"
+			const stop = src.indexOf(">", start + 2)
+			end = stop === -1 ? src.length : stop + 1
+		} else if (isLetter(next) || (next === "/" && isLetter(src[start + 2]))) {
+			kind = next === "/" ? "close" : "open"
+			tag = readTag(src, start + (kind === "close" ? 2 : 1))
+			end = tag.end
+		} else {
+			at = start + 1
+			continue
+		}
+		const resume = visit(kind, start, end, tag)
+		if (resume === Infinity) return
+		at = resume ?? (kind === "open" && RAW.has(tag.name) ? closeOf(src, end, tag.name) : end)
+	}
+}
+
+// Script data with its escaped and double-escaped states: a </script> inside <!--<script>...-->
+// does not end the script. Returns the end of the closing tag, or the end of input.
+const SCRIPT_MARKS = { data: /<!--|<\/script(?=[\s/>])/gi, escaped: /-->|<\/?script(?=[\s/>])/gi, double: /-->|<\/script(?=[\s/>])/gi }
+function scriptEnd(src, from) {
+	let state = "data"
+	let at = from
+	for (;;) {
+		const marks = SCRIPT_MARKS[state]
+		marks.lastIndex = at
+		const match = marks.exec(src)
+		if (!match) return src.length
+		const token = match[0].toLowerCase()
+		if (token === "-->") [state, at] = ["data", match.index + 3]
+		else if (token === "<!--") [state, at] = ["escaped", match.index + 2]
+		else if (token === "<script") [state, at] = ["double", match.index + 7]
+		else if (state === "double") [state, at] = ["escaped", match.index + 8]
+		else return readTag(src, match.index + 2).end
+	}
+}
+
+function closeOf(src, from, name) {
+	if (name === "script") return scriptEnd(src, from)
+	if (RAW.has(name)) {
+		const close = new RegExp(`</${name}(?=[\\s/>])[^>]*>`, "gi")
+		close.lastIndex = from
+		const match = close.exec(src)
+		return match ? match.index + match[0].length : src.length
+	}
+	let depth = 0
+	let stop = src.length
+	scan(src, from, (kind, _start, end, tag) => {
+		if (tag?.name !== name) return undefined
+		if (kind === "open") depth++
+		else if (depth === 0) {
+			stop = end
+			return Infinity
+		} else depth--
+		return undefined
+	})
+	return stop
+}
+
+const endOf = (src, end, tag) => VOID.has(tag.name) ? end : closeOf(src, end, tag.name)
+
+/** Raw markup sequence, corresponding text slots, and markup with frozen elements omitted. */
+export function markupParts(html) {
+	const src = String(html)
+	const markup = []
+	const text = []
+	let source = ""
+	let kept = 0
+	scan(src, 0, (kind, start, end, tag) => {
+		const frozen = kind === "open" && FROZEN.has(tag.name)
+		const stop = frozen ? endOf(src, end, tag) : end
+		text.push(src.slice(kept, start))
+		markup.push(src.slice(start, stop))
+		source += src.slice(kept, start) + (frozen || kind === "skip" ? " " : src.slice(start, stop))
+		kept = stop
+		return stop
+	})
+	text.push(src.slice(kept))
+	source += src.slice(kept)
+	return { markup, text, source }
+}
+
+/** Whole elements accepted by the caller; nested matches stay within the outer match. */
+export function elementSpans(html, accept) {
+	const src = String(html)
+	const spans = []
+	scan(src, 0, (kind, start, end, tag) => {
+		if (kind !== "open" || !accept(tag.name, tag.attrs)) return undefined
+		const stop = endOf(src, end, tag)
+		spans.push({ start, end: stop, tag })
+		return stop
+	})
+	return spans
+}
+
+export function tagAttributes(html) {
+	const tags = []
+	scan(String(html), 0, (kind, _start, _end, tag) => {
+		if (kind === "open") tags.push({ name: tag.name, attrs: tag.attrs })
+		return undefined
+	})
+	return tags
+}
+
+/**
+ * Constructs this tokenizer does not model exactly; renderer output never contains them, so polish
+ * refuses a document holding any of them instead of trusting the markup comparison.
+ */
+export function ambiguousMarkup(html) {
+	const src = String(html)
+	const found = new Set()
+	if (/<\/(?![a-z])/i.test(src)) found.add("</ before a non-letter")
+	if (/<!\[CDATA\[/i.test(src)) found.add("<![CDATA[")
+	if (src.includes("<?")) found.add("<?")
+	if (src.includes("--!>")) found.add("--!>")
+	scan(src, 0, (kind, start, end, tag) => {
+		if (kind !== "skip" && src.slice(start + 1, end).includes("<")) found.add("< inside a tag or attribute value")
+		if (kind === "open" && RAW.has(tag.name) && src.slice(end, closeOf(src, end, tag.name)).includes("<!--")) found.add(`<!-- inside ${tag.name}`)
+		return undefined
+	})
+	return [...found]
+}
+
+/** One character reference token of a text node: & up to the first ; or non-name character. */
+export const CHARACTER_REFERENCE = /&[^;\s<&]*;?/g
+
+/**
+ * The skeleton of a document: every markup token (tags, comments, bogus comments and the frozen
+ * content of script/style/template) and every character reference of a text node, in document
+ * order, each with its byte offset. Polish may change text node characters only, and an edit can
+ * carry neither <, > nor & and may not touch a character reference, so an edited span holds no
+ * skeleton token: a polished document keeps this sequence byte-identical.
+ */
+export function skeletonTokens(html) {
+	const { markup, text } = markupParts(html)
+	const tokens = []
+	let at = 0
+	text.forEach((slot, index) => {
+		for (const match of slot.matchAll(CHARACTER_REFERENCE)) tokens.push({ kind: "reference", value: match[0], offset: at + match.index })
+		at += slot.length
+		if (index < markup.length) {
+			tokens.push({ kind: "markup", value: markup[index], offset: at })
+			at += markup[index].length
+		}
+	})
+	return tokens
+}
+
+const describeToken = (token) => (token ? `${token.kind} ${JSON.stringify(token.value)} at offset ${token.offset}` : "end of document")
+
+/** The first skeleton token two documents disagree on, as a message, or null when they agree. */
+export function skeletonChange(beforeHtml, afterHtml) {
+	const [before, after] = [skeletonTokens(beforeHtml), skeletonTokens(afterHtml)]
+	for (let index = 0; index < Math.max(before.length, after.length); index++) {
+		if (before[index]?.value === after[index]?.value) continue
+		return `skeleton changed at token ${index}: ${describeToken(before[index])} became ${describeToken(after[index])}`
+	}
+	return null
+}

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 }
+}