oh-my-opencode 5.1.44 → 5.1.46

package/dist/skills/ulw-research/scripts/meaning-check.test.ts

@@ -0,0 +1,228 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { DRIFT_KINDS, ingestVerdicts } from "./meaning-check.mjs"
+
+type Verdict = Record<string, unknown>
+type Result = {
+	defects: { code: string; severity: string; integrity: boolean; pair_id: string; drift_kind: string; fragment: string; source_fragment: string }[]
+	dropped: { pair_id: string | null; reason: string; model_tier: string | null; file: string }[]
+	unverified: { pair_id: string; reason: string }[]
+	calibrationLines: string[]
+}
+
+const PAIRS = [
+	{ pair_id: "P1", kind: "quote", sentence_key: "findings#Q1", fact_ids: ["Q1"], quote: "The pilot covered North America.", sentence: "The rollout was worldwide.", force_strong: true },
+	{ pair_id: "P2", kind: "claim", claim_id: "C2", statement: "Revenue may grow in 2026.", sentence: "Revenue will grow in 2026.", force_strong: true },
+]
+
+const base = (tier: string, extra: Verdict = {}): Verdict => ({
+	pair_id: "P1",
+	verdict: "drift",
+	drift_kind: "scope_widened",
+	fragment: "worldwide",
+	source_fragment: "North America",
+	explanation: "The assertion broadens the reported region.",
+	model_tier: tier,
+	...extra,
+})
+
+let dir = ""
+beforeEach(() => {
+	dir = mkdtempSync(join(tmpdir(), "meaning-check-"))
+})
+afterEach(() => {
+	rmSync(dir, { recursive: true, force: true })
+})
+
+function file(name: string, verdicts: Verdict[]): string {
+	const path = join(dir, name)
+	writeFileSync(path, JSON.stringify(verdicts))
+	return path
+}
+
+function run(cheap: Verdict[], strong: Verdict[] = [], options: object = {}): Result {
+	return ingestVerdicts(PAIRS, [file("cheap.json", cheap), file("strong.json", strong)], options) as Result
+}
+
+describe("ingestVerdicts: tier agreement", () => {
+	test("#given cheap and strong agree on scope_widened #when ingested #then meaning_drift_confirmed (major, non-integrity)", () => {
+		const result = run([base("cheap")], [base("strong")])
+		expect(result.defects).toHaveLength(1)
+		expect(result.defects[0]).toMatchObject({ code: "meaning_drift_confirmed", severity: "major", integrity: false, pair_id: "P1", drift_kind: "scope_widened" })
+		expect(result.dropped).toEqual([])
+	})
+
+	test("#given only the cheap tier flags #when ingested #then meaning_drift_warn (minor)", () => {
+		const result = run([base("cheap")])
+		expect(result.defects.map((d) => [d.code, d.severity])).toEqual([["meaning_drift_warn", "minor"]])
+	})
+
+	test("#given both tiers agree on other #when ingested #then warn only, never confirmed", () => {
+		const result = run([base("cheap", { drift_kind: "other" })], [base("strong", { drift_kind: "other" })])
+		expect(result.defects.map((d) => d.code)).toEqual(["meaning_drift_warn"])
+	})
+
+	test("#given the tiers name different drift kinds #when ingested #then warn only", () => {
+		const result = run([base("cheap")], [base("strong", { drift_kind: "subject_changed" })])
+		expect(result.defects.map((d) => d.code)).toEqual(["meaning_drift_warn"])
+	})
+
+	test("#given an ok verdict #when ingested #then no defect and no calibration line", () => {
+		const result = run([{ pair_id: "P1", verdict: "ok", model_tier: "cheap" }])
+		expect(result.defects).toEqual([])
+		expect(result.calibrationLines).toEqual([])
+	})
+
+	test("#given a claim pair #when both tiers agree on evidence_grade_raised #then confirmed against the statement", () => {
+		const verdict = { pair_id: "P2", verdict: "drift", drift_kind: "evidence_grade_raised", fragment: "will grow", source_fragment: "may grow", explanation: "certainty raised" }
+		const result = run([{ ...verdict, model_tier: "cheap" }], [{ ...verdict, model_tier: "strong" }])
+		expect(result.defects.map((d) => [d.code, d.pair_id])).toEqual([["meaning_drift_confirmed", "P2"]])
+	})
+})
+
+describe("ingestVerdicts: grounding drops", () => {
+	test("#given a fragment that is not in the sentence #when ingested #then dropped and counted, no defect", () => {
+		const result = run([base("cheap", { fragment: "Europe" })])
+		expect(result.defects).toEqual([])
+		expect(result.dropped).toHaveLength(1)
+		expect(result.dropped[0]).toMatchObject({ pair_id: "P1", reason: "fragment_not_found", model_tier: "cheap" })
+	})
+
+	test("#given a source fragment that is not in the quote #when ingested #then dropped", () => {
+		const result = run([base("cheap", { source_fragment: "Asia" })])
+		expect(result.defects).toEqual([])
+		expect(result.dropped.map((d) => d.reason)).toEqual(["source_fragment_not_found"])
+	})
+
+	test("#given empty or blank fragments #when ingested #then dropped as empty", () => {
+		const result = run([base("cheap", { fragment: "" })], [base("strong", { source_fragment: "   " })])
+		expect(result.defects).toEqual([])
+		expect(result.dropped.map((d) => d.reason)).toEqual(["empty_fragment", "empty_fragment"])
+	})
+
+	test("#given an unknown drift_kind #when ingested #then dropped", () => {
+		const result = run([base("cheap", { drift_kind: "tone_shifted" })])
+		expect(result.defects).toEqual([])
+		expect(result.dropped.map((d) => d.reason)).toEqual(["unknown_drift_kind"])
+	})
+
+	test("#given an unknown pair id or tier #when ingested #then dropped", () => {
+		const result = run([base("cheap", { pair_id: "P99" }), base("medium")])
+		expect(result.dropped.map((d) => d.reason)).toEqual(["unknown_pair", "invalid_model_tier"])
+	})
+
+	test("#given extra whitespace in a fragment #when ingested #then it still grounds", () => {
+		const result = run([base("cheap", { fragment: "rollout \n  was", source_fragment: " North  America " })])
+		expect(result.dropped).toEqual([])
+		expect(result.defects.map((d) => d.code)).toEqual(["meaning_drift_warn"])
+	})
+
+	test("#given the closed drift_kind set #when read #then it holds exactly the nine kinds", () => {
+		expect([...DRIFT_KINDS]).toEqual([
+			"subject_changed", "scope_widened", "hedge_dropped", "certainty_added", "causality_added",
+			"direction_flipped", "population_changed", "evidence_grade_raised", "other",
+		])
+	})
+})
+
+describe("ingestVerdicts: calibration log", () => {
+	test("#given a dispute on a confirmed pair #when ingested #then the defect stays and the line records disputed:true", () => {
+		const result = run([base("cheap")], [base("strong")], { dispute: { pair_id: "P1", reason: "Scope is justified by a second observation." } })
+		expect(result.defects.map((d) => d.code)).toEqual(["meaning_drift_confirmed"])
+		expect(result.calibrationLines.map((line) => JSON.parse(line))).toEqual([
+			{ kind: "quote", pair_id: "P1", tiers: ["cheap", "strong"], drift_kind: "scope_widened", confirmed: true, disputed: true, reason: "Scope is justified by a second observation." },
+		])
+	})
+
+	test("#given two flagged pairs and one ok verdict #when ingested with a calibration path #then exactly one line per flagged pair is appended", () => {
+		const calibrationPath = join(dir, "fidelity-calibration.jsonl")
+		const claimDrift = { pair_id: "P2", verdict: "drift", drift_kind: "certainty_added", fragment: "will", source_fragment: "may", explanation: "x", model_tier: "cheap" }
+		const cheap = [base("cheap"), claimDrift, { pair_id: "P1", verdict: "ok", model_tier: "cheap" }]
+		const first = run(cheap, [], { calibrationPath })
+		expect(first.calibrationLines).toHaveLength(2)
+		const lines = () => readFileSync(calibrationPath, "utf8").split("\n").filter(Boolean)
+		expect(lines()).toHaveLength(2)
+		expect(JSON.parse(lines()[1])).toEqual({ kind: "claim", pair_id: "P2", tiers: ["cheap"], drift_kind: "certainty_added", confirmed: false, disputed: false, reason: null })
+		run(cheap, [], { calibrationPath })
+		expect(lines()).toHaveLength(4)
+	})
+})
+
+describe("ingestVerdicts: coverage", () => {
+	test("#given a pair no reader judged #when ingested #then it is reported as unverified, never as clean", () => {
+		const result = run([base("cheap")], [base("strong")])
+		expect(result.unverified).toEqual([{ pair_id: "P2", reason: "no_verdict" }])
+	})
+
+	test("#given a force_strong pair with only a cheap verdict #when ingested #then unverified says no_strong_verdict", () => {
+		const result = run([base("cheap"), { pair_id: "P2", verdict: "ok", model_tier: "cheap" }])
+		expect(result.unverified).toEqual([
+			{ pair_id: "P1", reason: "no_strong_verdict" },
+			{ pair_id: "P2", reason: "no_strong_verdict" },
+		])
+	})
+
+	test("#given every pair read by both tiers #when ingested #then unverified is empty", () => {
+		const ok = (pair_id: string, tier: string): Verdict => ({ pair_id, verdict: "ok", model_tier: tier })
+		const result = run([ok("P1", "cheap"), ok("P2", "cheap")], [ok("P1", "strong"), ok("P2", "strong")])
+		expect(result.unverified).toEqual([])
+		expect(result.defects).toEqual([])
+	})
+
+	test("#given only dropped verdicts on a pair #when ingested #then the pair counts as unread", () => {
+		const result = run([base("cheap", { fragment: "Europe" })], [base("strong", { fragment: "Europe" })])
+		expect(result.unverified.map((entry) => entry.pair_id)).toEqual(["P1", "P2"])
+	})
+})
+
+describe("ingestVerdicts: the reported fragment", () => {
+	test("#given an earlier other verdict #when the tiers agree on a later kind #then the fragment comes from the agreed verdict", () => {
+		const other = base("cheap", { drift_kind: "other", fragment: "The rollout", source_fragment: "The pilot" })
+		const result = run([other, base("cheap")], [base("strong")])
+		expect(result.defects).toHaveLength(1)
+		expect(result.defects[0]).toMatchObject({ code: "meaning_drift_confirmed", drift_kind: "scope_widened", fragment: "worldwide", source_fragment: "North America" })
+	})
+})
+
+describe("ingestVerdicts: determinism", () => {
+	test("#given the same verdicts twice #when ingested #then both results are byte-for-byte equal", () => {
+		const cheap = [base("cheap"), { pair_id: "P2", verdict: "drift", drift_kind: "certainty_added", fragment: "will grow", source_fragment: "may grow", model_tier: "cheap" }, base("medium")]
+		const strong = [base("strong")]
+		const first = JSON.stringify(run(cheap, strong))
+		const second = JSON.stringify(run(cheap, strong))
+		expect(second).toBe(first)
+	})
+})
+
+describe("ingestVerdicts: unreadable verdict files", () => {
+	test("#given a missing verdict file #when ingested #then a short typed error names the file", () => {
+		const missing = join(dir, "absent.json")
+		expect(() => ingestVerdicts(PAIRS, [missing])).toThrow(TypeError)
+		expect(() => ingestVerdicts(PAIRS, [missing])).toThrow(/absent\.json: cannot read the verdict file/u)
+	})
+
+	test("#given invalid JSON #when ingested #then a short typed error names the file", () => {
+		const path = join(dir, "broken.json")
+		writeFileSync(path, "{ not json")
+		expect(() => ingestVerdicts(PAIRS, [path])).toThrow(/broken\.json: the verdict file is not valid JSON/u)
+	})
+})
+
+describe("ingestVerdicts: malformed pairs input", () => {
+	test("#given a missing or malformed pairs input #when ingested #then it refuses instead of reporting a clean result", () => {
+		for (const bad of [undefined, null, {}, { pairs: "P1" }, "pairs.json", 7]) {
+			expect(() => ingestVerdicts(bad as never, []), JSON.stringify(bad)).toThrow(TypeError)
+		}
+		expect(ingestVerdicts({ pairs: [] }, []).unverified).toEqual([])
+	})
+})
+
+describe("ingestVerdicts: the no-model contract", () => {
+	test("#given the module source #when read #then it never fetches or imports a network or model client", () => {
+		const text = readFileSync(join(import.meta.dir, "meaning-check.mjs"), "utf8")
+		expect(text).not.toMatch(/\bfetch\s*\(|node:https?|node:net|from\s+"(?!\.\/|node:)/u)
+	})
+})

package/dist/skills/ulw-research/scripts/numerals.mjs

@@ -0,0 +1,226 @@
+// numerals.mjs - shared numeral patterns and the numeral parser.
+//
+// NUM, UNIT, NOT_CLAIMS and CLAIMS are the claim-detection patterns the unsourced-number gate uses
+// (gates-text.mjs imports them from here). parseNumeral reads one numeral into an exact decimal
+// string: thousands separators, Korean and Latin scale words, percent and percentage points, the
+// English number words one to twelve, an adjacent currency symbol or unit, and an adjacent bounding
+// qualifier. No numeral is ever passed through Number(). Plain Node ESM, sibling imports only.
+
+import { add, fromDecimal, mul, toDecimal } from "./rational.mjs"
+import { normalizeUnit } from "./units.mjs"
+
+const MONTH = "(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\\.?"
+/** Stripped before claim detection: dates, versions, figure refs, times, bare years. */
+export const NOT_CLAIMS = [
+	/\b\d{4}[-./]\d{1,2}(?:[-./]\d{1,2})?\b/g,
+	/\b\d{2}\.\d{2}\.\d{2}\b/g,
+	/\d{2,4}\s*\uB144\s*\d{1,2}\s*\uC6D4(?:\s*\d{1,2}\s*\uC77C)?/g,
+	/\d{1,2}\s*\uC6D4(?:\s*\d{1,2}\s*\uC77C)?/g,
+	/(?:19|20)\d{2}\s*\uB144/g,
+	new RegExp(`\\b${MONTH}\\s+\\d{1,2}(?:st|nd|rd|th)?(?:,?\\s+\\d{4})?`, "gi"),
+	new RegExp(`\\b\\d{1,2}(?:st|nd|rd|th)?\\s+${MONTH}(?:\\s+\\d{4})?`, "gi"),
+	/\bv\d+(?:\.\d+)*\b|\b\d+(?:\.\d+){2,}\b/gi,
+	/\b(?:version|ver\.?|release)\s*\d+(?:\.\d+)*/gi,
+	/\b(?:fig(?:ure)?\.?|table|chart|section|step|phase|wave|part)\s*\d+(?:\.\d+)*/gi,
+	/(?:\uADF8\uB9BC|\uB3C4\uD45C|\uD45C|\uBC84\uC804)\s*\d+(?:\.\d+)*/g,
+	/\b\d{1,2}:\d{2}\b/g,
+	/\b(?:19|20)\d{2}s?\b/g,
+]
+export const NUM = "(?<![\\p{L}\\d.,])\\d+(?:[.,]\\d+)*"
+export const UNIT =
+	"(?:%|\\u2030|\\u00D7|\\uD37C\\uC13C\\uD2B8|\\uB2EC\\uB7EC|\\uC720\\uB85C|\\uC5D4|\\uC6D0|\\uB9CC|\\uC5B5|\\uC870|\\uCC9C|\\uCD08|\\uBD84|\\uC2DC\\uAC04|\\uC77C|\\uC8FC|\\uAC1C\\uC6D4|\\uB144|\\uBA85|\\uAC74|\\uAC1C|\\uD68C|\\uBC88|\\uBC30" +
+	"|(?:percent|pp|bps?|x|k|m|b|bn|million|billion|thousand|trillion|usd|krw|eur|ms|s|secs?|seconds?|mins?|minutes?|h|hrs?|hours?|days?|weeks?|months?|years?|kb|mb|gb|tb|users?|people|employees|engineers|tokens?|requests?|stars?|downloads?|customers?)(?![\\p{L}\\d]))"
+export const CLAIMS = [
+	new RegExp(`[$\\u20AC\\u00A3\\u00A5\\u20A9]\\s?${NUM}`, "u"),
+	new RegExp(`${NUM}\\s?${UNIT}`, "iu"),
+	/(?<![\d.,])\d{1,3}(?:,\d{3})+(?![\d,])/,
+	/(?<![\d.])\d+\.\d+(?![\d.])/,
+]
+
+const WORDS = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve"]
+const WORD_RE = new RegExp(`\\b(?:${WORDS.join("|")})\\b`, "gi")
+/** Korean scale words: cheon (1e3) inside a group, then man, eok, jo as group scales. */
+const CHEON = "\uCC9C"
+const BIG = new Map([["\uB9CC", 10000n], ["\uC5B5", 100000000n], ["\uC870", 1000000000000n]])
+/** A scale word that starts a longer word is not a scale: jogak (pieces), mankeum (as much as). */
+const KO_GROUP = /^(\s?)(?:(\uCC9C)?([\uB9CC\uC5B5\uC870])|(\uCC9C))(?![\uAC01\uD07C])/
+const KO_NEXT = new RegExp(`^\\s?(${NUM})(\uCC9C)?([\uB9CC\uC5B5\uC870])?`, "u")
+const LATIN_SCALE = /^(?:(k|K|M|bn|B)|\s(thousand|million|billion|trillion|bn))(?![\p{L}\d])/u
+const LATIN_FACTOR = { k: 1000n, K: 1000n, M: 1000000n, bn: 1000000000n, B: 1000000000n, thousand: 1000n, million: 1000000n, billion: 1000000000n, trillion: 1000000000000n }
+const CURRENCY = "$\u20AC\u00A3\u00A5\u20A9"
+const SYMBOL_UNIT = /^\s?(%p|%|\u2030|\u00D7|\u00B0C|\u00B0F|\u2103|\u2109)/
+const LATIN_UNIT = /^\s?([A-Za-z]+)(?![\p{L}\d])/u
+const HANGUL_UNIT = /^\s?([\uAC00-\uD7A3]+)/
+/** "3 bun-ui 1" is the fraction one third, not 3 minutes. */
+const FRACTION = /^\s?\uBD84\uC758\s?\d/
+const UNIT_AFTER = new RegExp(`^\\s?${UNIT}`, "iu")
+const NUM_AT = new RegExp(`^${NUM}`, "u")
+/** Range separators: hyphen, en dash, tilde, "to". */
+const RANGE_SEP = /^(?:\s?[-\u2013~]\s?|\sto\s)/
+const SIGN = "-\u2212"
+/** Bounding qualifiers: before the value (Korean and English) and right after it (Korean). */
+const QUALIFIERS_BEFORE = ["up to", "at least", "at most", "more than", "less than", "about", "approximately", "nearly", "over", "under", "\uCD5C\uB300", "\uCD5C\uC18C", "\uC57D"]
+const QUALIFIER_AFTER = /^\s?(\uC774\uC0C1|\uC774\uD558|\uBBF8\uB9CC|\uCD08\uACFC|\uB0B4\uC678|\uAE4C\uC9C0)/
+
+/** "1,237" -> "1237"; a malformed group ("1,23") keeps only the leading plain number. */
+function cleanDigits(raw) {
+	if (/^\d{1,3}(?:,\d{3})+(?:\.\d+)?$/.test(raw)) return { digits: raw.replace(/,/g, ""), length: raw.length }
+	const plain = /^\d+(?:\.\d+)?/.exec(raw)[0]
+	return { digits: plain, length: plain.length }
+}
+
+/** The bare-year and four-digit-date patterns: a numeral they cover can still be a value. */
+const YEAR_SHAPED = new Set([NOT_CLAIMS[0], NOT_CLAIMS[12]])
+
+function excludedRanges(text) {
+	const ranges = []
+	for (const re of NOT_CLAIMS) {
+		for (const match of text.matchAll(re)) ranges.push([match.index, match.index + match[0].length, YEAR_SHAPED.has(re)])
+	}
+	return ranges
+}
+
+/** A year-shaped numeral is a value when it has a decimal part or a currency, scale word or unit touches it. */
+function anchored(text, at, end, digits) {
+	if (digits.includes(".") || (at > 0 && CURRENCY.includes(text[at - 1]))) return true
+	return UNIT_AFTER.test(text.slice(end)) || unitAfter(text, end) !== null
+}
+
+/**
+ * First digit run or number word at or after `from` that no NOT_CLAIMS pattern covers. A year-shaped
+ * match exactly over the numeral (not "2020s", not "2020-03") is lifted when the numeral is anchored.
+ */
+function findStart(text, from, ranges) {
+	const covering = (at) => ranges.filter(([s, e]) => at >= s && at < e)
+	let digit = null
+	for (const match of text.slice(from).matchAll(new RegExp(NUM, "gu"))) {
+		const at = from + match.index
+		const candidate = { at, ...cleanDigits(match[0]) }
+		const end = at + candidate.length
+		const cover = covering(at)
+		const lifted = cover.every(([s, e, yearShaped]) => yearShaped && s === at && e <= end)
+		if (cover.length === 0 || (lifted && anchored(text, at, end, candidate.digits))) {
+			digit = candidate
+			break
+		}
+	}
+	const free = (at) => covering(at).length === 0
+	for (const match of text.slice(from).matchAll(WORD_RE)) {
+		const at = from + match.index
+		if (digit && digit.at < at) break
+		if (free(at)) return { at, digits: String(WORDS.indexOf(match[0].toLowerCase()) + 1), length: match[0].length }
+	}
+	return digit
+}
+
+/** Korean groups such as "4jo 2,000eok": each later group needs a smaller scale. */
+function koreanScale(text, at, digits) {
+	const first = KO_GROUP.exec(text.slice(at))
+	if (!first) return null
+	const big = first[3] ? BIG.get(first[3]) : 1n
+	const firstFactor = (first[2] || first[4] ? 1000n : 1n) * big
+	let value = mul(fromDecimal(digits), firstFactor)
+	let end = at + first[0].length
+	let last = first[3] ? big : 0n
+	let groups = 1
+	while (last > 1n) {
+		const next = KO_NEXT.exec(text.slice(end))
+		if (!next) break
+		const factor = (next[2] ? 1000n : 1n) * (next[3] ? BIG.get(next[3]) : 1n)
+		if (factor <= 1n || factor >= last) break
+		value = add(value, mul(fromDecimal(cleanDigits(next[1]).digits), factor))
+		end += next[0].length
+		last = next[3] ? BIG.get(next[3]) : 0n
+		groups++
+	}
+	return { value, end, factor: groups === 1 ? firstFactor : null }
+}
+
+/** Scale words after a numeral: { value (rational) | null, end, factor | null (one plain factor) }. */
+function scaled(text, end, digits) {
+	const korean = koreanScale(text, end, digits)
+	if (korean) return korean
+	const latin = LATIN_SCALE.exec(text.slice(end))
+	if (!latin) return { value: null, end, factor: null }
+	const factor = LATIN_FACTOR[latin[1] ?? latin[2].toLowerCase()]
+	return { value: mul(fromDecimal(digits), factor), end: end + latin[0].length, factor }
+}
+
+/** The second endpoint of "5-10", "5 to 10", "5~10" or "5\u201310", or null. */
+function rangeEnd(text, at, ranges) {
+	const sep = RANGE_SEP.exec(text.slice(at))
+	if (!sep) return null
+	const pos = at + sep[0].length
+	const num = NUM_AT.exec(text.slice(pos))
+	if (!num || ranges.some(([s, e]) => pos >= s && pos < e)) return null
+	const { digits, length } = cleanDigits(num[0])
+	const scale = scaled(text, pos + length, digits)
+	return { value: scale.value ? toDecimal(scale.value) : digits, end: scale.end, factor: scale.factor }
+}
+
+function unitAfter(text, at) {
+	const rest = text.slice(at)
+	if (FRACTION.test(rest)) return null
+	const symbol = SYMBOL_UNIT.exec(rest)
+	if (symbol) return { unitRaw: symbol[1], end: at + symbol[0].length }
+	const latin = LATIN_UNIT.exec(rest)
+	if (latin) return normalizeUnit(latin[1]) ? { unitRaw: latin[1], end: at + latin[0].length } : null
+	const hangul = HANGUL_UNIT.exec(rest)
+	if (!hangul) return null
+	const lead = hangul[0].length - hangul[1].length
+	for (let size = hangul[1].length; size > 0; size--) {
+		const candidate = hangul[1].slice(0, size)
+		if (!BIG.has(candidate) && candidate !== CHEON && normalizeUnit(candidate)) return { unitRaw: candidate, end: at + lead + size }
+	}
+	return null
+}
+
+function qualifierBefore(text, at) {
+	const tokens = text.slice(0, at).trim().split(/\s+/).slice(-2).map((token) => token.replace(/^[^\p{L}]+/u, ""))
+	for (const phrase of QUALIFIERS_BEFORE) {
+		const words = phrase.split(" ")
+		for (let skip = 0; skip + words.length <= tokens.length; skip++) {
+			const window = tokens.slice(tokens.length - skip - words.length, tokens.length - skip)
+			if (window.join(" ").toLowerCase() === phrase) return window.join(" ")
+		}
+	}
+	return null
+}
+
+/**
+ * The first numeral at or after `from`: { value, raw, span: [start, end], unitRaw, qualifierRaw },
+ * or null. `value` is an exact decimal string with scale words folded in ("3eok won" -> "300000000",
+ * unit "won") and a leading minus sign ("-" or U+2212) kept as "-"; `span` covers the sign, an
+ * adjacent currency symbol, the numeral, scale words and the unit. A range ("5-10 m", "5 to 10 m",
+ * "5~10%") adds `valueEnd` and `range: true`; the unit, and a scale word written only on the second
+ * endpoint ("3~5eok"), apply to both endpoints.
+ */
+export function parseNumeral(text, from = 0) {
+	const ranges = excludedRanges(text)
+	const found = findStart(text, from, ranges)
+	if (!found) return null
+	let start = found.at
+	const first = scaled(text, found.at + found.length, found.digits)
+	let value = first.value
+	let end = first.end
+	const second = rangeEnd(text, end, ranges)
+	if (second) {
+		end = second.end
+		if (!value && second.factor) value = mul(fromDecimal(found.digits), second.factor)
+	}
+	let unitRaw = null
+	if (start > 0 && CURRENCY.includes(text[start - 1])) [unitRaw, start] = [text[start - 1], start - 1]
+	const negative = start > 0 && SIGN.includes(text[start - 1]) && !/[\p{L}\p{N}]/u.test(text[start - 2] ?? "")
+	if (negative) start--
+	const unit = unitRaw ? null : unitAfter(text, end)
+	if (unit) [unitRaw, end] = [unit.unitRaw, unit.end]
+	const after = QUALIFIER_AFTER.exec(text.slice(end))
+	return {
+		value: (negative ? "-" : "") + (value ? toDecimal(value) : found.digits),
+		...(second ? { valueEnd: second.value, range: true } : {}),
+		raw: text.slice(start, end),
+		span: [start, end],
+		unitRaw,
+		qualifierRaw: qualifierBefore(text, start) ?? (after ? after[1] : null),
+	}
+}

package/dist/skills/ulw-research/scripts/numerals.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "bun:test"
+
+import { CLAIMS, NOT_CLAIMS, NUM, parseNumeral, UNIT } from "./numerals.mjs"
+import { normalizeUnit } from "./units.mjs"
+
+describe("shared claim patterns", () => {
+	test("exports the gate patterns", () => {
+		expect(typeof NUM).toBe("string")
+		expect(typeof UNIT).toBe("string")
+		expect(NOT_CLAIMS.length).toBe(13)
+		expect(CLAIMS.length).toBe(4)
+	})
+})
+
+describe("parseNumeral", () => {
+	test("a length with its unit", () => {
+		expect(parseNumeral("320 m")).toEqual({ value: "320", raw: "320 m", span: [0, 5], unitRaw: "m", qualifierRaw: null })
+		expect(parseNumeral("320 mm")?.unitRaw).toBe("mm")
+	})
+
+	test("thousands separators", () => {
+		const parsed = parseNumeral("we shipped 1,237 units")
+		expect(parsed?.value).toBe("1237")
+		expect(parsed?.span).toEqual([11, 16])
+	})
+
+	test("Korean scale words fold into the value and leave the currency unit", () => {
+		const parsed = parseNumeral("3억 원")
+		expect(parsed?.value).toBe("300000000")
+		expect(parsed?.raw).toBe("3억 원")
+		expect(normalizeUnit(parsed?.unitRaw as string)).toBe(normalizeUnit("원"))
+		expect(parseNumeral("4조 2,000억 원")?.value).toBe("4200000000000")
+		expect(parseNumeral("3천만 원")?.value).toBe("30000000")
+	})
+
+	test("Latin suffixes and scale words", () => {
+		expect(parseNumeral("1.2k")?.value).toBe("1200")
+		expect(parseNumeral("$3M")).toMatchObject({ value: "3000000", raw: "$3M", unitRaw: "$" })
+		expect(parseNumeral("2.5bn")?.value).toBe("2500000000")
+		expect(parseNumeral("$4B")?.value).toBe("4000000000")
+		expect(parseNumeral("3 million users")?.value).toBe("3000000")
+		expect(parseNumeral("5 km")).toMatchObject({ value: "5", unitRaw: "km" })
+	})
+
+	test("percent and percentage points stay distinct", () => {
+		expect(parseNumeral("15.2%")).toMatchObject({ value: "15.2", unitRaw: "%" })
+		expect(parseNumeral("2%p")).toMatchObject({ value: "2", unitRaw: "%p" })
+	})
+
+	test("long decimals keep every digit", () => {
+		expect(parseNumeral("10000000000000000.1")?.value).toBe("10000000000000000.1")
+	})
+
+	test("English number words one to twelve only", () => {
+		expect(parseNumeral("three engineers")?.value).toBe("3")
+		expect(parseNumeral("Twelve")?.value).toBe("12")
+		expect(parseNumeral("thirteen")).toBeNull()
+	})
+
+	test("qualifiers before and after the value", () => {
+		expect(parseNumeral("최대 4조 2,000억 원")).toMatchObject({ value: "4200000000000", qualifierRaw: "최대", span: [3, 14] })
+		expect(parseNumeral("up to 320 m")?.qualifierRaw).toBe("up to")
+		expect(parseNumeral("320 m 이상")?.qualifierRaw).toBe("이상")
+		expect(parseNumeral("the 320 m mast")?.qualifierRaw).toBeNull()
+	})
+
+	test("dates, versions and figure references are not numerals", () => {
+		expect(parseNumeral("v2.3.1")).toBeNull()
+		expect(parseNumeral("see figure 3")).toBeNull()
+		expect(parseNumeral("2026-10-23")).toBeNull()
+		expect(parseNumeral("v2.3.1 shipped 40 fixes")?.value).toBe("40")
+	})
+
+	test("year-shaped values next to a currency, scale word or unit, or with a decimal part, are numerals", () => {
+		expect(parseNumeral("2000억 원")).toMatchObject({ value: "200000000000", unitRaw: "원" })
+		expect(parseNumeral("1900만 원")).toMatchObject({ value: "19000000", unitRaw: "원" })
+		expect(parseNumeral("2050명")).toMatchObject({ value: "2050", unitRaw: "명" })
+		expect(parseNumeral("$2000")).toMatchObject({ value: "2000", raw: "$2000", unitRaw: "$" })
+		expect(parseNumeral("1999 users")?.value).toBe("1999")
+		expect(parseNumeral("1234.56 m")).toMatchObject({ value: "1234.56", unitRaw: "m" })
+		expect(parseNumeral("$1500.25")).toMatchObject({ value: "1500.25", unitRaw: "$" })
+		expect(parseNumeral("2020.5억")?.value).toBe("202050000000")
+	})
+
+	test("bare years and dates stay excluded", () => {
+		expect(parseNumeral("in 2020")).toBeNull()
+		expect(parseNumeral("2020-03-01")).toBeNull()
+		expect(parseNumeral("the 2020s")).toBeNull()
+		expect(parseNumeral("in 2020, 5 users")?.value).toBe("5")
+	})
+
+	test("a leading minus sign is part of the value and the span", () => {
+		expect(parseNumeral("-5%")).toMatchObject({ value: "-5", raw: "-5%", span: [0, 3], unitRaw: "%" })
+		expect(parseNumeral("fell \u22123.2%")).toMatchObject({ value: "-3.2", span: [5, 10], unitRaw: "%" })
+		expect(parseNumeral("COVID-19 cases")?.value).toBe("19")
+	})
+
+	test("ranges carry both endpoints and share the unit", () => {
+		expect(parseNumeral("5-10 m")).toMatchObject({ value: "5", valueEnd: "10", range: true, raw: "5-10 m", span: [0, 6], unitRaw: "m" })
+		expect(parseNumeral("5 to 10 m")).toMatchObject({ value: "5", valueEnd: "10", range: true, raw: "5 to 10 m", unitRaw: "m" })
+		expect(parseNumeral("5~10%")).toMatchObject({ value: "5", valueEnd: "10", range: true, unitRaw: "%" })
+		expect(parseNumeral("5\u201310%")).toMatchObject({ value: "5", valueEnd: "10", range: true, unitRaw: "%" })
+		expect(parseNumeral("3~5억 원")).toMatchObject({ value: "300000000", valueEnd: "500000000", range: true, unitRaw: "원" })
+		expect(parseNumeral("320 m")).not.toHaveProperty("valueEnd")
+	})
+
+	test("Korean scale words and units need a word boundary", () => {
+		expect(parseNumeral("5조각")).toMatchObject({ value: "5", raw: "5", unitRaw: null })
+		expect(parseNumeral("3분의 1")).toMatchObject({ value: "3", raw: "3", unitRaw: null })
+		expect(parseNumeral("3분의 휴식")?.unitRaw).toBe("분")
+		expect(parseNumeral("매출 10억은")?.value).toBe("1000000000")
+	})
+
+	test("from skips earlier numerals", () => {
+		const text = "320 m and 15%"
+		const first = parseNumeral(text)
+		expect(parseNumeral(text, first?.span[1])).toMatchObject({ value: "15", unitRaw: "%" })
+		expect(parseNumeral("no numbers here")).toBeNull()
+	})
+})

package/dist/skills/ulw-research/scripts/outcome.mjs

@@ -1,12 +1,10 @@
-// outcome.mjs - the per-run outcome manifest (`outcome.json`) and the closing briefing.
-// Manifest functions are pure (they return a new manifest); the briefing reads only the
-// manifest, the sources-ledger text, and an injected `now`. node: builtins only.
+// outcome.mjs - the per-run outcome manifest (`outcome.json`) and the closing briefing. Manifest functions are pure (they return a new manifest).
+// The briefing reads only the manifest, the sources-ledger text, and an injected `now`. node: builtins only.
 
 import * as nodeFs from "node:fs"
 import { basename, dirname, join } from "node:path"
 
-import { DELIVERABLE_FORMATS, DELIVERABLE_STATUSES, GATE_NAMES, GATE_STATUSES, LANES } from "./contracts.mjs"
-import { MANIFEST_CODES, SCHEMA_VERSION, validateOutcomeManifest } from "./contracts.mjs"
+import { DELIVERABLE_FORMATS, DELIVERABLE_STATUSES, GATE_NAMES, GATE_STATUSES, LANES, MANIFEST_CODES, normalizeManifest, SCHEMA_VERSION, validateOutcomeManifest } from "./contracts.mjs"
 
 export const MANIFEST_FILENAME = "outcome.json"
 const MISSING = MANIFEST_CODES[0]
@@ -87,7 +85,7 @@ export function setDeliverable(manifest, format, status, detail = {}) {
 	const next = clone(manifest)
 	const index = next.deliverables.findIndex((row) => row.format === format)
 	const row = { format, status, promised: index >= 0 ? next.deliverables[index].promised : false, updatedAt: stamp(detail.now) }
-	for (const key of ["path", "reason", "pages", "bytes"]) {
+	for (const key of ["path", "reason", "pages", "bytes", "verifiedBy", "renderedFrom"]) {
 		if (detail[key] !== undefined) row[key] = detail[key]
 	}
 	if (index >= 0) next.deliverables[index] = row
@@ -95,11 +93,13 @@ export function setDeliverable(manifest, format, status, detail = {}) {
 	return next
 }
 
-export function setGate(manifest, gate, status) {
+export function setGate(manifest, gate, status, detail = {}) {
 	assertOneOf("unknown_gate", "gate", gate, GATE_NAMES)
 	assertOneOf("unknown_gate_status", "gate status", status, GATE_STATUSES)
+	if (gate === "fidelity" && status === "not_run" && (typeof detail.reason !== "string" || !detail.reason.trim())) throw new OutcomeError("gate_reason_required", "fidelity not_run requires a non-empty --reason")
 	const next = clone(manifest)
 	next.gates[gate] = status
+	next.gateHistory = [...(next.gateHistory ?? []), { gate, status, ...(detail.reason !== undefined ? { reason: detail.reason.trim() } : {}), at: stamp(detail.now) }]
 	return next
 }
 
@@ -226,7 +226,7 @@ function assertValid(manifest, where) {
 export function readManifest(file) {
 	let manifest
 	try {
-		manifest = JSON.parse(nodeFs.readFileSync(file, "utf8"))
+		manifest = normalizeManifest(JSON.parse(nodeFs.readFileSync(file, "utf8")))
 	} catch (error) {
 		if (error instanceof SyntaxError) throw new OutcomeError("invalid_manifest", `${file}: not valid JSON (${error.message})`)
 		throw error

package/dist/skills/ulw-research/scripts/outcome.test.ts

@@ -258,6 +258,35 @@ describe("readManifest and writeManifest", () => {
 		writeFileSync(file, "{not json")
 		expect(() => readManifest(file)).toThrow(OutcomeError)
 	})
+
+	test("#given a manifest file written before the fidelity gate (four gates) #when read and written back #then it loads and the file gains fidelity not_run", () => {
+		// given
+		const dir = sessionDir()
+		const file = join(dir, MANIFEST_FILENAME)
+		const old = {
+			schemaVersion: 1,
+			sessionDir: dir,
+			startedAt: START_LOCAL.toISOString(),
+			finishedAt: null,
+			elapsedMinutes: null,
+			lane: "no-format",
+			interview: null,
+			deliverables: [{ format: "pdf", status: "pending", promised: true, updatedAt: START_LOCAL.toISOString() }],
+			renders: [],
+			gates: { static: "pass", layout: "not_run", visual: "fail", proofread: "not_run" },
+			residualDefects: [],
+			repair: null,
+			sources: null,
+		}
+		writeFileSync(file, JSON.stringify(old))
+		// when
+		const manifest = readManifest(file)
+		writeManifest(file, manifest)
+		// then
+		const written = JSON.parse(readFileSync(file, "utf8"))
+		expect(written.gates).toEqual({ static: "pass", fidelity: "not_run", layout: "not_run", visual: "fail", proofread: "not_run" })
+		expect(written.schemaVersion).toBe(1)
+	})
 })
 
 describe("round trip in a stamped session dir", () => {