lazycodex-ai 5.1.43 → 5.1.45

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

@@ -0,0 +1,103 @@
+// fact-ledger.mjs - the verbatim fact ledger: one row per measured, quoted, derived, assumed,
+// or converted value, with its source locator and exact rational. Rows are never deleted:
+// retract and supersede change status and append an event. Validation and the field vocabulary
+// live in fact-ledger-schema.mjs and are re-exported here. node: builtins only.
+
+import { existsSync } from "node:fs"
+import { join } from "node:path"
+
+import { CliError, readJsonFile, writeJsonAtomic } from "./cli-support.mjs"
+import { DECIMAL, exactComesFromValue, exactFromDecimal, idPrefix, isString } from "./fact-ledger-kinds.mjs"
+import { LEDGER_SCHEMA_VERSION, ROW_DEFAULTS, ROW_FIELDS, transitionError, validateLedger } from "./fact-ledger-schema.mjs"
+
+export { exactFromDecimal } from "./fact-ledger-kinds.mjs"
+export { FACT_KINDS, FACT_STATUSES, LEDGER_SCHEMA_VERSION, OPERATIONS, QUALIFIERS, ROW_FIELDS, TRANSITIONS, transitionError, validateLedger } from "./fact-ledger-schema.mjs"
+
+export const LEDGER_FILENAME = "fact-ledger.json"
+
+export function emptyLedger() {
+	return { schemaVersion: LEDGER_SCHEMA_VERSION, rows: [], events: [] }
+}
+
+function assertValid(ledger) {
+	const errors = validateLedger(ledger)
+	if (errors.length > 0) throw new CliError(`invalid fact ledger: ${errors.join("; ")}`)
+}
+
+export function readLedger(dir) {
+	const file = join(dir, LEDGER_FILENAME)
+	if (!existsSync(file)) return emptyLedger()
+	const ledger = readJsonFile(file)
+	assertValid(ledger)
+	return ledger
+}
+
+export function writeLedger(dir, ledger) {
+	assertValid(ledger)
+	const file = join(dir, LEDGER_FILENAME)
+	writeJsonAtomic(file, ledger)
+	return file
+}
+
+const ID_NUMBER = Object.freeze({ F: /^F(\d+)$/, Q: /^Q(\d+)$/ })
+
+/** The next id with the kind's prefix from KIND_RULES (F<n> for value rows, Q<n> for quotes). */
+export function nextId(ledger, kind) {
+	const prefix = idPrefix(kind)
+	let max = 0
+	for (const row of ledger.rows) {
+		const match = ID_NUMBER[prefix].exec(row.fact_id ?? "")
+		if (match) max = Math.max(max, Number(match[1]))
+	}
+	return `${prefix}${max + 1}`
+}
+
+/**
+ * Fill defaults, assign the next id, validate the whole ledger (provenance included), then append.
+ * Only kinds whose KIND_RULES exact is from_value (measured) get exact from their decimal:
+ * derived and converted rows carry the exact that derive computed from the operands and factor,
+ * never one read back from the rounded value.
+ */
+export function addRow(ledger, row) {
+	const filled = { ...structuredClone(ROW_DEFAULTS), ...row, fact_id: row.fact_id ?? nextId(ledger, row.kind) }
+	if (exactComesFromValue(filled.kind) && filled.exact === null && isString(filled.value) && DECIMAL.test(filled.value)) {
+		filled.exact = exactFromDecimal(filled.value)
+	}
+	const ordered = Object.fromEntries(ROW_FIELDS.filter((key) => Object.hasOwn(filled, key)).map((key) => [key, filled[key]]))
+	for (const key of Object.keys(filled)) if (!ROW_FIELDS.includes(key)) ordered[key] = filled[key]
+	assertValid({ ...ledger, rows: [...ledger.rows, ordered] })
+	ledger.rows.push(ordered)
+	return ordered
+}
+
+/** Build the event from the row's current status and append it only if transitionError allows it. */
+function changeStatus(ledger, id, to, replacement, reason) {
+	const row = ledger.rows.find((candidate) => candidate.fact_id === id)
+	const event = { fact_id: id, from: row?.status ?? null, to, replacement: replacement ?? null, reason }
+	const problem = transitionError(new Map(ledger.rows.map((candidate) => [candidate.fact_id, candidate.status])), event)
+	if (problem) throw new CliError(problem)
+	ledger.events.push(event)
+	row.status = to
+	return row
+}
+
+export function retractRow(ledger, id, reason) {
+	return changeStatus(ledger, id, "retracted", null, reason)
+}
+
+export function supersedeRow(ledger, id, replacementId, reason) {
+	return changeStatus(ledger, id, "superseded", replacementId, reason)
+}
+
+function cell(value) {
+	return value === null || value === undefined ? "" : String(value).replace(/\|/g, "\\|").replace(/\n/g, " ")
+}
+
+/** The `--view` table: one line per row, retracted and superseded rows included. */
+export function renderLedgerMarkdown(ledger) {
+	const lines = ["| fact_id | kind | label | value | unit | source | status | raw |", "|---|---|---|---|---|---|---|---|"]
+	for (const row of ledger.rows) {
+		lines.push(`| ${[row.fact_id, row.kind, row.label, row.value, row.unit, row.source_id, row.status, row.raw].map(cell).join(" | ")} |`)
+	}
+	return `${lines.join("\n")}\n`
+}

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

