lazycodex-ai 5.1.43 → 5.1.45

package/packages/shared-skills/skills/ulw-research/scripts/particles-ko.mjs

@@ -0,0 +1,108 @@
+// Korean particle normalization after a filled value: read the value's final sound, then pick the
+// particle form. Hangul and the particle table are \u escapes (this directory ships no Hangul).
+
+// Unit token -> reading of its Korean name. Duplicated from the planned units.koreanReadingOf so this
+// module has no dependency on a sibling not yet landed; the units module reconciles the two tables.
+// Hangul unit words (won, dalleo, jo, eok, ...) need no row: they are read by code point.
+const UNIT_READINGS = new Map([
+	["%", "open"], // peosenteu
+	["%p", "open"], // peosenteu pointeu
+	["pp", "open"], // peosenteu pointeu
+	["m", "open"], // miteo
+	["mm", "open"], // millimiteo
+	["cm", "open"], // sentimiteo
+	["km", "open"], // killomiteo
+	["kg", "closed"], // killogeuraem
+	["g", "closed"], // geuraem
+	["t", "closed"], // ton
+	["s", "open"], // cho
+	["ms", "open"], // millicho
+	["min", "closed"], // bun
+	["h", "closed"], // sigan
+	["B", "open"], // baiteu
+	["KB", "open"], // killobaiteu
+	["MB", "open"], // megabaiteu
+	["GB", "open"], // gigabaiteu
+	["TB", "open"], // terabaiteu
+	["C", "open"], // do
+	["\u00B0C", "open"], // do
+	["F", "open"], // do
+	["\u00B0F", "open"], // do
+	["USD", "open"], // dalleo
+	["$", "open"], // dalleo
+	["KRW", "closed"], // won
+	["EUR", "open"], // yuro
+	["JPY", "closed"], // en
+	["x", "open"], // bae
+	["\u00D7", "open"], // bae
+])
+
+// Sino-Korean digit readings: yeong il i sam sa o yuk chil pal gu.
+const DIGIT_READINGS = Object.freeze(["closed", "l", "open", "closed", "open", "open", "closed", "l", "l", "open"])
+
+// Spoken ending of a power of ten beyond the units digit: sip baek cheon, then the 10^4 group markers
+// man eok jo gyeong. Only jo (10^12) is open.
+const TEN_POWER_READINGS = Object.freeze(["closed", "closed", "closed"])
+const GROUP_READINGS = Object.freeze({ 4: "closed", 8: "closed", 12: "open", 16: "closed" })
+
+// [particle, form after an open vowel, form after final l, form after another final consonant]
+const PARTICLES = Object.freeze([
+	Object.freeze(["\uC73C\uB85C", "\uB85C", "\uB85C", "\uC73C\uB85C"]),
+	Object.freeze(["\uB85C", "\uB85C", "\uB85C", "\uC73C\uB85C"]),
+	Object.freeze(["\uC740", "\uB294", "\uC740", "\uC740"]),
+	Object.freeze(["\uB294", "\uB294", "\uC740", "\uC740"]),
+	Object.freeze(["\uC774", "\uAC00", "\uC774", "\uC774"]),
+	Object.freeze(["\uAC00", "\uAC00", "\uC774", "\uC774"]),
+	Object.freeze(["\uC744", "\uB97C", "\uC744", "\uC744"]),
+	Object.freeze(["\uB97C", "\uB97C", "\uC744", "\uC744"]),
+	Object.freeze(["\uC640", "\uC640", "\uACFC", "\uACFC"]),
+	Object.freeze(["\uACFC", "\uC640", "\uACFC", "\uACFC"]),
+])
+const FORM_INDEX = Object.freeze({ open: 1, l: 2, closed: 3 })
+
+const HANGUL_FIRST = 0xac00
+const HANGUL_LAST = 0xd7a3
+const BOUNDARY = /^[\s\p{P}]/u
+const TRAILING_DIGITS = /([0-9][0-9,]*)(?:\.([0-9]+))?$/
+
+function hangulReading(char) {
+	const code = char.codePointAt(0)
+	if (code === undefined || code < HANGUL_FIRST || code > HANGUL_LAST) return null
+	const finalConsonant = (code - HANGUL_FIRST) % 28
+	if (finalConsonant === 0) return "open"
+	return finalConsonant === 8 ? "l" : "closed"
+}
+
+function numberReading(text) {
+	const match = TRAILING_DIGITS.exec(text)
+	if (!match) return null
+	// Decimals read digit by digit: 6.50 ends on yeong, so a trailing 0 after the point is closed.
+	if (match[2] !== undefined) return DIGIT_READINGS[Number(match[2].at(-1))]
+	const digits = match[1].replaceAll(",", "")
+	const trailingZeros = digits.length - digits.replace(/0+$/, "").length
+	if (trailingZeros === 0 || trailingZeros === digits.length) return DIGIT_READINGS[Number(digits.at(-1))]
+	// From 10^4 up the spoken end is the last non-zero group word (sipjo ends on jo), not sip/baek/cheon.
+	if (trailingZeros >= 4) return GROUP_READINGS[trailingZeros - (trailingZeros % 4)] ?? null
+	return TEN_POWER_READINGS[trailingZeros - 1]
+}
+
+export function finalReading(valueText, unitToken) {
+	if (unitToken !== null && unitToken !== undefined) return UNIT_READINGS.get(unitToken) ?? hangulReading(unitToken.at(-1) ?? "")
+	const text = valueText.trimEnd()
+	const last = text.at(-1)
+	if (last === undefined) return null
+	const hangul = hangulReading(last)
+	if (hangul !== null) return hangul
+	if (last >= "0" && last <= "9") return numberReading(text)
+	const token = /[^\s0-9.,]+$/u.exec(text)?.[0] ?? ""
+	return UNIT_READINGS.get(token) ?? null
+}
+
+export function rewriteParticle(following, reading) {
+	const entry = PARTICLES.find(([particle]) => following.startsWith(particle))
+	if (entry === undefined) return { text: following, applied: false, candidate: false }
+	const rest = following.slice(entry[0].length)
+	const index = FORM_INDEX[reading]
+	if ((rest !== "" && !BOUNDARY.test(rest)) || index === undefined) return { text: following, applied: false, candidate: true }
+	return { text: entry[index] + rest, applied: true, candidate: true }
+}

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

