oh-my-opencode 5.1.48 → 5.1.51

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

@@ -3,7 +3,7 @@ import { leaves, parseExpr } from "./fact-expr.mjs"
 import { readRow } from "./fact-ledger-kinds.mjs"
 import { addRow, nextId, validateLedger } from "./fact-ledger.mjs"
 import { recompute, verifyGraph } from "./fact-recompute.mjs"
-import { canonicalUnit, inputScale, refuse } from "./unit-algebra.mjs"
+import { canonicalUnit, inputScale, refuse, RuleError } from "./unit-algebra.mjs"
 import { refusal } from "./unit-errors.mjs"
 import { object, sameDeclared } from "./unit-metadata.mjs"
 import { display, renderValue, resultPrecision, toText } from "./unit-precision.mjs"
@@ -29,7 +29,11 @@ function declaredUnit(spec, rule) {
 	return canonicalUnit(declared)
 }
 
+/** Refused before any work, under its own code: time is the caller's (spec.now), never the clock. */
+const MISSING_NOW = Object.freeze({ error: "missing_now", shape: "missing_now", expected: "an ISO timestamp in spec.now", detail: "derive needs a caller-supplied now timestamp" })
+
 export function derive(ledger, spec) {
+	if (object(spec) && typeof spec.now !== "string") return { ...MISSING_NOW }
 	try {
 		if (!object(spec)) refuse("spec must be an object")
 		const errors = validateLedger(ledger)
@@ -54,13 +58,14 @@ export function derive(ledger, spec) {
 		const result = compute(spec.op, rows, expected, ast, context, spec.formula)
 		const row = addRow(ledger, {
 			kind: rule.kind, unit: expected, quote: "", extracted_by: "fact-derive",
-			observed_at: spec.now ?? new Date().toISOString(),
+			observed_at: spec.now,
 			label: spec.label ?? `${spec.op}-${nextId(ledger, rule.kind).toLowerCase()}`,
 			...result, operation: spec.op, operands: ids, derived_from: ids,
 			rationale: spec.rationale ?? null, context,
 		})
 		return { row, compatibility: rule.compatibility }
 	} catch (error) {
+		if (!(error instanceof RuleError)) throw error
 		return { error: "incompatible_operands", ...refusal(error) }
 	}
 }

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

@@ -9,6 +9,7 @@ import { finalReading, rewriteParticle } from "./particles-ko.mjs"
 import { failureCount, markReplaced, sentenceKey } from "./fidelity-state.mjs"
 import { findPlaceholders, lead, qualifiedText, renderBlockquote, renderQuote, renderValueHtml, subSpan, valueParts } from "./placeholder.mjs"
 import { splitSentences } from "./sentence-split.mjs"
+import { CLAIM_KINDS } from "./claim-kinds.mjs"
 
 /** The output formats fill renders. */
 export const FILL_FORMATS = Object.freeze(["html", "md"])
@@ -24,7 +25,7 @@ function resolveValue(row, parsed, format) {
 	const { valueText, unitText } = valueParts(row)
 	const text = { full: row.raw, value: valueText, unit: unitText, q: qualifiedText(row) }[parsed.mode]
 	if (text === null) return { code: "quote_anchor_unresolved", message: `${row.fact_id} has qualifier ${row.qualifier}, but its quote holds no qualifier beside "${row.raw}"` }
-	return { row, parsed, visible: text, rendered: format === "html" ? renderValueHtml(row, text) : text }
+	return { row, parsed, visible: text, rendered: format === "html" ? renderValueHtml(row, text, { mode: parsed.mode, claimKind: parsed.claimKind ?? null }) : text }
 }
 
 function resolveQuote(row, parsed, format) {
@@ -33,17 +34,18 @@ function resolveQuote(row, parsed, format) {
 	if (selection === null) {
 		return { code: "quote_anchor_unresolved", message: `from "${parsed.from}" and to "${parsed.to}" must each occur exactly once in ${row.fact_id}'s quote, in that order` }
 	}
-	const rendered = renderQuote(row, parsed.selector, selection.text, format)
+	const rendered = renderQuote(row, parsed.selector, selection.text, format, parsed.claimKind)
 	return { row, parsed, visible: `[${row.source_id}]`, rendered, selector: parsed.selector, quote_span: [selection.start, selection.end] }
 }
 
 function resolve(found, rows, format) {
 	const { parsed } = found
-	if (parsed.error) return { code: "unresolved_placeholder", message: parsed.error }
+	if (parsed.error) return { code: "unresolved_placeholder", message: `${parsed.error}; for literal opening braces, write {{ instead of {{ (including in code spans)` }
 	const row = rows.get(parsed.id)
 	if (row === undefined) return { code: "unresolved_placeholder", message: `${parsed.id} is not in the fact ledger` }
 	if (row.status !== "active") return { code: "unresolved_placeholder", message: `${parsed.id} is ${row.status}; cite its replacement` }
 	if (row.label !== parsed.label) return { code: "pointer_label_mismatch", message: `${parsed.id} has label "${row.label}", not "${parsed.label}"` }
+	if (parsed.claimKind && !CLAIM_KINDS[parsed.claimKind].rowKinds.includes(row.kind)) return { code: CLAIM_KINDS[parsed.claimKind].defect, message: `${parsed.claimKind} does not accept a ${row.kind} row (${parsed.id})` }
 	return parsed.kind === "Q" ? resolveQuote(row, parsed, format) : resolveValue(row, parsed, format)
 }
 
@@ -146,7 +148,7 @@ function assemble(text, parts, context) {
 		flush(part.start)
 		const start = context.out.length
 		if (part.parsed) {
-			const extra = part.selector === undefined ? {} : { selector: part.selector, quote_span: part.quote_span }
+			const extra = { ...(part.selector === undefined ? {} : { selector: part.selector, quote_span: part.quote_span }), ...(part.parsed.claimKind ? { claimKind: part.parsed.claimKind } : {}), ...(part.parsed.mode === "value" ? { mode: "value" } : {}) }
 			context.fillMap.push({ token: part.token, fact_id: part.row.fact_id, start, end: start + part.rendered.length, rendered: part.rendered, ...extra })
 		} else if (part.rendered !== "") {
 			context.fillMap.push({ token: null, fact_id: part.source.fact_id, replaced: part.key, start, end: start + part.rendered.length, rendered: part.rendered })

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

@@ -3,7 +3,6 @@
 // per-kind choices (id prefix, measured exact) from it, and the per-kind table in
 // references/fact-ledger-grammar.md is rendered from it (`node fact-ledger-kinds.mjs --render-grammar`).
 // Also the value primitives the schema shares. Pure functions with no IO; node: builtins only.
-
 import { isCliEntry } from "./entry-guard.mjs"
 import { canonicalUnit, inputScale, RuleError } from "./unit-algebra.mjs"
 import { metadataErrors } from "./unit-metadata.mjs"
@@ -15,7 +14,6 @@ export const DECIMAL = /^-?\d+(?:\.\d+)?$/
 const INTEGER = /^-?\d+$/
 const SHA256 = /^[0-9a-f]{64}$/
 const SOURCE_ID = /^S\d+$/
-
 export const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
 export const isString = (value) => typeof value === "string"
 export const isNonEmpty = (value) => typeof value === "string" && value.length > 0
@@ -48,6 +46,7 @@ export function locatorErrors(locator, at) {
 	const errors = []
 	if (!isObject(locator)) return errors
 	if (!isNonEmpty(locator.artifact)) errors.push(`${at}.artifact must be a non-empty string`)
+	if (locator.unit !== undefined && locator.unit !== "bytes") errors.push(`${at}.unit must be bytes`)
 	if (!(isCount(locator.char_start) && isCount(locator.char_end) && locator.char_start <= locator.char_end)) errors.push(`${at}.char_start/char_end must be integers with start <= end`)
 	for (const key of ["page", "line"]) {
 		if (locator[key] !== undefined && !(Number.isInteger(locator[key]) && locator[key] >= 1)) errors.push(`${at}.${key} must be an integer >= 1`)
@@ -87,6 +86,7 @@ export const RULES = Object.freeze({
 	rational_or_null: { cell: "rational or null", says: "null or { num: integer string, den: positive integer string }", test: orNull(isRational) },
 	by_derive: { cell: "reduced rational", says: "a reduced { num: integer string, den: positive integer string }", test: isRational },
 	context_by_derive: { cell: "written by derive (object or null)", says: "null or an object", test: orNull(isObject) },
+	source_context: { cell: "quote context or null (legacy)", says: "null or { prefix, suffix } up to 32 characters each", test: orNull((v) => isObject(v) && Object.keys(v).sort().join(",") === "prefix,suffix" && [v.prefix, v.suffix].every((s) => isString(s) && [...s].length <= 32)) },
 	derived_operation: { cell: "sum/diff/growth/share/ratio/expr", says: "a derived operation", test: (v) => Object.hasOwn(OPERATION_RULES, v) && OPERATION_RULES[v].kind === "derived" },
 	convert_operation: { cell: "`convert`", says: "convert", test: (v) => Object.hasOwn(OPERATION_RULES, v) && OPERATION_RULES[v].kind === "converted" },
 	precision: { cell: "`{ places, sigfigs }`", says: "nonnegative places and positive sigfigs", test: (v) => isObject(v) && Object.keys(v).sort().join(",") === "places,sigfigs" && Number.isSafeInteger(v.places) && v.places >= 0 && Number.isSafeInteger(v.sigfigs) && v.sigfigs >= 1 },
@@ -101,14 +101,13 @@ const unsourced = { source_id: "source_or_null", locator: "locator_or_null", sna
 const row = (cells) => Object.freeze(Object.fromEntries(KIND_COLUMNS.map((column) => [column, cells[column] ?? (["precision", "compatibility"].includes(column) && cells.operation !== "null" ? column : "null")])))
 
 export const KIND_RULES = Object.freeze({
-	measured: row({ fact_id: "f_id", value: "decimal", ...sourced, rationale: "string_or_null", exact: "from_value", context: "null", operation: "null" }),
-	quote: row({ fact_id: "q_id", value: "null", ...sourced, rationale: "string_or_null", exact: "null", context: "null", operation: "null" }),
+	measured: row({ fact_id: "f_id", value: "decimal", ...sourced, rationale: "string_or_null", exact: "from_value", context: "source_context", operation: "null" }),
+	quote: row({ fact_id: "q_id", value: "null", ...sourced, rationale: "string_or_null", exact: "null", context: "source_context", operation: "null" }),
 	derived: row({ fact_id: "f_id", value: "decimal", ...unsourced, rationale: "string_or_null", exact: "by_derive", context: "context_by_derive", operation: "derived_operation" }),
 	assumed: row({ fact_id: "f_id", value: "decimal", ...unsourced, rationale: "non_empty", exact: "rational_or_null", context: "null", operation: "null" }),
 	converted: row({ fact_id: "f_id", value: "decimal", ...unsourced, rationale: "string_or_null", exact: "by_derive", context: "context_by_derive", operation: "convert_operation" }),
 })
 
-/** The id prefix nextId assigns for a kind; an unknown kind gets F and fails validation later. */
 export function idPrefix(kind) {
 	return RULES[KIND_RULES[kind]?.fact_id ?? "f_id"].prefix
 }
@@ -169,7 +168,7 @@ const carriesDerivation = (row) => row.operation !== null || row.operands?.lengt
 /** Dimension 32: a stored exact must equal the row's own value at the value's decimal places. */
 function valueExactDisagreement(row) {
 	const exact = readExact(row.exact)
-	const value = readDecimal(row.value)
+	const value = isString(row.value) ? readDecimal(row.value).replace(/^-(0+(?:\.0+)?)$/, "$1") : row.value
 	if (!isRational(exact) || !isDecimal(value) || roundPlaces(toBig(exact), placesOf(value)) === value) return null
 	return `value ${value} disagrees with exact ${exact.num}/${exact.den} at ${placesOf(value)} decimal places`
 }
@@ -212,7 +211,7 @@ export function kindRuleErrors(candidate, at) {
 		const value = candidate[column] === undefined && LATER_COLUMNS.includes(column) ? null : candidate[column]
 		const rule = RULES[legacy && column === "exact" ? "rational_or_null" : rules[column]]
 		// An exact with unknown keys loads as written (never stripped); readFlaws refuses it at use and at write.
-		if (column === "exact" && hasUnknownExactKeys(value) && !isCurrentDerived(candidate)) continue
+		if (column === "exact" && rules[column] !== "null" && hasUnknownExactKeys(value) && !isCurrentDerived(candidate)) continue
 		if (rule.test(value, candidate)) continue
 		errors.push(`${at}.${column} must be ${rule.says} for a ${candidate.kind} row`)
 		if (rule.detail) errors.push(...rule.detail(value, `${at}.${column}`))

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

@@ -1,10 +1,12 @@
-// fact-locate.mjs - deterministic fact locators over a source snapshot.
+// fact-locate.mjs - deterministic fact locators over a source snapshot's locator text.
 //
 // Each locator returns { value, unit, raw, quote, value_span, sentence_id, qualifier, locator } or
 // { error: "fact_not_located" | "fact_ambiguous", candidates }; it never guesses. `quote` is the
-// whole containing sentence, cell, or line of text.txt, `value_span` is [start, end] inside
-// `quote` with quote.slice(...value_span) === raw, and locator.char_start/char_end place `quote`
-// in text.txt. Every call takes `sourceId` (S<n>) so sentence ids match sentences.jsonl.
+// whole containing sentence, cell, or line of the view text (source-view.mjs: the visible text
+// nodes of a page, never markup), `value_span` is [start, end] inside `quote` with
+// quote.slice(...value_span) === raw, and locator.char_start/char_end place `quote` in that text;
+// raw-locator.mjs turns them into bytes. Every call takes `sourceId` (S<n>) so sentence ids match
+// sentences.jsonl, which indexes the same text.
 // Plain Node ESM, sibling imports only; no network, no OCR.
 
 import { proseText } from "./html-lite.mjs"
@@ -101,7 +103,8 @@ export function locateFind(text, { find, unitExpected, sourceId }) {
 	return result.unit === expected ? result : { error: "unit_expected_mismatch", expected, found: result.unit, candidates: [result] }
 }
 
-function cellsOf(row) {
+/** A row's cells by visual column (a colspan cell repeats). */
+export function cellsOf(row) {
 	const cells = []
 	for (const cell of row.children.filter((child) => child.tag === "td" || child.tag === "th")) {
 		const span = Math.max(1, Number.parseInt(cell.attrs.colspan ?? "1", 10) || 1)
@@ -110,7 +113,7 @@ function cellsOf(row) {
 	return cells
 }
 
-function rowsOf(table) {
+export function rowsOf(table) {
 	const rows = []
 	const walk = (node) => {
 		for (const child of node.children) {
@@ -142,10 +145,13 @@ function tablesOf(root) {
 const cellLabel = (cell) => label(proseText(cell))
 const indexesOf = (labels, wanted) => labels.flatMap((value, index) => (value === wanted ? [index] : []))
 
-/** --table/--row/--col: the table by id, caption, or a header label; row and column by normalized label, never by index. */
-export function locateTable(sourceHtml, { table, row, col, sourceId }) {
+/**
+ * --table/--row/--col: the table by id, caption, or a header label; row and column by normalized label,
+ * never by index. `source` is page html or an extracted view ({ root, text, blocks }) of one.
+ */
+export function locateTable(source, { table, row, col, sourceId }) {
 	requireSource(sourceId)
-	const { root, text, blocks } = snapshotBlocks(sourceHtml)
+	const { root, text, blocks } = typeof source === "string" ? snapshotBlocks(source) : source
 	const key = label(table)
 	const tables = tablesOf(root).filter((entry) => entry.table.attrs.id === table || entry.caption === key || (entry.header && cellsOf(entry.header).map(cellLabel).includes(key)))
 	if (tables.length !== 1) return tables.length === 0 ? notLocated() : ambiguous(tables.map((entry) => ({ table: entry.table.attrs.id ?? entry.caption })))

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

@@ -14,6 +14,7 @@
 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 { isClaimSegment } from "./sources-citation.mjs"
 import { proseText } from "./html-lite.mjs"
 
 const marked = (node) => node.attrs?.[CLAIM_ATTRIBUTE] !== undefined
@@ -63,7 +64,7 @@ export function claimChecks(ctx, rows, provenanceOf, flag) {
 		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}")`
+			const mark = need && `{{${CLAIM_KINDS[need].prefix}:${id}:${rows.get(id).label}}} (${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
 		}
@@ -77,8 +78,8 @@ export function claimChecks(ctx, rows, provenanceOf, flag) {
 		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) {
+		if (block.kind === "toc") continue
+		for (const sentence of block.kind === "sources" ? block.sentences.filter((s) => isClaimSegment(s.text)) : 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

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

@@ -0,0 +1,32 @@
+// Read fact export CSV records, including quoted commas, escaped quotes and newlines.
+import { existsSync, readFileSync } from "node:fs"
+
+export function readCsv(path) {
+	if (!existsSync(path)) return null
+	const text = readFileSync(path, "utf8")
+	const records = []
+	let cells = []
+	let cell = ""
+	let quoted = false
+	for (let i = 0; i <= text.length; i++) {
+		const char = text[i]
+		if (char === '"') {
+			if (quoted && text[i + 1] === '"') {
+				cell += '"'
+				i++
+			} else quoted = !quoted
+		} else if (!quoted && (char === "," || char === "\n" || char === undefined)) {
+			cells.push(cell.trim())
+			cell = ""
+			if (char !== ",") {
+				if (cells.some((value) => value !== "")) records.push(cells)
+				cells = []
+			}
+		} else if (char !== undefined) cell += char
+	}
+	if (quoted) return null
+	const [head = [], ...rows] = records
+	const [id, value, unit] = ["fact_id", "plot_value", "unit"].map((name) => head.indexOf(name))
+	if (id < 0 || value < 0 || unit < 0 || rows.length === 0) return null
+	return rows.map((c) => ({ fact_id: c[id], plot_value: c[value], unit: c[unit] ?? "" }))
+}

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

@@ -4,7 +4,7 @@
 // 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
+// verifier; name_outside_quote and scope_widened_warn also emit minor defects. 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.
 

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

@@ -0,0 +1,161 @@
+// Check displayed conversion originals against their operands, not the mutable render field.
+import { sameValue, unitKey } from "./fidelity-binding.mjs"
+import { proseText } from "./html-lite.mjs"
+import { parseNumeral } from "./numerals.mjs"
+import { normalizeText } from "./text-normalize.mjs"
+import { display } from "./unit-precision.mjs"
+import { dimensionOf } from "./units.mjs"
+
+const DERIVED = new Set(["converted", "derived"])
+/**
+ * The one bracket grammar of the skill. After NFKC (fullwidth parentheses and square brackets fold
+ * to ASCII), an original is a () [] 【】 「」 or 〔〕 group. Inside a derived or converted element every
+ * group is an original, never prose; a dash separator is not an original.
+ */
+const PAIRS = [["(", ")"], ["[", "]"], ["\u3010", "\u3011"], ["\u300C", "\u300D"], ["\u3014", "\u3015"]]
+const [OPEN, CLOSE] = [PAIRS.map((pair) => pair[0]).join(""), PAIRS.map((pair) => pair[1]).join("")]
+const inClass = (chars) => chars.replace(/[\\\]\[^-]/g, "\\$&")
+const literal = (chars) => chars.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+const ANY = inClass(OPEN + CLOSE)
+const GROUP = new RegExp(PAIRS.map(([open, close]) => `${literal(open)}([^${ANY}]*)${literal(close)}`).join("|"), "gu")
+const BRACKET = new RegExp(`[${ANY}]`, "u")
+const folded = (text) => String(text).normalize("NFKC")
+const innerOf = (match) => match.slice(1).find((part) => part !== undefined)
+const mismatch = (message) => ["value_mismatch", message, "original"]
+
+const halfFits = (row, half) => {
+	const expected = normalizeText(folded(display(String(row.value), row.unit ?? null)))
+	const text = normalizeText(half)
+	return text === expected || (text.endsWith(` ${expected}`) && !/\d/.test(text.slice(0, -expected.length)))
+}
+
+/** The converted half (the text outside the originals) equals display(row.value, row.unit), rebuilt from the row. */
+export function convertedHalfFits(row, shown) {
+	if (!DERIVED.has(row.kind) || row.value === null || row.value === undefined) return false
+	return halfFits(row, folded(shown).replace(GROUP, ""))
+}
+
+/** A second number outside the value verify reads and its originals ("320,000 mm - 999 m"). */
+function strayNumber(row, half) {
+	if (row.value === null || row.value === undefined || halfFits(row, half)) return null
+	const read = parseNumeral(half)
+	if (!read || !sameValue(read.value, row.value)) return null
+	const rest = half.slice(0, read.span[0]) + half.slice(read.span[1])
+	return /\d/.test(row.unit ? rest.split(row.unit).join("") : rest) ? mismatch(`"${half.trim()}" carries a number besides the value and its originals`) : null
+}
+
+/** `valueMode`: the element shows the bare value ({{F:x:value}}), so no original is due. */
+export function originalProblem(row, shown, rows, valueMode = false) {
+	if (!DERIVED.has(row.kind)) return null
+	const text = folded(shown)
+	const groups = [...text.matchAll(GROUP)]
+	const half = text.replace(GROUP, "")
+	if (BRACKET.test(half)) return mismatch("original brackets are malformed or nested")
+	const operands = (row.derived_from ?? []).map((id) => rows.get(id))
+	for (const [index, match] of groups.entries()) {
+		const [inner, operand] = [innerOf(match), operands[index]]
+		const parsed = parseNumeral(inner)
+		if (!operand) return mismatch(`original "${inner}" has no operand of ${row.fact_id}`)
+		if (!parsed || !sameValue(parsed.value, operand.value)) return mismatch(`original "${inner}" differs from operand ${operand.fact_id}`)
+		if (unitKey(parsed.unitRaw ?? "") !== unitKey(operand.unit ?? "")) return ["unit_mismatch", `original "${inner}" is not in ${operand.unit}`, "original"]
+		const expected = normalizeText(folded(display(operand.value, operand.unit ?? null)))
+		if (normalizeText(inner) !== expected) return mismatch(`original "${inner}" differs from "${expected}"`)
+	}
+	if (groups.length > 0 && !/\d/.test(text.slice(0, groups[0].index))) return mismatch(`original "${innerOf(groups[0])}" precedes the value`)
+	if (row.kind === "converted" && !valueMode && /\d/.test(half) && groups.length < operands.length) return mismatch(`the original of ${row.derived_from[groups.length]} is missing after the value`)
+	return strayNumber(row, half)
+}
+
+/** Stands for a filled element or another fill-map value in the text after a fill site. */
+const FILLED = "\uFFFC"
+/** After a fill site the grammar also reads the brackets an element never carries as originals. */
+const FOLLOW = [...PAIRS, ["\u300E", "\u300F"], ["\u300A", "\u300B"], ["\u3008", "\u3009"], ["\u27E8", "\u27E9"]]
+const dimension = (unit) => dimensionOf(String(unit).replace(/-e\d+$/u, "")) ?? unitKey(unit)
+
+/** What the text after a fill site opens: a bracket group's content, or the clause after a separator (`open`); else null. */
+function openedGroup(text) {
+	const rest = folded(text).trimStart()
+	const pair = FOLLOW.find(([open]) => rest.startsWith(open))
+	const close = pair ? rest.indexOf(pair[1], 1) : -1
+	if (pair) return { group: rest.slice(1, close === -1 ? undefined : close).trim(), open: false }
+	return /^[-\u2013\u2014/]/u.test(rest) ? { group: rest.slice(1).split(/[,;:!?)\]]|\.(?!\d)/u)[0].trim(), open: true } : null
+}
+
+/**
+ * Whether the text right after a fill site of `row` opens another original: a bracket group or a
+ * separator clause that is exactly a numeral with a unit of the row's or an operand's dimension (a
+ * separator clause may end in a glued particle, as Korean writes "- 999 m\uC774\uB2E4").
+ * A filled element, a fill-map value (`fills`), a placeholder, a unitless number (a year, a
+ * footnote) and prose with digits are not originals; untraceable_number still reads a stray number.
+ */
+export const followsOriginal = (row, rows, fills = []) => (text) => {
+	if (!DERIVED.has(row?.kind)) return false
+	const after = [...fills].filter(Boolean).sort((a, b) => b.length - a.length).reduce((cur, fill) => cur.split(fill).join(FILLED), String(text))
+	const { group, open } = openedGroup(after) ?? { group: "" }
+	if (!group || group.includes(FILLED) || group.includes("{{")) return false
+	const units = [row.unit, ...(row.derived_from ?? []).map((id) => rows.get(id)?.unit)].filter(Boolean)
+	return [group, ...(open ? [group.replace(/[\uAC00-\uD7A3]+$/u, "").trim()] : [])].some((body) => {
+		const read = parseNumeral(body, 0)
+		return Boolean(read?.unitRaw) && read.span[0] === 0 && read.span[1] === body.length && units.some((unit) => dimension(unit) === dimension(read.unitRaw))
+	})
+}
+
+/** The prose after `node` in its parent, each filled element (data-fact) read as one FILLED mark. */
+export const textAfter = (node) => {
+	const siblings = node.parent?.children.slice(node.parent.children.indexOf(node) + 1) ?? []
+	return proseText({ children: siblings.map((child) => (child.attrs?.["data-fact"] === undefined ? child : { tag: "#text", text: FILLED })) })
+}
+
+const SPACE = "[\\s\\u3000]"
+const DIGIT = "[0-9\\uFF10-\\uFF19]"
+/** Each character with the fullwidth form NFKC folds onto it. */
+const wide = (chars) => [...chars].map((ch) => ch + (/[!-~]/.test(ch) ? String.fromCharCode(ch.charCodeAt(0) + 0xfee0) : "")).join("")
+const [WIDE_OPEN, WIDE_CLOSE] = [inClass(wide(OPEN)), inClass(wide(CLOSE))]
+
+/** A pattern reading `rendered` modulo the bracket grammar: NFKC fullwidth forms, bracket style, spacing around brackets. */
+function renderPattern(rendered) {
+	const text = folded(rendered).trim()
+	let body = ""
+	for (let at = 0; at < text.length; at += 1) {
+		const ch = text[at]
+		const beside = (OPEN + CLOSE).includes(text.slice(at).trimStart()[0]) || OPEN.includes(text[at - 1])
+		if (/\s/.test(ch)) body += beside ? "" : `${SPACE}+`
+		else if (OPEN.includes(ch)) body += `${SPACE}*([${WIDE_OPEN}])${SPACE}*`
+		else if (CLOSE.includes(ch)) body += `${SPACE}*([${WIDE_CLOSE}])`
+		else body += `[${inClass(wide(ch))}]`
+	}
+	// A digit may not run into a render's leading or trailing digit ("1,320 m" holds no "320 m"); a bracket ends the render.
+	return new RegExp(`${/^\d/.test(text) ? `(?<!${DIGIT})` : ""}${body}${/\d$/.test(text) ? `(?!${DIGIT})` : ""}`, "gu")
+}
+
+const pairIndex = (ch, side) => [...side].findIndex((open) => open === folded(ch))
+/** [start, end) of `rendered` in `text` from `from` under the bracket grammar, not followed by another original (`follows`); or null. */
+export function findRender(text, rendered, from = 0, follows = () => false) {
+	const pattern = renderPattern(rendered)
+	pattern.lastIndex = from
+	for (let match = pattern.exec(text); match; match = pattern.exec(text)) {
+		const marks = match.slice(1)
+		const paired = marks.every((mark, i) => i % 2 === 1 || pairIndex(mark, OPEN) === pairIndex(marks[i + 1] ?? "", CLOSE))
+		const end = match.index + match[0].length
+		if (paired && !follows(text.slice(end))) return [match.index, end]
+		pattern.lastIndex = match.index + 1
+	}
+	return null
+}
+
+/** Where a stale fill-map entry's text sits: derived and converted renders are read under the bracket grammar. */
+export const renderLocator = (rows, fillMap) => (entry, text, from) => {
+	const row = rows.get(entry.fact_id)
+	if (DERIVED.has(row?.kind)) return findRender(text, entry.rendered, from, followsOriginal(row, rows, (fillMap ?? []).map((other) => other.rendered)))
+	const hit = text.indexOf(entry.rendered, from)
+	return hit === -1 ? null : [hit, hit + entry.rendered.length]
+}
+
+/** Null when a stale derived render is still in the report; "original" when only its converted half is; "gone" otherwise. */
+export function staleRender(row, rendered, text, follows) {
+	if (findRender(text, rendered, 0, follows) !== null) return null
+	const half = folded(rendered).replace(GROUP, "").trim()
+	return half !== "" && /\d/.test(half) && findRender(text, half) !== null ? "original" : "gone"
+}
+
+export const isDerivedRow = (row) => DERIVED.has(row?.kind)

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

@@ -137,11 +137,11 @@ function sourcesOf(row, rows, seen = new Set()) {
 /** sha256 of the locked `## Fidelity` block normalized: the seven fields in FIDELITY_FIELDS order, `field: value` per line. */
 export const briefHashOf = (parsed) => sha256Of(FIDELITY_FIELDS.map((field) => `${field}: ${parsed.fields[field]}`).join("\n"))
 
-/** brief_changed when a fill map was not written under the current brief (or predates the binding). */
+/** brief_changed when there is no fill map (map null) or it was not written under the current brief (or predates the binding). */
 export function briefBindingErrors(map, mapPath, parsed) {
-	if (map.brief_sha256 === briefHashOf(parsed)) return []
-	const why = typeof map.brief_sha256 === "string" ? "was filled under a different ## Fidelity block" : "records no brief_sha256"
-	return [{ code: "brief_changed", token: null, line: null, message: `${mapPath} ${why}; re-run fact fill under the current brief`, severity: DEFECT_CODES.brief_changed.severity, integrity: DEFECT_CODES.brief_changed.integrity, hint: DEFECT_CODES.brief_changed.hint }]
+	if (map?.brief_sha256 === briefHashOf(parsed)) return []
+	const why = map === null ? `no fill map at ${mapPath}` : `${mapPath} ${typeof map.brief_sha256 === "string" ? "was filled under a different ## Fidelity block" : "records no brief_sha256"}`
+	return [{ code: "brief_changed", token: null, line: null, message: `${why}; re-run fact fill under the current brief`, severity: DEFECT_CODES.brief_changed.severity, integrity: DEFECT_CODES.brief_changed.integrity, hint: DEFECT_CODES.brief_changed.hint }]
 }
 
 function metaOf(sessionDir, sourceId, cache) {

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

@@ -15,7 +15,7 @@
 // fidelity record exists, the barrier refuses the unverified edition regardless of it, and the same
 // exemption is the only way a required record may be absent.
 
-import { existsSync, readFileSync } from "node:fs"
+import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs"
 import { join } from "node:path"
 
 import { CliError, readJsonFile, sha256Of, writeJsonAtomic } from "./cli-support.mjs"
@@ -24,7 +24,10 @@ import { meaningCheckEnabled, requireLockedBrief } from "./fidelity-brief.mjs"
 import { blocksDelivery, deliveryBlockReason } from "./gates-fidelity.mjs"
 
 export const FIDELITY_RECORD = "fidelity-defects.json"
+/** The legacy session meaning record: a candidate for every edition whose bytes it claims, like any edition record (newest run wins). */
 export const MEANING_RECORD = "fidelity-meaning-defects.json"
+/** The meaning record of one delivered edition, named by its outcome format (`fact meaning-check --edition`). */
+export const meaningRecordName = (format) => `fidelity-meaning-defects.${format}.json`
 
 /** The fields every fidelity record carries, whatever its kind. */
 export const RECORD_ENVELOPE = Object.freeze(["record_kind", "artifact_sha256", "report", "written_at", "defects"])
@@ -39,13 +42,67 @@ function meaningRequired({ sessionDir }) {
 }
 
 const subjectOf = (row) => row.renderedFrom ?? row.path ?? null
+const hashOf = (path) => (existsSync(path) ? sha256Of(readFileSync(path)) : null)
 
 /** One record per delivered edition: the file its row names with --verified-by, bound to that edition's bytes. */
 const perEdition = (sessionDir, delivered) =>
 	delivered.map((row) => ({ path: row.verifiedBy ?? null, declared: row.verifiedBy !== undefined, format: row.format, at: `${row.format}: `, subjects: [subjectOf(row)].filter((subject) => subject !== null) }))
 
-/** One record per session, in the session directory, bound to any delivered edition's bytes. */
-const perSession = (file) => (sessionDir, delivered) => [{ path: join(sessionDir, file), declared: false, format: null, at: "", subjects: delivered.map(subjectOf).filter((subject) => subject !== null) }]
+const sessionTarget = (sessionDir, file) => ({ path: join(sessionDir, file), declared: false, format: null, at: "", subjects: [] })
+
+/** Include every existing session fidelity record, even when no delivered row attaches it. */
+const perEditionAndSession = (sessionDir, delivered) => [
+	...perEdition(sessionDir, delivered),
+	...(existsSync(join(sessionDir, FIDELITY_RECORD)) ? [sessionTarget(sessionDir, FIDELITY_RECORD)] : []),
+]
+
+/** Edition meaning records on disk (fidelity-meaning-defects.<format>.json). */
+const EDITION_MEANING = /^fidelity-meaning-defects\.[^.]+\.json$/u
+
+/** Verdict severity for equal times: a confirmed drift, then any other blocking defect (unverified), then clean. */
+const severityOf = (defects) =>
+	defects.some((defect) => defect?.code === "meaning_drift_confirmed") ? 2 : defects.some((defect) => typeof defect?.code === "string" && blocksDelivery(defect)) ? 1 : 0
+
+/**
+ * What selection reads from a meaning record: the bytes it claims, when it was written, how severe it is.
+ * An unreadable record matches no bytes (its own row still reads and refuses it); a record with no
+ * readable written_at sorts newest, so the barrier reads it and refuses it as malformed.
+ */
+function claimOf(path) {
+	let record
+	try {
+		record = readJsonFile(path)
+	} catch {
+		return null
+	}
+	const at = Date.parse(record?.written_at)
+	return { path, hash: record?.artifact_sha256 ?? null, at: Number.isNaN(at) ? Infinity : at, severity: severityOf(Array.isArray(record?.defects) ? record.defects : []) }
+}
+
+/** Newest written_at first; on equal times the more severe verdict first. File names never decide. */
+const newestFirst = (a, b) => (a.at === b.at ? b.severity - a.severity : b.at > a.at ? 1 : -1)
+
+/**
+ * One meaning record per delivered edition, bound to that edition's bytes. Every record whose
+ * artifact_sha256 equals the edition's current bytes (a PDF counts its --rendered-from bytes) is a
+ * candidate: its own fidelity-meaning-defects.<format>.json, another edition's record (a
+ * byte-identical copy, or the html edition a PDF renders), and the legacy session record. The
+ * newest reader run wins; on equal times the more severe verdict wins. When no record claims these
+ * bytes the target is its own record (refused as for a different edition), else the legacy record,
+ * else its own name, so the refusal names the file to write (meaning gate not run).
+ */
+function perEditionMeaning(sessionDir, delivered) {
+	if (delivered.length === 0) return [sessionTarget(sessionDir, MEANING_RECORD)]
+	const legacy = join(sessionDir, MEANING_RECORD)
+	const editions = readdirSync(sessionDir).filter((name) => EDITION_MEANING.test(name)).map((name) => join(sessionDir, name))
+	const claims = [...editions, ...(existsSync(legacy) ? [legacy] : [])].map(claimOf).filter((claim) => claim !== null)
+	return perEdition(sessionDir, delivered).map((target) => {
+		const own = join(sessionDir, meaningRecordName(target.format))
+		const bytes = target.subjects.length > 0 ? hashOf(target.subjects[0]) : null
+		const [newest] = bytes === null ? [] : claims.filter((claim) => claim.hash === bytes).sort(newestFirst)
+		return { ...target, declared: false, path: newest?.path ?? (existsSync(own) ? own : existsSync(legacy) ? legacy : own) }
+	})
+}
 
 /** Every fidelity record the barrier reads, in check order; each column is one rule the barrier applies. */
 export const FIDELITY_RECORDS = Object.freeze([
@@ -53,7 +110,7 @@ export const FIDELITY_RECORDS = Object.freeze([
 		kind: "fidelity",
 		file: FIDELITY_RECORD,
 		step: "fidelity gate",
-		targets: perEdition,
+		targets: perEditionAndSession,
 		requiredWhen: ({ hasFidelity }, target) => hasFidelity || GATED_FORMATS.includes(target.format),
 		remedy: (target) => `run fact verify on ${target.subjects[0] ?? "the edition"} and set it with --verified-by`,
 		bindsTo: "artifact_sha256",
@@ -64,17 +121,25 @@ export const FIDELITY_RECORDS = Object.freeze([
 		kind: "meaning",
 		file: MEANING_RECORD,
 		step: "meaning gate",
-		targets: perSession(MEANING_RECORD),
+		targets: perEditionMeaning,
 		requiredWhen: meaningRequired,
-		remedy: () => "run fact pairs and fact meaning-check before delivery",
+		remedy: (target) => `run fact pairs and fact meaning-check --edition ${target.format} on ${target.subjects[0] ?? "the edition"} before delivery`,
 		bindsTo: "artifact_sha256",
 		blocking: blocksDelivery,
 		payload: Object.freeze(["command", "status", "exitCode", "run_id", "pairs_sha256", "counts", "dropped", "unverified", "calibration_path", "calibration_written", "calibration_replaced", "promotion_eligibility"]),
 	}),
 ])
 
+// Collection warnings use the same envelope, but are not delivery-gate records.
+const SOURCE_RECORDS = Object.freeze([
+	Object.freeze({
+		kind: "source_conversion",
+		payload: Object.freeze(["conversion_altered_numbers", "lost", "raw_count", "converted_count"]),
+	}),
+])
+
 const entryOf = (kind) => {
-	const entry = FIDELITY_RECORDS.find((row) => row.kind === kind)
+	const entry = [...FIDELITY_RECORDS, ...SOURCE_RECORDS].find((row) => row.kind === kind)
 	if (entry === undefined) throw new CliError(`unknown fidelity record kind ${kind}`)
 	return entry
 }
@@ -124,19 +189,20 @@ export function readFidelityRecord(path, kind) {
 }
 
 const unresolved = (format, codes, path) => ({ code: "fidelity_unresolved", format, codes, message: codes.map((code) => deliveryBlockReason({ code })).join("; "), path })
-const hashOf = (path) => (existsSync(path) ? sha256Of(readFileSync(path)) : null)
 
 /** Barrier problems for `outcome verify` and `outcome finish`; empty when nothing blocks delivery. */
 export function fidelityProblems(sessionDir, manifest) {
 	const delivered = manifest.deliverables.filter((row) => row.status === "delivered")
-	const hasFidelity = existsSync(join(sessionDir, LEDGER_FILENAME)) || FIDELITY_RECORDS.some((entry) => existsSync(join(sessionDir, entry.file)))
+	const targets = FIDELITY_RECORDS.map((entry) => [entry, entry.targets(sessionDir, delivered)])
+	// Any session record a row did not name (a session fidelity record, a meaning record) is fidelity evidence.
+	const hasFidelity = existsSync(join(sessionDir, LEDGER_FILENAME)) || targets.some(([, list]) => list.some((target) => !target.declared && target.path !== null && existsSync(target.path)))
 	const lastFidelity = manifest.gateHistory?.findLast((entry) => entry.gate === "fidelity")
 	const exempt = !hasFidelity && manifest.gates.fidelity === "not_run" && lastFidelity?.status === "not_run" && Boolean(lastFidelity.reason?.trim())
 	const context = { sessionDir, hasFidelity }
 	const problems = []
 	const counted = new Set()
-	for (const entry of FIDELITY_RECORDS) {
-		for (const target of entry.targets(sessionDir, delivered)) {
+	for (const [entry, list] of targets) {
+		for (const target of list) {
 			const refuse = (message, path = target.path) => problems.push({ code: "edition_unverified", format: target.format, message: `${target.at}${message}`, path })
 			if (target.path === null || !existsSync(target.path)) {
 				if (target.declared) refuse(`${entry.kind} record ${target.path} is missing`)
@@ -151,10 +217,11 @@ export function fidelityProblems(sessionDir, manifest) {
 				continue
 			}
 			if (target.subjects.length > 0 && !target.subjects.some((subject) => hashOf(subject) === record[entry.bindsTo])) {
-				refuse(`${entry.kind} record ${target.path} is for a different edition than ${target.subjects.join(", ")}`)
+				refuse(`${entry.kind} record ${target.path} is for a different edition than ${target.subjects.join(", ")}; ${entry.remedy(target)}`)
 			}
-			if (counted.has(target.path)) continue
-			counted.add(target.path)
+			const path = realpathSync.native(target.path)
+			if (counted.has(path)) continue
+			counted.add(path)
 			const codes = [...new Set(record.defects.filter(entry.blocking).map((defect) => defect.code))].sort()
 			if (codes.length > 0) problems.push(unresolved(target.format, codes, target.path))
 		}