@@ -0,0 +1,145 @@
+// fidelity-brief.mjs - parse the `## Fidelity` block of brief.md and decide whether it is locked.
+//
+// Grammar (fable-interview.md section 3, "Parser contract"): the block starts at a line
+// `## Fidelity` and ends at the next `## ` heading. It holds the seven field lines below, in any
+// order, each `<field>: <value> (answered_by: user|default|request|pending)`, plus an optional
+// `asked: <field>, <field>` history line. Values carry no parentheses, and `answered_by: pending`
+// is legal only with the value `pending`. Trailing whitespace on a line is ignored; a second
+// `## Fidelity` block is a parse error. This module parses; it never interprets a value, which
+// is each consumer's job. Plain Node ESM, node: builtins only.
+
+import { readFileSync } from "node:fs"
+
+export const FIDELITY_FIELDS = Object.freeze([
+	"as of",
+	"meaning check",
+	"source floor",
+	"derived numbers",
+	"languages",
+	"identifier classes",
+	"fallback",
+])
+export const FIDELITY_ANSWERED_BY = Object.freeze(["user", "default", "request", "pending"])
+const LOCKED_ANSWERED_BY = new Set(["user", "default", "request"])
+
+export const FIDELITY_INCOMPLETE = "fidelity_interview_incomplete"
+const INCOMPLETE_HINT =
+	"A fidelity field is pending or missing in brief.md; answer the open question or record its default, then rerun."
+
+const BLOCK_HEADING = /^## Fidelity\s*$/
+const NEXT_HEADING = /^## /
+const FIELD_LINE = /^([a-z][a-z ]*[a-z]): ([^()]+) \(answered_by: (user|default|request|pending)\)$/
+const ASKED_LINE = /^asked:(.*)$/
+
+function blockLines(markdown) {
+	const lines = String(markdown)
+		.split(/\r?\n/)
+		.map((line) => line.trimEnd())
+	const headings = lines.flatMap((line, index) => (BLOCK_HEADING.test(line) ? [index] : []))
+	if (headings.length === 0) return null
+	const [start, ...duplicates] = headings
+	const body = []
+	for (let index = start + 1; index < lines.length; index += 1) {
+		if (NEXT_HEADING.test(lines[index])) break
+		body.push({ text: lines[index], line: index + 1 })
+	}
+	return { body, duplicates: duplicates.map((index) => index + 1) }
+}
+
+function parseAsked(rest, line, text, errors) {
+	const names = rest
+		.split(",")
+		.map((name) => name.trim())
+		.filter(Boolean)
+	const unknown = names.filter((name) => !FIDELITY_FIELDS.includes(name))
+	if (unknown.length > 0) {
+		errors.push(`line ${line}: malformed asked line, unknown field ${unknown.join(", ")}: ${text}`)
+		return []
+	}
+	return names
+}
+
+function parseFieldLine({ text, line }, parsed, errors) {
+	const match = FIELD_LINE.exec(text)
+	if (!match) return errors.push(`line ${line}: malformed fidelity line: ${text}`)
+	const [, field, rawValue, answeredBy] = match
+	const value = rawValue.trim()
+	if (!FIDELITY_FIELDS.includes(field)) return errors.push(`line ${line}: malformed fidelity line, unknown field "${field}": ${text}`)
+	if (Object.hasOwn(parsed.fields, field)) return errors.push(`line ${line}: malformed fidelity line, duplicate field "${field}": ${text}`)
+	if ((answeredBy === "pending") !== (value === "pending")) {
+		return errors.push(`line ${line}: malformed fidelity line, value pending and answered_by: pending go together: ${text}`)
+	}
+	parsed.fields[field] = value
+	parsed.answered_by[field] = answeredBy
+}
+
+/**
+ * @param {string} briefMd the whole brief.md text
+ * @returns {{ present: boolean, fields: Record<string, string>, answered_by: Record<string, string>,
+ *   asked: string[], missing: string[], pending: string[], errors: string[] }}
+ */
+export function parseFidelityBlock(briefMd) {
+	const parsed = { present: false, fields: {}, answered_by: {}, asked: [], missing: [], pending: [], errors: [] }
+	const block = blockLines(briefMd)
+	if (block !== null) {
+		const { body, duplicates } = block
+		parsed.present = true
+		for (const line of duplicates) parsed.errors.push(`line ${line}: duplicate ## Fidelity block, only one is allowed`)
+		let sawAsked = false
+		for (const entry of body) {
+			if (entry.text.trim() === "") continue
+			const asked = ASKED_LINE.exec(entry.text)
+			if (!asked) {
+				parseFieldLine(entry, parsed, parsed.errors)
+				continue
+			}
+			if (sawAsked) parsed.errors.push(`line ${entry.line}: malformed asked line, duplicate: ${entry.text}`)
+			else parsed.asked = parseAsked(asked[1], entry.line, entry.text, parsed.errors)
+			sawAsked = true
+		}
+	}
+	parsed.missing = FIDELITY_FIELDS.filter((field) => !Object.hasOwn(parsed.fields, field))
+	parsed.pending = FIDELITY_FIELDS.filter((field) => parsed.answered_by[field] === "pending")
+	return parsed
+}
+
+/** Locked = no parse error and all seven fields present with answered_by user, default, or request. */
+export function isLocked(parsed) {
+	if (!parsed || parsed.errors.length > 0) return false
+	return FIDELITY_FIELDS.every((field) => Object.hasOwn(parsed.fields, field) && LOCKED_ANSWERED_BY.has(parsed.answered_by[field]))
+}
+
+function incompleteDefect(briefPath, parsed) {
+	const reasons = []
+	if (!parsed.present) reasons.push("no ## Fidelity block")
+	else if (parsed.missing.length > 0) reasons.push(`missing: ${parsed.missing.join(", ")}`)
+	if (parsed.pending.length > 0) reasons.push(`pending: ${parsed.pending.join(", ")}`)
+	return {
+		code: FIDELITY_INCOMPLETE,
+		severity: "blocker",
+		integrity: true,
+		selector: null,
+		line: null,
+		message: `${briefPath}: fidelity interview incomplete (${reasons.join("; ")})`,
+		hint: INCOMPLETE_HINT,
+	}
+}
+
+/**
+ * The lock check the reader-facing CLI stages run before writing anything.
+ * exitCode 0 = locked; 1 = pending, missing, or no brief (one `fidelity_interview_incomplete`
+ * defect); 2 = malformed block (usage error, `errors` name the lines, no defect).
+ * @param {string} briefPath
+ */
+export function requireLockedBrief(briefPath) {
+	let markdown = ""
+	try {
+		markdown = readFileSync(briefPath, "utf8")
+	} catch (error) {
+		if (error?.code !== "ENOENT") throw error
+	}
+	const parsed = parseFidelityBlock(markdown)
+	if (parsed.errors.length > 0) return { locked: false, exitCode: 2, defects: [], errors: parsed.errors, parsed }
+	if (isLocked(parsed)) return { locked: true, exitCode: 0, defects: [], errors: [], parsed }
+	return { locked: false, exitCode: 1, defects: [incompleteDefect(briefPath, parsed)], errors: [], parsed }
+}

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