@@ -0,0 +1,86 @@
+import { describe, expect, test } from "bun:test"
+
+import { finalReading, rewriteParticle } from "./particles-ko.mjs"
+
+describe("finalReading", () => {
+	test("given a value ending in a Hangul syllable when read then the final consonant decides", () => {
+		expect(finalReading("3조 8,000억 원", null)).toBe("closed")
+		expect(finalReading("5조", null)).toBe("open")
+		expect(finalReading("7달", null)).toBe("l")
+	})
+
+	test("given a value ending in a unit token when read then the unit's Korean reading decides", () => {
+		expect(finalReading("15.2%", null)).toBe("open")
+		expect(finalReading("3.1%p", null)).toBe("open")
+		expect(finalReading("320 m", null)).toBe("open")
+		expect(finalReading("12 kg", null)).toBe("closed")
+	})
+
+	test("given a value ending in a digit when read then the Sino-Korean reading decides", () => {
+		expect(finalReading("4,200", null)).toBe("closed")
+		expect(finalReading("1", null)).toBe("l")
+		expect(finalReading("2", null)).toBe("open")
+		expect(finalReading("3", null)).toBe("closed")
+		expect(finalReading("7", null)).toBe("l")
+		expect(finalReading("8", null)).toBe("l")
+		expect(finalReading("9", null)).toBe("open")
+		expect(finalReading("6.5", null)).toBe("open")
+	})
+
+	test("given an integer whose spoken end is jo when read then the magnitude decides, not the last zero", () => {
+		expect(finalReading("1000000000000", null)).toBe("open")
+		expect(finalReading("10,000", null)).toBe("closed")
+	})
+
+	test("given a round integer past one jo when read then the last 10^4 group word decides, not sip/baek/cheon", () => {
+		expect(finalReading("10000000000000", null)).toBe("open")
+		expect(finalReading("100000000000000", null)).toBe("open")
+		expect(finalReading("1000000000000000", null)).toBe("open")
+		expect(finalReading("100000", null)).toBe("closed")
+		expect(finalReading("1000000000", null)).toBe("closed")
+	})
+
+	test("given an explicit unit token when read then it overrides the value text", () => {
+		expect(finalReading("15.2", "%")).toBe("open")
+		expect(finalReading("15", "kg")).toBe("closed")
+	})
+
+	test("given an unknown trailing token when read then no reading is claimed", () => {
+		expect(finalReading("12 zorks", null)).toBeNull()
+	})
+})
+
+describe("rewriteParticle", () => {
+	test("given an object particle with a boundary after an open value when rewritten then it becomes the open form", () => {
+		expect(rewriteParticle("을 기록", "open")).toEqual({ text: "를 기록", applied: true, candidate: true })
+	})
+
+	test("given a bare particle at end of string when rewritten then it is applied", () => {
+		expect(rewriteParticle("은", "open")).toEqual({ text: "는", applied: true, candidate: true })
+	})
+
+	test("given a particle-like prefix with no boundary when rewritten then it stays untouched and is flagged as a candidate", () => {
+		expect(rewriteParticle("이상 기록", "closed")).toEqual({ text: "이상 기록", applied: false, candidate: true })
+		expect(rewriteParticle("이상.", "open")).toEqual({ text: "이상.", applied: false, candidate: true })
+	})
+
+	test("given English or a non-particle word when rewritten then nothing changes and it is not a candidate", () => {
+		expect(rewriteParticle(" is the span", "open")).toEqual({ text: " is the span", applied: false, candidate: false })
+		expect(rewriteParticle("기록했다", "open")).toEqual({ text: "기록했다", applied: false, candidate: false })
+	})
+
+	test("given each particle pair when rewritten then the reading picks the form", () => {
+		expect(rewriteParticle("이 올랐다", "open").text).toBe("가 올랐다")
+		expect(rewriteParticle("가 올랐다", "closed").text).toBe("이 올랐다")
+		expect(rewriteParticle("는,", "l").text).toBe("은,")
+		expect(rewriteParticle("과 함께", "open").text).toBe("와 함께")
+		expect(rewriteParticle("와 함께", "l").text).toBe("과 함께")
+		expect(rewriteParticle("로 늘었다", "closed").text).toBe("으로 늘었다")
+		expect(rewriteParticle("으로 늘었다", "l").text).toBe("로 늘었다")
+		expect(rewriteParticle("으로 늘었다", "open").text).toBe("로 늘었다")
+	})
+
+	test("given no reading when rewritten then a candidate is left unchanged", () => {
+		expect(rewriteParticle("을 기록", null)).toEqual({ text: "을 기록", applied: false, candidate: true })
+	})
+})

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)
+}

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

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test"
+
+import { add, div, eq, fromDecimal, mul, sigFigsOf, sub, toDecimal } from "./rational.mjs"
+
+describe("rational", () => {
+	test("keeps every digit of a long decimal through multiplication", () => {
+		const product = mul(fromDecimal("10000000000000000.1"), fromDecimal("3"))
+		expect(toDecimal(product)).toBe("30000000000000000.3")
+	})
+
+	test("rounds a recurring quotient to the requested significant figures", () => {
+		expect(toDecimal(div(fromDecimal("1"), fromDecimal("3")), 3)).toBe("0.333")
+		expect(toDecimal(div(fromDecimal("2"), fromDecimal("3")), 2)).toBe("0.67")
+		expect(toDecimal(fromDecimal("319999"), 2)).toBe("320000")
+		expect(toDecimal(fromDecimal("-2.5"), 1)).toBe("-3")
+	})
+
+	test("refuses an exact decimal for a recurring value", () => {
+		expect(() => toDecimal(div(fromDecimal("1"), fromDecimal("3")))).toThrow(RangeError)
+	})
+
+	test("add, sub and eq work on reduced fractions", () => {
+		const third = div(fromDecimal("1"), fromDecimal("3"))
+		expect(eq(add(third, add(third, third)), fromDecimal("1"))).toBe(true)
+		expect(toDecimal(sub(fromDecimal("0.3"), fromDecimal("0.1")))).toBe("0.2")
+		expect(eq(fromDecimal("1.50"), fromDecimal("1.5"))).toBe(true)
+		expect(eq(fromDecimal("1.5"), fromDecimal("1.6"))).toBe(false)
+	})
+
+	test("never routes values through floating point", () => {
+		const r = fromDecimal("0.1")
+		expect(typeof r.num).toBe("bigint")
+		expect(typeof r.den).toBe("bigint")
+		expect(() => fromDecimal("1e3")).toThrow()
+		expect(() => div(fromDecimal("1"), fromDecimal("0"))).toThrow(RangeError)
+	})
+
+	test("counts significant figures: decimals from the first nonzero digit, integers every digit", () => {
+		expect(sigFigsOf("3.2")).toBe(2)
+		expect(sigFigsOf("0.050")).toBe(2)
+		expect(sigFigsOf("320")).toBe(3)
+		expect(sigFigsOf("100")).toBe(3)
+		expect(sigFigsOf("20")).toBe(2)
+		expect(sigFigsOf("-1.0")).toBe(2)
+	})
+})

