lazycodex-ai 5.1.44 → 5.1.46

package/packages/shared-skills/skills/ulw-research/scripts/polish-markup.test.ts

@@ -0,0 +1,187 @@
+import { describe, expect, test } from "bun:test"
+
+import { markupParts, skeletonChange } from "./html-markup.mjs"
+import { applyEdits, POLISH_MARKUP_REASON, textOf } from "./polish-apply.mjs"
+import { diffPolish } from "./polish-diff.mjs"
+
+const LEDGER = { rows: [{ fact_id: "F1", quote: "Revenue may reach 320 m." }] }
+const FACT = '<data data-fact="F1">320 m</data>'
+const BASE = `<p id="a" class="plain" style="color:red">Revenue may reach ${FACT} this year.</p>`
+
+// The public polish boundary must freeze bytes, not inferred HTML/CSS semantics.
+const MARKUP_CASES = [
+	["hidden added", BASE, BASE.replace('<p ', '<p hidden ')],
+	["id changed under existing CSS", `<style>#gone{display:none}</style>${BASE}`, `<style>#gone{display:none}</style>${BASE.replace('id="a"', 'id="gone"')}`],
+	["class changed", BASE, BASE.replace('class="plain"', 'class="gone"')],
+	["style changed", BASE, BASE.replace("color:red", "display:none")],
+	["stylesheet inserted", BASE, `<style>.plain{display:none}</style>${BASE}`],
+	["self-closing slash added", BASE, BASE.replace('color:red">', 'color:red"/>')],
+	["wrapper added", BASE, BASE.replace(FACT, `<span>${FACT}</span>`)],
+	["wrapper removed", BASE.replace(FACT, `<span>${FACT}</span>`), BASE],
+	["comment added", BASE, `${BASE}<!-- note -->`],
+	["comment changed", `${BASE}<!-- note -->`, `${BASE}<!-- notes -->`],
+	["attribute reorder", BASE, BASE.replace('id="a" class="plain"', 'class="plain" id="a"')],
+	["attribute quote changed", BASE, BASE.replace('id="a"', "id='a'")],
+	["attribute name case changed", BASE, BASE.replace('id="a"', 'ID="a"')],
+	["duplicate attribute changed", BASE.replace('<p ', '<p id="first" '), BASE.replace('<p ', '<p id="other" ')],
+	["href changed", '<a href="/a">Reference</a>', '<a href="/b">Reference</a>'],
+	["closing tag changed", BASE, BASE.replace("</p>", "</div>")],
+	["tag renamed", "<p>Results may improve.</p>", "<div>Results may improve.</div>"],
+	["tag whitespace changed", BASE, BASE.replace('<p ', '<p  ')],
+	["declaration changed", `<!doctype html>${BASE}`, `<!DOCTYPE html>${BASE}`],
+	["script content changed", `${BASE}<script>let x = "note"</script>`, `${BASE}<script>let x = "notes"</script>`],
+	["style content changed", `${BASE}<style>.a{color:red}</style>`, `${BASE}<style>.a{color:tan}</style>`],
+	["template text changed", `${BASE}<template>note</template>`, `${BASE}<template>notes</template>`],
+	["nested template text changed", `${BASE}<template><template>x</template>note</template>`, `${BASE}<template><template>x</template>notes</template>`],
+	["unclosed script content changed", `${BASE}<script>note`, `${BASE}<script>notes`],
+	["unclosed template content changed", `${BASE}<template>note`, `${BASE}<template>notes`],
+] as const
+
+describe("polish text-node-only markup contract", () => {
+	test.each(MARKUP_CASES)("#given %s #then apply refuses markup changed and diff blocks", (_label: string, before: string, after: string) => {
+		const result = applyEdits(before, [{ before, after }], LEDGER)
+		expect(result.applied).toEqual([])
+		expect(result.out).toBe(before)
+		expect(result.rejected[0]?.reason).toContain("markup changed")
+		const defects = diffPolish(before, after, LEDGER)
+		expect(defects.find((item: { code: string }) => item.code === "polish_diff_fail")?.severity).toBe("blocker")
+	})
+
+	test.each([
+		["existing self-closing hidden span", `<p>Revenue ${FACT} may rise. <span hidden/> Fine.</p>`, `<p>Revenue ${FACT} rise. <span hidden/> may Fine.</p>`],
+		["existing closed dialog", `<p>Revenue ${FACT} may rise.</p><dialog>Note.</dialog>`, `<p>Revenue ${FACT} rise.</p><dialog>may Note.</dialog>`],
+		["existing duplicate hidden style", '<p>Results may improve.</p><div style="display:none" style="color:red">Note.</div>', '<p>Results improve.</p><div style="display:none" style="color:red">may Note.</div>'],
+		["aria-hidden fact text", `<p>Revenue <span aria-hidden="true">${FACT}</span> may rise.</p>`, `<p>Revenue <span aria-hidden="true">${FACT.replace("320", "321")}</span> may rise.</p>`],
+		["plain text inside aria-hidden fact", '<q data-fact="F1" aria-hidden="true">Revenue may rise.</q>', '<q data-fact="F1" aria-hidden="true">Revenue may soar.</q>'],
+		["number moved between text nodes", "<p>Revenue 320 m.</p><span hidden>Note.</span>", "<p>Revenue.</p><span hidden>320 m Note.</span>"],
+	])("#given %s #then protected text cannot migrate or change", (_label: string, before: string, after: string) => {
+		expect(applyEdits(before, [{ before, after }], LEDGER).applied).toEqual([])
+		expect(diffPolish(before, after, LEDGER).length).toBeGreaterThan(0)
+	})
+
+	test.each([
+		["plain prose", "<p>Results may improve steadily.</p>", "steadily", "slowly"],
+		["prose beside a fact", BASE, "this year", "next year"],
+		["quoted greater-than attribute", '<p title="a>b">Results may improve steadily.</p>', "steadily", "slowly"],
+		["literal less-than text", "<p>Growth < limits may persist steadily.</p>", "steadily", "slowly"],
+		["untouched entity beside the edit", "<p>R&amp;D may grow steadily.</p>", "steadily", "slowly"],
+		["unchanged frozen content", "<style>.a{display:none}</style><template>note</template><p>Results may improve steadily.</p>", "steadily", "slowly"],
+	])("#given %s #then a text-only edit with protected tokens intact passes", (_label: string, html: string, from: string, to: string) => {
+		const after = html.replace(from, to)
+		expect(applyEdits(html, [{ before: from, after: to }], LEDGER).out).toBe(after)
+		expect(diffPolish(html, after, LEDGER)).toEqual([])
+	})
+})
+
+// Review #11152 round 4: an edit may never carry <, > or &, so it cannot create, alter, close or
+// escape any tag, comment, bogus comment, CDATA section, entity or script, whatever the tokenizer models.
+const DATA = '<p>Revenue reached <data class="fact" data-fact="F1">320 m</data> in spring.</p>'
+const SCRIPT = "<p>Results may improve steadily.</p><script><!--<script></script>foo();</script>"
+describe("polish edits never carry markup characters", () => {
+	test.each([
+		["bogus comment before a fact span", DATA, "Revenue reached ", "Revenue reached </ "],
+		["bogus comment hiding a sentence", "<p>Fine. The board met in spring.</p>", "The board met in spring.", "</ The board met in spring.>"],
+		["empty end tag", "<p>Results may improve steadily.</p>", "steadily", "steadily </>"],
+		["introduced entity", "<p>Results may improve steadily.</p>", "steadily", "steadily &lt;b&gt;"],
+		["introduced greater-than", "<p>Results may improve steadily.</p>", "steadily", "steadily >"],
+		["removed entity", "<p>R&amp;D may grow steadily.</p>", "R&amp;D", "RD"],
+	])("#given %s #then apply rejects it and diff blocks", (_label: string, html: string, from: string, to: string) => {
+		const result = applyEdits(html, [{ before: from, after: to }], LEDGER)
+		expect(result.applied).toEqual([])
+		expect(result.out).toBe(html)
+		expect(result.rejected[0]?.reason).toContain("edit contains markup characters (<, >, &): route this section through the full fidelity gates")
+		if (from === "R&amp;D" || to.includes("&lt;") || to === "steadily >") return
+		expect(diffPolish(html, html.replace(from, to), LEDGER).find((item: { code: string }) => item.code === "polish_diff_fail")?.severity).toBe("blocker")
+	})
+
+	test.each([
+		["words around R&amp;D", "<p>Our R&amp;D budget grew in 2025.</p>", "budget grew", "budget rose", true],
+		["an edit spanning R&amp;D", "<p>Our R&amp;D budget grew in 2025.</p>", "Our R&amp;D budget grew", "The R&amp;D budget rose", false],
+		["words around p &lt; 0.05", "<p>The effect held at p &lt; 0.05 in the trial.</p>", "in the trial", "across the trial", true],
+		["an edit spanning p &lt; 0.05", "<p>The effect held at p &lt; 0.05 in the trial.</p>", "held at p &lt; 0.05", "stayed at p &lt; 0.05", false],
+	])("#given legitimate prose with %s #then only an edit leaving the entity bytes untouched applies", (_label: string, html: string, from: string, to: string, passes: boolean) => {
+		const result = applyEdits(html, [{ before: from, after: to }], LEDGER)
+		if (passes) {
+			expect(result.out).toBe(html.replace(from, to))
+			expect(diffPolish(html, result.out, LEDGER)).toEqual([])
+			return
+		}
+		expect(result.out).toBe(html)
+		expect(result.rejected[0]?.reason).toContain(POLISH_MARKUP_REASON)
+	})
+
+	test("#given double-escaped script code #then the ambiguity refusal blocks a text-only edit of it", () => {
+		const result = applyEdits(SCRIPT, [{ before: "foo();", after: "bar();" }], LEDGER)
+		expect(result.applied).toEqual([])
+		expect(result.rejected[0]?.reason).toContain("ambiguous markup: <!-- inside script")
+		expect(diffPolish(SCRIPT, SCRIPT.replace("foo", "bar"), LEDGER)[0]?.message).toContain("ambiguous markup")
+	})
+
+	test.each([
+		["end tag open before a non-letter", "<p>a </ b> c</p>"],
+		["empty end tag", "<p>a </> c</p>"],
+		["comment opener inside script", "<script><!-- x --></script><p>c</p>"],
+		["comment opener inside style", "<style><!-- .a{} --></style><p>c</p>"],
+		["CDATA section", "<p>a <![CDATA[ b ]]> c</p>"],
+		["processing instruction", "<p>a <?x b?> c</p>"],
+		["less-than inside an attribute value", '<p title="a<b">c</p>'],
+		["comment closed by --!>", "<p>a <!-- b --!> c</p>"],
+	])("#given a document with %s #then diff refuses it as ambiguous markup", (_label: string, html: string) => {
+		const defect = diffPolish(html, html, LEDGER).find((item: { code: string }) => item.code === "polish_diff_fail")
+		expect(defect?.message).toContain("ambiguous markup")
+	})
+
+	test("#given an end tag open before a non-letter #then the tokenizer skips a bogus comment to the next >", () => {
+		expect(markupParts("a </ b> c </> d").markup).toEqual(["</ b>", "</>"])
+	})
+
+	test("#given a double-escaped script #then the script runs to the close outside the escape", () => {
+		expect(markupParts(`${SCRIPT}<p>x</p>`).markup).toEqual(["<p>", "</p>", "<script><!--<script></script>foo();</script>", "<p>", "</p>"])
+		expect(markupParts("<script><!-- a --></script><b>x</b>").markup).toEqual(["<script><!-- a --></script>", "<b>", "</b>"])
+	})
+})
+
+// Review #11152 round 5: the primary rule is a whole-document skeleton comparison. Every markup
+// token and every character reference in text must be byte-identical; an edit's located region may
+// not touch a character reference either, so an edit can neither change nor create one.
+const AMPD = "<p>We fund R&amp;D labs here.</p>"
+const TOM = "<p>Tom & Jerry ran.</p>"
+describe("polish keeps character references intact", () => {
+	test.each([
+		["an edit starting inside an entity", AMPD, "amp;D labs", "lt;D labs"],
+		["an edit starting right after a bare ampersand", TOM, " Jerry ran", "lt; ran"],
+	])("#given %s #then apply refuses it and diff blocks the hand edit", (_label: string, html: string, from: string, to: string) => {
+		const result = applyEdits(html, [{ before: from, after: to }], LEDGER)
+		expect(result.applied).toEqual([])
+		expect(result.out).toBe(html)
+		expect(result.rejected[0]?.reason).toContain("character reference")
+		const defects = diffPolish(html, html.replace(from, to), LEDGER)
+		expect(defects.find((item: { code: string }) => item.code === "polish_diff_fail")?.severity).toBe("blocker")
+	})
+
+	test("#given a hand edit from R&amp;D to R&lt;D #then diff blocks it", () => {
+		const defect = diffPolish(AMPD, AMPD.replace("&amp;", "&lt;"), LEDGER).find((item: { code: string }) => item.code === "polish_diff_fail")
+		expect(defect?.message).toContain("skeleton changed")
+	})
+
+	test.each([
+		["an entity changed", AMPD, AMPD.replace("&amp;", "&lt;")],
+		["an entity created", TOM, "<p>Tom &lt; ran.</p>"],
+		["an entity removed", AMPD, AMPD.replace("R&amp;D", "RD")],
+		["a tag changed", AMPD, AMPD.replace("<p>", "<div>")],
+	])("#given %s #then the skeleton check alone names the first differing token", (_label: string, before: string, after: string) => {
+		expect(skeletonChange(before, after)).toContain("skeleton changed at token")
+	})
+
+	test.each([
+		["words beside an entity", AMPD, AMPD.replace("labs here", "labs nearby")],
+		["words beside a bare ampersand", TOM, TOM.replace("ran", "walked")],
+		["an unchanged document", AMPD, AMPD],
+	])("#given %s #then the skeleton is unchanged", (_label: string, before: string, after: string) => {
+		expect(skeletonChange(before, after)).toBeNull()
+	})
+
+	test("#given a quoted greater-than in an attribute #then the text projection follows the scanner", () => {
+		expect(textOf('<p title="a>b">Results may improve.</p>').trim()).toBe("Results may improve.")
+	})
+})

