oh-my-opencode 5.1.48 → 5.1.54

package/dist/skills/ulw-research/scripts/html-text-map.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, test } from "bun:test"
+
+import { extractHtml } from "./html-text-map.mjs"
+
+/** {T} is the target sentence: every row runs once with English text and once with Korean text. */
+const TARGET = { en: "Target length is 999 m.", ko: "\ubaa9\ud45c \uae38\uc774\ub294 999 m\uc774\ub2e4." }
+const CONTROL = "Control length is 410 m."
+
+type Row = { form: string; html: string; expected: "hidden" | "visible" }
+
+const css = (sheet: string, element = '<p class="x">{T}</p>') => `<style>${sheet}</style>${element}`
+
+const ROWS: Row[] = [
+	// conditional and grouping at-rules: only an unconditional rule hides; a conditional one never does
+	{ form: "@media (max-width:600px)", html: css("@media (max-width:600px){.x{display:none}}"), expected: "visible" },
+	{ form: "@media print", html: css("@media print{.x{display:none}}"), expected: "visible" },
+	{ form: "@media screen and (min-width:0)", html: css("@media screen and (min-width: 0){.x{display:none}}"), expected: "visible" },
+	{ form: "@media not print", html: css("@media not print{.x{display:none}}"), expected: "visible" },
+	{ form: "@media all", html: css("@media all{.x{display:none}}"), expected: "hidden" },
+	{ form: "@media all and (min-width:1px)", html: css("@media all and (min-width:1px){.x{display:none}}"), expected: "visible" },
+	{ form: "@supports (display:grid)", html: css("@supports (display:grid){.x{display:none}}"), expected: "visible" },
+	{ form: "@container (min-width:400px)", html: css("@container (min-width: 400px){.x{display:none}}"), expected: "visible" },
+	{ form: "@scope (.card)", html: css("@scope (.card){.x{display:none}}", '<div class="card"><p class="x">{T}</p></div>'), expected: "visible" },
+	{ form: "@starting-style", html: css("@starting-style{.x{display:none}}"), expected: "visible" },
+	{ form: "@document url-prefix()", html: css("@-moz-document url-prefix(){.x{display:none}}"), expected: "visible" },
+	{ form: "@layer base (block)", html: css("@layer base{.x{display:none}}"), expected: "hidden" },
+	{ form: "@layer statement then block", html: css("@layer a, b; @layer b{.x{display:none}}"), expected: "hidden" },
+	{ form: "@layer inside @media", html: css("@media print{@layer a{.x{display:none}}}"), expected: "visible" },
+	{ form: "@media inside @layer", html: css("@layer a{@media print{.x{display:none}}}"), expected: "visible" },
+	{ form: "@media inside @supports", html: css("@supports (display:grid){@media (min-width:1px){.x{display:none}}}"), expected: "visible" },
+	{ form: "@media nested in a style rule", html: css(".x{color:red;@media print{display:none}}"), expected: "visible" },
+	{ form: "@import before a rule", html: css('@import url("print.css") print; .x{display:none}'), expected: "hidden" },
+	{ form: "@font-face before a rule", html: css("@font-face{font-family:F;src:url(f.woff2)} .x{display:none}"), expected: "hidden" },
+	{ form: "@keyframes hiding steps", html: css("@keyframes k{from{visibility:hidden}to{display:none}} .x{animation:k 1s}"), expected: "visible" },
+	{ form: "@page", html: css("@page{display:none} .y{display:none}"), expected: "visible" },
+	{ form: "CSS nesting (combinator, not evaluated)", html: css(".card{.x{display:none}}", '<div class="card"><p class="x">{T}</p></div>'), expected: "visible" },
+	{ form: "conditional rule after an unconditional one", html: css(".x{display:none} @media print{.x{color:red}}"), expected: "hidden" },
+	// comments
+	{ form: "rule inside a comment", html: css("/* .x{display:none} */"), expected: "visible" },
+	{ form: "comment before the declaration", html: css(".x{/* display:block */display:none}"), expected: "hidden" },
+	{ form: "comment inside the value", html: css(".x{display:/**/none}"), expected: "hidden" },
+	{ form: "HTML comment markers in <style>", html: css("<!-- .x{display:none} -->"), expected: "hidden" },
+	{ form: "comment in an inline style", html: '<p style="display:/* hide */none">{T}</p>', expected: "hidden" },
+	// selector lists and the cascade
+	{ form: "selector list", html: css(".a, .x {display:none}"), expected: "hidden" },
+	{ form: "selector list with a compound part", html: css("div p, .x{display:none}"), expected: "hidden" },
+	{ form: "compound selector alone (not evaluated)", html: css("p.x{display:none}"), expected: "visible" },
+	{ form: "descendant selector alone (not evaluated)", html: css("div .x{display:none}", '<div><p class="x">{T}</p></div>'), expected: "visible" },
+	{ form: "attribute selector (not evaluated)", html: css("[data-off]{display:none}", "<p data-off>{T}</p>"), expected: "visible" },
+	{ form: "later rule shows again", html: css(".x{display:none} .x{display:block}"), expected: "visible" },
+	{ form: "later rule hides", html: css(".x{display:block} .x{display:none}"), expected: "hidden" },
+	{ form: "id outranks class", html: css("#y{display:block} .x{display:none}", '<p id="y" class="x">{T}</p>'), expected: "visible" },
+	{ form: "class outranks tag", html: css(".x{display:none} p{display:block}"), expected: "hidden" },
+	{ form: "responsive show (d-none d-md-block)", html: css(".x{display:none} @media (min-width:768px){.y{display:block}}", '<p class="x y">{T}</p>'), expected: "visible" },
+	{ form: "important hide beats a conditional show", html: css(".x{display:none!important} @media (min-width:768px){.y{display:block}}", '<p class="x y">{T}</p>'), expected: "hidden" },
+	{ form: "important hide and important conditional show", html: css(".x{display:none!important} @media (min-width:768px){.y{display:block!important}}", '<p class="x y">{T}</p>'), expected: "visible" },
+	{ form: "compound show may apply", html: css(".x{display:none} div .x{display:block}", '<div><p class="x">{T}</p></div>'), expected: "visible" },
+	{ form: "compound show that cannot match", html: css(".x{display:none} div .z{display:block}", '<div><p class="x">{T}</p></div>'), expected: "hidden" },
+	{ form: "layered show loses to unlayered hide", html: css("@layer base{.x{display:block}} .x{display:none}"), expected: "hidden" },
+	{ form: "unlayered show beats layered hide", html: css("@layer base{.x{display:none}} p{display:block}"), expected: "visible" },
+	{ form: "later layer beats earlier layer", html: css("@layer a, b; @layer b{.x{display:none}} @layer a{#y{display:block}}", '<p id="y" class="x">{T}</p>'), expected: "hidden" },
+	// !important against inline styles
+	{ form: "important rule beats inline show", html: css(".x{display:none !important}", '<p class="x" style="display:block">{T}</p>'), expected: "hidden" },
+	{ form: "inline show beats a normal rule", html: css(".x{display:none}", '<p class="x" style="display:block">{T}</p>'), expected: "visible" },
+	{ form: "important show beats inline hide", html: css(".x{display:block !important}", '<p class="x" style="display:none">{T}</p>'), expected: "visible" },
+	{ form: "important without a space", html: css(".x{display:none!important}"), expected: "hidden" },
+	{ form: "inline important beats important rule", html: css(".x{display:block!important}", '<p class="x" style="display:none!important">{T}</p>'), expected: "hidden" },
+	// which properties hide
+	{ form: "display:none (rule)", html: css(".x{display:none}"), expected: "hidden" },
+	{ form: "visibility:hidden (rule)", html: css(".x{visibility:hidden}"), expected: "hidden" },
+	{ form: "visibility:collapse", html: '<p style="visibility:collapse">{T}</p>', expected: "hidden" },
+	{ form: "visibility:hidden parent, visible child", html: '<div style="visibility:hidden"><p style="visibility:visible">{T}</p></div>', expected: "visible" },
+	{ form: "visibility:hidden parent, plain child", html: '<div style="visibility:hidden"><p>{T}</p></div>', expected: "hidden" },
+	{ form: "visibility:hidden parent, child by rule", html: css(".x{visibility:visible}", '<div style="visibility:hidden"><p class="x">{T}</p></div>'), expected: "visible" },
+	{ form: "display:none parent, visible child", html: '<div style="display:none"><p style="visibility:visible;display:block">{T}</p></div>', expected: "hidden" },
+	{ form: "content-visibility:hidden", html: '<div style="content-visibility:hidden"><p>{T}</p></div>', expected: "hidden" },
+	{ form: "display:contents", html: '<p style="display:contents">{T}</p>', expected: "visible" },
+	{ form: "opacity:0", html: '<p style="opacity:0">{T}</p>', expected: "visible" },
+	{ form: "clip rect (sr-only)", html: '<p style="position:absolute;clip:rect(0 0 0 0);width:1px;height:1px;overflow:hidden">{T}</p>', expected: "visible" },
+	{ form: "clip-path inset", html: '<p style="clip-path:inset(50%)">{T}</p>', expected: "visible" },
+	{ form: "height:0 with overflow hidden", html: '<p style="height:0;overflow:hidden">{T}</p>', expected: "visible" },
+	{ form: "font-size:0", html: '<p style="font-size:0">{T}</p>', expected: "visible" },
+	{ form: "off-screen position", html: '<p style="position:absolute;left:-9999px">{T}</p>', expected: "visible" },
+	{ form: "transparent color", html: '<p style="color:transparent">{T}</p>', expected: "visible" },
+	// the hidden attribute
+	{ form: "hidden attribute", html: "<p hidden>{T}</p>", expected: "hidden" },
+	{ form: 'hidden="hidden"', html: '<p hidden="hidden">{T}</p>', expected: "hidden" },
+	{ form: "HIDDEN in upper case", html: "<p HIDDEN>{T}</p>", expected: "hidden" },
+	{ form: 'hidden="until-found"', html: '<p hidden="until-found">{T}</p>', expected: "visible" },
+	{ form: "hidden attribute under an author display rule", html: css(".x{display:block}", '<p class="x" hidden>{T}</p>'), expected: "visible" },
+	{ form: "hidden attribute under an inline display", html: '<p hidden style="display:block">{T}</p>', expected: "visible" },
+	{ form: "descendant of a hidden element", html: "<div hidden><p>{T}</p></div>", expected: "hidden" },
+	// aria-hidden
+	{ form: 'aria-hidden="true"', html: '<p aria-hidden="true">{T}</p>', expected: "hidden" },
+	{ form: 'aria-hidden=" TRUE "', html: '<p aria-hidden=" TRUE ">{T}</p>', expected: "hidden" },
+	{ form: 'aria-hidden="false"', html: '<p aria-hidden="false">{T}</p>', expected: "visible" },
+	{ form: "descendant of aria-hidden", html: '<div aria-hidden="true"><p>{T}</p></div>', expected: "hidden" },
+	// inline style spellings
+	{ form: "inline display:none", html: '<p style="display:none">{T}</p>', expected: "hidden" },
+	{ form: "inline with spaces and a trailing semicolon", html: '<p style=" display : none ; ">{T}</p>', expected: "hidden" },
+	{ form: "inline in upper case", html: '<p style="DISPLAY:NONE">{T}</p>', expected: "hidden" },
+	{ form: "inline after another declaration", html: '<p style="color:red;display:none">{T}</p>', expected: "hidden" },
+	{ form: "inline: last declaration wins", html: '<p style="display:none;display:block">{T}</p>', expected: "visible" },
+	{ form: "inline custom property", html: '<p style="--display:none">{T}</p>', expected: "visible" },
+	{ form: "inline var() value", html: '<p style="display:var(--d)">{T}</p>', expected: "visible" },
+	{ form: "inline display:none in a string value", html: '<p style="font-family:\'display:none\'">{T}</p>', expected: "visible" },
+	// case: tag names are case-insensitive, class and id names are case-sensitive
+	{ form: ".Foo vs class=foo", html: css(".Foo{display:none}", '<p class="foo">{T}</p>'), expected: "visible" },
+	{ form: ".foo vs class=Foo", html: css(".foo{display:none}", '<p class="Foo">{T}</p>'), expected: "visible" },
+	{ form: ".Foo vs class=Foo", html: css(".Foo{display:none}", '<p class="Foo">{T}</p>'), expected: "hidden" },
+	{ form: "#Gone vs id=gone", html: css("#Gone{display:none}", '<p id="gone">{T}</p>'), expected: "visible" },
+	{ form: "#gone vs id=gone", html: css("#gone{display:none}", '<p id="gone">{T}</p>'), expected: "hidden" },
+	{ form: "P{} vs <p>", html: css("P{display:none}", "<p>{T}</p>"), expected: "hidden" },
+	{ form: "p{} vs <P>", html: css("p{display:none}", "<P>{T}</P>"), expected: "hidden" },
+	{ form: "Hangul class name", html: css(".\uc228\uae40{display:none}", '<p class="\uc228\uae40">{T}</p>'), expected: "hidden" },
+	{ form: "upper-case property and value", html: css(".x{DISPLAY:NONE}"), expected: "hidden" },
+	// elements whose contents a reader never sees
+	{ form: "<noscript>", html: "<noscript><p>{T}</p></noscript>", expected: "hidden" },
+	{ form: "<template>", html: "<template><p>{T}</p></template>", expected: "hidden" },
+	{ form: "<script>", html: '<script>var note = "{T}"</script>', expected: "hidden" },
+	{ form: "<style> content", html: '<style>.x::after{content:"{T}"}</style>', expected: "hidden" },
+	{ form: "<title> in <head>", html: "<head><title>{T}</title></head>", expected: "hidden" },
+	{ form: "<svg> text", html: "<svg><text>{T}</text></svg>", expected: "hidden" },
+	{ form: "closed <dialog>", html: "<dialog><p>{T}</p></dialog>", expected: "hidden" },
+	{ form: "open <dialog>", html: "<dialog open><p>{T}</p></dialog>", expected: "visible" },
+	{ form: "closed <details> body", html: "<details><summary>More</summary><p>{T}</p></details>", expected: "visible" },
+	// which <style> elements apply
+	{ form: "<style> inside <template> is inert", html: '<template><style>.x{display:none}</style></template><p class="x">{T}</p>', expected: "visible" },
+	{ form: "<style> inside <noscript> applies only without scripts", html: '<noscript><style>.x{display:none}</style></noscript><p class="x">{T}</p>', expected: "visible" },
+	{ form: "<style> inside a hidden element still applies", html: '<div hidden><style>.x{display:none}</style></div><p class="x">{T}</p>', expected: "hidden" },
+	{ form: "<style> inside <svg> applies to the page", html: '<svg><style>.x{display:none}</style></svg><p class="x">{T}</p>', expected: "hidden" },
+	{ form: '<style media="print">', html: '<style media="print">.x{display:none}</style><p class="x">{T}</p>', expected: "visible" },
+	{ form: '<style media="all">', html: '<style media="all">.x{display:none}</style><p class="x">{T}</p>', expected: "hidden" },
+	{ form: '<style type="text/plain">', html: '<style type="text/plain">.x{display:none}</style><p class="x">{T}</p>', expected: "visible" },
+	{ form: "external stylesheet (not evaluated)", html: '<link rel="stylesheet" href="hide.css"><p class="d-none">{T}</p>', expected: "visible" },
+]
+
+const CASES = ROWS.flatMap((row) =>
+	(["en", "ko"] as const).map((lang) => [`${row.form} [${lang}] -> ${row.expected}`, row.html.replaceAll("{T}", TARGET[lang]), TARGET[lang], row.expected] as const),
+)
+
+describe("reader-visible text: one row per hiding form, English and Korean", () => {
+	test.each(CASES)("#given %s #when extracted #then the target is that", (_name, html, target, expected) => {
+		const { text } = extractHtml(`${html}<blockquote>${CONTROL}</blockquote>`)
+		expect(text).toContain(CONTROL)
+		expect(text.includes(target) ? "visible" : "hidden").toBe(expected)
+	})
+})

