oh-my-opencode 5.1.48 → 5.1.54

package/packages/shared-skills/skills/ulw-research/scripts/tests/report-tools-support.ts

@@ -0,0 +1,182 @@
+import { describe, expect, onTestFinished, test } from "bun:test"
+import { createHash } from "node:crypto"
+import { copyFileSync, existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { delimiter, join } from "node:path"
+import { PROMOTION } from "../fact-commands-meaning.mjs"
+import { writeFidelityRecord } from "../fidelity-records.mjs"
+import { PAIR_KINDS } from "../fact-pairs.mjs"
+import { VERDICT_SCHEMA } from "../meaning-check.mjs"
+import { POLISH_MARKUP_REASON } from "../polish-apply.mjs"
+import { COMMANDS, run } from "../report-tools.mjs"
+
+
+const SCRIPT = join(join(import.meta.dir, ".."), "report-tools.mjs")
+
+const FIXTURES = join(join(import.meta.dir, ".."), "tests", "fixtures")
+
+/** The caller-owned observation time every CLI derive passes (derive never reads the clock). */
+const NOW = "2026-10-23T08:00:00Z"
+
+
+function sessionDir() {
+	const root = mkdtempSync(join(tmpdir(), "report-tools-cli-"))
+	onTestFinished(() => rmSync(root, { recursive: true, force: true }))
+	const dir = join(root, "20260101-120000")
+	mkdirSync(dir)
+	return dir
+}
+
+
+function nodeWithoutBun(args: string[]) {
+	const nodePath = Bun.which("node")
+	if (nodePath === null) throw new Error("node not found on PATH")
+	const path = (process.env.PATH ?? "").split(delimiter).filter((entry) => !entry.includes(".bun")).join(delimiter)
+	return Bun.spawnSync({ cmd: [nodePath, SCRIPT, ...args], env: { ...process.env, PATH: path } })
+}
+
+
+function defectsFile(dir: string, name: string, codes: string[]) {
+	const file = join(dir, name)
+	writeFileSync(file, JSON.stringify(codes.map((code) => ({ code, message: code }))))
+	return file
+}
+
+
+const FIDELITY = join(FIXTURES, "fidelity")
+
+const sha256 = (path: string) => createHash("sha256").update(readFileSync(path)).digest("hex")
+
+
+type CliRow = { fact_id: string; kind: string; value: string | null }
+
+type CliJson = { data: { row: CliRow; context: { match: string } }; defects: { code: string }[] }
+
+
+function nodeJson(args: string[]) {
+	const proc = nodeWithoutBun(args)
+	const stdout = proc.stdout.toString()
+	let json = {} as CliJson
+	try {
+		json = JSON.parse(stdout) as CliJson
+	} catch {}
+	return { code: proc.exitCode, json, stdout, stderr: proc.stderr.toString() }
+}
+
+
+/** A session with the locked brief, S4 snapshotted, F1 (span), Q1 (completion), and F<n> (span in mm). */
+function fidelitySession() {
+	const dir = sessionDir()
+	copyFileSync(join(FIXTURES, "fidelity-brief-locked.md"), join(dir, "brief.md"))
+	const s = ["--session-dir", dir]
+	const snap = nodeJson(["source", "snapshot", "--id", "S4", "--html", join(FIDELITY, "sources", "S4.html"), ...s])
+	const add = nodeJson(["fact", "add", "--source", "S4", "--find", "Span length", "--label", "span_len", "--json", ...s])
+	const quote = nodeJson(["fact", "quote", "--source", "S4", "--match", "no earlier than 2027", "--label", "completion", "--json", ...s])
+	const derive = nodeJson(["fact", "derive", "--op", "convert", "F1", "--to", "mm", "--label", "span_mm", "--now", NOW, "--json", ...s])
+	const mm = derive.json.data?.row?.fact_id
+	const source = [
+		'<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Bridge</title></head><body><h1>Bridge</h1>',
+		"<h2>Findings</h2>",
+		"<p>The span length is {{F1:span_len}} [S4].</p>",
+		`<p>In millimetres the span is {{${mm}:span_mm}} [S4].</p>`,
+		"<p>The operator wrote {{Q1:completion}} [S4].</p>",
+		"<h2>How this report was made</h2><p>Collected from one cited public page [S4].</p>",
+		'<h2>Sources</h2><ol><li id="s4">[S4] Bridge page, retrieved 2026-10-01.</li></ol></body></html>',
+	].join("\n")
+	writeFileSync(join(dir, "report.src.html"), source)
+	return { dir, s, snap, add, quote, derive, mm }
+}
+
+
+function verify(dir: string, report: string, extra: string[] = []) {
+	return nodeJson(["fact", "verify", join(dir, report), "--sources", join(dir, "sources"), "--brief", join(dir, "brief.md"), "--session-dir", dir, ...extra])
+}
+
+
+const codesOf = (json: { defects?: { code: string }[] }) => (json.defects ?? []).map((d) => d.code)
+
+
+type Pair = { pair_id: string; kind: string; fact_ids?: string[]; sentence: string; quote?: string }
+
+
+/** A filled session plus the pair artifact `fact pairs` wrote for it. */
+function pairedSession() {
+	const session = fidelitySession()
+	const { dir, s } = session
+	nodeJson(["fact", "fill", join(dir, "report.src.html"), "--out", join(dir, "report.html"), ...s])
+	const pairs = nodeJson(["fact", "pairs", join(dir, "report.html"), "--ledger", join(dir, "fact-ledger.json"), "--out", join(dir, "pairs.json"), ...s])
+	return { ...session, pairs }
+}
+
+
+function verdicts(dir: string, name: string, tier: string, list: object[]) {
+	const file = join(dir, name)
+	writeFileSync(file, JSON.stringify({ model_tier: tier, verdicts: list }))
+	return file
+}
+
+
+const calibrationRows = (dir: string) =>
+	readFileSync(join(dir, "fidelity-calibration.jsonl"), "utf8")
+		.trim()
+		.split("\n")
+		.map((line) => JSON.parse(line))
+		.filter((row) => row.header !== true && row.run !== true)
+
+
+const runLines = (dir: string) =>
+	readFileSync(join(dir, "fidelity-calibration.jsonl"), "utf8")
+		.trim()
+		.split("\n")
+		.map((line) => JSON.parse(line))
+		.filter((row) => row.run === true)
+
+
+type PolishJson = { data: { out: string; applied: number; rejected: number; unlocated: number }; defects: { code: string; index: number; reason?: string }[] }
+
+
+/** A filled session whose first finding names an acquirer and a target around F1. */
+function polishSession() {
+	const session = fidelitySession()
+	const { dir, s } = session
+	const source = readFileSync(join(dir, "report.src.html"), "utf8").replace("<p>The span length is", "<p>Acme acquired Bolt before the span length reached")
+	writeFileSync(join(dir, "report.src.html"), source)
+	nodeJson(["fact", "fill", join(dir, "report.src.html"), "--out", join(dir, "report.html"), ...s])
+	return session
+}
+
+
+function polishApply(dir: string, edits: string) {
+	const args = ["fact", "polish-apply", join(dir, "report.html"), "--edits", edits, "--ledger", join(dir, "fact-ledger.json"), "--out", join(dir, "report.polished.html"), "--session-dir", dir]
+	const proc = nodeJson(args)
+	return { ...proc, json: proc.json as unknown as PolishJson }
+}
+
+
+/** Rewrite one `## Fidelity` field line of the session's brief.md. */
+function setField(dir: string, field: string, value: string, answeredBy = "user") {
+	const path = join(dir, "brief.md")
+	const line = new RegExp(`^${field}: .*$`, "mu")
+	writeFileSync(path, readFileSync(path, "utf8").replace(line, `${field}: ${value} (answered_by: ${answeredBy})`))
+}
+
+
+function fillTemplate(dir: string, body: string, extra: string[] = []) {
+	const source = ['<!doctype html><html lang="en"><head><meta charset="utf-8"><title>T</title></head><body><h1>T</h1>', "<h2>Findings</h2>", body, "</body></html>"].join("\n")
+	writeFileSync(join(dir, "t.src.html"), source)
+	return nodeJson(["fact", "fill", join(dir, "t.src.html"), "--out", join(dir, "t.html"), "--session-dir", dir, ...extra])
+}
+
+
+/** Snapshot a one-line text source under `id` with the given provenance (omitted: unknown) and register its span row. */
+function textSource(dir: string, id: string, provenance?: string) {
+	writeFileSync(join(dir, `${id}.txt`), "Commentary: the span length is 320 m according to this review.\n")
+	const prov = provenance === undefined ? [] : ["--provenance", provenance]
+	const snap = nodeJson(["source", "snapshot", "--id", id, "--raw", join(dir, `${id}.txt`), "--kind", "document", ...prov, "--session-dir", dir])
+	const add = nodeJson(["fact", "add", "--source", id, "--find", "span length", "--label", `span_${id.toLowerCase()}`, "--json", "--session-dir", dir])
+	return { snap, row: add.json.data?.row }
+}
+
+
+const ledgerRow = (dir: string, id: string) => JSON.parse(readFileSync(join(dir, "fact-ledger.json"), "utf8")).rows.find((r: { fact_id: string }) => r.fact_id === id)
+export { SCRIPT, FIXTURES, NOW, sessionDir, nodeWithoutBun, defectsFile, FIDELITY, sha256, CliRow, CliJson, nodeJson, fidelitySession, verify, codesOf, Pair, pairedSession, verdicts, calibrationRows, runLines, PolishJson, polishSession, polishApply, setField, fillTemplate, textSource, ledgerRow }

package/packages/shared-skills/skills/ulw-research/scripts/tests/value-mode-support.ts

@@ -0,0 +1,48 @@
+import { expect, onTestFinished } from "bun:test"
+import { copyFileSync, cpSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { run } from "../report-tools.mjs"
+
+// Shared by the value-mode unit tests: the verify fixture ledger plus value rows, and one fill -> verify session.
+export type Row = Record<string, unknown> & { fact_id: string }
+export type VerifyResult = { exitCode: number; json: { defects: { code: string; severity: string }[] } }
+export const FIX = join(import.meta.dir, "fixtures")
+const BASE: { rows: Row[] } = JSON.parse(readFileSync(join(FIX, "fidelity", "ledger-verify.json"), "utf8"))
+export const F1 = BASE.rows.find((r) => r.fact_id === "F1") as Row
+const extra = (fact_id: string, label: string, raw: string, value: string, unit: string, num: string, den = "1"): Row => ({ ...F1, fact_id, label, raw, value, unit, exact: { num, den } })
+// Korean units and particles as \u escapes: pp (peosenteu pointeu), eok won, myeong, geon, dalleo, particles ro/euro/ui/ida.
+export const LEDGER = {
+	...BASE,
+	rows: [
+		...BASE.rows,
+		extra("F20", "gap_pp", "3.2%p", "3.2", "%p", "16", "5"),
+		extra("F21", "rev_eok", "3,234 KRW-e8", "3234", "KRW-e8", "3234"),
+		extra("F22", "staff", "5\uBA85", "5", "person", "5"),
+		extra("F23", "price", "$12", "12", "USD", "12"),
+		extra("F24", "deck_len", "1.2 km", "1.2", "km", "6", "5"),
+	],
+}
+
+/** Fill `body` in a fresh session; verify re-checks the edition, write replaces its text (the fill map stays). */
+export async function filled(body: string, format = "html", ledger: { rows: Row[] } = LEDGER) {
+	const dir = mkdtempSync(join(tmpdir(), "value-mode-unit-"))
+	onTestFinished(() => rmSync(dir, { recursive: true, force: true }))
+	writeFileSync(join(dir, "fact-ledger.json"), JSON.stringify(ledger))
+	copyFileSync(join(FIX, "fidelity-brief-locked.md"), join(dir, "brief.md"))
+	cpSync(join(FIX, "fidelity", "sources"), join(dir, "sources"), { recursive: true })
+	const source = join(dir, `report.src.${format}`)
+	const report = join(dir, `report.${format}`)
+	writeFileSync(source, body)
+	const result = await run(["fact", "fill", source, "--out", report, "--session-dir", dir])
+	expect(result.exitCode).toBe(0)
+	const verify = async () => (await run(["fact", "verify", report, "--session-dir", dir])) as VerifyResult
+	const edit = (from: string, to: string) => writeFileSync(report, readFileSync(report, "utf8").replace(from, to))
+	const text = readFileSync(report, "utf8")
+	const write = (next: string) => writeFileSync(report, next)
+	return { verify, edit, text, write }
+}
+
+export const codes = (result: VerifyResult) => result.json.defects.map((d) => d.code)
+export const prose = (pointer: string, tail: string) => `<h2>Findings</h2><p>Up to ${pointer}${tail} [S4].</p>`

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

@@ -21,6 +21,9 @@ const TABLE = [
 	["s", "time", "1", "open", ["sec", "secs", "second", "seconds", "\uCD08"]], // cho
 	["min", "time", "60", "closed", ["mins", "minute", "minutes", "\uBD84"]], // bun
 	["h", "time", "3600", "closed", ["hr", "hrs", "hour", "hours", "\uC2DC\uAC04"]], // sigan
+	// Months and years are a calendar dimension of their own (a year is no fixed number of seconds).
+	["mo", "calendar", "1", "l", []], // gaewol
+	["yr", "calendar", "12", "closed", ["yrs"]], // nyeon
 	["B", "data", "1", "open", ["byte", "bytes", "\uBC14\uC774\uD2B8"]], // baiteu
 	["KB", "data", "1000", "open", ["\uD0AC\uB85C\uBC14\uC774\uD2B8"]],
 	["MB", "data", "1000000", "open", ["\uBA54\uAC00\uBC14\uC774\uD2B8"]],
@@ -28,13 +31,13 @@ const TABLE = [
 	["TB", "data", "1000000000000", "open", ["\uD14C\uB77C\uBC14\uC774\uD2B8"]],
 	["C", "temperature", "1", "open", ["\u00B0C", "\u2103", "celsius", "\uC12D\uC528"], "0"], // do
 	["F", "temperature", "5/9", "open", ["\u00B0F", "\u2109", "fahrenheit", "\uD654\uC528"], "-160/9"], // do
-	["%", "percent", "1", "open", ["percent", "\uD37C\uC13C\uD2B8", "\uD504\uB85C"]], // peosenteu
+	["%", "percent", "1", "open", ["percent", "pct", "\uD37C\uC13C\uD2B8", "\uD504\uB85C"]], // peosenteu
 	["\u2030", "percent", "0.1", "l", ["permille", "\uD37C\uBC00"]], // peomil
-	["%p", "percentage-point", "1", "open", ["pp", "%pt", "percentage point", "percentage points", "\uD37C\uC13C\uD2B8\uD3EC\uC778\uD2B8", "%\uD3EC\uC778\uD2B8"]],
+	["%p", "percentage-point", "1", "open", ["pp", "%pt", "percentage point", "percentage points", "percent point", "percent points", "% point", "% points", "\uD37C\uC13C\uD2B8\uD3EC\uC778\uD2B8", "%\uD3EC\uC778\uD2B8"]],
 	["x", "multiple", "1", "open", ["\u00D7", "times", "\uBC30"]], // bae
 	["e3", "scale", "1000", "closed", ["k", "thousand", "\uCC9C"]], // cheon
 	["e4", "scale", "10000", "closed", ["\uB9CC"]], // man
-	["e6", "scale", "1000000", "closed", ["M", "million", "\uBC31\uB9CC"]], // baengman
+	["e6", "scale", "1000000", "closed", ["M", "mn", "million", "\uBC31\uB9CC"]], // baengman
 	["e8", "scale", "100000000", "closed", ["\uC5B5"]], // eok
 	["e9", "scale", "1000000000", "closed", ["bn", "billion", "\uC2ED\uC5B5"]], // sibeok
 	["e12", "scale", "1000000000000", "open", ["trillion", "\uC870"]], // jo
@@ -59,6 +62,8 @@ const ENTRIES = new Map()
 const EXACT = new Map()
 /** Case-insensitive keys: multi-letter ASCII aliases only, so m/M and B/b never collide. */
 const WORD = new Map()
+/** Aliases written with their own spacing ("percentage points"), by lower-case text. */
+const SPACED = new Map()
 for (const [token, dimension, factor, reading, aliases, offset] of TABLE) {
 	const entry = Object.freeze({ token, dimension, factor: parse(factor), offset: parse(offset ?? "0"), reading })
 	ENTRIES.set(token, entry)
@@ -66,6 +71,7 @@ for (const [token, dimension, factor, reading, aliases, offset] of TABLE) {
 		const key = squash(alias)
 		EXACT.set(key, entry)
 		if (alias !== token && key.length > 2 && /^[a-z]+$/.test(key) && !WORD.has(key.toLowerCase())) WORD.set(key.toLowerCase(), entry)
+		if (/\s/.test(alias)) SPACED.set(alias.toLowerCase(), entry)
 	}
 }
 
@@ -81,6 +87,11 @@ export function normalizeUnit(raw) {
 	return entryOf(raw)?.token ?? null
 }
 
+/** Canonical token for a multi-word unit written with its alias's own spacing, or null (never a squashed join). */
+export function spacedAliasUnit(raw) {
+	return SPACED.get(String(raw).trim().replace(/\s+/g, " ").toLowerCase())?.token ?? null
+}
+
 /** Dimension of a unit ("length", "currency:KRW", ...), or null. */
 export function dimensionOf(token) {
 	return entryOf(token)?.dimension ?? null

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

@@ -14,6 +14,16 @@ describe("normalizeUnit", () => {
 		expect(normalizeUnit("furlongs")).toBeNull()
 	})
 
+	test("common measure suffixes read as units: mn, pct, hrs, yr(s), mo", () => {
+		expect(normalizeUnit("mn")).toBe(normalizeUnit("M"))
+		expect(normalizeUnit("pct")).toBe(normalizeUnit("%"))
+		expect(normalizeUnit("hrs")).toBe(normalizeUnit("h"))
+		expect(normalizeUnit("yrs")).toBe(normalizeUnit("yr"))
+		expect(normalizeUnit("mo")).not.toBeNull()
+		expect(convertFactor("yr", "mo")).toEqual({ num: 12n, den: 1n })
+		expect(convertFactor("yr", "s")).toBeNull()
+	})
+
 	test("a normalized token normalizes to itself", () => {
 		for (const raw of ["억 원", "m", "kg", "GB", "%p", "USD", "C", "F"]) {
 			const token = normalizeUnit(raw)

package/packages/shared-skills/skills/ulw-research/scripts/value-mode-unit-classes.test.ts

@@ -0,0 +1,255 @@
+import { describe, expect, test } from "bun:test"
+
+import { valueChecks } from "./fidelity-values.mjs"
+import { buildContext } from "./gates-static.mjs"
+import { parseHtml } from "./html-lite.mjs"
+import { escapeHtml } from "./placeholder.mjs"
+import { F1, codes, filled, prose } from "./tests/value-mode-support"
+import { dimensionOf, normalizeUnit } from "./units.mjs"
+
+// One table per class of value-mode unit reading; every row is { input, expected } and a run lists every row that
+// disagrees. Korean text is written as \u escapes (romanized in the comments).
+type Verdict = "pass" | "unit_mismatch" | "unit_unbound"
+const verdictOf = (found: string[]): Verdict => (found.includes("unit_mismatch") ? "unit_mismatch" : found.includes("unit_unbound") ? "unit_unbound" : "pass")
+
+// Hand-written oracle: every alias units.mjs accepts, by canonical token (internal scale tokens such as e3 omitted).
+const ALIASES: [string, string[]][] = [
+	["mm", ["mm", "millimeter", "millimeters", "millimetre", "millimetres", "\uBC00\uB9AC\uBBF8\uD130"]],
+	["cm", ["cm", "centimeter", "centimeters", "centimetre", "centimetres", "\uC13C\uD2F0\uBBF8\uD130"]],
+	["m", ["m", "meter", "meters", "metre", "metres", "\uBBF8\uD130"]],
+	["km", ["km", "kilometer", "kilometers", "kilometre", "kilometres", "\uD0AC\uB85C\uBBF8\uD130"]],
+	["g", ["g", "gram", "grams", "\uADF8\uB7A8"]],
+	["kg", ["kg", "kilogram", "kilograms", "\uD0AC\uB85C\uADF8\uB7A8"]],
+	["t", ["t", "ton", "tons", "tonne", "tonnes", "\uD1A4"]],
+	["ms", ["ms", "millisecond", "milliseconds", "\uBC00\uB9AC\uCD08"]],
+	["s", ["s", "sec", "secs", "second", "seconds", "\uCD08"]],
+	["min", ["min", "mins", "minute", "minutes", "\uBD84"]],
+	["h", ["h", "hr", "hrs", "hour", "hours", "\uC2DC\uAC04"]],
+	["B", ["B", "byte", "bytes", "\uBC14\uC774\uD2B8"]],
+	["KB", ["KB", "\uD0AC\uB85C\uBC14\uC774\uD2B8"]],
+	["MB", ["MB", "\uBA54\uAC00\uBC14\uC774\uD2B8"]],
+	["GB", ["GB", "\uAE30\uAC00\uBC14\uC774\uD2B8"]],
+	["TB", ["TB", "\uD14C\uB77C\uBC14\uC774\uD2B8"]],
+	["C", ["C", "\u00B0C", "\u2103", "celsius", "\uC12D\uC528"]],
+	["F", ["F", "\u00B0F", "\u2109", "fahrenheit", "\uD654\uC528"]],
+	["%", ["%", "percent", "\uD37C\uC13C\uD2B8", "\uD504\uB85C"]],
+	["\u2030", ["\u2030", "permille", "\uD37C\uBC00"]],
+	["%p", ["%p", "pp", "%pt", "percentage point", "percentage points", "percent point", "percent points", "% point", "% points", "\uD37C\uC13C\uD2B8\uD3EC\uC778\uD2B8", "%\uD3EC\uC778\uD2B8"]],
+	["x", ["x", "\u00D7", "times", "\uBC30"]],
+	["e3", ["k", "thousand", "\uCC9C"]],
+	["e4", ["\uB9CC"]],
+	["e6", ["M", "million", "\uBC31\uB9CC"]],
+	["e8", ["\uC5B5"]],
+	["e9", ["bn", "billion", "\uC2ED\uC5B5"]],
+	["e12", ["trillion", "\uC870"]],
+	["person", ["person", "persons", "people", "\uBA85"]],
+	["case", ["case", "cases", "\uAC74"]],
+	["KRW", ["KRW", "\uC6D0", "\u20A9", "won"]],
+	["KRW-e3", ["\uCC9C\uC6D0"]],
+	["KRW-e4", ["\uB9CC\uC6D0"]],
+	["KRW-e8", ["\uC5B5\uC6D0"]],
+	["KRW-e12", ["\uC870\uC6D0"]],
+	["USD", ["USD", "$", "US$", "dollar", "dollars", "\uB2EC\uB7EC"]],
+	["EUR", ["EUR", "\u20AC", "euro", "euros", "\uC720\uB85C"]],
+	["JPY", ["JPY", "\u00A5", "yen", "\uC5D4"]],
+	["GBP", ["GBP", "\u00A3", "pound", "pounds", "\uD30C\uC6B4\uB4DC"]],
+]
+// i, ga, eun, neun, eul, reul, ui, gwa, wa, ro, euro, e, eseo, do, man, buteo, kkaji.
+const PARTICLES = ["\uC774", "\uAC00", "\uC740", "\uB294", "\uC744", "\uB97C", "\uC758", "\uACFC", "\uC640", "\uB85C", "\uC73C\uB85C", "\uC5D0", "\uC5D0\uC11C", "\uB3C4", "\uB9CC", "\uBD80\uD130", "\uAE4C\uC9C0"]
+// chogwa, isang, miman, iha, jeongdo, garyang, jjeum: written glued after a unit.
+const GLUED_QUALIFIERS = ["\uCD08\uACFC", "\uC774\uC0C1", "\uBBF8\uB9CC", "\uC774\uD558", "\uC815\uB3C4", "\uAC00\uB7C9", "\uCBE4"]
+// The same plus gwaban (majority) and yak (about): whole words standing alone after the value.
+const QUALIFIER_WORDS = [...GLUED_QUALIFIERS, "\uACFC\uBC18", "\uC57D"]
+const CHOGWA = "\uCD08\uACFC"
+const ORDINARY = new Set(["won", "second", "pound", "pounds"])
+
+const element = (unit: string) => `<data class="fact" value="320" data-fact="F1" data-unit="${escapeHtml(unit)}" data-fact-mode="value">320</data>`
+/** valueChecks over a Findings section holding one value-mode element of a row in `unit`. */
+function readHtml(html: string, unit: string): Verdict {
+	const ledger = { rows: [{ ...F1, unit, raw: `320 ${unit}` }] }
+	return verdictOf((valueChecks(buildContext(parseHtml(`<h2>Findings</h2>${html}`), {}), ledger, null, null) as { code: string }[]).map((d) => d.code))
+}
+/** The same element with `after` written right after it. */
+const readAfter = (after: string, unit: string) => readHtml(`<p>Up to ${element(unit)}${escapeHtml(after)} [S4].</p>`, unit)
+
+type Case = { input: string; unit: string; expected: Verdict }
+function tokenizationCases(): Case[] {
+	const cases: Case[] = []
+	for (const [token, aliases] of ALIASES) {
+		const other = dimensionOf(token) === "length" ? "KRW" : "m"
+		for (const alias of aliases) {
+			const suffixes = [...["", ...PARTICLES].flatMap((p) => [` ${alias}${p}`, `${alias}${p}`]), ...GLUED_QUALIFIERS.map((q) => ` ${alias}${q}`)]
+			for (const input of suffixes) {
+				const qualifier = input.trim() === CHOGWA
+				cases.push({ input, unit: token, expected: qualifier ? "unit_unbound" : "pass" })
+				cases.push({ input, unit: other, expected: qualifier || ORDINARY.has(alias) ? "unit_unbound" : "unit_mismatch" })
+			}
+		}
+	}
+	for (const word of QUALIFIER_WORDS) cases.push({ input: ` ${word}`, unit: "m", expected: "unit_unbound" }, { input: ` m ${word}`, unit: "m", expected: "pass" }, { input: ` mm ${word}`, unit: "m", expected: "unit_mismatch" })
+	// English words that collide with unit aliases or read like them; "3 bun-ui 1" is a fraction, not minutes.
+	const words: [string, string, Verdict][] = [
+		[" in total", "m", "unit_unbound"], [" a year", "m", "unit_unbound"], [" or more", "m", "unit_unbound"], [" or less", "m", "unit_unbound"],
+		[" min", "min", "pass"], [" min", "m", "unit_mismatch"], [" sec", "s", "pass"], [" sec", "m", "unit_mismatch"], [" SEC filings", "m", "unit_unbound"],
+		[" second", "m", "unit_unbound"], [" second", "s", "pass"], [" won awards", "person", "unit_unbound"], [" won", "KRW", "pass"],
+		[" pound", "m", "unit_unbound"], [" times", "x", "pass"], [" times", "m", "unit_mismatch"],
+		["\uBD84\uC758 1", "%", "unit_unbound"], ["\uBD84\uC758 1", "min", "unit_unbound"], [" (m)", "m", "pass"], [" (mm)", "m", "unit_mismatch"], [" (approx.)", "m", "unit_unbound"],
+	]
+	for (const [input, unit, expected] of words) cases.push({ input, unit, expected })
+	return cases
+}
+
+describe("class 1: the unit token written after a value", () => {
+	test("#given every alias with every particle and qualifier, and the colliding words #when read #then each row gets its expected verdict", () => {
+		const cases = tokenizationCases()
+		for (const [token, aliases] of ALIASES) for (const alias of aliases) expect([alias, normalizeUnit(alias)]).toEqual([alias, token])
+		const wrong = cases.map((row) => ({ ...row, actual: readAfter(row.input, row.unit) })).filter((row) => row.actual !== row.expected)
+		expect(cases.length).toBeGreaterThan(9000)
+		expect(wrong).toEqual([])
+	}, 120000)
+})
+
+type Form = { name: string; format: "html" | "md"; body: string; at: (unit: string) => string; units: [same: string, known: string, unknown: string] }
+const m3: [string, string, string] = ["m", "mm", "ft"]
+const P = "{{F1:span_len:value}}"
+const head = (th: string) => `<h2>Findings</h2><table><thead><tr><th>${th}</th></tr></thead><tbody><tr><td>${P}</td></tr></tbody></table>`
+const FORMS: Form[] = [
+	{ name: "glued", format: "html", body: prose(P, "m"), at: (u) => `</data>${u} [S4]`, units: m3 },
+	{ name: "spaced", format: "html", body: prose(P, " m"), at: (u) => `</data> ${u} [S4]`, units: m3 },
+	...["b", "span", "em", "code"].map((tag): Form => ({ name: `wrapped in ${tag}`, format: "html", body: prose(P, ` <${tag}>m</${tag}>`), at: (u) => `</data> <${tag}>${u}</${tag}>`, units: m3 })),
+	{ name: "parenthesized", format: "html", body: prose(P, " (m)"), at: (u) => `</data> (${u})`, units: m3 },
+	{ name: "after a line break", format: "html", body: prose(P, "\nm"), at: (u) => `</data>\n${u} [S4]`, units: m3 },
+	{ name: "after a br", format: "html", body: prose(P, "<br>m"), at: (u) => `</data><br>${u} [S4]`, units: m3 },
+	{ name: "header-bound column", format: "html", body: head("Span (m)"), at: (u) => `<th>Span${u ? ` (${u})` : ""}</th>`, units: m3 },
+	{ name: "currency sign before", format: "html", body: prose("${{F23:price:value}}", ""), at: (u) => `Up to ${u}<data`, units: ["$", "\u20AC", "Rs"] },
+	...([["glued", "m"], ["spaced", " m"], ["parenthesized", " (m)"], ["after a line break", "\nm"]] as const).map(([name, tail]): Form => ({ name: `md ${name}`, format: "md", body: `## Findings\n\nUp to ${P}${tail} [S4].`, at: (u) => `320${tail.replace("m", u)} [S4]`, units: m3 })),
+]
+
+describe("class 2: a unit hand-edited after fill", () => {
+	test("#given every form a bound unit takes #when it is kept, changed to a known or unknown unit, or deleted, with and without data-fact-mode #then each row gets its expected verdict", async () => {
+		const rows: { form: string; edit: string; attr: string; expected: Verdict; actual?: Verdict; exit?: number }[] = []
+		for (const form of FORMS) {
+			const { verify, text, write } = await filled(form.body, form.format)
+			const [same, known, unknown] = form.units
+			expect(text).toContain(form.at(same))
+			for (const [edit, unit, expected] of [["kept", same, "pass"], ["known", known, "unit_mismatch"], ["unknown", unknown, "unit_mismatch"], ["deleted", "", "unit_mismatch"]] as const) {
+				for (const attr of form.format === "html" ? ["kept", "deleted"] : ["n/a"]) {
+					const edited = text.replace(form.at(same), form.at(unit))
+					write(attr === "deleted" ? edited.replace(' data-fact-mode="value"', "") : edited)
+					const result = await verify()
+					rows.push({ form: form.name, edit, attr, expected, actual: verdictOf(codes(result)), exit: result.exitCode })
+				}
+			}
+		}
+		for (const [name, body, edit, expected] of [["no unit at fill", prose(P, " long"), ["</data> long", "</data> long"], "unit_unbound"], ["no unit at fill, mm added", prose(P, " long"), ["</data> long", "</data> mm long"], "unit_mismatch"], ["unknown unit at fill", prose(P, " ft"), ["</data> ft", "</data> ft"], "unit_unbound"], ["unknown unit at fill, m written", prose(P, " ft"), ["</data> ft", "</data> m"], "pass"]] as const) {
+			const { verify, text, write } = await filled(body)
+			write(text.replace(edit[0], edit[1]))
+			const result = await verify()
+			rows.push({ form: name, edit: "as named", attr: "kept", expected, actual: verdictOf(codes(result)), exit: result.exitCode })
+		}
+		const wrong = rows.filter((row) => row.actual !== row.expected || row.exit !== (row.expected === "unit_mismatch" ? 1 : 0))
+		expect(rows.length).toBe(FORMS.filter((f) => f.format === "html").length * 8 + FORMS.filter((f) => f.format === "md").length * 4 + 4)
+		expect(wrong).toEqual([])
+	}, 120000)
+})
+
+// Class 2b: a currency sign on both sides of the element's edge. Fill renders a prefix currency value from its raw text,
+// so the sign may sit inside the element ($<data>$12</data>) as well as outside it. Every bound sign, outside before the
+// element or inside it (prefix or suffix), must agree with the row's currency; two signs that disagree flag.
+// EN forms $, US$, USD, euro sign, pound sign; KO forms won sign, won, dalleo, man-won. A form of the row's own currency at
+// another scale (won sign under a man-won row) is the element numeral's value and scale reading, not a sign position: skipped.
+const PREFIX_SIGNS: [form: string, unit: string][] = [["$", "USD"], ["US$", "USD"], ["USD ", "USD"], ["\u20AC", "EUR"], ["\u00A3", "GBP"], ["\u20A9", "KRW"]]
+const SUFFIX_SIGNS: [form: string, unit: string][] = [["\u20AC", "EUR"], [" \u20AC", "EUR"], [" USD", "USD"], ["\u00A3", "GBP"], ["\uC6D0", "KRW"], [" \uC6D0", "KRW"], ["\uB2EC\uB7EC", "USD"], [" \uB2EC\uB7EC", "USD"], ["\uB9CC\uC6D0", "KRW"]]
+const SIGN_ROW_UNITS = ["USD", "EUR", "GBP", "KRW", "KRW-e4"]
+const KO = /[\u20A9\uAC00-\uD7A3]/u
+type SignCase = { position: string; outside: string; inside: string; unit: string; expected: Verdict }
+function signCases(): SignCase[] {
+	const cases: SignCase[] = []
+	const insides: [form: string, unit: string, where: string][] = [["", "", ""], ...PREFIX_SIGNS.map(([f, u]): [string, string, string] => [`${f}320`, u, "prefix"]), ...SUFFIX_SIGNS.map(([f, u]): [string, string, string] => [`320${f}`, u, "suffix"])]
+	for (const [outside, outsideUnit] of [["", ""], ...PREFIX_SIGNS]) for (const [inside, insideUnit, where] of insides) for (const unit of SIGN_ROW_UNITS) {
+		const bound = [outsideUnit, insideUnit].filter(Boolean)
+		if (bound.some((u) => u !== unit && dimensionOf(u) === dimensionOf(unit))) continue
+		const agree = bound.every((u) => dimensionOf(u) === dimensionOf(unit))
+		const position = !outsideUnit && !insideUnit ? "no sign" : !insideUnit ? "outside-before only" : !outsideUnit ? `inside-${where} only` : dimensionOf(outsideUnit) !== dimensionOf(insideUnit) ? "outside vs inside conflicting" : "outside and inside agreeing"
+		const label = outsideUnit && !insideUnit && !agree ? "outside disagreeing with the row" : position
+		cases.push({ position: label, outside, inside: inside || "320", unit, expected: bound.length === 0 ? "unit_unbound" : agree ? "pass" : "unit_mismatch" })
+	}
+	return cases
+}
+/** The row's value is what the element's text reads ("320 man-won" inside is 3,200,000 won), so the value check passes and the unit is what is asked. */
+function signed(outside: string, inside: string, unit: string): Verdict {
+	const value = inside.includes("\uB9CC") ? "3200000" : "320"
+	const html = `<h2>Findings</h2><p>Up to ${escapeHtml(outside)}<data class="fact" value="${value}" data-fact="F1" data-unit="${escapeHtml(unit)}" data-fact-mode="value">${escapeHtml(inside)}</data> [S4].</p>`
+	const ledger = { rows: [{ ...F1, unit, value, raw: `${value} ${unit}`, exact: { num: value, den: "1" } }] }
+	return verdictOf((valueChecks(buildContext(parseHtml(html), {}), ledger, null, null) as { code: string }[]).map((d) => d.code))
+}
+
+describe("class 2b: a currency sign outside and inside a value-mode element", () => {
+	test("#given every EN and KO sign outside before, inside as prefix or suffix, both, or none #when read #then every bound sign must agree with the row and with each other", () => {
+		const cases = signCases()
+		const positions = ["outside-before only", "inside-prefix only", "inside-suffix only", "outside and inside agreeing", "outside vs inside conflicting", "outside disagreeing with the row", "no sign"]
+		for (const position of positions) {
+			const here = cases.filter((row) => row.position === position)
+			if (position !== "no sign") expect([position, here.some((row) => KO.test(row.outside + row.inside)), here.some((row) => !KO.test(row.outside + row.inside) && row.outside + row.inside !== "320")]).toEqual([position, true, true])
+			else expect(here.length).toBe(SIGN_ROW_UNITS.length)
+		}
+		const wrong = cases.map((row) => ({ ...row, actual: signed(row.outside, row.inside, row.unit) })).filter((row) => row.actual !== row.expected)
+		expect(wrong).toEqual([])
+	}, 120000)
+})
+
+// Class 3: unit prefix shadowing. Every pair of aliases of different units where one (spaces removed) starts the other
+// ("%" / "%p", "m" / "mm" / "min", "k" / "km", "M" / "MB", cheon / cheon-won, peosenteu / peosenteu pointeu) and every alias that
+// starts a qualifier word (cho / chogwa). The longer unit is read whole, never as its prefix.
+const squashed = (alias: string) => alias.replace(/\s+/g, "")
+const LETTERS = /^[A-Za-z]+$/
+const scaleOf = (unit: string) => /-(e\d+)$/.exec(unit)?.[1] ?? null
+type Pair = { short: string; shortUnit: string; long: string; longUnit: string }
+function prefixPairs(): Pair[] {
+	const all = ALIASES.flatMap(([token, aliases]) => aliases.map((alias) => ({ alias, token })))
+	const longer = (short: string, long: string) => squashed(long) !== squashed(short) && squashed(long).startsWith(squashed(short))
+	return all.flatMap((s) => all.filter((l) => l.token !== s.token && longer(s.alias, l.alias)).map((l) => ({ short: s.alias, shortUnit: s.token, long: l.alias, longUnit: l.token })))
+}
+function prefixCases(): Case[] {
+	const cases: Case[] = []
+	const add = (input: string, unit: string, expected: Verdict) => cases.push({ input, unit, expected })
+	for (const { short, shortUnit, long, longUnit } of prefixPairs()) {
+		// A scale word alone agrees with a scaled currency row (the currency may be a sign, "$12 million"): cheon under a cheon-won row.
+		const scaleOnly = dimensionOf(shortUnit) === "scale" && scaleOf(longUnit) === shortUnit
+		for (const gap of ["", " "]) {
+			add(`${gap}${short}`, shortUnit, "pass")
+			add(`${gap}${long}`, shortUnit, "unit_mismatch")
+			add(`${gap}${short}`, longUnit, scaleOnly ? "pass" : "unit_mismatch")
+			add(`${gap}${long}`, longUnit, "pass")
+		}
+		if (/\s/.test(long)) continue
+		// Split at the prefix: English words stay apart ("m in" is m, then in); a symbol or Hangul joins ("% p", cheon won).
+		const rest = squashed(long).slice(squashed(short).length)
+		const english = LETTERS.test(short) && LETTERS.test(rest)
+		add(` ${short} ${rest}`, shortUnit, english ? "pass" : "unit_mismatch")
+		add(` ${short} ${rest}`, longUnit, english ? "unit_mismatch" : "pass")
+	}
+	for (const [token, aliases] of ALIASES) for (const alias of aliases) for (const word of [...QUALIFIER_WORDS, "\uB0B4\uC678", "\uAE4C\uC9C0"]) {
+		if (word !== alias && word.startsWith(alias)) for (const gap of ["", " "]) add(`${gap}${word}`, token, "unit_unbound")
+	}
+	return cases
+}
+
+// An ordinary word that is also a unit ("pounds", "won", "second") is read when a sign or header binds a unit of its kind.
+const SIGNED: [html: string, unit: string, expected: Verdict][] = [
+	["<p>Up to ${V} pounds [S4].</p>", "USD", "unit_mismatch"], ["<p>Up to ${V} pound [S4].</p>", "USD", "unit_mismatch"], ["<p>Up to ${V} won [S4].</p>", "USD", "unit_mismatch"],
+	["<p>Up to \u20AC{V} pounds [S4].</p>", "EUR", "unit_mismatch"], ["<p>Up to \u20A9{V} pounds [S4].</p>", "KRW", "unit_mismatch"], ["<p>Up to \u00A3{V} pounds [S4].</p>", "GBP", "pass"],
+	["<p>Up to ${V} SEC filings [S4].</p>", "USD", "pass"], ["<p>Up to ${V} second [S4].</p>", "USD", "pass"], ["<p>Up to {V} pounds [S4].</p>", "USD", "unit_unbound"],
+	["<table><thead><tr><th>Cost ($)</th></tr></thead><tbody><tr><td>{V} pounds</td></tr></tbody></table>", "USD", "unit_mismatch"],
+	["<table><thead><tr><th>Time (min)</th></tr></thead><tbody><tr><td>{V} second</td></tr></tbody></table>", "min", "unit_mismatch"],
+	["<table><thead><tr><th>Span (m)</th></tr></thead><tbody><tr><td>{V} second</td></tr></tbody></table>", "m", "pass"],
+]
+
+describe("class 3: a longer unit that starts with a shorter one", () => {
+	test("#given every prefix pair of aliases, spaced, glued and split, and the signed ordinary words #when read #then each row gets its expected verdict", () => {
+		const pairs = prefixPairs().map((p) => `${p.short}/${p.long}`)
+		for (const pair of ["%/%p", "%/%\uD3EC\uC778\uD2B8", "\uD37C\uC13C\uD2B8/\uD37C\uC13C\uD2B8\uD3EC\uC778\uD2B8", "percent/percent points", "m/mm", "m/min", "k/km", "M/MB", "\uCC9C/\uCC9C\uC6D0"]) expect(pairs).toContain(pair)
+		const rows = [...prefixCases().map((row) => ({ ...row, actual: readAfter(row.input, row.unit) })), ...SIGNED.map(([html, unit, expected]) => ({ input: html, unit, expected, actual: readHtml(html.replace("{V}", element(unit)), unit) }))]
+		expect(rows.filter((row) => row.actual !== row.expected)).toEqual([])
+	}, 120000)
+})