package/packages/shared-skills/skills/ulw-research/scripts/polish-project.mjs

@@ -0,0 +1,125 @@
+// polish-project.mjs - the protected projection of report markup that every polish check compares.
+//
+// project(markup) yields the ordered fact spans {id, html}, the visible text, the masked text (each
+// fact span replaced by SLOT) and the ordered href values. Callers pass markup already reduced by
+// html-markup.markupParts().source, with frozen script/style/template content omitted. Fact spans are the
+// placeholder.mjs FACT_ELEMENT_TAGS elements carrying data-fact (any quoting), found by
+// html-markup.elementSpans (a same-name nested element and a quoted ">" stay inside). Hedge and
+// qualifier terms come from fidelity-lexicon (guardedTerms, lexicalPattern "guard" mode).
+// No IO, no model. Plain Node ESM.
+
+import { decodeEntities } from "./entities.mjs"
+import { guardedTerms, lexicalPattern, QUALIFIER_FORMS } from "./fidelity-lexicon.mjs"
+import { elementSpans, markupParts, tagAttributes } from "./html-markup.mjs"
+import { HEDGES } from "./lexicon.mjs"
+import { parseNumeral } from "./numerals.mjs"
+import { FACT_ELEMENT_TAGS } from "./placeholder.mjs"
+import { splitSentences } from "./sentence-split.mjs"
+import { normalizeUnit } from "./units.mjs"
+
+/** The link attributes polish_link_changed owns; a data-claim id change is a markup (fact-binding) change. */
+export const POLISH_LINK_ATTRIBUTES = Object.freeze(["href"])
+/** The bare digit runs compared outside fact spans when no quantity parses around them. */
+export const POLISH_DIGITS = /\d+(?:[.,]\d+)*/g
+/** Stands in for one fact span in masked text; a private-use char, so no numeral or word matches it. */
+export const SLOT = "\uE000"
+const FACT_TAGS = new Set(FACT_ELEMENT_TAGS)
+const isFactElement = (name, attrs) => FACT_TAGS.has(name) && (attrs["data-fact"] ?? "") !== ""
+
+/** Each fact span of the markup as {id, start, end, html}, in order; an unclosed one runs to the end. */
+export function factSpans(markup) {
+	const src = String(markup)
+	return elementSpans(src, isFactElement).map(({ start, end, tag }) => ({ id: tag.attrs["data-fact"], start, end, html: src.slice(start, end) }))
+}
+
+/**
+ * Visible text of an HTML fragment: the scanner's text slots joined by a space (so a quoted ">"
+ * inside a tag stays markup), entities decoded, whitespace collapsed. One tokenization is shared
+ * with the markup rules; no second tag-stripping regex.
+ */
+export function textOf(html) {
+	return decodeEntities(markupParts(html).text.join(" ")).replace(/\s+/g, " ")
+}
+
+/** The protected projection of (already visible) markup; see the header. */
+export function project(markup) {
+	const facts = []
+	let visible = ""
+	let masked = ""
+	let at = 0
+	for (const span of factSpans(markup)) {
+		const outside = textOf(markup.slice(at, span.start))
+		facts.push({ id: span.id, html: span.html.replace(/\s+/g, " ") })
+		visible += `${outside}${textOf(span.html)}`
+		masked += `${outside} ${SLOT} `
+		at = span.end
+	}
+	const rest = textOf(markup.slice(at))
+	const links = tagAttributes(markup).flatMap(({ attrs }) =>
+		POLISH_LINK_ATTRIBUTES.filter((name) => Object.hasOwn(attrs, name)).map((name) => `${name}=${attrs[name]}`),
+	)
+	return { facts, visible: (visible + rest).replace(/\s+/g, " ").trim(), masked: (masked + rest).replace(/\s+/g, " ").trim(), links }
+}
+
+const unitKey = (raw) => (raw === null ? "" : (normalizeUnit(raw) ?? raw.toLowerCase()))
+
+/** Ordered numeral keys: a parsed quantity as "value unit" (once), any other digit run as written. */
+export function numeralKeys(text) {
+	const quantities = []
+	for (let found = parseNumeral(text); found !== null; found = parseNumeral(text, found.span[1])) quantities.push(found)
+	const keys = []
+	let k = 0
+	for (const match of text.matchAll(POLISH_DIGITS)) {
+		while (k < quantities.length && quantities[k].span[1] <= match.index) k++
+		const quantity = quantities[k]
+		if (!quantity || quantity.span[0] > match.index) keys.push(match[0])
+		else if (!quantity.counted) {
+			quantity.counted = true
+			keys.push(`${quantity.value}${quantity.range ? `~${quantity.valueEnd}` : ""} ${unitKey(quantity.unitRaw)}`.trim())
+		}
+	}
+	return keys
+}
+
+/** term -> occurrence count of each listed term in the text (guard mode of the lexical engine). */
+export function termCounts(text, terms = guardedTerms()) {
+	const counts = new Map()
+	for (const term of terms) {
+		const n = [...text.matchAll(lexicalPattern(term, "guard"))].length
+		if (n > 0) counts.set(term, n)
+	}
+	return counts
+}
+
+const add = (into, term, n) => into.set(term, (into.get(term) ?? 0) + n)
+
+/**
+ * The hedge and qualifier tokens the text before a polish holds and must keep (term -> count), per
+ * sentence of the masked text: a sentence without fact spans keeps all its guarded tokens; a
+ * sentence with fact spans keeps those of its tokens that the referenced rows' quote hedges or
+ * qualifier forms name. A ledger term the sentence never held is never required.
+ */
+export function requiredTerms(projection, rows) {
+	const required = new Map()
+	let cursor = 0
+	for (const { text } of splitSentences(projection.masked)) {
+		const slots = text.split(SLOT).length - 1
+		const facts = projection.facts.slice(cursor, cursor + slots)
+		cursor += slots
+		const present = termCounts(text)
+		const sourced = new Set()
+		for (const { id } of facts) {
+			const row = rows.get(id)
+			for (const term of termCounts(row?.quote ?? "", HEDGES).keys()) sourced.add(term)
+			for (const form of QUALIFIER_FORMS[row?.qualifier] ?? []) sourced.add(form)
+		}
+		for (const [term, n] of present) if (slots === 0 || sourced.has(term)) add(required, term, n)
+	}
+	return required
+}
+
+/** Required terms the text no longer holds as many times, as "term" names. */
+export function missingTerms(required, text) {
+	const have = termCounts(text, [...required.keys()])
+	return [...required].filter(([term, n]) => (have.get(term) ?? 0) < n).map(([term]) => term)
+}

