oh-my-opencode 5.1.45 → 5.1.47

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

@@ -0,0 +1,185 @@
+// fact-pairs.mjs - (source, report sentence) pairs for the meaning verifier.
+//
+// extractPairs walks the prose sentences of a filled HTML report and emits, in document order:
+// a quote pair per distinct ledger quote cited by a findings sentence (facts sharing one quote
+// share one pair), a claim pair per sentence bound only by data-claim (the statement comes from
+// the claim index), and a translation pair per data-translates span. force_strong routes a pair
+// to the strong reader when the lexicon raised name_outside_quote or scope_widened_warn, when the
+// hedge-position heuristic fired, or when the source hedges and the sentence's last six tokens do
+// not. No model, no IO: the readers run as separate lanes. Plain Node ESM; no Hangul here.
+
+import { isExemptKind, proseSentences } from "./fidelity-binding.mjs"
+import { isKoreanTerm, lexicalPattern, lexiconChecks } from "./fidelity-lexicon.mjs"
+import { sentenceKey } from "./fidelity-state.mjs"
+import { buildContext } from "./gates-static.mjs"
+import { parseHtml, proseText } from "./html-lite.mjs"
+import { HEDGES } from "./lexicon.mjs"
+import { normalizeText } from "./text-normalize.mjs"
+
+/** Every pair kind the producers below emit; consumers count and schema pairs by this list. */
+export const PAIR_KINDS = Object.freeze(["quote", "claim", "translation"])
+const TAIL = 6
+
+const lang = (text) => (isKoreanTerm(text) ? "ko" : "en")
+/** Sentence text with its fact spans cut out, so a Korean value does not make an English sentence Korean. */
+const outsideFacts = (sentence) => sentence.facts.reduceRight((text, fact) => text.slice(0, fact.start - sentence.start) + text.slice(fact.end - sentence.start), sentence.text)
+
+/** Latin hedges match whole words ("exact"); Korean hedges match as substrings, one syllable as a token prefix ("stem"). */
+const HEDGE_RES = HEDGES.map((term) => lexicalPattern(term, isKoreanTerm(term) ? "stem" : "exact"))
+
+/** Hedge terms that are also month names; capitalized and followed by a date number, they are months. */
+const MONTH_WORDS = new Set(["may"])
+
+/** A capitalized Latin match after the first word is a name or a month ("in May"), not a hedge. */
+const isHedgeAt = (text, match) => {
+	if (!/^\p{Lu}/u.test(match[0]) || isKoreanTerm(match[0])) return true
+	if (match.index !== 0) return false
+	// At the start of a text a capital is only sentence case, so the word still hedges - unless it is a
+	// month name followed by a date number ("May 2024 sales rose.").
+	return !(MONTH_WORDS.has(match[0].toLowerCase()) && /^\s+\p{Nd}/u.test(text.slice(match.index + match[0].length)))
+}
+
+export const hasHedge = (text) => {
+	const normal = normalizeText(text)
+	return HEDGE_RES.some((re) => [...normal.matchAll(re)].some((match) => isHedgeAt(normal, match)))
+}
+
+/** The source hedges and none of the sentence's last six tokens carries a hedge. */
+function tailDropsHedge(source, sentence) {
+	if (!hasHedge(source)) return false
+	return !hasHedge(normalizeText(sentence).split(/\s+/u).filter(Boolean).slice(-TAIL).join(" "))
+}
+
+function slugOf(scope) {
+	const heading = scope.section?.heading
+	if (!heading) return ""
+	return (heading.attrs.id ?? proseText(heading))
+		.toLowerCase()
+		.replace(/[^\p{L}\p{N}]+/gu, "-")
+		.replace(/^-+|-+$/gu, "")
+}
+
+function claimMap(claims) {
+	const list = Array.isArray(claims) ? claims : (claims?.claims ?? [])
+	return new Map(list.map((claim) => [claim.claim_id, claim]))
+}
+
+const idsOf = (attr) => String(attr ?? "").split(/[\s,]+/u).filter(Boolean)
+
+/** Claim ids that bind a sentence: on the block or an ancestor, or on an inner element whose text the sentence holds. */
+function claimIdsFor(ctx, block, sentence) {
+	const { closest, descendants } = ctx.util
+	const up = block.owner.attrs["data-claim"] !== undefined ? block.owner : closest(block.owner, (node) => node.attrs?.["data-claim"] !== undefined)
+	const ids = up ? idsOf(up.attrs["data-claim"]) : []
+	const text = normalizeText(sentence.text)
+	for (const node of descendants(block.owner)) {
+		if (node.attrs?.["data-claim"] === undefined) continue
+		const inner = normalizeText(proseText(node))
+		if (inner !== "" && text.includes(inner)) ids.push(...idsOf(node.attrs["data-claim"]))
+	}
+	return [...new Set(ids)]
+}
+
+function exempt(ctx, node) {
+	return isExemptKind(node.attrs["data-kind"]) || Boolean(ctx.util.closest(node, (cur) => isExemptKind(cur.attrs?.["data-kind"])))
+}
+
+/** Lexicon routing for every fact span of one quote group in one sentence. */
+function lexiconRouted(group, sentence) {
+	const probes = group.facts.map((fact, index) => ({
+		pair_id: String(index),
+		quote: group.quote,
+		sentence: sentence.text,
+		span: [fact.start - sentence.start, fact.end - sentence.start],
+		qualifier: group.row.kind === "quote" ? null : (group.rows.get(fact.id)?.qualifier ?? null),
+	}))
+	return lexiconChecks(probes).forceStrong.length > 0
+}
+
+function quotePairs(sentence, rows, slug, reportLang) {
+	const groups = new Map()
+	for (const fact of sentence.facts) {
+		const row = rows.get(fact.id)
+		if (!row?.quote) continue
+		const group = groups.get(row.quote) ?? { quote: row.quote, row, rows, facts: [], ids: [] }
+		group.facts.push(fact)
+		if (!group.ids.includes(fact.id)) group.ids.push(fact.id)
+		groups.set(row.quote, group)
+	}
+	const allIds = [...new Set(sentence.facts.map((fact) => fact.id))]
+	return [...groups.values()].map((group) => ({
+		kind: "quote",
+		sentence_key: sentenceKey(slug, allIds),
+		fact_ids: [...group.ids].sort(),
+		quote: group.quote,
+		sentence: sentence.text,
+		source_lang: lang(group.quote),
+		report_lang: reportLang ?? lang(outsideFacts(sentence)),
+		force_strong: lexiconRouted(group, sentence) || tailDropsHedge(group.quote, sentence.text),
+	}))
+}
+
+function claimPairs(ctx, block, sentence, byClaim, slug, reportLang) {
+	if (sentence.facts.length > 0 || exempt(ctx, block.owner)) return []
+	return claimIdsFor(ctx, block, sentence)
+		.map((id) => byClaim.get(id))
+		.filter(Boolean)
+		.map((claim) => ({
+			kind: "claim",
+			sentence_key: sentenceKey(slug, [claim.claim_id]),
+			claim_id: claim.claim_id,
+			statement: claim.statement,
+			sentence: sentence.text,
+			source_lang: lang(claim.statement),
+			report_lang: reportLang ?? lang(sentence.text),
+			force_strong: lexiconChecks([{ pair_id: "c", quote: claim.statement, sentence: sentence.text }]).forceStrong.length > 0 || tailDropsHedge(claim.statement, sentence.text),
+		}))
+}
+
+function translationPair(node, rows, slug, reportLang) {
+	const id = node.attrs["data-translates"]
+	const row = rows.get(id)
+	const text = proseText(node)
+	if (!row?.quote || text === "") return null
+	return {
+		kind: "translation",
+		sentence_key: sentenceKey(slug, [id]),
+		fact_ids: [id],
+		quote: row.quote,
+		sentence: text,
+		source_lang: lang(row.quote),
+		report_lang: reportLang ?? lang(text),
+		force_strong: tailDropsHedge(row.quote, text),
+	}
+}
+
+/**
+ * @param {string} html the filled report
+ * @param {{ rows: object[] }} ledger
+ * @param {{ claims: object[] } | object[] | null} claims indexClaims(...) output or its claims array
+ * @returns {object[]} pairs with pair_id P1, P2, ... in document order
+ */
+export function extractPairs(html, ledger, claims) {
+	const ctx = buildContext(parseHtml(html), {})
+	const rows = new Map((ledger?.rows ?? []).map((row) => [row.fact_id, row]))
+	const byClaim = claimMap(claims)
+	const htmlLang = ctx.all.find((node) => node.tag === "html")?.attrs.lang
+	const reportLang = htmlLang ? htmlLang.toLowerCase().split("-")[0] : null
+	const out = []
+	const seenSpans = new Set()
+	for (const block of proseSentences(ctx)) {
+		const findings = Boolean(block.scope.section) && block.kind === null
+		if (!findings) continue
+		const slug = slugOf(block.scope)
+		for (const sentence of block.sentences) {
+			out.push(...quotePairs(sentence, rows, slug, reportLang), ...claimPairs(ctx, block, sentence, byClaim, slug, reportLang))
+		}
+		for (const node of ctx.util.descendants(block.owner)) {
+			if (node.attrs?.["data-translates"] === undefined || seenSpans.has(node)) continue
+			seenSpans.add(node)
+			const pair = translationPair(node, rows, slug, reportLang)
+			if (pair) out.push(pair)
+		}
+	}
+	return out.map((pair, index) => ({ pair_id: `P${index + 1}`, ...pair }))
+}

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

