lazycodex-ai 5.1.44 → 5.1.46

package/packages/shared-skills/skills/ulw-research/scripts/fidelity-brief.mjs

@@ -0,0 +1,150 @@
+// fidelity-brief.mjs - parse the `## Fidelity` block of brief.md and decide whether it is locked.
+//
+// Grammar (fable-interview.md section 3, "Parser contract"): the block starts at a line
+// `## Fidelity` and ends at the next `## ` heading. It holds the seven field lines below, in any
+// order, each `<field>: <value> (answered_by: user|default|request|pending)`, plus an optional
+// `asked: <field>, <field>` history line. Values carry no parentheses, and `answered_by: pending`
+// is legal only with the value `pending`. Trailing whitespace on a line is ignored; a second
+// `## Fidelity` block is a parse error. This module parses; it never interprets a value, which
+// is each consumer's job. Plain Node ESM, node: builtins only.
+
+import { readFileSync } from "node:fs"
+
+export const FIDELITY_FIELDS = Object.freeze([
+	"as of",
+	"meaning check",
+	"source floor",
+	"derived numbers",
+	"languages",
+	"identifier classes",
+	"fallback",
+])
+export const FIDELITY_ANSWERED_BY = Object.freeze(["user", "default", "request", "pending"])
+const LOCKED_ANSWERED_BY = new Set(["user", "default", "request"])
+
+export const FIDELITY_INCOMPLETE = "fidelity_interview_incomplete"
+const INCOMPLETE_HINT =
+	"A fidelity field is pending or missing in brief.md; answer the open question or record its default, then rerun."
+
+const BLOCK_HEADING = /^## Fidelity\s*$/
+const NEXT_HEADING = /^## /
+const FIELD_LINE = /^([a-z][a-z ]*[a-z]): ([^()]+) \(answered_by: (user|default|request|pending)\)$/
+const ASKED_LINE = /^asked:(.*)$/
+
+function blockLines(markdown) {
+	const lines = String(markdown)
+		.split(/\r?\n/)
+		.map((line) => line.trimEnd())
+	const headings = lines.flatMap((line, index) => (BLOCK_HEADING.test(line) ? [index] : []))
+	if (headings.length === 0) return null
+	const [start, ...duplicates] = headings
+	const body = []
+	for (let index = start + 1; index < lines.length; index += 1) {
+		if (NEXT_HEADING.test(lines[index])) break
+		body.push({ text: lines[index], line: index + 1 })
+	}
+	return { body, duplicates: duplicates.map((index) => index + 1) }
+}
+
+function parseAsked(rest, line, text, errors) {
+	const names = rest
+		.split(",")
+		.map((name) => name.trim())
+		.filter(Boolean)
+	const unknown = names.filter((name) => !FIDELITY_FIELDS.includes(name))
+	if (unknown.length > 0) {
+		errors.push(`line ${line}: malformed asked line, unknown field ${unknown.join(", ")}: ${text}`)
+		return []
+	}
+	return names
+}
+
+function parseFieldLine({ text, line }, parsed, errors) {
+	const match = FIELD_LINE.exec(text)
+	if (!match) return errors.push(`line ${line}: malformed fidelity line: ${text}`)
+	const [, field, rawValue, answeredBy] = match
+	const value = rawValue.trim()
+	if (!FIDELITY_FIELDS.includes(field)) return errors.push(`line ${line}: malformed fidelity line, unknown field "${field}": ${text}`)
+	if (Object.hasOwn(parsed.fields, field)) return errors.push(`line ${line}: malformed fidelity line, duplicate field "${field}": ${text}`)
+	if ((answeredBy === "pending") !== (value === "pending")) {
+		return errors.push(`line ${line}: malformed fidelity line, value pending and answered_by: pending go together: ${text}`)
+	}
+	parsed.fields[field] = value
+	parsed.answered_by[field] = answeredBy
+}
+
+/**
+ * @param {string} briefMd the whole brief.md text
+ * @returns {{ present: boolean, fields: Record<string, string>, answered_by: Record<string, string>,
+ *   asked: string[], missing: string[], pending: string[], errors: string[] }}
+ */
+export function parseFidelityBlock(briefMd) {
+	const parsed = { present: false, fields: {}, answered_by: {}, asked: [], missing: [], pending: [], errors: [] }
+	const block = blockLines(briefMd)
+	if (block !== null) {
+		const { body, duplicates } = block
+		parsed.present = true
+		for (const line of duplicates) parsed.errors.push(`line ${line}: duplicate ## Fidelity block, only one is allowed`)
+		let sawAsked = false
+		for (const entry of body) {
+			if (entry.text.trim() === "") continue
+			const asked = ASKED_LINE.exec(entry.text)
+			if (!asked) {
+				parseFieldLine(entry, parsed, parsed.errors)
+				continue
+			}
+			if (sawAsked) parsed.errors.push(`line ${entry.line}: malformed asked line, duplicate: ${entry.text}`)
+			else parsed.asked = parseAsked(asked[1], entry.line, entry.text, parsed.errors)
+			sawAsked = true
+		}
+	}
+	parsed.missing = FIDELITY_FIELDS.filter((field) => !Object.hasOwn(parsed.fields, field))
+	parsed.pending = FIDELITY_FIELDS.filter((field) => parsed.answered_by[field] === "pending")
+	return parsed
+}
+
+/** Locked = no parse error and all seven fields present with answered_by user, default, or request. */
+export function isLocked(parsed) {
+	if (!parsed || parsed.errors.length > 0) return false
+	return FIDELITY_FIELDS.every((field) => Object.hasOwn(parsed.fields, field) && LOCKED_ANSWERED_BY.has(parsed.answered_by[field]))
+}
+
+/** The brief's `meaning check` field turns the meaning verifier off only when it reads "off". */
+export function meaningCheckEnabled(parsed) {
+	return !/^off\b/iu.test(parsed?.fields?.["meaning check"] ?? "")
+}
+
+function incompleteDefect(briefPath, parsed) {
+	const reasons = []
+	if (!parsed.present) reasons.push("no ## Fidelity block")
+	else if (parsed.missing.length > 0) reasons.push(`missing: ${parsed.missing.join(", ")}`)
+	if (parsed.pending.length > 0) reasons.push(`pending: ${parsed.pending.join(", ")}`)
+	return {
+		code: FIDELITY_INCOMPLETE,
+		severity: "blocker",
+		integrity: true,
+		selector: null,
+		line: null,
+		message: `${briefPath}: fidelity interview incomplete (${reasons.join("; ")})`,
+		hint: INCOMPLETE_HINT,
+	}
+}
+
+/**
+ * The lock check the reader-facing CLI stages run before writing anything.
+ * exitCode 0 = locked; 1 = pending, missing, or no brief (one `fidelity_interview_incomplete`
+ * defect); 2 = malformed block (usage error, `errors` name the lines, no defect).
+ * @param {string} briefPath
+ */
+export function requireLockedBrief(briefPath) {
+	let markdown = ""
+	try {
+		markdown = readFileSync(briefPath, "utf8")
+	} catch (error) {
+		if (error?.code !== "ENOENT") throw error
+	}
+	const parsed = parseFidelityBlock(markdown)
+	if (parsed.errors.length > 0) return { locked: false, exitCode: 2, defects: [], errors: parsed.errors, parsed }
+	if (isLocked(parsed)) return { locked: true, exitCode: 0, defects: [], errors: [], parsed }
+	return { locked: false, exitCode: 1, defects: [incompleteDefect(briefPath, parsed)], errors: [], parsed }
+}