package/packages/shared-skills/skills/ulw-research/scripts/polish-rules.mjs

@@ -0,0 +1,170 @@
+// polish-rules.mjs - the one rule set behind polish-apply (per edit) and polish-diff (whole document).
+//
+// polishDefects(beforeHtml, afterHtml, ledger, {ordered}) compares the visible projections
+// (html-markup.markupParts, then polish-project.project) and returns {code, message} per failure.
+// Polish may change text nodes only. The primary rule is the whole-document skeleton comparison
+// (html-markup.skeletonChange): every markup token (tags, comments, bogus comments and frozen
+// script/style/template content) and every character reference of a text node must be byte-identical
+// in document order; an edited span holds no skeleton token, so any difference is polish_diff_fail
+// naming the first differing token and its offset. The remaining checks compare the projections:
+//   polish_diff_fail: fact spans (id + rendered markup), numerals outside fact spans (with units),
+//     tickers (TICKER: 1-5 capitals with an optional ".XX" class, or a 6-digit KRX code), or a
+//     table's row count changed; any tag, attribute, comment, declaration, or script/style/template
+//     content changed; protected tokens also stay within their original text-node boundaries;
+//   polish_hedging_decreased: a hedge or qualifier the before text holds and must keep is gone;
+//   polish_text_churn: more than POLISH_CHURN_LIMIT of the normalized visible prose changed;
+//   polish_link_changed: href values changed or an internal #target stopped resolving;
+//   polish_name_changed: a proper noun (POLISH_NAME) of a ledger quote, present before, is gone.
+// A document holding a construct html-markup.ambiguousMarkup lists (</ + non-letter, <!-- inside
+// script/style, <![CDATA[, <?, --!>, or < inside a tag) is refused first with polish_diff_fail
+// "ambiguous markup": the byte comparison is only trusted where the tokenizer is exact.
+// ordered (polish-apply) also refuses a reordering of fact spans, numerals, tickers and links;
+// without it they compare as multisets. Severity lives only in contracts.DEFECT_CODES.
+// No IO, no model. Plain Node ESM.
+
+import { ambiguousMarkup, markupParts, skeletonChange, tagAttributes } from "./html-markup.mjs"
+import { missingTerms, numeralKeys, project, requiredTerms, termCounts, textOf } from "./polish-project.mjs"
+import { splitSentences } from "./sentence-split.mjs"
+import { normalizeText } from "./text-normalize.mjs"
+
+/** The codes polishDefects can emit, in report order. */
+export const POLISH_CODES = Object.freeze(["polish_diff_fail", "polish_hedging_decreased", "polish_text_churn", "polish_link_changed", "polish_name_changed"])
+export const TICKER = /(?<![\p{L}\p{N}])(?:[A-Z]{1,5}(?:\.[A-Z]{1,2})?|\d{6})(?![\p{L}\p{N}])/gu
+/** The capitalized-token heuristic for proper nouns in ledger quotes. */
+export const POLISH_NAME = /\p{Lu}[\p{L}\p{N}&'-]+/gu
+/** Above this share of changed normalized prose a polish composed instead of proofreading. */
+export const POLISH_CHURN_LIMIT = 0.5
+/** Above this many cells a gap counts as fully rewritten instead of running the quadratic distance. */
+const DISTANCE_CELLS = 25_000_000
+
+const sorted = (list) => [...list].sort()
+const same = (a, b) => a.length === b.length && a.every((item, k) => item === b[k])
+
+/** null when unchanged; a reorder counts only when ordered. */
+function listChange(label, before, after, ordered) {
+	if (same(before, after)) return null
+	const remaining = sorted(before)
+	const added = []
+	for (const item of after) {
+		const at = remaining.indexOf(item)
+		if (at === -1) added.push(item)
+		else remaining.splice(at, 1)
+	}
+	if (remaining.length > 0 || added.length > 0) return `${label} changed: removed [${remaining.join(", ")}], added [${added.join(", ")}]`
+	return ordered ? `${label} reordered: [${before.join(", ")}] became [${after.join(", ")}]` : null
+}
+
+const tableRows = (html) => html.split(/<table\b/i).slice(1).map((part) => (part.split(/<\/table\s*>/i)[0].match(/<tr\b/gi) ?? []).length)
+
+function levenshtein(a, b) {
+	if (a === b) return 0
+	if (a.length * b.length > DISTANCE_CELLS) return Math.max(a.length, b.length)
+	let previous = Array.from({ length: b.length + 1 }, (_, k) => k)
+	for (let i = 1; i <= a.length; i++) {
+		const current = [i]
+		for (let j = 1; j <= b.length; j++) {
+			current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1))
+		}
+		previous = current
+	}
+	return previous[b.length]
+}
+
+/** Changed share of normalized prose: edit distance over unmatched sentence runs / longer length. */
+export function churnRatio(beforeText, afterText) {
+	const [a, b] = [normalizeText(beforeText), normalizeText(afterText)]
+	const longest = Math.max(a.length, b.length)
+	if (longest === 0) return 0
+	const [sa, sb] = [splitSentences(a).map((s) => s.text), splitSentences(b).map((s) => s.text)]
+	const lcs = Array.from({ length: sa.length + 1 }, () => new Array(sb.length + 1).fill(0))
+	for (let i = sa.length - 1; i >= 0; i--) {
+		for (let j = sb.length - 1; j >= 0; j--) lcs[i][j] = sa[i] === sb[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1])
+	}
+	let distance = 0
+	let gap = [[], []]
+	const flush = () => {
+		distance += levenshtein(gap[0].join(" "), gap[1].join(" "))
+		gap = [[], []]
+	}
+	let [i, j] = [0, 0]
+	while (i < sa.length || j < sb.length) {
+		if (i < sa.length && j < sb.length && sa[i] === sb[j]) {
+			flush()
+			i++
+			j++
+		} else if (j >= sb.length || (i < sa.length && lcs[i + 1][j] >= lcs[i][j + 1])) gap[0].push(sa[i++])
+		else gap[1].push(sb[j++])
+	}
+	flush()
+	return distance / longest
+}
+
+function linkChange(from, to, before, after, ordered) {
+	const change = listChange("href and data-claim values", from.links, to.links, ordered)
+	if (change) return change
+	const ids = (html) => new Set(tagAttributes(html).flatMap(({ attrs }) => (Object.hasOwn(attrs, "id") ? [attrs.id] : [])))
+	const [idsBefore, idsAfter] = [ids(before), ids(after)]
+	const targets = to.links.filter((link) => link.startsWith("href=#")).map((link) => link.slice(5))
+	const broken = targets.filter((href) => idsBefore.has(href.slice(1)) && !idsAfter.has(href.slice(1)))
+	return broken.length > 0 ? `internal link targets stopped resolving: [${[...new Set(broken)].join(", ")}]` : null
+}
+
+/** Capitalized tokens of the ledger quotes, minus each sentence's first word. */
+function ledgerNames(rows) {
+	const names = new Set()
+	for (const row of rows) {
+		for (const { text } of splitSentences(row.quote ?? "")) {
+			const first = text.match(/^\P{L}*\p{L}+/u)?.[0].length ?? 0
+			for (const match of text.matchAll(POLISH_NAME)) if (match.index >= first) names.add(match[0])
+		}
+	}
+	return names
+}
+
+const hasWord = (text, word) => new RegExp(`(?<![\\p{L}\\p{N}])${word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\p{L}\\p{N}])`, "u").test(text)
+
+/**
+ * @param {string} beforeHtml
+ * @param {string} afterHtml
+ * @param {{ rows: object[] }} ledger
+ * @param {{ ordered?: boolean }} [options]
+ * @returns {{ code: string, message: string }[]} in POLISH_CODES order
+ */
+export function polishDefects(beforeHtml, afterHtml, ledger, { ordered = false } = {}) {
+	const ambiguous = [...new Set([...ambiguousMarkup(beforeHtml), ...ambiguousMarkup(afterHtml)])]
+	if (ambiguous.length > 0) return [{ code: "polish_diff_fail", message: `ambiguous markup: ${ambiguous.join(", ")}` }]
+	const [beforeParts, afterParts] = [markupParts(beforeHtml), markupParts(afterHtml)]
+	const [before, after] = [beforeParts.source, afterParts.source]
+	const [from, to] = [project(before), project(after)]
+	const rows = ledger?.rows ?? []
+	const defects = []
+	const note = (code, message) => message && defects.push({ code, message })
+	const factKey = (fact) => `${fact.id} ${fact.html}`
+	const tickers = (text) => text.match(TICKER) ?? []
+	const markupEqual = same(beforeParts.markup, afterParts.markup)
+	note("polish_diff_fail", markupEqual ? null : "markup changed")
+	note("polish_diff_fail", skeletonChange(beforeHtml, afterHtml))
+	note("polish_diff_fail", listChange("fact spans", from.facts.map(factKey), to.facts.map(factKey), ordered))
+	note("polish_diff_fail", listChange("numerals outside fact spans", numeralKeys(from.masked), numeralKeys(to.masked), ordered))
+	note("polish_diff_fail", listChange("tickers", tickers(from.masked), tickers(to.masked), ordered))
+	const [rowsBefore, rowsAfter] = [tableRows(before), tableRows(after)]
+	if (!same(rowsBefore, rowsAfter)) note("polish_diff_fail", `table row counts changed: [${rowsBefore}] became [${rowsAfter}]`)
+	const required = requiredTerms(from, new Map(rows.map((row) => [row.fact_id, row])))
+	if (markupEqual) {
+		for (const [index, raw] of beforeParts.text.entries()) {
+			const [a, b] = [raw, afterParts.text[index]].map(textOf)
+			note("polish_diff_fail", listChange("text-node numerals", numeralKeys(a), numeralKeys(b), ordered))
+			note("polish_diff_fail", listChange("text-node tickers", tickers(a), tickers(b), ordered))
+			const lost = missingTerms(termCounts(a, [...required.keys()]), b)
+			if (lost.length) note("polish_hedging_decreased", `text-node hedges removed: ${lost.join(", ")}`)
+		}
+	}
+	const missing = missingTerms(required, to.visible)
+	if (missing.length > 0) note("polish_hedging_decreased", `hedges or qualifiers removed: ${missing.map((term) => `"${term}"`).join(", ")}`)
+	const ratio = churnRatio(from.visible, to.visible)
+	if (ratio > POLISH_CHURN_LIMIT) note("polish_text_churn", `${(ratio * 100).toFixed(1)} percent of the normalized prose changed`)
+	note("polish_link_changed", linkChange(from, to, before, after, ordered))
+	const lost = [...ledgerNames(rows)].filter((name) => hasWord(from.visible, name) && !hasWord(to.visible, name))
+	if (lost.length > 0) note("polish_name_changed", `ledger-quote names missing after polish: ${lost.join(", ")}`)
+	return defects.sort((a, b) => POLISH_CODES.indexOf(a.code) - POLISH_CODES.indexOf(b.code))
+}