@@ -0,0 +1,63 @@
+// fidelity-state.mjs - per-sentence failure counts for the fidelity repair loop. A sentence is
+// keyed by its section slug and the sorted fact ids it cites, so a reworded sentence that
+// cites the same facts keeps its count. node: builtins only.
+
+import { existsSync } from "node:fs"
+import { join } from "node:path"
+
+import { CliError, readJsonFile, writeJsonAtomic } from "./cli-support.mjs"
+
+export const STATE_FILENAME = "fidelity-state.json"
+export const STATE_SCHEMA_VERSION = 1
+
+/** slug + '#' + the fact ids sorted and joined by ','. */
+export function sentenceKey(sectionSlug, factIds) {
+	return `${sectionSlug}#${[...factIds].sort().join(",")}`
+}
+
+function emptyState() {
+	return { schemaVersion: STATE_SCHEMA_VERSION, failures: {}, replaced: [] }
+}
+
+function isValid(state) {
+	return (
+		state !== null &&
+		typeof state === "object" &&
+		state.schemaVersion === STATE_SCHEMA_VERSION &&
+		state.failures !== null &&
+		typeof state.failures === "object" &&
+		!Array.isArray(state.failures) &&
+		Object.values(state.failures).every((count) => Number.isInteger(count) && count >= 0) &&
+		Array.isArray(state.replaced) &&
+		state.replaced.every((key) => typeof key === "string")
+	)
+}
+
+export function readState(dir) {
+	const file = join(dir, STATE_FILENAME)
+	if (!existsSync(file)) return emptyState()
+	const state = readJsonFile(file)
+	if (!isValid(state)) throw new CliError(`${file} is not a valid fidelity state`)
+	return state
+}
+
+export function recordFailure(state, key) {
+	state.failures[key] = (state.failures[key] ?? 0) + 1
+	return state.failures[key]
+}
+
+export function failureCount(state, key) {
+	return state.failures[key] ?? 0
+}
+
+export function markReplaced(state, key) {
+	if (!state.replaced.includes(key)) state.replaced.push(key)
+	return state
+}
+
+export function writeState(dir, state) {
+	if (!isValid(state)) throw new CliError("refusing to write an invalid fidelity state")
+	const file = join(dir, STATE_FILENAME)
+	writeJsonAtomic(file, state)
+	return file
+}

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