package/packages/shared-skills/skills/ulw-research/scripts/fidelity-brief.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { FIDELITY_FIELDS, isLocked, parseFidelityBlock, requireLockedBrief } from "./fidelity-brief.mjs"
+
+const fixture = (name: string) => join(import.meta.dir, "tests", "fixtures", name)
+const lockedMd = await Bun.file(fixture("fidelity-brief-locked.md")).text()
+const pendingMd = await Bun.file(fixture("fidelity-brief-pending.md")).text()
+
+function withoutLine(markdown: string, prefix: string): string {
+	return markdown
+		.split("\n")
+		.filter((line) => !line.startsWith(prefix))
+		.join("\n")
+}
+
+describe("parseFidelityBlock", () => {
+	test("#given a complete block #when parsed #then seven fields are read and the brief is locked", () => {
+		// when
+		const parsed = parseFidelityBlock(lockedMd)
+		// then
+		expect(parsed.errors).toEqual([])
+		expect(Object.keys(parsed.fields).sort()).toEqual([...FIDELITY_FIELDS].sort())
+		expect(parsed.fields["as of"]).toBe("latest at run start, 2026-10-23")
+		expect(parsed.fields.languages).toBe("report ko; sources ko, en; quotes original with translation beside")
+		expect(parsed.answered_by["derived numbers"]).toBe("user")
+		expect(parsed.answered_by.fallback).toBe("request")
+		expect(parsed.asked).toEqual(["derived numbers"])
+		expect(isLocked(parsed)).toBe(true)
+	})
+
+	test("#given a block missing as of #when parsed #then it is not locked and the missing field is named", () => {
+		// when
+		const parsed = parseFidelityBlock(withoutLine(lockedMd, "as of:"))
+		// then
+		expect(isLocked(parsed)).toBe(false)
+		expect(parsed.missing).toEqual(["as of"])
+		expect(parsed.errors).toEqual([])
+	})
+
+	test("#given a field answered_by pending #when parsed #then it is not locked and not malformed", () => {
+		// when
+		const parsed = parseFidelityBlock(pendingMd)
+		// then
+		expect(parsed.errors).toEqual([])
+		expect(parsed.answered_by["derived numbers"]).toBe("pending")
+		expect(parsed.pending).toEqual(["derived numbers"])
+		expect(isLocked(parsed)).toBe(false)
+	})
+
+	test("#given a malformed field line #when parsed #then errors name the line as malformed", () => {
+		// given
+		const markdown = lockedMd.replace("meaning check: on (answered_by: default)", "meaning check: on")
+		// when
+		const parsed = parseFidelityBlock(markdown)
+		// then
+		expect(parsed.errors.length).toBe(1)
+		expect(parsed.errors[0]).toContain("malformed")
+		expect(parsed.errors[0]).toContain("meaning check: on")
+		expect(isLocked(parsed)).toBe(false)
+	})
+
+	test("#given grammar violations #when parsed #then each is a malformed error", () => {
+		const cases = [
+			lockedMd.replace("fallback: block-quote (answered_by: request)", "fallback: block-quote (answered_by: someone)"),
+			lockedMd.replace("meaning check: on (answered_by: default)", "meaning check: on (maybe) (answered_by: default)"),
+			lockedMd.replace("meaning check: on (answered_by: default)", "meaning check: on (answered_by: pending)"),
+			lockedMd.replace("asked: derived numbers", "asked: derived numbers\ntone: formal (answered_by: user)"),
+			lockedMd.replace("asked: derived numbers", "asked: derived numbers\nfallback: omit (answered_by: user)"),
+			lockedMd.replace("asked: derived numbers", "asked: tone"),
+		]
+		for (const markdown of cases) expect(parseFidelityBlock(markdown).errors.length).toBe(1)
+	})
+
+	test("#given a brief with no Fidelity block #when parsed #then it is not locked and every field is missing", () => {
+		// when
+		const parsed = parseFidelityBlock("# Brief\n\n## Deliverable\nformat: pdf (answered_by: request)\n")
+		// then
+		expect(parsed.present).toBe(false)
+		expect(parsed.missing).toEqual([...FIDELITY_FIELDS])
+		expect(isLocked(parsed)).toBe(false)
+	})
+
+	test("#given field lines after the next heading #when parsed #then they are outside the block", () => {
+		// given
+		const markdown = withoutLine(lockedMd, "fallback:") + "\nfallback: omit (answered_by: user)\n"
+		// then
+		expect(parseFidelityBlock(markdown).missing).toEqual(["fallback"])
+	})
+
+	test("#given a second Fidelity block #when parsed #then the duplicate is an error", () => {
+		// given
+		const markdown = lockedMd + "\n## Fidelity\nas of: x (answered_by: user)\n"
+		// when
+		const parsed = parseFidelityBlock(markdown)
+		// then
+		expect(parsed.errors.length).toBe(1)
+		expect(parsed.errors[0]).toContain("duplicate")
+		expect(parsed.fields["as of"]).toBe("latest at run start, 2026-10-23")
+		expect(isLocked(parsed)).toBe(false)
+	})
+})
+
+describe("requireLockedBrief", () => {
+	function briefFile(contents: string | null): { path: string; cleanup: () => void } {
+		const dir = mkdtempSync(join(tmpdir(), "fidelity-brief-"))
+		const path = join(dir, "brief.md")
+		if (contents !== null) writeFileSync(path, contents)
+		return { path, cleanup: () => rmSync(dir, { recursive: true, force: true }) }
+	}
+
+	test("#given a locked brief #when required #then exit 0 and no defect", () => {
+		const brief = briefFile(lockedMd)
+		try {
+			expect(requireLockedBrief(brief.path)).toMatchObject({ locked: true, exitCode: 0, defects: [], errors: [] })
+		} finally {
+			brief.cleanup()
+		}
+	})
+
+	test("#given field lines with trailing spaces, a tab, and CRLF endings #when required #then they parse like trimmed lines", () => {
+		// given
+		const markdown = lockedMd
+			.replace("meaning check: on (answered_by: default)", "meaning check: on (answered_by: default)  ")
+			.replace("fallback: block-quote (answered_by: request)", "fallback: block-quote (answered_by: request)\t")
+			.replace("as of: latest at run start, 2026-10-23 (answered_by: default)\n", "as of: latest at run start, 2026-10-23 (answered_by: default)  \r\n")
+		const brief = briefFile(markdown)
+		try {
+			// when
+			const result = requireLockedBrief(brief.path)
+			// then
+			expect(result).toMatchObject({ locked: true, exitCode: 0, defects: [], errors: [] })
+			expect(result.parsed.fields.fallback).toBe("block-quote")
+		} finally {
+			brief.cleanup()
+		}
+	})
+
+	test("#given a second Fidelity block #when required #then exit 2 naming the duplicate", () => {
+		const brief = briefFile(lockedMd + "\n## Fidelity\nas of: x (answered_by: user)\n")
+		try {
+			const result = requireLockedBrief(brief.path)
+			expect(result).toMatchObject({ locked: false, exitCode: 2, defects: [] })
+			expect(result.errors[0]).toContain("duplicate ## Fidelity block")
+		} finally {
+			brief.cleanup()
+		}
+	})
+
+	test("#given a pending, partial, or absent brief #when required #then exit 1 with the single lock defect", () => {
+		for (const contents of [pendingMd, withoutLine(lockedMd, "as of:"), "# Brief\n", null]) {
+			const brief = briefFile(contents)
+			try {
+				const result = requireLockedBrief(brief.path)
+				expect(result.locked).toBe(false)
+				expect(result.exitCode).toBe(1)
+				expect(result.defects.length).toBe(1)
+				expect(result.defects[0]).toMatchObject({ code: "fidelity_interview_incomplete", severity: "blocker", integrity: true })
+				expect(typeof result.defects[0].message).toBe("string")
+				expect(typeof result.defects[0].hint).toBe("string")
+			} finally {
+				brief.cleanup()
+			}
+		}
+	})
+
+	test("#given a malformed brief #when required #then exit 2 with the parse errors and no defect", () => {
+		const brief = briefFile(lockedMd.replace("meaning check: on (answered_by: default)", "meaning check: on"))
+		try {
+			const result = requireLockedBrief(brief.path)
+			expect(result).toMatchObject({ locked: false, exitCode: 2, defects: [] })
+			expect(result.errors[0]).toContain("malformed")
+		} finally {
+			brief.cleanup()
+		}
+	})
+})

