oh-my-opencode 5.1.48 → 5.1.51

package/packages/omo-codex/plugin/skills/ulw-research/scripts/gates-static.mjs

@@ -14,6 +14,7 @@ import { figureGates } from "./gates-figures.mjs"
 import { structureGates } from "./gates-structure.mjs"
 import { textGates } from "./gates-text.mjs"
 import { PROSE_TAGS, proseText, selectorPath } from "./html-lite.mjs"
+import { sourcesClaims } from "./sources-citation.mjs"
 
 const CITATION_MARKER = /\[S\d+\]|\[Source\s*\d+\]|\[\uCD9C\uCC98[^\]]*\]|\[\^\d+\]/i
 const ANCHOR_HREF = /^#(?:s|src|source|ref|fn)/i
@@ -65,6 +66,11 @@ function hasCitation(node) {
 	return CITATION_MARKER.test(proseText(node)) || descendants(node).some(isCitationAnchor)
 }
 
+function proseScope(scope, owner) {
+	if (scope.section?.kind !== "sources" || !owner || sourcesClaims(owner).length === 0) return scope
+	return { ...scope, section: { ...scope.section, kind: null } }
+}
+
 function toRegExp(pattern) {
 	const re = pattern instanceof RegExp ? pattern : new RegExp(String(pattern), "i")
 	return new RegExp(re.source, re.flags.replace(/[gy]/g, ""))
@@ -181,7 +187,10 @@ export function checkStatic(doc, options = {}) {
 			continue
 		}
 		gatesRun.push(...gate.codes)
-		defects.push(...gate.run(ctx))
+		const context = gate.codes.includes("unsourced_number")
+			? { ...ctx, elements: ctx.elements.map(({ node, scope }) => ({ node, scope: proseScope(scope, node) })) }
+			: ctx
+		defects.push(...gate.run(context))
 	}
 	return { defects, gatesRun, gatesSkipped }
 }

package/packages/omo-codex/plugin/skills/ulw-research/scripts/html-lite.mjs