package/packages/shared-skills/skills/ulw-research/scripts/report-tools-commands.mjs

@@ -5,7 +5,7 @@ import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs"
 import { dirname, join, resolve } from "node:path"
 
 import { CliError, parseArgs, readJsonFile, writeJsonAtomic } from "./cli-support.mjs"
-import { REPAIR_DEFAULTS } from "./contracts.mjs"
+import { GATE_NAMES, GATE_STATUSES, REPAIR_DEFAULTS } from "./contracts.mjs"
 import { parseLineageMode, parsePalette, renderDesignSpec } from "./design-spec.mjs"
 import { extractFromHtml, extractFromPath, fetchHtml } from "./format-extract.mjs"
 import { checkLayout } from "./gates-layout.mjs"
@@ -149,7 +149,7 @@ export function runOutcome(argv) {
 		}
 		case "gate": {
 			const [gate, status] = args.positionals
-			if (!gate || !status) throw new CliError("usage: outcome gate <static|layout|visual|proofread> <pass|fail|not_run>")
+			if (!gate || !status) throw new CliError(`usage: outcome gate <${GATE_NAMES.join("|")}> <${GATE_STATUSES.join("|")}>`)
 			outcome.writeManifest(file, outcome.setGate(outcome.readManifest(file), gate, status))
 			return { json: { command: "outcome gate", gate, status }, exitCode: 0 }
 		}