package/packages/shared-skills/skills/ulw-research/scripts/fidelity-claims.mjs

@@ -0,0 +1,89 @@
+// fidelity-claims.mjs - the claim-kind checks of the deterministic fidelity gate.
+//
+// A mark (the data-claim-kind attribute) binds per cited fact: a data-fact element takes the kind
+// of its nearest mark (its own, else the closest marked ancestor), and only that kind is checked
+// against its ledger row (claim-kinds.mjs CLAIM_KINDS); a row that fails is the kind's defect
+// (unsupported_verification for `verified`). A fact under two marks of different kinds is a
+// claim_kind_mismatch, and a mark that owns no fact of its own kind (every fact under it cites
+// nothing or is shadowed by another kind) is its kind's defect: shadowing never satisfies a parent.
+// An unmarked fact citing a row neither fact nor quote accepts (an assumed row) is a
+// claim_kind_mismatch naming the mark it needs. A sentence that matches a kind's unmarked patterns warns (minor, verification_claim_unmarked)
+// unless every fact it cites is marked that kind; a sentence citing no fact warns unless its block
+// is marked. No model, no network.
+
+import { CLAIM_ATTRIBUTE, CLAIM_KINDS, claimSatisfied, unmarkedKinds, unmarkedRequires } from "./claim-kinds.mjs"
+import { proseSentences } from "./fidelity-binding.mjs"
+import { clip } from "./fidelity-trace.mjs"
+import { proseText } from "./html-lite.mjs"
+
+const marked = (node) => node.attrs?.[CLAIM_ATTRIBUTE] !== undefined
+const kindOf = (node) => node.attrs[CLAIM_ATTRIBUTE].trim()
+const isFact = (node) => node.attrs["data-fact"] !== undefined
+
+/** The marks over a node, nearest first: its own mark, then each marked ancestor. */
+function marksOver(node) {
+	const marks = []
+	for (let cur = node; cur; cur = cur.parent) if (marked(cur)) marks.push(cur)
+	return marks
+}
+
+const nearestKind = (node) => {
+	const [mark] = marksOver(node)
+	return mark ? kindOf(mark) : null
+}
+
+/** Whether `mark` binds `fact`: every mark from the fact up to `mark` names the same kind. */
+function binds(mark, fact) {
+	const marks = marksOver(fact)
+	const at = marks.indexOf(mark)
+	return at >= 0 && marks.slice(0, at + 1).every((cur) => kindOf(cur) === kindOf(mark))
+}
+
+/**
+ * @param {object} ctx buildContext(...) from gates-static.mjs
+ * @param {Map<string, object>} rows ledger rows by fact_id
+ * @param {(row: object) => string | undefined} provenanceOf meta.json kind of the snapshot holding the row's own locator artifact
+ * @param {(code: string, node: object, message: string) => void} flag
+ */
+export function claimChecks(ctx, rows, provenanceOf, flag) {
+	for (const node of ctx.all.filter(marked)) {
+		const name = kindOf(node)
+		const entry = CLAIM_KINDS[name]
+		if (!entry) {
+			flag("claim_kind_mismatch", node, `${CLAIM_ATTRIBUTE}="${name}" is not a claim kind (${Object.keys(CLAIM_KINDS).join(", ")})`)
+			continue
+		}
+		const cited = [node, ...ctx.util.descendants(node)].filter(isFact)
+		if (cited.some((fact) => binds(node, fact))) continue
+		const why = cited.length === 0 ? "cites no fact" : "cites no fact of its own (a nested mark of another kind never satisfies it)"
+		flag(entry.defect, node, `"${clip(proseText(node))}" is marked ${name} but ${why}`)
+	}
+	for (const fact of ctx.all.filter(isFact)) {
+		const [nearest, ...outer] = marksOver(fact)
+		const id = fact.attrs["data-fact"]
+		if (!nearest) {
+			const need = unmarkedRequires(rows.get(id))
+			const mark = need && `{{${CLAIM_KINDS[need].prefix}:${id}}} (${CLAIM_ATTRIBUTE}="${need}")`
+			if (need) flag("claim_kind_mismatch", fact, `${id} is a ${rows.get(id).kind} row cited with no mark; an unmarked numeral reads as a fact, so mark it ${mark}`)
+			continue
+		}
+		const name = kindOf(nearest)
+		const conflict = outer.find((mark) => kindOf(mark) !== name)
+		if (conflict) flag("claim_kind_mismatch", fact, `${id} is marked ${name} inside a ${kindOf(conflict)} mark; a fact carries one claim kind`)
+		const entry = CLAIM_KINDS[name]
+		const row = rows.get(id)
+		if (!entry || !row || claimSatisfied(name, row, provenanceOf(row))) continue
+		const source = entry.sourceKinds ? ` and not one whose own locator artifact sits in a ${entry.sourceKinds.join(" or ")} snapshot` : ""
+		flag(entry.defect, fact, `${row.fact_id} is marked ${name}, but it is a ${row.kind} row${source}`)
+	}
+	for (const block of proseSentences(ctx)) {
+		if (block.kind === "sources" || block.kind === "toc") continue
+		for (const sentence of block.sentences) {
+			for (const name of unmarkedKinds(sentence.text)) {
+				const covered = sentence.facts.length > 0 ? sentence.facts.every((fact) => nearestKind(fact.node) === name) : nearestKind(block.owner) === name
+				if (covered) continue
+				flag(CLAIM_KINDS[name].unmarked.code, block.owner, `"${clip(sentence.text)}" reads as a ${name} claim but cites a fact with no ${CLAIM_ATTRIBUTE}="${name}" mark`)
+			}
+		}
+	}
+}