package/dist/skills/ulw-research/scripts/markdown-closers.mjs

@@ -0,0 +1,126 @@
+// markdown-closers.mjs - the Markdown closer runs a converter writes after a piece of text, read with
+// the CommonMark inline grammar instead of a hand-written pattern. A closer run is any sequence of:
+// an inline link ending `](dest "title")` (the destination either in <...> or bare with balanced
+// parentheses, the optional title in "...", '...' or (...), backslash escapes inside both), a full or
+// collapsed reference ending `][ref]` / `][]`, a whole image `![alt](...)` or `![alt][ref]` (its alt
+// text is not context), the `[` that opened a link whose text is all markup (`[![x](i.png)](/p)`),
+// an emphasis, strike or code delimiter, a bare `)`, `]` or `>`, and a backslash-escaped closer
+// (`\*`, `\_`, `\]`, `\)`, `\~`, a backtick), which stands for the raw character and is skipped like
+// it. An escaped opener (`\[`, `\(`) is a real character and ends the run. Shared by the conversion
+// probe's sign reading and its link-syntax spans. Pure; no imports.
+
+const SIMPLE = new Set(["*", "_", "~", "`", ")", "]", ">"])
+const BREAK = "\u0001"
+
+/** Whether the character at `index` is backslash-escaped (an odd run of backslashes before it). */
+export function escapedAt(text, index) {
+	let count = 0
+	for (let i = index - 1; i >= 0 && text[i] === "\\"; i--) count++
+	return count % 2 === 1
+}
+
+/** The end (exclusive) of an inline link target `dest "title")` that starts right after its "(", or -1. */
+export function inlineTargetEnd(text, from) {
+	let i = from
+	const space = () => {
+		while (text[i] === " " || text[i] === "\t") i++
+	}
+	space()
+	if (text[i] === "<") {
+		for (i++; i < text.length && text[i] !== ">"; i++) {
+			if (text[i] === "\\") i++
+			else if (text[i] === "<" || text[i] === BREAK) return -1
+		}
+		if (text[i++] !== ">") return -1
+	} else {
+		let depth = 0
+		for (; i < text.length; i++) {
+			const ch = text[i]
+			if (ch === "\\") i++
+			else if (ch === "(") depth++
+			else if (ch === ")" && depth === 0) break
+			else if (ch === ")") depth--
+			else if (ch === " " || ch === "\t" || ch === BREAK) break
+		}
+		if (depth !== 0) return -1
+	}
+	const destEnd = i
+	space()
+	const open = text[i]
+	if (i > destEnd && (open === '"' || open === "'" || open === "(")) {
+		const close = open === "(" ? ")" : open
+		for (i++; i < text.length && text[i] !== close; i++) {
+			if (text[i] === "\\") i++
+			else if (text[i] === BREAK || (open === "(" && text[i] === "(")) return -1
+		}
+		if (text[i++] !== close) return -1
+		space()
+	}
+	return text[i] === ")" ? i + 1 : -1
+}
+
+/** The unescaped "[" that the unescaped "]" at `close` closes (brackets balance), or -1. */
+function openerOf(text, close) {
+	let depth = 0
+	for (let i = close; i >= 0 && text[i] !== BREAK; i--) {
+		if ((text[i] !== "[" && text[i] !== "]") || escapedAt(text, i)) continue
+		depth += text[i] === "]" ? 1 : -1
+		if (depth === 0) return i
+	}
+	return -1
+}
+
+/** The "](" positions whose inline target ends exactly at `end`, leftmost first (so a title holding "](" is not cut). */
+function inlineLinkClose(text, end) {
+	const from = Math.max(0, text.lastIndexOf(BREAK, end - 1))
+	for (let k = text.indexOf("](", from); k !== -1 && k < end; k = text.indexOf("](", k + 1)) {
+		if (!escapedAt(text, k) && inlineTargetEnd(text, k + 2) === end) return k
+	}
+	return -1
+}
+
+/** Where the link or image tail ending at `end` starts, and whether its "[" is still open; null when none ends there. */
+function linkTail(text, end) {
+	let close = -1
+	if (text[end - 1] === ")") close = inlineLinkClose(text, end)
+	else if (text[end - 1] === "]" && !escapedAt(text, end - 1)) {
+		const ref = openerOf(text, end - 1)
+		if (ref > 0 && text[ref - 1] === "]" && !escapedAt(text, ref - 1)) close = ref - 1
+	}
+	if (close === -1) return null
+	const open = openerOf(text, close)
+	if (open > 0 && text[open - 1] === "!" && !escapedAt(text, open - 1)) return { start: open - 1, opened: 0 }
+	return { start: close, opened: open === -1 ? 0 : 1 }
+}
+
+/** `text` without the Markdown closer run it ends with. */
+export function stripClosers(text) {
+	let end = text.length
+	let owed = 0
+	for (;;) {
+		const tail = linkTail(text, end)
+		if (tail) {
+			end = tail.start
+			owed += tail.opened
+			continue
+		}
+		const ch = text[end - 1]
+		if (SIMPLE.has(ch)) end -= escapedAt(text, end - 1) ? 2 : 1
+		else if (ch === "[" && owed > 0 && !escapedAt(text, end - 1)) {
+			end--
+			owed--
+		} else return text.slice(0, end)
+	}
+}
+
+/** [start, end) spans of every inline link or image with its target (an image from its "!"), for link-syntax cover. */
+export function inlineLinkSpans(text) {
+	const spans = []
+	for (let k = text.indexOf("]("); k !== -1; k = text.indexOf("](", k + 1)) {
+		const end = escapedAt(text, k) ? -1 : inlineTargetEnd(text, k + 2)
+		if (end === -1) continue
+		const open = openerOf(text, k)
+		spans.push([open > 0 && text[open - 1] === "!" ? open - 1 : k, end])
+	}
+	return spans
+}

