oh-my-opencode 5.1.47 → 5.1.51

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

@@ -0,0 +1,229 @@
+// conversion-probe.mjs - numeric multiset differences after source conversion.
+// Inline markup may split one number; superscripts must not merge into it. Numbers are read with the
+// one grouped-number grammar (number-grammar.mjs). A cell, row, list-item, block or line break is a
+// hard boundary: a space never groups digits across it. A sign counts when no Latin, Greek or
+// Cyrillic letter, digit or underscore touches it (an en dash before a digit is a minus too), and a
+// "-" or U+2212 counts after ONE such letter ("\u0394\u22125") or after an exponent ("1e-5"); a run of
+// two or more ("cite_note-7", "AB-12", "UTF-8", "2019-2023") is an identifier or range and carries no
+// negative. Markdown markup a converter writes beside a sign never decides it: the closer run before it
+// (read with the CommonMark inline grammar in markdown-closers.mjs: emphasis, code, strike, titled and
+// parenthesised link and image targets, reference endings, backslash-escaped closers) is skipped to
+// the first character it closes ("**2019**-2023" and '[1990](/wiki/1990 "1990")-2000' are ranges), and
+// an opener run between the sign and its digits ("-**5**") keeps the sign. A raw-side character
+// reference (`−`, ` `) is decoded on BOTH sides with the one entities.mjs table, so a
+// verbatim copy probes clean. Raw inline HTML a converter leaves in the Markdown (pandoc's gfm writer
+// emits `<sup>`, `<sub>`, `<img ... width=320>`, `<span>`, `<br>`) is read with the html-lite tag
+// reader: sup, sub and break tags are boundaries, as on the raw side, and any other tag or comment is
+// dropped with its attributes, so it is a closer or opener like Markdown markup. Digits a converter
+// writes out from a link target, an image source, alt text, or a title cover a converted number only
+// inside Markdown link or image syntax (`](...)` with any title and balanced parentheses,
+// `![...](...)`, `<https://...>`, `[ref]: url "title"` with the title on the same or the next line),
+// never in prose; a footnote
+// definition's text ("[^1]: ...") is prose. Converter syntax is not a number: a line-start list marker
+// ("1. ", "2) ", "(3) ", indented or after "> ") is exempt only while the source has an <ol> item with
+// that number and the markers so far do not outnumber the <ol> items (so lazy "1. 1. 1." numbering
+// over three items passes), a numeric reference label ("[x][1]" with its "[1]: url") only while both
+// halves are present, and a footnote definition label ("[^1]:") only while its "[^1]" is used;
+// otherwise each is a candidate. A converter's hard wrap may split a space-grouped number over one line
+// break; the two halves read as one number only when the raw side holds that number and not both
+// halves, so raw "12 345 and 12 and 345" wrapped inside "12 345" reports both halves (it fails safe).
+// The built-in snapshot writes no attribute text, syntax, wraps or tags, and its text is already
+// decoded, so it gets none of these allowances. Constructs outside this grammar are declared out of
+// scope in references/fact-ledger.md: they report as altered (the safe direction).
+
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { CliError } from "./cli-support.mjs"
+import { decodeEntities, parseHtml, PROSE_BREAKS, readTag } from "./html-lite.mjs"
+import { escapedAt, inlineLinkSpans, stripClosers } from "./markdown-closers.mjs"
+import { NUMBER_SOURCE, plainDecimal } from "./number-grammar.mjs"
+
+const LETTER = "\\p{Script=Latin}\\p{Script=Greek}\\p{Script=Cyrillic}"
+const WORD = new RegExp(`[${LETTER}\\p{N}_]`, "u")
+const ALPHA = new RegExp(`[${LETTER}]`, "u")
+const EXPONENT = new RegExp(`(?<![${LETTER}\\p{N}_.,])\\d+(?:[.,]\\d+)?[eE]$`, "u")
+/** A dash, then any Markdown opener run, then a number; signed() decides whether the dash is a minus. */
+const NUMBERS = new RegExp(`(?:([-\\u2212\\u2013])([*_~\`[]*))?(${NUMBER_SOURCE})`, "gu")
+/** Sup, sub, datetime chunks and every break join no neighbour: neither a digit, a separator, nor whitespace. */
+const BOUNDARY = "\u0001"
+const CARRIED = ["href", "src", "alt", "title"]
+const LIST_MARKER = /(?:^|\u0001)(?: ?>)* ?(?:\d+[.)]|\(\d+\)) /gu
+const REF_USE = /\]\[(\d+)\]/gu
+const REF_DEF = /(?:^|\u0001)(?: ?>)* ?\[(\d+)\]:/gu
+const NOTE_USE = /\[\^(\d+)\](?!:)/gu
+const NOTE_DEF = /(?:^|\u0001)(?: ?>)* ?\[\^(\d+)\]:/gu
+const TITLE = `(?:"[^"\u0001]*"|'[^'\u0001]*'|\\([^)\u0001]*\\))`
+/** A reference definition's title may sit alone on the next line (only whitespace after it). */
+const REF_DEFINITION = `(?:^|\u0001) ?\\[(?!\\^)[^\\]\u0001]+\\]: ?[^\\s\u0001]*(?: ${TITLE}| ?\u0001 ?${TITLE}(?= ?(?:\u0001|$)))?`
+const LINK_SYNTAX = new RegExp(`!\\[[^\\]\u0001]*\\](?:\\([^)\u0001]*\\))?|\\]\\([^)\u0001]*\\)|<https?:\\/\\/[^>\\s\u0001]+>|${REF_DEFINITION}`, "gu")
+const TAG_NAME = /^[a-z][a-z0-9-]*$/u
+/** What a tag leaves in the numeric text on either side: sup, sub and every break join no neighbour. */
+const edgeOf = (tag) => (tag === "sup" || tag === "sub" || PROSE_BREAKS.has(tag) ? BOUNDARY : "")
+
+/** Prose text, attribute text and <ol> item numbers of an HTML document; a non-HTML document is prose only. */
+function numericText(source, html) {
+	if (!html) return { prose: decodeEntities(source), carried: "", listed: [] }
+	const chunks = []
+	const carried = []
+	const listed = []
+	const walk = (node) => {
+		if (node.tag === "#text") { chunks.push(node.text.replace(/\s+/gu, " ")); return }
+		for (const name of CARRIED) if (node.attrs?.[name] !== undefined) carried.push(node.attrs[name])
+		if (node.tag === "ol") {
+			const start = /^\s*\d+\s*$/u.test(node.attrs.start ?? "") ? Number(node.attrs.start) : 1
+			node.children.filter((child) => child.tag === "li").forEach((_, index) => listed.push(String(start + index)))
+		}
+		const edge = edgeOf(node.tag)
+		chunks.push(edge)
+		if (node.tag === "time" && node.attrs.datetime !== undefined) chunks.push(`${BOUNDARY}${node.attrs.datetime}${BOUNDARY}`)
+		for (const child of node.children) walk(child)
+		chunks.push(edge)
+	}
+	walk(parseHtml(source))
+	return { prose: chunks.join(""), carried: carried.join(BOUNDARY), listed }
+}
+
+/** Raw inline HTML in converted Markdown: sup, sub and break tags become boundaries, other tags and comments go. */
+function inlineHtml(text) {
+	let out = ""
+	let kept = 0
+	for (let lt = text.indexOf("<"); lt !== -1; lt = text.indexOf("<", Math.max(lt + 1, kept))) {
+		const comment = text.startsWith("<!--", lt)
+		const name = lt + (text[lt + 1] === "/" ? 2 : 1)
+		if (escapedAt(text, lt) || (!comment && !/[a-z]/iu.test(text[name] ?? ""))) continue
+		const tag = comment ? null : readTag(text, name)
+		const end = comment ? text.indexOf("-->", lt + 4) + 3 : tag.end
+		if (end <= lt || (tag && !(TAG_NAME.test(tag.name) && text[end - 1] === ">")) || /\n[ \t\r]*\n/u.test(text.slice(lt, end))) continue
+		out += text.slice(kept, lt) + (tag ? edgeOf(tag.name) : "")
+		kept = end
+	}
+	return out + text.slice(kept)
+}
+
+/**
+ * Start offsets of numeric reference labels whose use ("][1]") and definition ("[1]:") are both present,
+ * and of footnote definition labels ("[^1]:") whose "[^1]" is used (the use itself mirrors the source).
+ */
+function referenceLabels(flat) {
+	const uses = [...flat.matchAll(REF_USE)]
+	const defs = [...flat.matchAll(REF_DEF)]
+	const used = new Set(uses.map((match) => match[1]))
+	const defined = new Set(defs.map((match) => match[1]))
+	const paired = [...uses.filter((match) => defined.has(match[1])), ...defs.filter((match) => used.has(match[1]))]
+	const noted = new Set([...flat.matchAll(NOTE_USE)].map((match) => match[1]))
+	const notes = [...flat.matchAll(NOTE_DEF)].filter((match) => noted.has(match[1]))
+	return new Set([...paired, ...notes].map((match) => match.index + match[0].search(/\d/u)))
+}
+
+/** Whether the dash at `at` is a minus: Markdown closers (and a backslash escaping the dash) before it are skipped, as is an opener run before a lone letter. */
+function signed(flat, at, dash) {
+	const before = stripClosers(flat.slice(Math.max(0, at - 512), escapedAt(flat, at) ? at - 1 : at))
+	const last = before.at(-1) ?? ""
+	if (!WORD.test(last)) return true
+	if (dash === "\u2013") return false
+	if (EXPONENT.test(before)) return true
+	return ALPHA.test(last) && !WORD.test(before.slice(0, -1).replace(/[*_~`[]+$/u, "").at(-1) ?? "")
+}
+
+/**
+ * Line breaks become boundaries, then whitespace runs one space; `linked` marks tokens inside link
+ * syntax, `marker` a line-start list marker, `label` a paired reference label, `gap` the text since
+ * the previous number.
+ */
+function tokensOf(text, { links = false } = {}) {
+	const flat = text.replace(/\r\n?|\n|\f/gu, BOUNDARY).replace(/\s+/gu, " ")
+	const spans = links ? [...[...flat.matchAll(LINK_SYNTAX)].map((match) => [match.index, match.index + match[0].length]), ...inlineLinkSpans(flat)] : []
+	const markers = new Set([...flat.matchAll(LIST_MARKER)].map((match) => match.index + match[0].search(/\d/u)))
+	const labels = referenceLabels(flat)
+	let previousEnd = 0
+	return [...flat.matchAll(NUMBERS)].map((match, n) => {
+		const sign = match[1] !== undefined && signed(flat, match.index, match[1])
+		const at = sign ? match.index : match.index + match[0].length - match[3].length
+		const gap = flat.slice(previousEnd, at)
+		previousEnd = match.index + match[0].length
+		return {
+			n,
+			gap,
+			text: sign ? match[0] : match[3],
+			key: `${sign ? "-" : ""}${plainDecimal(match[3])}`,
+			linked: spans.some(([start, end]) => at >= start && at < end),
+			marker: markers.has(at),
+			label: labels.has(at),
+		}
+	})
+}
+
+/** The comparison key of one number token, so other tools can match a converted number against a probe record. */
+export const numberKey = (token) => tokensOf(String(token))[0]?.key ?? null
+
+/** The numbers in `texts` that the source's conversion probe recorded as altered (sources/<id>/conversion.json). */
+export function alteredIn(sourceDir, texts) {
+	const record = join(sourceDir, "conversion.json")
+	let altered = []
+	if (existsSync(record)) {
+		try {
+			altered = JSON.parse(readFileSync(record, "utf8")).conversion_altered_numbers ?? []
+		} catch (error) {
+			throw new CliError(`${record} is not a readable conversion record (${error.message}); snapshot the source again`)
+		}
+	}
+	const keys = new Set(altered.map(numberKey))
+	return texts.flatMap((text) => tokensOf(String(text ?? ""))).filter((token) => keys.has(token.key)).map((token) => token.text)
+}
+
+/** Rejoin a grouped number a hard wrap split over one line break, when only the joined reading is in the raw counts. */
+function joinWrapped(tokens, raw) {
+	const out = []
+	for (const token of tokens) {
+		const prev = out.at(-1)
+		const wrapped = prev?.n === token.n - 1 && /^ ?\u0001 ?$/u.test(token.gap) && !prev.linked && !token.linked
+		const [joined, ...more] = wrapped ? tokensOf(`${prev.text} ${token.text}`) : []
+		if (joined && more.length === 0 && raw.has(joined.key) && !(raw.has(prev.key) && raw.has(token.key))) {
+			out[out.length - 1] = { ...joined, n: token.n, text: `${prev.text}\n${token.text}` }
+			continue
+		}
+		out.push(token)
+	}
+	return out
+}
+
+const countOf = (tokens) => tokens.reduce((counts, token) => counts.set(token.key, (counts.get(token.key) ?? 0) + 1), new Map())
+
+/** The tokens `counts` cannot cover; each covered token uses up one count. */
+function uncovered(tokens, counts) {
+	return tokens.filter((token) => {
+		const remaining = counts.get(token.key) ?? 0
+		if (remaining === 0) return true
+		counts.set(token.key, remaining - 1)
+		return false
+	})
+}
+
+/**
+ * Preserve token spelling in diagnostics; the raw side is read as HTML, the converted side as Markdown
+ * with raw inline tags, both decoded with one entity table. `attributes: false`
+ * (the built-in snapshot) gives attribute digits no cover, converter syntax no exemption and no wrap rejoin. An exempt
+ * marker or label is not a converted number at all: it neither covers a raw number nor counts as altered.
+ */
+export function probeConversion(raw, converted, { attributes = true } = {}) {
+	const source = numericText(raw, /<[a-z!/]/i.test(raw))
+	const before = tokensOf(source.prose)
+	const listed = new Set(source.listed)
+	let items = attributes ? source.listed.length : 0
+	const syntax = tokensOf(attributes ? decodeEntities(inlineHtml(converted)) : converted, { links: attributes })
+		.filter((token) => !(attributes && token.label) && !(token.marker && listed.has(token.key) && items-- > 0))
+	const after = attributes ? joinWrapped(syntax, countOf(before)) : syntax
+	const counts = countOf(before)
+	const extra = new Set(uncovered(after.filter((token) => !token.linked), counts))
+	for (const token of tokensOf(source.carried)) counts.set(token.key, (counts.get(token.key) ?? 0) + 1)
+	for (const token of uncovered(after.filter((token) => token.linked), counts)) extra.add(token)
+	const lost = uncovered(before, countOf(after)).map((token) => token.text)
+	return { altered: after.filter((token) => extra.has(token)).map((token) => token.text), lost, raw_count: before.length, converted_count: after.length }
+}
+
+export function runConversionProbe(argv) {
+	if (argv.length !== 2) throw new CliError("usage: source probe-conversion <raw-file> <converted-file>")
+	const result = probeConversion(readFileSync(argv[0], "utf8"), readFileSync(argv[1], "utf8"))
+	return { json: result, summary: `source probe-conversion: ${result.altered.length} altered, ${result.lost.length} lost`, exitCode: result.altered.length === 0 ? 0 : 1 }
+}

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

@@ -0,0 +1,158 @@
+// css-hiding.mjs - whether CSS hides an element of a page from every reader, from its inline style and
+// the page's own <style> rules (external stylesheets and scripts are not evaluated).
+//
+// Text counts as reader-visible when it is visible under at least one condition. So a rule can hide
+// only when it certainly applies: it sits outside every at-rule except @layer (and @media all), its
+// <style> element applies everywhere (no media other than all, CSS type, not in <noscript>), and its
+// selector is one tag (case-insensitive), one .class or one #id (case-sensitive). A rule that only
+// might apply (inside @media, @supports, @container, @scope, @starting-style, @document, @keyframes,
+// nested in another style rule, or with a compound, combinator, attribute or pseudo-class selector)
+// never hides, but it can make text visible when its subject could match and it outranks the hiding
+// declaration in the cascade (origin and importance, inline style, layer order, specificity, order).
+// Hiding properties: display:none and content-visibility:hidden remove the subtree;
+// visibility:hidden|collapse is inherited and a descendant's visibility:visible shows it again.
+// The hidden attribute (except hidden="until-found") and a closed <dialog> are the user-agent
+// display:none, which any author display declaration overrides. opacity, clip, zero size, font-size,
+// off-screen positions and colors do not hide: the text still renders or is read aloud.
+// Plain Node ESM, sibling imports only.
+
+import { scanRules } from "./css-lite.mjs"
+
+const PROPS = new Set(["display", "visibility", "content-visibility"])
+const INHERITED = new Set(["inherit", "unset", "revert", "revert-layer"])
+const IMPORTANT = /!\s*important\s*$/i
+const SIMPLE = /^(?:[.#][^\s.#:[\]>+~,()*"'\\]+|[a-z][a-z0-9-]*)$/iu
+const PSEUDO_ELEMENT = /::|:(?:before|after|first-line|first-letter)\b/i
+const NAME = "[^\\s.#:[\\]>+~,()*\"'\\\\]+"
+const STYLE_IN_SVG = /<style\b[^>]*>([\s\S]*?)<\/style\s*>/gi
+
+/** [tier (0 user agent, 1 author, 2 author !important), inline, layer, specificity, order]: higher wins. */
+const outranks = (a, b) => {
+	for (let k = 0; k < a.length; k++) if (a[k] !== b[k]) return a[k] > b[k]
+	return false
+}
+
+function specificity(selector) {
+	const core = selector.replace(/\[[^\]]*\]/g, " [] ")
+	const ids = core.match(new RegExp(`#${NAME}`, "gu"))?.length ?? 0
+	const classes = (core.match(new RegExp(`\\.${NAME}`, "gu"))?.length ?? 0) + (core.match(/\[\]|:(?!:)[\w-]+/g)?.length ?? 0)
+	const tags = core.match(/(?:^|[\s>+~(])[a-z][\w-]*/gi)?.length ?? 0
+	return ids * 10000 + classes * 100 + tags
+}
+
+/** The subject compound of a selector: its tag, classes and ids (attribute and pseudo-class parts dropped). */
+function subject(selector) {
+	const compound = selector.trim().match(/(?:[^\s>+~[\]()]|\[[^\]]*\]|\([^)]*\))+$/)?.[0] ?? ""
+	const core = compound.replace(/\([^)]*\)/g, "").replace(/\[[^\]]*\]/g, "").replace(/:+[\w-]+/g, "")
+	const tag = core.match(/^[a-z][a-z0-9-]*/i)?.[0].toLowerCase() ?? null
+	const classes = [...core.matchAll(new RegExp(`\\.(${NAME})`, "gu"))].map((match) => match[1])
+	const ids = [...core.matchAll(new RegExp(`#(${NAME})`, "gu"))].map((match) => match[1])
+	return { tag, classes, ids, key: ids[0] ? `#${ids[0]}` : classes[0] ? `.${classes[0]}` : tag ?? "*" }
+}
+
+const classList = (node) => String(node.attrs?.class ?? "").split(/[ \t\n\f\r]+/).filter(Boolean)
+
+function matches(sub, node) {
+	if (sub.tag !== null && sub.tag !== node.tag) return false
+	const names = classList(node)
+	return sub.classes.every((name) => names.includes(name)) && sub.ids.every((id) => id === node.attrs?.id)
+}
+
+/** Whether every enclosing at-rule leaves the rule unconditional (@layer, @media all), its layer name, and keyframe steps. */
+function context(atRule) {
+	const entries = atRule ? atRule.split(/\s(?=@)/) : []
+	const layers = entries.filter((entry) => /^@layer\b/i.test(entry)).map((entry) => entry.slice(6).trim())
+	const conditional = entries.some((entry) => !/^@layer\b/i.test(entry) && !/^@media(?:\s+all)?\s*$/i.test(entry))
+	return { conditional, layer: layers.length ? layers.join(".") : null, keyframe: entries.some((entry) => /^@(?:-[a-z]+-)?keyframes\b/i.test(entry)) }
+}
+
+const declaration = (value) => ({ value: value.replace(IMPORTANT, "").trim().toLowerCase(), important: IMPORTANT.test(value) })
+
+/** Every <style> text that applies to the page, with whether it applies only under a condition. */
+function sheets(root) {
+	const found = []
+	const visit = (node, conditional) => {
+		if (node.tag === "template") return
+		const inner = conditional || node.tag === "noscript"
+		if (node.tag === "style") {
+			const type = String(node.attrs?.type ?? "").trim().toLowerCase()
+			const media = String(node.attrs?.media ?? "").trim().toLowerCase()
+			if (type === "" || type === "text/css") found.push({ css: String(node.raw ?? ""), conditional: inner || (media !== "" && media !== "all") })
+		}
+		if (node.tag === "svg") for (const match of String(node.raw ?? "").matchAll(STYLE_IN_SVG)) found.push({ css: match[1], conditional: inner })
+		for (const child of node.children ?? []) visit(child, inner)
+	}
+	visit(root, false)
+	return found
+}
+
+/** Index every rule declaring display, visibility or content-visibility by its subject key. */
+function indexRules(root) {
+	const index = new Map()
+	const layers = []
+	const layerRank = (name, important) => {
+		if (name === null) return important ? -1 : 1e6
+		if (!layers.includes(name)) layers.push(name)
+		return important ? 1e6 - layers.indexOf(name) : layers.indexOf(name)
+	}
+	let order = 0
+	for (const sheet of sheets(root)) {
+		const css = sheet.css.replace(/<!--|-->/g, " ")
+		for (const match of css.replace(/\/\*[\s\S]*?(?:\*\/|$)/g, "").matchAll(/@layer\s+([^{;]*)[{;]/gi)) {
+			for (const name of match[1].split(",").map((part) => part.trim())) if (name && !layers.includes(name)) layers.push(name)
+		}
+		for (const rule of scanRules(css)) {
+			const decls = rule.declarations.filter((entry) => PROPS.has(entry.prop))
+			if (!decls.length || rule.selector.startsWith("@")) continue
+			const { conditional, layer, keyframe } = context(rule.atRule)
+			if (keyframe) continue
+			for (const selector of rule.selector.split(/,(?![^()[\]]*[)\]])/).map((part) => part.trim())) {
+				if (!selector || PSEUDO_ELEMENT.test(selector)) continue
+				const sub = subject(selector)
+				const certain = !sheet.conditional && !conditional && !rule.nested && SIMPLE.test(selector)
+				const spec = specificity(selector)
+				for (const entry of decls) {
+					const { value, important } = declaration(entry.value)
+					const rank = [important ? 2 : 1, 0, layerRank(layer, important), spec, order++]
+					if (!index.has(sub.key)) index.set(sub.key, [])
+					index.get(sub.key).push({ sub, prop: entry.prop, value, rank, certain })
+				}
+			}
+		}
+	}
+	return index
+}
+
+/** The values a property can take on the element: the certain winner, plus every possible rule that outranks it. */
+function possible(candidates, prop) {
+	let top = null
+	for (const entry of candidates) if (entry.prop === prop && entry.certain && (top === null || outranks(entry.rank, top.rank))) top = entry
+	const values = [top === null ? "unset" : top.value]
+	for (const entry of candidates) if (entry.prop === prop && !entry.certain && (top === null || outranks(entry.rank, top.rank))) values.push(entry.value)
+	return values
+}
+
+/**
+ * cssVisibility(root) -> (node, parentShown) => null when CSS removes the element and its subtree from every
+ * rendering, else whether its own text can be seen (visibility, inherited from parentShown).
+ */
+export function cssVisibility(root) {
+	const index = indexRules(root)
+	return (node, parentShown) => {
+		const attrs = node.attrs ?? {}
+		const keys = ["*", node.tag, ...classList(node).map((name) => `.${name}`), attrs.id === undefined ? null : `#${attrs.id}`]
+		const candidates = []
+		for (const key of new Set(keys)) for (const entry of index.get(key) ?? []) if (matches(entry.sub, node)) candidates.push(entry)
+		const hiddenAttr = attrs.hidden !== undefined && String(attrs.hidden).trim().toLowerCase() !== "until-found"
+		if (hiddenAttr || (node.tag === "dialog" && attrs.open === undefined)) candidates.push({ prop: "display", value: "none", rank: [0, 0, 0, 0, -1], certain: true })
+		const inline = attrs.style ? (scanRules(`x{${attrs.style}}`)[0]?.declarations ?? []) : []
+		inline.forEach((entry, at) => {
+			if (!PROPS.has(entry.prop)) return
+			const { value, important } = declaration(entry.value)
+			candidates.push({ prop: entry.prop, value, rank: [important ? 2 : 1, 1, 0, 0, at], certain: true })
+		})
+		if (possible(candidates, "display").every((value) => value === "none")) return null
+		if (possible(candidates, "content-visibility").every((value) => value === "hidden")) return null
+		return possible(candidates, "visibility").some((value) => (INHERITED.has(value) ? parentShown : value !== "hidden" && value !== "collapse"))
+	}
+}

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