package/packages/shared-skills/skills/ulw-research/scripts/rational.mjs

@@ -0,0 +1,139 @@
+// rational.mjs - exact rational arithmetic over BigInt numerator/denominator pairs.
+//
+// A rational is { num: bigint, den: bigint }, reduced, with den > 0. Numerals enter as decimal
+// strings and never pass through Number(), so no value is ever rounded by floating point.
+// Plain Node ESM, no imports.
+
+const DECIMAL = /^([+-]?)(\d+)(?:\.(\d+))?$/
+
+const abs = (n) => (n < 0n ? -n : n)
+
+function gcd(a, b) {
+	let x = abs(a)
+	let y = abs(b)
+	while (y !== 0n) [x, y] = [y, x % y]
+	return x
+}
+
+function make(num, den) {
+	if (den === 0n) throw new RangeError("rational: zero denominator")
+	const sign = den < 0n ? -1n : 1n
+	const g = gcd(num, den) || 1n
+	return Object.freeze({ num: (sign * num) / g, den: (sign * den) / g })
+}
+
+/** Accepts a rational, a bigint, a safe integer, or a decimal string. */
+function coerce(value) {
+	if (typeof value === "bigint") return make(value, 1n)
+	if (typeof value === "number") {
+		if (!Number.isSafeInteger(value)) throw new TypeError(`rational: ${value} is not a safe integer; pass a decimal string`)
+		return make(BigInt(value), 1n)
+	}
+	if (typeof value === "string") return fromDecimal(value)
+	if (value && typeof value.num === "bigint" && typeof value.den === "bigint") return make(value.num, value.den)
+	throw new TypeError("rational: expected a rational, bigint, integer, or decimal string")
+}
+
+/** "12.50" -> 25/2. Accepts an optional sign, digits, and an optional fraction; nothing else. */
+export function fromDecimal(str) {
+	const match = DECIMAL.exec(String(str).trim())
+	if (!match) throw new SyntaxError(`rational: "${str}" is not a plain decimal`)
+	const [, sign, whole, frac = ""] = match
+	const num = BigInt(whole + frac) * (sign === "-" ? -1n : 1n)
+	return make(num, 10n ** BigInt(frac.length))
+}
+
+export function add(a, b) {
+	const x = coerce(a)
+	const y = coerce(b)
+	return make(x.num * y.den + y.num * x.den, x.den * y.den)
+}
+
+export function sub(a, b) {
+	const x = coerce(a)
+	const y = coerce(b)
+	return make(x.num * y.den - y.num * x.den, x.den * y.den)
+}
+
+export function mul(a, b) {
+	const x = coerce(a)
+	const y = coerce(b)
+	return make(x.num * y.num, x.den * y.den)
+}
+
+export function div(a, b) {
+	const x = coerce(a)
+	const y = coerce(b)
+	if (y.num === 0n) throw new RangeError("rational: division by zero")
+	return make(x.num * y.den, x.den * y.num)
+}
+
+export function eq(a, b) {
+	const x = coerce(a)
+	const y = coerce(b)
+	return x.num === y.num && x.den === y.den
+}
+
+/** Digits of a non-negative integer scaled by 10^-scale, as a decimal string. */
+function placeDecimal(digits, scale) {
+	if (scale <= 0) return digits + "0".repeat(-scale)
+	const padded = digits.padStart(scale + 1, "0")
+	return `${padded.slice(0, padded.length - scale)}.${padded.slice(padded.length - scale)}`
+}
+
+/** Exact decimal; throws RangeError when the expansion does not terminate. */
+function exactDecimal(r) {
+	let den = r.den
+	let twos = 0
+	let fives = 0
+	while (den % 2n === 0n) [den, twos] = [den / 2n, twos + 1]
+	while (den % 5n === 0n) [den, fives] = [den / 5n, fives + 1]
+	if (den !== 1n) throw new RangeError(`rational: ${r.num}/${r.den} has no finite decimal; pass sigFigs`)
+	const scale = Math.max(twos, fives)
+	const digits = (abs(r.num) * 10n ** BigInt(scale)) / r.den
+	return (r.num < 0n ? "-" : "") + placeDecimal(digits.toString(), scale)
+}
+
+/** Number of decimal digits in the integer part of |num/den| (0 when below 1). */
+function integerDigits(num, den) {
+	const whole = num / den
+	if (whole > 0n) return whole.toString().length
+	let exp = 0
+	let scaled = num
+	while (scaled < den) [scaled, exp] = [scaled * 10n, exp - 1]
+	return exp + 1
+}
+
+/**
+ * Decimal string. Without sigFigs the value must terminate and is rendered exactly. With sigFigs it
+ * is rounded half away from zero to that many significant figures; integers are never written
+ * with an exponent, so 319999 at 2 figures renders "320000".
+ */
+export function toDecimal(value, sigFigs) {
+	const r = coerce(value)
+	if (sigFigs === undefined) return exactDecimal(r)
+	if (!Number.isInteger(sigFigs) || sigFigs < 1) throw new RangeError("rational: sigFigs must be a positive integer")
+	if (r.num === 0n) return sigFigs > 1 ? `0.${"0".repeat(sigFigs - 1)}` : "0"
+	const num = abs(r.num)
+	const scale = sigFigs - integerDigits(num, r.den)
+	const numer = scale >= 0 ? num * 10n ** BigInt(scale) : num
+	const denom = scale >= 0 ? r.den : r.den * 10n ** BigInt(-scale)
+	let digits = numer / denom
+	let places = scale
+	if ((numer % denom) * 2n >= denom) digits += 1n
+	if (digits.toString().length > sigFigs) [digits, places] = [digits / 10n, places - 1]
+	return (r.num < 0n ? "-" : "") + placeDecimal(digits.toString(), places)
+}
+
+/**
+ * Significant figures of a decimal string. With a decimal point: digits from the first nonzero
+ * digit to the end, trailing zeros included ("3.2" -> 2, "0.050" -> 2). Without one: every digit
+ * after leading zeros counts ("320" -> 3, "100" -> 3, "20" -> 2).
+ */
+export function sigFigsOf(decimalStr) {
+	const match = DECIMAL.exec(String(decimalStr).trim())
+	if (!match) throw new SyntaxError(`rational: "${decimalStr}" is not a plain decimal`)
+	const [, , whole, frac] = match
+	const digits = (whole + (frac ?? "")).replace(/^0+/, "")
+	return Math.max(digits.length, 1)
+}