package/packages/shared-skills/skills/ulw-research/scripts/sentence-split.mjs

@@ -0,0 +1,77 @@
+// sentence-split.mjs - deterministic sentence index for snapshot text.
+//
+// splitSentences(text) returns [{ sid, start, end, text }] with sid "s<k>" (1-based) and
+// start/end as offsets into the raw text, so text.slice(start, end) === record.text.
+// Boundaries: a line break; ". ! ?" followed by whitespace or end of line (known
+// abbreviations such as "e.g." excepted); and the Korean endings da. yo. nida. kka? even
+// with no following space, unless closing punctuation follows (quoted speech such as
+// '...da."rago' then needs whitespace like any other terminator). "no." is an abbreviation
+// only before a number ("No. 5"). Plain Node ESM, no dependencies.
+
+import { normalizeText } from "./text-normalize.mjs"
+
+const TERMINATORS = ".!?"
+const CLOSERS = "\"')]}\u201D\u2019\u00BB\u300D\u300F"
+const KOREAN_PERIOD_ENDINGS = new Set(["\uB2E4", "\uC694"]) // da, yo (nida ends in da)
+const KOREAN_QUESTION_ENDING = "\uAE4C" // kka
+const ABBREVIATIONS = new Set([
+	"e.g", "i.e", "etc", "vs", "cf", "approx", "al", "fig", "no", "mr", "mrs", "ms", "dr", "prof", "inc", "ltd", "jr", "sr",
+])
+const SPACE = /\s/u
+
+function isKoreanEnding(line, at) {
+	const prev = line[at - 1]
+	if (line[at] === ".") return KOREAN_PERIOD_ENDINGS.has(prev)
+	return line[at] === "?" && prev === KOREAN_QUESTION_ENDING
+}
+
+function isAbbreviation(line, from, at) {
+	let k = at
+	while (k > from && !SPACE.test(line[k - 1])) k--
+	const word = line.slice(k, at).replace(/^[("'[]+/u, "").toLowerCase()
+	if (word === "no") return /^\s*\d/u.test(line.slice(at + 1))
+	return ABBREVIATIONS.has(word)
+}
+
+function pushSegment(line, base, from, to, out) {
+	let start = from
+	let end = to
+	while (start < end && SPACE.test(line[start])) start++
+	while (end > start && SPACE.test(line[end - 1])) end--
+	const text = line.slice(start, end)
+	if (normalizeText(text) === "") return
+	out.push({ sid: `s${out.length + 1}`, start: base + start, end: base + end, text })
+}
+
+function splitLine(line, base, out) {
+	let from = 0
+	for (let i = 0; i < line.length; i++) {
+		if (!TERMINATORS.includes(line[i])) continue
+		let j = i + 1
+		while (j < line.length && (TERMINATORS.includes(line[j]) || CLOSERS.includes(line[j]))) j++
+		const atBreak = j >= line.length || SPACE.test(line[j])
+		const closed = [...line.slice(i + 1, j)].some((c) => CLOSERS.includes(c))
+		const korean = !closed && isKoreanEnding(line, i)
+		const abbreviation = line[i] === "." && !korean && isAbbreviation(line, from, i)
+		if ((atBreak || korean) && !abbreviation) {
+			pushSegment(line, base, from, j, out)
+			from = j
+		}
+		i = j - 1
+	}
+	pushSegment(line, base, from, line.length, out)
+}
+
+export function splitSentences(text) {
+	const source = String(text ?? "")
+	const out = []
+	let base = 0
+	while (base <= source.length) {
+		const newline = source.indexOf("\n", base)
+		const stop = newline === -1 ? source.length : newline
+		splitLine(source.slice(base, stop), base, out)
+		if (newline === -1) break
+		base = newline + 1
+	}
+	return out
+}

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

@@ -0,0 +1,109 @@
+import { describe, expect, test } from "bun:test"
+
+import { splitSentences } from "./sentence-split.mjs"
+
+type Sentence = { sid: string; start: number; end: number; text: string }
+
+function at(records: Sentence[], index: number): Sentence {
+	const record = records[index]
+	if (record === undefined) throw new Error(`no sentence at index ${index}`)
+	return record
+}
+
+function expectSlices(text: string, records: Sentence[]): void {
+	for (const record of records) expect(text.slice(record.start, record.end)).toBe(record.text)
+}
+
+describe("splitSentences", () => {
+	test("#given a Korean paragraph with da/yo/nida endings #when split #then sids and offsets match each sentence", () => {
+		// given
+		const text = "매출은 100억 원입니다. 비용도 늘었어요. 이익은 줄었다.다만 회복이 기대된다."
+		// when
+		const records = splitSentences(text) as Sentence[]
+		// then
+		expect(records.map((r) => r.sid)).toEqual(["s1", "s2", "s3", "s4"])
+		expect(records.map((r) => r.text)).toEqual([
+			"매출은 100억 원입니다.",
+			"비용도 늘었어요.",
+			"이익은 줄었다.",
+			"다만 회복이 기대된다.",
+		])
+		expect(at(records, 1).start).toBe(text.indexOf("비용도"))
+		expectSlices(text, records)
+	})
+
+	test("#given an English paragraph with abbreviations and decimals #when split #then e.g. and 3.2 do not end a sentence", () => {
+		// given
+		const text = "Use units, e.g. 3.2 m per bar. The next one follows! Is it fine? Yes."
+		// when
+		const records = splitSentences(text) as Sentence[]
+		// then
+		expect(records.map((r) => r.sid)).toEqual(["s1", "s2", "s3", "s4"])
+		expect(records.map((r) => r.text)).toEqual([
+			"Use units, e.g. 3.2 m per bar.",
+			"The next one follows!",
+			"Is it fine?",
+			"Yes.",
+		])
+		expect(at(records, 3).start).toBe(text.indexOf("Yes."))
+		expect(at(records, 3).end).toBe(text.length)
+		expectSlices(text, records)
+	})
+
+	test("#given line breaks and blank lines #when split #then each non-empty line yields its own record", () => {
+		// given
+		const text = "매출은 100억 원이다. 다만 아직 확정되지 않았다.\n\n  Second line without stop\nThird?"
+		// when
+		const records = splitSentences(text) as Sentence[]
+		// then
+		expect(records.map((r) => r.text)).toEqual([
+			"매출은 100억 원이다.",
+			"다만 아직 확정되지 않았다.",
+			"Second line without stop",
+			"Third?",
+		])
+		expect(records.map((r) => r.sid)).toEqual(["s1", "s2", "s3", "s4"])
+		expectSlices(text, records)
+	})
+
+	test("#given Korean quoted speech closed right after a da ending #when split #then the quote stays inside one sentence", () => {
+		// given
+		const single = '그는 "매출이 늘었다."라고 말했다.'
+		const pair = '그는 "매출이 늘었다."라고 말했다. 다음 날 떨어졌다.'
+		const bracket = "그는 「좋아요.」라고 답했다."
+		// when
+		const singleRecords = splitSentences(single) as Sentence[]
+		const pairRecords = splitSentences(pair) as Sentence[]
+		const bracketRecords = splitSentences(bracket) as Sentence[]
+		// then
+		expect(singleRecords.map((r) => r.text)).toEqual([single])
+		expect(pairRecords.map((r) => r.text)).toEqual(['그는 "매출이 늘었다."라고 말했다.', "다음 날 떨어졌다."])
+		expect(pairRecords.map((r) => r.sid)).toEqual(["s1", "s2"])
+		expect(at(pairRecords, 0).start).toBe(0)
+		expect(at(pairRecords, 1).start).toBe(pair.indexOf("다음 날"))
+		expect(at(pairRecords, 1).end).toBe(pair.length)
+		expect(bracketRecords.map((r) => r.text)).toEqual([bracket])
+		expectSlices(pair, pairRecords)
+	})
+
+	test("#given the word no #when split #then it is an abbreviation only before a number", () => {
+		// given
+		const answer = "The answer was no. Then we left."
+		const numbered = "See No. 5 for details. Then stop."
+		// when
+		const answerRecords = splitSentences(answer) as Sentence[]
+		const numberedRecords = splitSentences(numbered) as Sentence[]
+		// then
+		expect(answerRecords.map((r) => r.text)).toEqual(["The answer was no.", "Then we left."])
+		expect(at(answerRecords, 1).start).toBe(answer.indexOf("Then"))
+		expect(numberedRecords.map((r) => r.text)).toEqual(["See No. 5 for details.", "Then stop."])
+		expectSlices(answer, answerRecords)
+		expectSlices(numbered, numberedRecords)
+	})
+
+	test("#given empty or whitespace-only text #when split #then no records are produced", () => {
+		// when / then
+		expect(splitSentences("")).toEqual([])
+		expect(splitSentences(" \n\t\n")).toEqual([])
+	})
+})

package/packages/shared-skills/skills/ulw-research/scripts/tests/fixtures/fidelity/claim-graph.md

@@ -0,0 +1,13 @@
+# Claim graph
+
+## verified-claims
+
+- C1: The bridge span is up to 320 m.
+
+## Claims
+
+| claim_id | statement | claim type | risk tier | status | final synthesis location |
+|---|---|---|---|---|---|
+| C1 | The bridge span is up to 320 m. | factual | high | supported | findings |
+| C2 | Revenue grew about 10 percent in 2025. | factual | normal | partial | findings |
+| C3 | The project finished ahead of schedule. | factual | high | refuted | gaps |

package/packages/shared-skills/skills/ulw-research/scripts/tests/fixtures/fidelity-brief-locked.md

@@ -0,0 +1,17 @@
+# Brief
+
+## Deliverable
+format: pdf (answered_by: request)
+
+## Fidelity
+as of: latest at run start, 2026-10-23 (answered_by: default)
+meaning check: on (answered_by: default)
+source floor: standard (answered_by: default)
+derived numbers: allowed (answered_by: user)
+languages: report ko; sources ko, en; quotes original with translation beside (answered_by: default)
+identifier classes: version strings, package names, commit ids (answered_by: default)
+fallback: block-quote (answered_by: request)
+asked: derived numbers
+
+## Notes
+free text that is not part of the block

package/packages/shared-skills/skills/ulw-research/scripts/tests/fixtures/fidelity-brief-pending.md

@@ -0,0 +1,17 @@
+# Brief
+
+## Deliverable
+format: pdf (answered_by: request)
+
+## Fidelity
+as of: latest at run start, 2026-10-23 (answered_by: default)
+meaning check: on (answered_by: default)
+source floor: standard (answered_by: default)
+derived numbers: pending (answered_by: pending)
+languages: report ko; sources ko, en; quotes original with translation beside (answered_by: default)
+identifier classes: version strings, package names, commit ids (answered_by: default)
+fallback: block-quote (answered_by: request)
+asked: derived numbers
+
+## Notes
+free text that is not part of the block