package/packages/shared-skills/skills/ulw-research/scripts/fidelity-lexicon.mjs

@@ -0,0 +1,145 @@
+// fidelity-lexicon.mjs - closed-list lexical checks over (source quote, report sentence) pairs.
+//
+// lexiconChecks compares each pair with the lexicon.mjs lists: hedge_dropped, direction_flipped,
+// causality_added, qualifier_dropped (six-token window around the fact span; a :q rendering puts
+// the qualifier inside the span), scope_widened_warn, and the acronym-aware name_outside_quote.
+// The hedge-position heuristic never yields a code; it only sets force_strong for the meaning
+// verifier, as do name_outside_quote and scope_widened_warn. Latin terms match whole words (terms
+// of four or more letters also match their inflections); Korean terms match as substrings, single
+// syllables as tokens. No model, no IO. Plain Node ESM; Korean strings are \u escapes.
+
+import { CAUSAL, CONCESSIVE, DIRECTION, HEDGES, NEGATION, QUALIFIERS, SCOPE_NARROW_TO_BROAD } from "./lexicon.mjs"
+import { normalizeText } from "./text-normalize.mjs"
+import { normalizeUnit } from "./units.mjs"
+
+/** Ledger qualifier terms -> their surface forms in either language (closed mapping). */
+export const QUALIFIER_FORMS = Object.freeze({
+	upper_inclusive: ["up to", "at most", "\uCD5C\uB300", "\uC774\uD558", "\uAE4C\uC9C0"],
+	lower_inclusive: ["at least", "\uCD5C\uC18C", "\uC774\uC0C1"],
+	approximate: ["about", "approximately", "\uC57D", "\uB0B4\uC678"],
+	near: ["nearly"],
+	lower_exclusive: ["over", "more than", "\uCD08\uACFC"],
+	upper_exclusive: ["under", "less than", "\uBBF8\uB9CC"],
+})
+/** Irregular and synonym direction forms the stem match cannot reach ("rose", "reduced"). */
+const DIRECTION_FORMS = { up: ["rose", "risen", "rising", "grew", "grown", "gain"], down: ["reduc", "fell", "fallen", "falling", "drop", "lower"] }
+const KOREAN = /[\uAC00-\uD7A3]/
+/** True when the term holds a Hangul syllable (Korean terms match by the Korean rules below). */
+export const isKoreanTerm = (term) => KOREAN.test(term)
+/** The guarded hedge and qualifier vocabulary: the union of HEDGES, QUALIFIERS and every QUALIFIER_FORMS surface form. */
+export const guardedTerms = () => [...new Set([...HEDGES, ...QUALIFIERS, ...Object.values(QUALIFIER_FORMS).flat()])]
+const ACRONYM = /(?<![\p{L}\p{N}])[A-Z]{2,6}(?![\p{L}\p{N}])/gu
+const WINDOW = 6
+const cache = new Map()
+
+const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+
+/**
+ * The lexical pattern engine. mode: "stem" (inflections, Korean one-syllable token prefix), "exact",
+ * "word", "suffix" (Korean attached to a value), "guard" (single Latin words of four or more letters
+ * take inflections, multiword terms never do; Korean terms match as plain substrings).
+ */
+export function lexicalPattern(term, mode) {
+	const key = `${mode}\u0001${term}`
+	if (cache.has(key)) return cache.get(key)
+	let source
+	if (!KOREAN.test(term)) {
+		const stems = term.length >= 4 && (mode === "stem" || (mode === "guard" && !term.includes(" ")))
+		source = `(?<![\\p{L}\\p{N}])${escape(term).replace(/ /g, "\\s+")}${stems ? "\\p{L}*" : ""}(?![\\p{L}\\p{N}])`
+	} else if (mode === "guard") source = escape(term)
+	else if (mode === "suffix") source = `(?<=^|[\\s\\p{P}\\p{N}A-Za-z])${escape(term)}(?=$|[\\s\\p{P}])`
+	else if ([...term].length >= 2 || mode === "word") source = escape(term)
+	else source = `(?<=^|[\\s\\p{P}])${escape(term)}${mode === "stem" ? "" : "(?=$|[\\s\\p{P}])"}`
+	const re = new RegExp(source, "giu")
+	cache.set(key, re)
+	return re
+}
+
+function positions(text, terms, mode) {
+	const out = []
+	for (const term of terms) for (const match of text.matchAll(lexicalPattern(term, mode))) out.push({ term, at: match.index })
+	return out.sort((a, b) => a.at - b.at)
+}
+
+const has = (text, terms, mode) => positions(text, terms, mode).length > 0
+const tokens = (text) => text.split(/\s+/).filter(Boolean)
+const stripQualifiers = (text) => QUALIFIERS.reduce((rest, term) => rest.replace(lexicalPattern(term, "exact"), " "), text)
+
+function directions(text) {
+	const rest = stripQualifiers(text)
+	return {
+		up: has(rest, DIRECTION.up, "stem") || has(rest, DIRECTION_FORMS.up, "stem"),
+		down: has(rest, DIRECTION.down, "stem") || has(rest, DIRECTION_FORMS.down, "stem"),
+	}
+}
+
+/** The fact span plus up to six tokens on each side, never crossing the sentence. */
+function qualifierWindow(sentence, span) {
+	const [start, end] = span
+	return [...tokens(sentence.slice(0, start)).slice(-WINDOW), sentence.slice(start, end), ...tokens(sentence.slice(end)).slice(0, WINDOW)].join(" ")
+}
+
+function qualifierDropped(pair) {
+	if (!pair.qualifier || !Array.isArray(pair.span)) return false
+	const forms = QUALIFIER_FORMS[pair.qualifier] ?? [pair.qualifier]
+	const window = qualifierWindow(pair.sentence, pair.span)
+	return !forms.some((form) => has(window, [form], KOREAN.test(form) ? "suffix" : "exact"))
+}
+
+/** A hedge before the sentence's last concessive while the quote hedges its own final clause. */
+function hedgeMoved(quote, sentence) {
+	const lastConcessive = (text) => positions(text, CONCESSIVE, "word").at(-1)?.at ?? -1
+	const sentenceHedge = positions(sentence, HEDGES, "stem")[0]?.at
+	const quoteHedge = positions(quote, HEDGES, "stem").at(-1)?.at
+	const sentenceConcessive = lastConcessive(sentence)
+	return sentenceHedge !== undefined && quoteHedge !== undefined && sentenceHedge < sentenceConcessive && quoteHedge > lastConcessive(quote)
+}
+
+function pairFindings(pair) {
+	const quote = normalizeText(pair.quote)
+	const sentence = normalizeText(pair.sentence)
+	const found = []
+	const add = (code, message) => found.push({ pair_id: pair.pair_id, code, message })
+	const dropped = qualifierDropped(pair)
+	if (dropped) add("qualifier_dropped", `the source bounds the value (${pair.qualifier}) and the sentence drops it`)
+	const sourceHedges = positions(quote, HEDGES, "stem")
+	const qualifierOnly = sourceHedges.every(({ term }) => QUALIFIERS.includes(term))
+	if (sourceHedges.length > 0 && !has(sentence, HEDGES, "stem") && !(dropped && qualifierOnly)) {
+		add("hedge_dropped", `the source hedges ("${sourceHedges[0].term}") and the sentence does not`)
+	}
+	const [from, to] = [directions(quote), directions(sentence)]
+	const negated = has(quote, NEGATION, "word") || has(sentence, NEGATION, "word")
+	if (!negated && ((from.up && !from.down && to.down && !to.up) || (from.down && !from.up && to.up && !to.down))) {
+		add("direction_flipped", `the source says ${from.up ? "up" : "down"} and the sentence says ${to.up ? "up" : "down"}`)
+	}
+	const causal = positions(sentence, CAUSAL, "word").find(({ term }) => !has(quote, [term], "word"))
+	if (causal) add("causality_added", `"${causal.term}" states a cause the source does not`)
+	const context = [quote, ...(pair.context ?? []).map(normalizeText)]
+	for (const [narrow, broad] of SCOPE_NARROW_TO_BROAD) {
+		if (has(quote, [narrow], "word") && has(sentence, [broad], "word") && !context.some((text) => has(text, [broad], "word"))) {
+			add("scope_widened_warn", `the source says "${narrow}" and the sentence says "${broad}"`)
+		}
+	}
+	const acronyms = pair.acronyms ?? {}
+	const quoteNames = new Set(quote.match(ACRONYM) ?? [])
+	const stray = (sentence.match(ACRONYM) ?? []).find((name) => !quoteNames.has(name) && !Object.hasOwn(acronyms, name) && !normalizeUnit(name))
+	if (stray) add("name_outside_quote", `"${stray}" is in neither the quote nor the source's acronym table`)
+	return found
+}
+
+/**
+ * @param {{ pair_id: string, quote: string, sentence: string, span?: [number, number] | null,
+ *   qualifier?: string | null, acronyms?: Record<string, string>, context?: string[] }[]} pairs
+ * @returns {{ findings: { pair_id: string, code: string, message: string }[], forceStrong: string[] }}
+ */
+export function lexiconChecks(pairs) {
+	const findings = []
+	const forceStrong = []
+	for (const pair of pairs) {
+		const found = pairFindings(pair)
+		findings.push(...found)
+		const routed = found.some(({ code }) => code === "name_outside_quote" || code === "scope_widened_warn")
+		if (routed || hedgeMoved(normalizeText(pair.quote), normalizeText(pair.sentence))) forceStrong.push(pair.pair_id)
+	}
+	return { findings, forceStrong }
+}