package/dist/skills/ulw-research/scripts/md-lite-boundaries.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test"
+
+import { parseMarkdown } from "./md-lite.mjs"
+import { parseNumeral } from "./numerals.mjs"
+
+describe("Markdown list continuation boundaries", () => {
+	test("#given a continuation after a list item #when parsed #then a later marker stays paragraph text", () => {
+		const text = "1. a\ncontinued\n2. b"
+		const { blocks } = parseMarkdown(text)
+		expect(blocks.map((block: { kind: string; text: string }) => [block.kind, block.text])).toEqual([
+			["list_item", "a"],
+			["paragraph", "continued\n2. b"],
+		])
+	})
+
+	test("#given numbers beside a list continuation #when parsed #then fidelity numerals retain source offsets", () => {
+		const text = "1. a 12%\ncontinued\n2. b 34%"
+		const { blocks } = parseMarkdown(text)
+		const found = blocks.flatMap((block: { text: string; start: number }) => {
+			const numerals = []
+			for (let numeral = parseNumeral(block.text); numeral; numeral = parseNumeral(block.text, numeral.span[1])) {
+				const [start, end] = numeral.span
+				numerals.push([numeral.value, text.slice(block.start + start, block.start + end)])
+			}
+			return numerals
+		})
+		expect(found).toEqual([["12", "12%"], ["2", "2"], ["34", "34%"]])
+	})
+})
+
+describe("Markdown closing fence indentation", () => {
+	test.each(["```", "~~~"])("#given a four-space %s closing candidate #when parsed #then the code runs to EOF", (fence: string) => {
+		const text = `${fence}\ncode 12\n    ${fence}\nclaim 34`
+		const { blocks, problems } = parseMarkdown(text)
+		expect(blocks.map((block: { kind: string; text: string }) => [block.kind, block.text])).toEqual([
+			["code", `code 12\n    ${fence}\nclaim 34`],
+		])
+		expect(problems).toEqual([{ code: "unterminated_fence", line: 1, start: 0 }])
+	})
+
+	test.each([0, 1, 2, 3])("#given a closing fence indented %s spaces #when parsed #then later prose is outside code", (spaces: number) => {
+		const { blocks, problems } = parseMarkdown(`\`\`\`\ncode\n${" ".repeat(spaces)}\`\`\`\nclaim 34`)
+		expect(blocks.map((block: { kind: string }) => block.kind)).toEqual(["code", "paragraph"])
+		expect(problems).toEqual([])
+	})
+})