@@ -57,8 +57,9 @@ function parseDeclarations(text) {
 }
 
 /**
- * @returns {{ selector: string, declarations: { prop: string, value: string }[], atRule?: string }[]}
- * atRule is the chain of enclosing grouping at-rule preludes joined by a space.
+ * @returns {{ selector: string, declarations: { prop: string, value: string }[], atRule?: string, nested?: true }[]}
+ * atRule is the chain of enclosing grouping at-rule preludes joined by a space; nested is true for a
+ * rule written inside another style rule (CSS nesting).
  */
 export function scanRules(css) {
 	if (typeof css !== "string") return []
@@ -88,6 +89,7 @@ export function scanRules(css) {
 				const atChain = stack.filter((entry) => entry.group).map((entry) => entry.prelude)
 				const rule = { selector: frame.prelude, declarations: parseDeclarations(frame.body + buffer) }
 				if (atChain.length) rule.atRule = atChain.join(" ")
+				if (stack.some((entry) => !entry.group)) rule.nested = true
 				slots[frame.slot] = rule
 			}
 			buffer = ""

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

@@ -1,14 +1,23 @@
 // entities.mjs - HTML character reference decoding for html-lite.mjs.
 //
-// Supports a fixed set of named entities plus decimal and hex numeric references. Unknown or
-// malformed references stay verbatim. Single indexOf scan; plain Node ESM, no dependencies.
+// Supports a fixed set of named entities (NAMED_ENTITIES) plus decimal and hex numeric references.
+// Unknown or malformed references stay verbatim. Single indexOf scan; plain Node ESM, no dependencies.
 
+// Beyond the common set, every named reference whose character a number reader treats specially is
+// listed (signs, dashes, the space separators that group digits, and Markdown punctuation), so the
+// conversion probe reads `−5` and `1 234` as a converter does.
 const NAMED_ENTITIES = {
 	amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: "\u00a0", mdash: "\u2014", ndash: "\u2013",
 	hellip: "\u2026", copy: "\u00a9", reg: "\u00ae", times: "\u00d7", middot: "\u00b7",
+	minus: "\u2212", hyphen: "\u2010", dash: "\u2010", NonBreakingSpace: "\u00a0", thinsp: "\u2009",
+	ThinSpace: "\u2009", numsp: "\u2007", puncsp: "\u2008", hairsp: "\u200a", VeryThinSpace: "\u200a",
+	ensp: "\u2002", emsp: "\u2003", emsp13: "\u2004", emsp14: "\u2005", MediumSpace: "\u205f",
+	comma: ",", period: ".", plus: "+", lowbar: "_", UnderBar: "_", ast: "*", midast: "*", grave: "`",
+	DiacriticalGrave: "`", lpar: "(", rpar: ")", lsqb: "[", lbrack: "[", rsqb: "]", rbrack: "]",
 }
 
-function decodeOne(body) {
+/** One reference body (between `&` and `;`), or null when unsupported. */
+export function decodeOne(body) {
 	if (Object.hasOwn(NAMED_ENTITIES, body)) return NAMED_ENTITIES[body]
 	if (body[0] !== "#") return null
 	const hex = body[1] === "x" || body[1] === "X"
@@ -26,7 +35,7 @@ export function decodeEntities(text) {
 	let at = source.indexOf("&")
 	while (at !== -1) {
 		const semi = source.indexOf(";", at + 1)
-		const decoded = semi !== -1 && semi - at <= 12 ? decodeOne(source.slice(at + 1, semi)) : null
+		const decoded = semi !== -1 && semi - at <= 32 ? decodeOne(source.slice(at + 1, semi)) : null
 		if (decoded !== null) {
 			out += source.slice(last, at) + decoded
 			last = semi + 1

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

@@ -0,0 +1,96 @@
+// fact-commands-fill.mjs - `fact fill`, the reader-facing fill of a placeholder source.
+//
+// It refuses an unlocked brief (fidelity_interview_incomplete) and applies the locked `## Fidelity`
+// fields: `derived numbers: none` and the source floor refuse rows (derived_not_allowed,
+// source_outside_floor, evaluated at every fill), `languages` decides whether a translation after a
+// quote binds to it, and `fallback` picks the block quote or omission for --replace-failed. Any
+// error writes no edition, fill map, or state; the one write that survives a refusal is the
+// ledger's cached outside_floor per row (skipped under --view). The fill map records brief_sha256,
+// the locked block fact verify checks it against. node: builtins and sibling imports only.
+
+import { readFileSync, writeFileSync } from "node:fs"
+import { dirname, extname, resolve } from "node:path"
+
+import { CliError, sha256Of, writeJsonAtomic } from "./cli-support.mjs"
+import { DEFECT_CODES } from "./contracts.mjs"
+import { markdownAsHtml } from "./fact-commands-verify.mjs"
+import { FILL_FORMATS, fill } from "./fact-fill.mjs"
+import { readLedger, writeLedger } from "./fact-ledger.mjs"
+import { briefHashOf, fillPolicy, lockedBrief, policyErrors } from "./fidelity-policy.mjs"
+import { readState, writeState } from "./fidelity-state.mjs"
+import { withBoundUnits } from "./fidelity-value-unit.mjs"
+import { parseMarkdown } from "./md-lite.mjs"
+import { findPlaceholders } from "./placeholder.mjs"
+import { sessionDirOf } from "./source-commands.mjs"
+
+/** The CLI's input vocabulary: fill's output formats plus aliases (tex is filled as md), and the extension defaults. */
+export const FILL_INPUT_FORMAT_RULES = Object.freeze({
+	aliases: Object.freeze({ tex: "md" }),
+	extensions: Object.freeze({ ".md": "md", ".tex": "tex" }),
+})
+export const FILL_INPUT_FORMATS = Object.freeze([...FILL_FORMATS, ...Object.keys(FILL_INPUT_FORMAT_RULES.aliases)])
+const fillFormatOf = (format) => FILL_INPUT_FORMAT_RULES.aliases[format] ?? format
+
+/** Value-mode entries carry the unit fill saw bound to them (unit_bound), read off the edition verify will check. */
+function boundUnits(out, entries, ledger, format) {
+	if (!entries.some((entry) => entry.mode === "value")) return entries
+	const html = fillFormatOf(format) === "html" ? out : parseMarkdown(out).problems.length === 0 ? markdownAsHtml(out, entries, ledger).html : null
+	return html === null ? entries : withBoundUnits(html, entries, new Map(ledger.rows.map((row) => [row.fact_id, row])))
+}
+
+function readText(path) {
+	try {
+		return readFileSync(path, "utf8")
+	} catch (error) {
+		throw new CliError(`cannot read ${path}: ${error.code ?? error.message}`)
+	}
+}
+
+/** The inline edition: local stylesheets and scripts inlined, relative image paths made absolute. */
+function inlineAssets(html, baseDir) {
+	const local = (ref) => !/^[a-z][a-z0-9+.-]*:|^\/\//i.test(ref)
+	return html
+		.replace(/<link\b[^>]*\brel=["']stylesheet["'][^>]*>/gi, (tag) => {
+			const href = /\bhref=["']([^"']+)["']/i.exec(tag)?.[1]
+			return href && local(href) ? `<style>${readText(resolve(baseDir, href))}</style>` : tag
+		})
+		.replace(/<script\b([^>]*)\bsrc=["']([^"']+)["']([^>]*)><\/script>/gi, (tag, pre, src, post) => (local(src) ? `<script${pre}${post}>${readText(resolve(baseDir, src))}</script>` : tag))
+		.replace(/(<img\b[^>]*\bsrc=["'])([^"']+)(["'])/gi, (tag, pre, src, post) => (local(src) && !src.startsWith("/") ? `${pre}${resolve(baseDir, src)}${post}` : tag))
+}
+
+/** @param {{ positionals: string[], flags: Record<string, any> }} args parsed by runFact */
+export function runFactFill(args) {
+	const [source] = args.positionals
+	const { flags } = args
+	if (!source || (flags.out === undefined && !flags.view)) throw new CliError("usage: fact fill <src> (--out <path> | --view) [--format html|md|tex] [--inline] [--replace-failed] [--brief brief.md]")
+	const format = flags.format ?? FILL_INPUT_FORMAT_RULES.extensions[extname(source).toLowerCase()] ?? "html"
+	if (!FILL_INPUT_FORMATS.includes(format)) throw new CliError(`--format must be ${FILL_INPUT_FORMATS.slice(0, -1).join(", ")}, or ${FILL_INPUT_FORMATS.at(-1)}`)
+	if (flags.inline && format !== "html") throw new CliError("--inline applies to the html edition only")
+	const sessionDir = sessionDirOf(flags)
+	const { parsed, refusal } = lockedBrief("fact fill", flags)
+	if (refusal) return refusal
+	const policy = fillPolicy(parsed)
+	const text = readText(source)
+	const ledger = readLedger(sessionDir)
+	const refused = policyErrors(text, findPlaceholders(text), ledger, sessionDir, policy)
+	if (refused.cacheChanged && !flags.view) writeLedger(sessionDir, ledger)
+	const state = flags["replace-failed"] ? readState(sessionDir) : null
+	const result = fill(text, ledger, { format: fillFormatOf(format), view: flags.view === true, fallback: policy.fallback, ...(state ? { replaceFailed: state } : {}) })
+	const warnings = result.warnings
+	if (result.out === null || refused.errors.length > 0) {
+		const filled = result.errors.map((error) => ({ ...error, severity: DEFECT_CODES[error.code]?.severity ?? "blocker", hint: DEFECT_CODES[error.code]?.hint ?? null }))
+		const defects = [...refused.errors, ...filled]
+		return { json: { command: "fact fill", status: "fail", exitCode: 1, defects, warnings }, summary: `fact fill: FAIL - ${defects.length} error(s), nothing written`, exitCode: 1 }
+	}
+	const entries = policy.translations ? result.fillMap : result.fillMap.filter((entry) => entry.translates === undefined)
+	const out = flags.inline ? inlineAssets(result.out, dirname(resolve(source))) : result.out
+	if (flags.view) return { text: out, summary: `fact fill --view: ${entries.length} pointer(s), ${warnings.length} warning(s)`, exitCode: 0 }
+	writeFileSync(flags.out, out)
+	if (state) writeState(sessionDir, state)
+	const artifact = sha256Of(out)
+	const map = `${resolve(flags.out)}.fill-map.json`
+	const brief = briefHashOf(parsed)
+	writeJsonAtomic(map, { schemaVersion: 1, format, artifact: resolve(flags.out), artifact_sha256: artifact, brief_sha256: brief, entries: boundUnits(out, entries, ledger, format) })
+	const data = { out: resolve(flags.out), map, artifact_sha256: artifact, brief_sha256: brief, occurrences: entries.length, warnings }
+	return { json: { command: "fact fill", status: "pass", exitCode: 0, defects: [], data }, summary: `fact fill: wrote ${flags.out} (${entries.length} pointer(s))`, exitCode: 0 }
+}