@@ -0,0 +1,89 @@
+// Iterative postorder verifier: one snapshot and one arithmetic evaluation per reachable node.
+import { compute } from "./fact-derive.mjs"
+import { parseExpr } from "./fact-expr.mjs"
+import { isLegacyDerived, kindRuleErrors, readFlaws, readRow } from "./fact-ledger-kinds.mjs"
+import { rowErrors } from "./fact-ledger-schema.mjs"
+import { refuse } from "./unit-algebra.mjs"
+import { refusal } from "./unit-errors.mjs"
+import { object, sameDeclared } from "./unit-metadata.mjs"
+import { expectedUnit, malformed, ruleOf, unitMismatch } from "./unit-rules.mjs"
+
+const derived = (row) => row.kind === "derived" || row.kind === "converted"
+const fail = (detail, shape, expected) => ({ ok: false, detail, shape, expected })
+function refuseLegacy(row) {
+	if (isLegacyDerived(row)) refuse(`${row.fact_id} was written before precision, compatibility, and context existed; regenerate it with derive`, undefined, "legacy derived row", "a derived row regenerated by derive")
+}
+
+function verifyRow(row, rows) {
+	const rule = ruleOf(row.operation)
+	const ast = rule.expression ? parseExpr(row.formula) : null
+	const context = { ...row.context, rationale: row.rationale }
+	const unit = expectedUnit(row.operation, rows, { ast, context })
+	const expected = { unit, ...compute(row.operation, rows, unit, ast, context, row.formula), derived_from: rows.map((r) => r.fact_id) }
+	if (row.unit !== unit) return fail(`${row.fact_id}: ${unitMismatch(row.operation, rows, row.unit, unit)}`, "result_unit", expected)
+	for (const field of Object.keys(expected)) {
+		if (!sameDeclared(row[field], expected[field])) return fail(`${row.fact_id}: stored ${field} differs from the recomputed result`, `${field}_mismatch`, expected)
+	}
+	return { ok: true, expected }
+}
+
+export function verifyGraph(ledger, roots, requireActive = false, override = null) {
+	try {
+		if (!object(ledger) || !Array.isArray(ledger.rows)) refuse("ledger rows must be an array")
+		const byId = new Map()
+		for (const r of ledger.rows) {
+			if (!object(r) || typeof r.fact_id !== "string" || byId.has(r.fact_id)) refuse("ledger rows need distinct fact ids", undefined, "identity", "distinct fact ids")
+			byId.set(r.fact_id, r)
+		}
+		if (override) byId.set(override.fact_id, override)
+		const states = new Map()
+		const snapshots = new Map()
+		const results = new Map()
+		const stack = roots.map((id) => ({ id, finish: false }))
+		while (stack.length) {
+			const { id, finish } = stack.pop()
+			if (states.get(id) === "done") continue
+			if (!finish) {
+				if (states.get(id) === "open") refuse(`${id}: operands form a cycle`, undefined, "cycle", "an acyclic dependency graph")
+				const original = byId.get(id)
+				if (!original) refuse(`no ledger row ${id}`, undefined, "missing_operand", "an existing fact id")
+				const row = { ...readRow(original) }
+				snapshots.set(id, row)
+				if (requireActive && row.status !== "active") refuse(`${id} is ${row.status}`, undefined, "inactive_dependency", "active dependencies at every depth")
+				const [flaw] = readFlaws(row)
+				if (flaw) refuse(`${id}: ${flaw.detail}`, undefined, flaw.shape, flaw.expected)
+				if (derived(row)) {
+					refuseLegacy(row)
+					const shape = malformed(row)
+					if (shape) refuse(`${id}: ${shape}`, undefined, "malformed_row", "the operation's registry row shape")
+				}
+				const errors = derived(row) ? kindRuleErrors(row, id) : rowErrors(row)
+				if (errors.length) refuse(errors.join("; "), undefined, "row_schema", "a canonical row matching its kind and operation")
+				if (row.exact === null || row.value === null) refuse(`${id} has no exact value to derive from`)
+				states.set(id, "open")
+				stack.push({ id, finish: true })
+				if (derived(row)) for (const dependency of row.operands) stack.push({ id: dependency, finish: false })
+			} else {
+				const row = snapshots.get(id)
+				if (derived(row)) {
+					const result = verifyRow(row, row.operands.map((ref) => snapshots.get(ref)))
+					if (!result.ok) return result
+					const errors = rowErrors(row)
+					if (errors.length) refuse(errors.join("; "), undefined, "row_schema", "a complete canonical row")
+					results.set(id, result)
+				}
+				states.set(id, "done")
+			}
+		}
+		return results.get(roots[0]) ?? { ok: true }
+	} catch (error) { return { ok: false, ...refusal(error) } }
+}
+
+export function recompute(ledger, row) {
+	try {
+		refuseLegacy(row)
+		const shape = malformed(row)
+		if (shape) refuse(shape, undefined, "malformed_row", "a valid derived or converted row")
+		return verifyGraph(ledger, [row.fact_id], false, row)
+	} catch (error) { return { ok: false, ...refusal(error) } }
+}

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