package/dist/skills/ulw-research/scripts/md-lite.mjs

@@ -113,7 +113,7 @@ export function parseMarkdown(text) {
 			const codeStart = Math.min(line.next, source.length)
 			let close = lines.length
 			for (let k = i + 1; k < lines.length; k++) {
-				const candidate = lines[k].raw.trim()
+				const candidate = lines[k].raw.replace(/^ {0,3}/, "").trimEnd()
 				if (candidate.startsWith(open[0].repeat(open.length)) && /^(`+|~+)$/.test(candidate)) {
 					close = k
 					break

package/dist/skills/ulw-research/scripts/number-grammar.mjs

@@ -0,0 +1,33 @@
+// number-grammar.mjs - the one grouped-number grammar. A grouped number is a 1-3 digit leading
+// group, then one or more 3-digit groups joined by ONE separator type, with no digit right after the
+// last group, then an optional decimal part. "12,3451" is therefore not "12,345" plus "1". A period
+// groups only when the reading is unambiguous: two or more period groups ("1.234.567") or one group
+// before a decimal comma ("1.234,5"); a lone "1.234" is a decimal, as numerals.mjs reads it. Shared by
+// numerals.mjs (comma grouping), the conversion probe (every separator), the value-mode unit check,
+// and the converted-half display check. Pure; no imports.
+
+/** Separators a thousands group may use: comma, period, space, NBSP, narrow NBSP, thin space, figure space. */
+export const GROUP_SEPARATORS = Object.freeze([",", ".", " ", "\u00A0", "\u202F", "\u2009", "\u2007"])
+
+const literal = (sep) => (sep === "." ? "\\." : sep === " " ? " " : sep === "," ? "," : `\\u${sep.charCodeAt(0).toString(16).padStart(4, "0")}`)
+const decimalAfter = (sep) => (sep === "," ? "\\." : sep === "." ? "," : "[.,]")
+
+/** Regex source of one grouped number using any of `separators` (one type per number); no flags needed. */
+export function groupedNumberSource(separators = GROUP_SEPARATORS) {
+	const one = (sep) => sep === "."
+		? "\\d{1,3}(?:(?:\\.\\d{3}(?!\\d)){2,}(?:,\\d+)?|\\.\\d{3}(?!\\d),\\d+)"
+		: `\\d{1,3}(?:${literal(sep)}\\d{3}(?!\\d))+(?:${decimalAfter(sep)}\\d+)?`
+	return `(?<!\\d)(?:${separators.map(one).join("|")})`
+}
+
+/** A grouped number or a plain one ("4.22", "12,3451" read as 12.3451), as regex source. */
+export const NUMBER_SOURCE = `(?:${groupedNumberSource()}|(?<!\\d)\\d+(?:[.,]\\d+)?)`
+
+const WHOLE = new Map(GROUP_SEPARATORS.map((sep) => [sep, new RegExp(`^${groupedNumberSource([sep])}$`)]))
+
+/** The plain decimal a number token spells: group separators dropped, a decimal comma read as a point. */
+export function plainDecimal(token) {
+	const sep = GROUP_SEPARATORS.find((candidate) => WHOLE.get(candidate).test(token))
+	const ungrouped = sep === undefined ? token : token.split(sep).join("")
+	return ungrouped.replace(",", ".")
+}

package/dist/skills/ulw-research/scripts/number-grammar.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test"
+
+import { NUMBER_SOURCE, groupedNumberSource, plainDecimal } from "./number-grammar.mjs"
+import { parseNumeral } from "./numerals.mjs"
+
+const numbers = (text: string) => [...text.matchAll(new RegExp(NUMBER_SOURCE, "g"))].map((match) => match[0])
+
+describe("the one grouped-number grammar", () => {
+	for (const [text, expected] of [
+		["12,3451", ["12,3451"]],
+		["212,34515,678", ["212,34515", "678"]],
+		["12,345.6 and 1 234 567", ["12,345.6", "1 234 567"]],
+		["1\u2009234\u2009567", ["1\u2009234\u2009567"]],
+		["2,500 300", ["2,500", "300"]],
+		["2023 500", ["2023", "500"]],
+		["1.234,5", ["1.234,5"]],
+		["1.234.567 and 1.234", ["1.234.567", "1.234"]],
+	] as const) {
+		test(`#given ${JSON.stringify(text)} #when tokenized #then ${JSON.stringify(expected)}`, () => expect(numbers(text)).toEqual([...expected]))
+	}
+
+	test("#given grouped and plain tokens #when normalized #then group separators drop and a decimal comma reads as a point", () => {
+		expect(["12,345.6", "1 234 567", "1.234,5", "12,3451", "4.22"].map(plainDecimal)).toEqual(["12345.6", "1234567", "1234.5", "12.3451", "4.22"])
+	})
+
+	test("#given a single period group #when normalized #then it is a decimal, as parseNumeral reads it", () => {
+		expect(["1.234", "1.234.567"].map(plainDecimal)).toEqual(["1.234", "1234567"])
+		expect(parseNumeral("1.234 units")?.value).toBe("1.234")
+	})
+
+	test("#given comma grouping #when parseNumeral reads it #then only a well-formed group is one value", () => {
+		expect(new RegExp(`^${groupedNumberSource([","])}$`).test("1,237")).toBe(true)
+		expect(parseNumeral("1,237 units")?.value).toBe("1237")
+		expect(parseNumeral("12,3451 units")?.value).not.toBe("123451")
+	})
+})

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

@@ -6,9 +6,12 @@
 // 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 { groupedNumberSource } from "./number-grammar.mjs"
 import { add, fromDecimal, mul, toDecimal } from "./rational.mjs"
 import { normalizeUnit } from "./units.mjs"
 
+/** European digit grouping ("1.234.567"): two or more dot groups of three digits, never a version. */
+export const DOT_GROUPED = "\\d{1,3}(?:\\.\\d{3}){2,}"
 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 = [
@@ -19,7 +22,7 @@ export const NOT_CLAIMS = [
 	/(?: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,
+	new RegExp(`\\bv\\d+(?:\\.\\d+)*\\b|\\b(?!${DOT_GROUPED}(?![\\d,]|\\.\\d))\\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,
@@ -45,8 +48,8 @@ const BIG = new Map([["\uB9CC", 10000n], ["\uC5B5", 100000000n], ["\uC870", 1000
 /** 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 LATIN_SCALE = /^(?:(k|K|M|mn|bn|B)|\s(thousand|million|billion|trillion|mn|bn))(?![\p{L}\d])/u
+const LATIN_FACTOR = { k: 1000n, K: 1000n, M: 1000000n, mn: 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
@@ -60,15 +63,23 @@ 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)/
+/** Korean bounding qualifiers written right after a value (isang, iha, miman, chogwa, naeoe, kkaji). */
+export const QUALIFIERS_AFTER = Object.freeze(["\uC774\uC0C1", "\uC774\uD558", "\uBBF8\uB9CC", "\uCD08\uACFC", "\uB0B4\uC678", "\uAE4C\uC9C0"])
+const QUALIFIER_AFTER = new RegExp(`^\\s?(${QUALIFIERS_AFTER.join("|")})`)
 
-/** "1,237" -> "1237"; a malformed group ("1,23") keeps only the leading plain number. */
+/** Comma grouping from the one grouped-number grammar (number-grammar.mjs). */
+const COMMA_GROUPED = new RegExp(`^${groupedNumberSource([","])}$`)
+
+/** "1,237" -> "1237"; a malformed group ("1,23", "12,3451") 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 }
+	if (COMMA_GROUPED.test(raw)) return { digits: raw.replace(/,/g, ""), length: raw.length }
 	const plain = /^\d+(?:\.\d+)?/.exec(raw)[0]
 	return { digits: plain, length: plain.length }
 }
 
+/** A numeral's digits, reading a European period grouping ("1.234.567") as one integer. */
+const digitsOf = (raw) => (new RegExp(`^${DOT_GROUPED}$`).test(raw) ? { digits: raw.replace(/\./g, ""), length: raw.length } : cleanDigits(raw))
+
 /** 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]])
 
@@ -95,7 +106,7 @@ function findStart(text, from, ranges) {
 	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 candidate = { at, ...digitsOf(match[0]) }
 		const end = at + candidate.length
 		const cover = covering(at)
 		const lifted = cover.every(([s, e, yearShaped]) => yearShaped && s === at && e <= end)

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

@@ -37,6 +37,9 @@ describe("parseNumeral", () => {
 		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("5mn users")?.value).toBe("5000000")
+		expect(parseNumeral("1.234.567 users")?.value).toBe("1234567")
+		expect(parseNumeral("build 0.30.14 shipped")).toBeNull()
 		expect(parseNumeral("$4B")?.value).toBe("4000000000")
 		expect(parseNumeral("3 million users")?.value).toBe("3000000")
 		expect(parseNumeral("5 km")).toMatchObject({ value: "5", unitRaw: "km" })

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

@@ -0,0 +1,66 @@
+// outcome-start.mjs - the run clock (outcome.json startedAt). `outcome init` is its one writer and
+// records it once: --started-at from the orchestrator, else the startedAt of a valid manifest an
+// earlier init wrote (a re-init keeps the clock), else terminal-state.json.started_at when a
+// supervisor wrote one, else the YYYYMMDD-HHMMSS session dir name. A recorded value must be a real
+// ISO time with Z or an offset, not after `now`, and within a day of a stamped dir name; otherwise
+// init refuses instead of falling back. Never the interview's as-of date. No clock reads.
+import { readFileSync } from "node:fs"
+import { basename, join, resolve } from "node:path"
+
+const ISO = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:Z|[+-](\d{2}):(\d{2}))$/
+const SESSION_STAMP = /^(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})$/
+const DAY_MS = 86_400_000
+
+/** A real calendar time (no 2026-02-30, no T24:00), or null. */
+function strictIso(value) {
+	const match = typeof value === "string" ? ISO.exec(value) : null
+	if (!match) return null
+	const [y, mo, d, h, mi, s, oh = 0, om = 0] = match.slice(1).map((part) => Number(part ?? 0))
+	const day = new Date(Date.UTC(y, mo - 1, d))
+	if (day.getUTCMonth() !== mo - 1 || day.getUTCDate() !== d || h > 23 || mi > 59 || s > 59 || oh > 23 || om > 59) return null
+	const date = new Date(value)
+	return Number.isNaN(date.getTime()) ? null : date
+}
+
+/** Local start time from a YYYYMMDD-HHMMSS dir name, null when the name is not a stamp. */
+function dirStamp(sessionDir, fail) {
+	const match = SESSION_STAMP.exec(basename(sessionDir))
+	if (!match) return null
+	const [y, mo, d, h, mi, s] = match.slice(1).map(Number)
+	const date = new Date(y, mo - 1, d, h, mi, s)
+	if (date.getMonth() !== mo - 1 || date.getDate() !== d || date.getHours() !== h) fail(`session dir basename is not a real local time: ${sessionDir}`)
+	return date
+}
+
+function readJson(sessionDir, file) {
+	try {
+		return { data: JSON.parse(readFileSync(join(sessionDir, file), "utf8")) }
+	} catch (error) {
+		if (error.code === "ENOENT" || error.code === "ENOTDIR") return null
+		if (error instanceof SyntaxError) return { corrupt: `${join(sessionDir, file)} is not valid JSON (${error.message})` }
+		throw error
+	}
+}
+
+/**
+ * @param {{ sessionDir: string, startedAt?: string, now?: Date, validManifest: (data: unknown) => boolean, fail: (message: string) => never }} input
+ * @returns {Date}
+ */
+export function runStart({ sessionDir, startedAt, now, validManifest, fail }) {
+	const dir = dirStamp(sessionDir, fail)
+	const check = (value, location) => {
+		const date = strictIso(value)
+		if (!date) fail(`invalid run timestamp in ${location}: ${JSON.stringify(value)} is not a real ISO time with Z or an offset`)
+		if (now && date > now) fail(`run timestamp in ${location} (${value}) is after now (${now.toISOString()})`)
+		if (dir && Math.abs(date - dir) > DAY_MS) fail(`run timestamp in ${location} (${value}) is not within a day of the session dir name ${basename(sessionDir)}: a copied or stale value`)
+		return date
+	}
+	if (startedAt !== undefined) return check(startedAt, "--started-at")
+	const manifest = readJson(sessionDir, "outcome.json")
+	if (manifest?.data && validManifest(manifest.data) && resolve(String(manifest.data.sessionDir)) === resolve(sessionDir)) return check(manifest.data.startedAt, "outcome.json.startedAt")
+	const terminal = readJson(sessionDir, "terminal-state.json")
+	if (terminal?.corrupt) fail(terminal.corrupt)
+	if (terminal?.data?.started_at !== undefined) return check(terminal.data.started_at, "terminal-state.json.started_at")
+	if (dir) return dir
+	return fail(`missing run timestamp: pass --started-at <ISO>, record terminal-state.json.started_at, or name the session dir YYYYMMDD-HHMMSS (${sessionDir})`)
+}