@@ -23,7 +23,7 @@ const PROSE_SKIP = new Set(["code", "pre", "kbd", "samp", "script", "style", "sv
 const SAFE_ID = /^[A-Za-z_][\w-]*$/
 
 export const PROSE_TAGS = new Set(["p", "li", ...HEADINGS, "td", "th", "figcaption", "blockquote", "dd", "dt"])
-const PROSE_BREAKS = new Set([...P_CLOSERS, ...PROSE_TAGS, "br", "tr"])
+export const PROSE_BREAKS = new Set([...P_CLOSERS, ...PROSE_TAGS, "br", "tr"])
 
 function makeNode(tag, attrs, parent, line) {
 	return { tag, attrs, children: [], parent, line, text: "", raw: null }
@@ -130,6 +130,8 @@ export function parseHtml(source) {
 	const flushText = (to) => {
 		if (to > textStart) {
 			const node = makeNode("#text", {}, top(), lineAt(starts, textStart))
+			node.source_start = textStart
+			node.source_end = to
 			node.text = decodeEntities(src.slice(textStart, to))
 			top().children.push(node)
 		}
@@ -157,7 +159,7 @@ export function parseHtml(source) {
 			const tag = readTag(src, lt + 2)
 			if (tag.name !== "body" && tag.name !== "html") {
 				for (let k = stack.length - 1; k > 0; k--) {
-					if (stack[k].tag === tag.name) { stack.length = k; break }
+					if (stack[k].tag === tag.name) { stack[k].source_end = lt; stack.length = k; break }
 				}
 			}
 			at = textStart = tag.end
@@ -169,6 +171,8 @@ export function parseHtml(source) {
 			if (P_CLOSERS.has(tag.name)) closeWithin("p", P_SCOPE)
 			if (tag.name === "li") closeWithin("li", LI_SCOPE)
 			const node = makeNode(tag.name, tag.attrs, top(), lineAt(starts, lt))
+			node.source_start = tag.end
+			node.source_end = src.length
 			top().children.push(node)
 			if (tag.name === "body") sawBody = true
 			if (tag.attrs.id) root.ids.set(tag.attrs.id, (root.ids.get(tag.attrs.id) ?? 0) + 1)

package/packages/omo-codex/plugin/skills/ulw-research/scripts/html-markup.mjs

@@ -61,10 +61,10 @@ function scriptEnd(src, from) {
 function closeOf(src, from, name) {
 	if (name === "script") return scriptEnd(src, from)
 	if (RAW.has(name)) {
-		const close = new RegExp(`</${name}(?=[\\s/>])[^>]*>`, "gi")
+		const close = new RegExp(`</${name}(?=[\\s/>])`, "gi")
 		close.lastIndex = from
 		const match = close.exec(src)
-		return match ? match.index + match[0].length : src.length
+		return match ? readTag(src, match.index + 2).end : src.length
 	}
 	let depth = 0
 	let stop = src.length

package/packages/omo-codex/plugin/skills/ulw-research/scripts/html-text-map.mjs

@@ -0,0 +1,140 @@
+// html-text-map.mjs - the reader-visible text of a page, with a source map back into the markup.
+//
+// extractHtml(html) returns { root, text, blocks, starts, ends }: `text` is one line per block
+// (prose blocks and table cells; whitespace collapsed, entities decoded) and text unit k came from
+// html.slice(starts[k], ends[k]). Only text nodes are read: attribute values, CSS, scripts, and
+// anything a reader never sees (head, script, style, svg, noscript, template, code-like elements,
+// aria-hidden="true" and their descendants, and what the page's CSS hides: css-hiding.mjs)
+// contribute nothing, so a locator over `text` can never land in markup. A synthetic separator
+// (collapsed break, line feed) maps to an empty range at the previous character's end.
+// Plain Node ESM, sibling imports only.
+
+import { cssVisibility } from "./css-hiding.mjs"
+import { decodeOne } from "./entities.mjs"
+import { parseHtml, PROSE_BREAKS, PROSE_TAGS } from "./html-lite.mjs"
+
+const SKIP = new Set(["head", "script", "style", "svg", "code", "pre", "kbd", "samp", "template", "noscript"])
+const INLINE = new Set([
+	"a", "abbr", "b", "bdi", "bdo", "cite", "data", "del", "dfn", "em", "font", "i", "ins", "label", "mark", "q", "s",
+	"small", "span", "strong", "sub", "sup", "time", "u", "var",
+])
+const SPACE = /\s/
+
+/** null when a reader never sees the element or anything inside it, else whether its own text shows (css: cssVisibility). */
+function shownState(node, css, parentShown) {
+	if (SKIP.has(node.tag) || String(node.attrs?.["aria-hidden"] ?? "").trim().toLowerCase() === "true") return null
+	return css(node, parentShown)
+}
+
+function newLine() {
+	return { node: null, text: "", starts: [], ends: [], space: null }
+}
+
+function put(line, unit, start, end) {
+	if (SPACE.test(unit)) {
+		if (line.text !== "" && line.space === null) line.space = [start, end]
+		return
+	}
+	if (line.space !== null) {
+		line.text += " "
+		line.starts.push(line.space[0])
+		line.ends.push(line.space[1])
+		line.space = null
+	}
+	line.text += unit
+	line.starts.push(start)
+	line.ends.push(end)
+}
+
+/** A collapsible break with no source character of its own. */
+function softBreak(line) {
+	if (line.text !== "" && line.space === null) {
+		const at = line.ends[line.ends.length - 1]
+		line.space = [at, at]
+	}
+}
+
+/** Append a text node's source range, decoding entities exactly as decodeEntities does. */
+function putText(line, src, from, to) {
+	for (let at = from; at < to; ) {
+		if (src[at] === "&") {
+			const semi = src.indexOf(";", at + 1)
+			const decoded = semi !== -1 && semi < to && semi - at <= 12 ? decodeOne(src.slice(at + 1, semi)) : null
+			if (decoded !== null) {
+				for (let k = 0; k < decoded.length; k++) put(line, decoded[k], at, semi + 1)
+				at = semi + 1
+				continue
+			}
+		}
+		put(line, src[at], at, at + 1)
+		at++
+	}
+}
+
+function putProse(line, src, node, css, shown) {
+	for (const child of node.children) {
+		if (child.tag === "#text") {
+			if (shown) putText(line, src, child.source_start, child.source_end)
+			continue
+		}
+		const state = shownState(child, css, shown)
+		if (state === null) continue
+		const breaks = PROSE_BREAKS.has(child.tag)
+		if (breaks) softBreak(line)
+		putProse(line, src, child, css, state)
+		if (breaks) softBreak(line)
+	}
+}
+
+/** See the file comment. blocks: [{ node, start, end }] with text.slice(start, end) one block line. */
+export function extractHtml(html) {
+	const src = String(html)
+	const root = parseHtml(src)
+	const css = cssVisibility(root)
+	const lines = []
+	let line = newLine()
+	const flush = (node) => {
+		if (line.text !== "") lines.push({ ...line, node })
+		line = newLine()
+	}
+	const walk = (node, shown) => {
+		for (const child of node.children) {
+			if (child.tag === "#text") {
+				if (shown) putText(line, src, child.source_start, child.source_end)
+				continue
+			}
+			const state = shownState(child, css, shown)
+			if (state === null) continue
+			if (child.tag === "br") flush(node)
+			else if (INLINE.has(child.tag)) walk(child, state)
+			else if (PROSE_TAGS.has(child.tag)) {
+				flush(node)
+				putProse(line, src, child, css, state)
+				flush(child)
+			} else {
+				flush(node)
+				walk(child, state)
+				flush(child)
+			}
+		}
+	}
+	walk(root, true)
+	flush(root)
+	const blocks = []
+	const starts = []
+	const ends = []
+	let text = ""
+	for (const entry of lines) {
+		if (text !== "") {
+			const at = ends[ends.length - 1]
+			text += "\n"
+			starts.push(at)
+			ends.push(at)
+		}
+		blocks.push({ node: entry.node, start: text.length, end: text.length + entry.text.length })
+		text += entry.text
+		starts.push(...entry.starts)
+		ends.push(...entry.ends)
+	}
+	return { root, text, blocks, starts, ends }
+}

package/packages/omo-codex/plugin/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/packages/omo-codex/plugin/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/packages/omo-codex/plugin/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/packages/omo-codex/plugin/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/packages/omo-codex/plugin/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})`)
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/outcome.mjs

@@ -1,14 +1,13 @@
 // 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, MANIFEST_CODES, normalizeManifest, SCHEMA_VERSION, validateOutcomeManifest } from "./contracts.mjs"
+import { runStart } from "./outcome-start.mjs"
 
 export const MANIFEST_FILENAME = "outcome.json"
 const MISSING = MANIFEST_CODES[0]
-const SESSION_STAMP = /^(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})$/
 const SOURCE_LINE = /^\[(S|Source )\d+\]/
 const URL_PATTERN = /https?:\/\/[^\s)<>\]"'`]+/g
 const DRAFT_MARKER = "STATUS: draft"
@@ -33,26 +32,20 @@ function assertOneOf(code, label, value, allowed) {
 
 const clone = (manifest) => structuredClone(manifest)
 const isMissing = (error) => error?.code === "ENOENT" || error?.code === "ENOTDIR"
-
 function stamp(now) {
 	return (now ?? new Date()).toISOString()
 }
-
-/** Local wall-clock start time from a `YYYYMMDD-HHMMSS` session dir basename. */
-export function parseSessionStart(sessionDir) {
-	const match = SESSION_STAMP.exec(basename(sessionDir))
-	if (!match) throw new OutcomeError("invalid_session_dir", `session dir basename must be YYYYMMDD-HHMMSS: ${sessionDir}`)
-	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) {
-		throw new OutcomeError("invalid_session_dir", `session dir basename is not a real local time: ${sessionDir}`)
+/** The run clock outcome init records (outcome-start.mjs owns the contract). */
+export function parseSessionStart(sessionDir, { startedAt, now } = {}) {
+	const fail = (message) => {
+		throw new OutcomeError("invalid_session_dir", message)
 	}
-	return date
+	return runStart({ sessionDir, startedAt, now, validManifest: (data) => validateOutcomeManifest(normalizeManifest(data)).ok, fail })
 }
 
-/** @param {{ sessionDir: string, promised: string[], lane: string|null, interview?: object|null, now?: Date }} input */
-export function initManifest({ sessionDir, promised, lane, interview = null, now }) {
-	const startedAt = parseSessionStart(sessionDir).toISOString()
+/** @param {{ sessionDir: string, promised: string[], lane: string|null, interview?: object|null, now?: Date, startedAt?: string }} input */
+export function initManifest({ sessionDir, promised, lane, interview = null, now, startedAt: recorded }) {
+	const startedAt = parseSessionStart(sessionDir, { startedAt: recorded, now }).toISOString()
 	if (lane !== null && lane !== undefined) assertOneOf("unknown_lane", "lane", lane, LANES)
 	const formats = [...new Set(promised)]
 	for (const format of formats) assertOneOf("unknown_format", "deliverable format", format, DELIVERABLE_FORMATS)
@@ -74,9 +67,7 @@ export function initManifest({ sessionDir, promised, lane, interview = null, now
 	}
 }
 
-/**
- * Set one format's row; every other row is kept as is. An unpromised format gets a new
- * row with promised=false. The row's detail fields are replaced by the ones given.
+/** Set one format's row, keeping other rows. New formats have promised=false.
  * @param {{ path?: string, reason?: string, pages?: number, bytes?: number, now?: Date }} [detail]
  */
 export function setDeliverable(manifest, format, status, detail = {}) {
@@ -143,9 +134,7 @@ export function verifyManifest(manifest, fs = nodeFs) {
 	return { ok: problems.length === 0, problems }
 }
 
-/**
- * none = missing or empty file; partial = `STATUS: draft` in the first 5 lines, or the
- * manifest (given, else a sibling outcome.json) still has a pending row; else complete.
+/** Missing/empty = none; draft marker or pending manifest = partial; else complete.
  * @returns {"none"|"partial"|"complete"}
  */
 export function deliverableState(deliverablePath, manifestOrNull) {