@@ -108,7 +108,7 @@ function walkBody(ctx, node, state) {
 	}
 }
 
-function buildContext(doc, options) {
+export function buildContext(doc, options) {
 	const lineageMode = options.lineageMode ?? "inline"
 	if (!LINEAGE_MODES.includes(lineageMode)) throw new TypeError(`lineageMode must be one of ${LINEAGE_MODES.join(", ")}`)
 	const closingPattern = options.closingPattern ? toRegExp(options.closingPattern) : null

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

@@ -9,7 +9,7 @@ import { join } from "node:path"
 import { proseText } from "./html-lite.mjs"
 
 const MIN_SECTION_PROSE = 120
-const UNCHECKED_KINDS = new Set(["closing", "sources", "toc", "appendix", "glossary"])
+export const UNCHECKED_KINDS = new Set(["closing", "sources", "toc", "appendix", "glossary"])
 const DEFINITION_TAGS = new Set(["p", "li", "dd", "dt", "td"])
 const DEFINITION_LINE = /^\[(S|Source\s*)(\d+)\]/i
 const MIN_DEFINITIONS = 3

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

@@ -4,6 +4,7 @@
 // Plain Node ESM, sibling imports only.
 
 import { proseText } from "./html-lite.mjs"
+import { CLAIMS, NOT_CLAIMS } from "./numerals.mjs"
 
 const HANGUL = /[\uAC00-\uD7A3]/g
 const KEEP_ALL = /word-break\s*:\s*keep-all/i
@@ -19,33 +20,6 @@ const MAX_HEADING_WORDS = 12
 const LINEAGE_TOKEN = /\b(?:MEASURED|ASSUMED|DERIVED)\b/
 const NUMBER_CONTAINERS = new Set(["figure", "table", "nav", "header", "footer"])
 const MAX_UNSOURCED = 50
-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. */
-const NOT_CLAIMS = [
-	/\b\d{4}[-./]\d{1,2}(?:[-./]\d{1,2})?\b/g,
-	/\b\d{2}\.\d{2}\.\d{2}\b/g,
-	/\d{2,4}\s*\uB144\s*\d{1,2}\s*\uC6D4(?:\s*\d{1,2}\s*\uC77C)?/g,
-	/\d{1,2}\s*\uC6D4(?:\s*\d{1,2}\s*\uC77C)?/g,
-	/(?:19|20)\d{2}\s*\uB144/g,
-	new RegExp(`\\b${MONTH}\\s+\\d{1,2}(?:st|nd|rd|th)?(?:,?\\s+\\d{4})?`, "gi"),
-	new RegExp(`\\b\\d{1,2}(?:st|nd|rd|th)?\\s+${MONTH}(?:\\s+\\d{4})?`, "gi"),
-	/\bv\d+(?:\.\d+)*\b|\b\d+(?:\.\d+){2,}\b/gi,
-	/\b(?:version|ver\.?|release)\s*\d+(?:\.\d+)*/gi,
-	/\b(?:fig(?:ure)?\.?|table|chart|section|step|phase|wave|part)\s*\d+(?:\.\d+)*/gi,
-	/(?:\uADF8\uB9BC|\uB3C4\uD45C|\uD45C|\uBC84\uC804)\s*\d+(?:\.\d+)*/g,
-	/\b\d{1,2}:\d{2}\b/g,
-	/\b(?:19|20)\d{2}s?\b/g,
-]
-const NUM = "(?<![\\p{L}\\d.,])\\d+(?:[.,]\\d+)*"
-const UNIT =
-	"(?:%|\\u2030|\\u00D7|\\uD37C\\uC13C\\uD2B8|\\uB2EC\\uB7EC|\\uC720\\uB85C|\\uC5D4|\\uC6D0|\\uB9CC|\\uC5B5|\\uC870|\\uCC9C|\\uCD08|\\uBD84|\\uC2DC\\uAC04|\\uC77C|\\uC8FC|\\uAC1C\\uC6D4|\\uB144|\\uBA85|\\uAC74|\\uAC1C|\\uD68C|\\uBC88|\\uBC30" +
-	"|(?:percent|pp|bps?|x|k|m|b|bn|million|billion|thousand|trillion|usd|krw|eur|ms|s|secs?|seconds?|mins?|minutes?|h|hrs?|hours?|days?|weeks?|months?|years?|kb|mb|gb|tb|users?|people|employees|engineers|tokens?|requests?|stars?|downloads?|customers?)(?![\\p{L}\\d]))"
-const CLAIMS = [
-	new RegExp(`[$\\u20AC\\u00A3\\u00A5\\u20A9]\\s?${NUM}`, "u"),
-	new RegExp(`${NUM}\\s?${UNIT}`, "iu"),
-	/(?<![\d.,])\d{1,3}(?:,\d{3})+(?![\d,])/,
-	/(?<![\d.])\d+\.\d+(?![\d.])/,
-]
 
 function snippet(text, index, span = 24) {
 	return text.slice(Math.max(0, index - span), index + span).trim()

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

@@ -0,0 +1,47 @@
+// Bilingual fidelity lexicon: data only, read by the fidelity checks and the meaning-pair router.
+// Korean entries are \u escapes (this directory ships no Hangul); each list is frozen.
+
+// Hedge tokens: a source hedge the report drops is hedge_dropped.
+export const HEDGES = Object.freeze([
+	...["estimated", "about", "approximately", "may", "might", "expected", "forecast", "provisional", "not yet"],
+	...["\uCD94\uC815", "\uC57D", "\uAC00\uB2A5", "\uC804\uB9DD", "\uC608\uC0C1", "\uC7A0\uC815", "\uC544\uC9C1", "\uBBF8\uD655\uC815", "\uAC83\uC73C\uB85C \uBCF4\uC778\uB2E4"],
+])
+
+// Closed qualifier list for the ledger qualifier field (bounding or approximation words).
+export const QUALIFIERS = Object.freeze([
+	...["up to", "at least", "at most", "about", "approximately", "nearly", "over", "under", "more than", "less than"],
+	...["\uCD5C\uB300", "\uCD5C\uC18C", "\uC57D", "\uC774\uC0C1", "\uC774\uD558", "\uBBF8\uB9CC", "\uCD08\uACFC", "\uB0B4\uC678", "\uAE4C\uC9C0"],
+])
+
+// Direction classes: a source in one class and an assertion in the other is direction_flipped.
+export const DIRECTION = Object.freeze({
+	up: Object.freeze([...["increase", "rise", "grow", "up"], ...["\uC99D\uAC00", "\uC0C1\uC2B9", "\uB298"]]),
+	down: Object.freeze([...["decrease", "fall", "decline", "down"], ...["\uAC10\uC18C", "\uD558\uB77D", "\uC904"]]),
+})
+
+// Causal connectives: one in the assertion but in no supporting quote is causality_added.
+export const CAUSAL = Object.freeze([
+	...["because", "due to", "leads to", "results in", "causes", "therefore"],
+	...["\uB54C\uBB38\uC5D0", "\uB85C \uC778\uD574", "\uB530\uB77C\uC11C", "\uADF8\uB798\uC11C", "\uCD08\uB798"],
+])
+
+// Concessive connectives for the hedge-position routing heuristic.
+export const CONCESSIVE = Object.freeze([
+	...["although", "but", "however", "despite", "while"],
+	...["\uC73C\uB098", "\uC9C0\uB9CC", "\uC5D0\uB3C4 \uBD88\uAD6C\uD558\uACE0", "\uBC18\uBA74", "\uC640 \uB2EC\uB9AC"],
+])
+
+// Narrow-to-broad scope pairs [narrow, broad] for scope_widened_warn.
+export const SCOPE_NARROW_TO_BROAD = Object.freeze([
+	Object.freeze(["\uBD81\uBBF8", "\uC804 \uC138\uACC4"]),
+	Object.freeze(["pilot", "system"]),
+	Object.freeze(["one region", "all regions"]),
+	Object.freeze(["\uC77C\uBD80", "\uC804\uCCB4"]),
+	Object.freeze(["\uD55C \uC9C0\uC5ED", "\uC804\uAD6D"]),
+])
+
+// Negation tokens; negated direction cases route to a reader instead of the lexicon.
+export const NEGATION = Object.freeze([
+	...["not", "no", "never"],
+	...["\uC54A", "\uC5C6", "\uBABB"],
+])

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

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

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

@@ -5,8 +5,7 @@
 import * as nodeFs from "node:fs"
 import { basename, dirname, join } from "node:path"
 
-import { DELIVERABLE_FORMATS, DELIVERABLE_STATUSES, GATE_NAMES, GATE_STATUSES, LANES } from "./contracts.mjs"
-import { MANIFEST_CODES, SCHEMA_VERSION, validateOutcomeManifest } from "./contracts.mjs"
+import { DELIVERABLE_FORMATS, DELIVERABLE_STATUSES, GATE_NAMES, GATE_STATUSES, LANES, MANIFEST_CODES, normalizeManifest, SCHEMA_VERSION, validateOutcomeManifest } from "./contracts.mjs"
 
 export const MANIFEST_FILENAME = "outcome.json"
 const MISSING = MANIFEST_CODES[0]
@@ -226,7 +225,7 @@ function assertValid(manifest, where) {
 export function readManifest(file) {
 	let manifest
 	try {
-		manifest = JSON.parse(nodeFs.readFileSync(file, "utf8"))
+		manifest = normalizeManifest(JSON.parse(nodeFs.readFileSync(file, "utf8")))
 	} catch (error) {
 		if (error instanceof SyntaxError) throw new OutcomeError("invalid_manifest", `${file}: not valid JSON (${error.message})`)
 		throw error