@@ -0,0 +1,130 @@
+// fidelity-binding.mjs - sentence binding and claim-status checks of the fidelity gate.
+//
+// proseSentences walks every leaf prose element (p, li) outside figures, tables and page chrome,
+// keeps the offsets of each data-fact element inside its text, and splits it into sentences, so
+// every check sees which ledger rows a sentence cites. bindingChecks raises unbound_sentence (a
+// findings sentence with no fact, placeholder, citation, or data-claim), claim_status_invalid (a
+// data-claim id that is unknown, refuted or unresolved outside a Gaps or Contradictions section,
+// or high-risk and missing from verified-claims), and conflicting_readings (two active rows with
+// one value and unit but different periods or qualifiers cited in one sentence). Plain Node ESM.
+
+import { proseText } from "./html-lite.mjs"
+import { fromDecimal, eq } from "./rational.mjs"
+import { splitSentences } from "./sentence-split.mjs"
+import { normalizeUnit } from "./units.mjs"
+
+const SKIP = new Set(["code", "pre", "kbd", "samp", "script", "style", "svg", "template", "noscript"])
+const CONTAINERS = new Set(["figure", "table", "nav", "header", "footer"])
+/** data-kind values whose sentences need no binding (opinion and recommendation blocks). */
+export const EXEMPT_KINDS = Object.freeze(["opinion", "recommendation"])
+export const isExemptKind = (kind) => EXEMPT_KINDS.includes(kind)
+const DECIMAL = /^-?\d+(?:\.\d+)?$/
+/** Gaps and Contradictions headings (English, and the Korean gap/limit/contradiction/conflict words). */
+const GAPS_HEADING = /\b(?:gaps?|contradictions?|unresolved)\b|\uACF5\uBC31|\uD55C\uACC4|\uBAA8\uC21C|\uC0C1\uCDA9/i
+
+/** Canonical unit token, or the raw unit without spaces, lowercased; "" for none. */
+export function unitKey(unit) {
+	if (unit === null || unit === undefined) return ""
+	return normalizeUnit(String(unit)) ?? String(unit).replace(/\s+/g, "").toLowerCase()
+}
+
+/** Exact decimal equality; false when either side is not a plain decimal. */
+export function sameValue(a, b) {
+	const [x, y] = [String(a ?? "").replace(/,/g, ""), String(b ?? "").replace(/,/g, "")]
+	return DECIMAL.test(x) && DECIMAL.test(y) && eq(fromDecimal(x), fromDecimal(y))
+}
+
+function serialize(node, out) {
+	for (const child of node.children) {
+		if (child.tag === "#text") out.text += child.text
+		else if (child.tag === "br") out.text += " "
+		else if (SKIP.has(child.tag)) continue
+		else if (child.attrs["data-fact"] !== undefined) {
+			const text = proseText(child)
+			out.facts.push({ id: child.attrs["data-fact"], start: out.text.length, end: out.text.length + text.length, text, node: child })
+			out.text += text
+		} else serialize(child, out)
+	}
+	return out
+}
+
+/**
+ * Leaf prose elements with their sentences and the facts each sentence cites.
+ * @returns {{ owner: object, scope: object, kind: string|null, sentences: { text: string, start: number, end: number, facts: object[] }[] }[]}
+ */
+export function proseSentences(ctx) {
+	const { closest, descendants } = ctx.util
+	const blocks = []
+	for (const { node, scope } of ctx.elements) {
+		if (node.tag !== "p" && node.tag !== "li") continue
+		if (node.tag === "li" && descendants(node).some((child) => child.tag === "p" || child.tag === "li")) continue
+		if (closest(node, (cur) => CONTAINERS.has(cur.tag))) continue
+		const { text, facts } = serialize(node, { text: "", facts: [] })
+		const sentences = splitSentences(text).map((s) => ({ ...s, facts: facts.filter((f) => f.start < s.end && f.end > s.start) }))
+		blocks.push({ owner: node, scope, kind: ctx.kindOf(scope), sentences })
+	}
+	return blocks
+}
+
+function claimList(claims) {
+	const list = Array.isArray(claims) ? claims : (claims?.claims ?? [])
+	return new Map(list.map((claim) => [claim.claim_id, claim]))
+}
+
+const selfOrUp = (ctx, node, test) => test(node) || Boolean(ctx.util.closest(node, test))
+
+function claimDefects(ctx, claims) {
+	const byId = claimList(claims)
+	const out = []
+	for (const { node, scope } of ctx.elements) {
+		const attr = node.attrs["data-claim"]
+		if (attr === undefined) continue
+		const heading = scope.section?.heading
+		const inGaps = Boolean(heading) && GAPS_HEADING.test(proseText(heading))
+		for (const id of attr.split(/[\s,]+/).filter(Boolean)) {
+			const claim = byId.get(id)
+			let why = null
+			if (!claim) why = `data-claim ${id} is not in the claim index`
+			else if (/refuted|unresolved/i.test(claim.status) && !inGaps) why = `claim ${id} is ${claim.status} but asserted outside Gaps or Contradictions`
+			else if (!inGaps && /high/i.test(claim.risk) && !claim.in_verified) why = `high-risk claim ${id} is not in verified-claims`
+			if (why) out.push(ctx.defect("claim_status_invalid", node, why))
+		}
+	}
+	return out
+}
+
+function conflict(rows, facts) {
+	const cited = [...new Set(facts.map((f) => f.id))].map((id) => rows.get(id)).filter((row) => row && row.status === "active" && row.kind !== "quote")
+	for (let i = 0; i < cited.length; i++) {
+		for (let k = i + 1; k < cited.length; k++) {
+			const [a, b] = [cited[i], cited[k]]
+			if (!sameValue(a.value, b.value) || unitKey(a.unit) !== unitKey(b.unit)) continue
+			if (a.valid_at !== b.valid_at || a.qualifier !== b.qualifier) return [a, b]
+		}
+	}
+	return null
+}
+
+/**
+ * @param {object} ctx buildContext(...) from gates-static.mjs
+ * @param {{ claims: object[] } | object[] | null} claims indexClaims(...) output or its claims array
+ * @param {{ rows: object[] } | null} ledger
+ */
+export function bindingChecks(ctx, claims, ledger) {
+	const rows = new Map((ledger?.rows ?? []).map((row) => [row.fact_id, row]))
+	const out = []
+	for (const block of proseSentences(ctx)) {
+		const findings = Boolean(block.scope.section) && block.kind === null
+		const exempt = selfOrUp(ctx, block.owner, (cur) => isExemptKind(cur.attrs["data-kind"]) || cur.attrs["data-claim"] !== undefined)
+		for (const sentence of block.sentences) {
+			const bound = sentence.facts.length > 0 || ctx.util.citationMarker.test(sentence.text) || sentence.text.includes("{{")
+			if (findings && !exempt && !bound) out.push(ctx.defect("unbound_sentence", block.owner, `no fact, citation, or data-claim binds: "${sentence.text.slice(0, 80)}"`))
+			const pair = conflict(rows, sentence.facts)
+			if (pair) {
+				const [a, b] = pair
+				out.push(ctx.defect("conflicting_readings", block.owner, `${a.fact_id} (${a.valid_at ?? "no period"}) and ${b.fact_id} (${b.valid_at ?? "no period"}) share ${a.value} ${a.unit ?? ""} in one sentence`))
+			}
+		}
+	}
+	return [...out, ...claimDefects(ctx, claims)]
+}

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

@@ -109,6 +109,11 @@ export function isLocked(parsed) {
 	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")

package/packages/omo-codex/plugin/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/omo-codex/plugin/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 }
+}