oh-my-opencode 5.1.45 → 5.1.47

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

@@ -0,0 +1,44 @@
+// Precision is stored independently from display strings; generated fields are rederived on replay.
+import { sigFigsOf, toDecimal } from "./rational.mjs"
+import { refuse } from "./unit-errors.mjs"
+
+export const toBig = (r) => ({ num: BigInt(r.num), den: BigInt(r.den) })
+export const toText = (r) => ({ num: String(r.num), den: String(r.den) })
+export const placesOf = (decimal) => (String(decimal).split(".")[1] ?? "").length
+export function terminates(r) {
+	let den = r.den
+	for (const prime of [2n, 5n]) while (den % prime === 0n) den /= prime
+	return den === 1n
+}
+export function precisionOf(row) {
+	if (row.precision !== null && row.precision !== undefined) {
+		const p = row.precision
+		if (!p || typeof p !== "object" || Object.keys(p).sort().join(",") !== "places,sigfigs" || !Number.isSafeInteger(p.places) || p.places < 0 || !Number.isSafeInteger(p.sigfigs) || p.sigfigs < 1) refuse("invalid stored precision", undefined, "precision_field", "{ places: nonnegative integer, sigfigs: positive integer }")
+		return p
+	}
+	return { places: placesOf(row.value), sigfigs: sigFigsOf(row.value) }
+}
+export function resultPrecision(rows, literals, exact, mode) {
+	const inputs = [...rows.map(precisionOf), ...literals.map((value) => precisionOf({ value }))]
+	const places = Math.min(...inputs.map((p) => p.places))
+	const sigfigs = Math.min(...inputs.map((p) => p.sigfigs))
+	if (mode === "places") return { places, sigfigs: sigFigsOf(roundPlaces(exact, places)) }
+	const rendered = toDecimal(exact, sigfigs)
+	return { places: placesOf(rendered), sigfigs }
+}
+export function roundPlaces(r, places) {
+	const digits = ((r.num < 0n ? -r.num : r.num) * 10n ** BigInt(places) * 2n + r.den) / (r.den * 2n)
+	const text = digits.toString().padStart(places + 1, "0")
+	return (r.num < 0n && digits !== 0n ? "-" : "") + (places ? `${text.slice(0, -places)}.${text.slice(-places)}` : text)
+}
+export function renderValue(exact, precision, mode) {
+	const plain = terminates(exact) ? toDecimal(exact) : null
+	const n = precision[mode]
+	if (plain !== null && (mode === "places" ? placesOf(plain) <= n : sigFigsOf(plain) < n)) return plain
+	return mode === "places" ? roundPlaces(exact, n) : toDecimal(exact, n)
+}
+export function display(value, unit) {
+	const [whole, fraction] = value.split(".")
+	const grouped = whole.replace(/\B(?=(\d{3})+(?!\d))/g, ",") + (fraction === undefined ? "" : `.${fraction}`)
+	return unit === null ? grouped : unit === "%" ? `${grouped}%` : `${grouped} ${unit}`
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/unit-rules-shapes.mjs

@@ -0,0 +1,64 @@
+// Structural rules used by the operation table, shared by schema and recomputation.
+import { leaves, parseExpr } from "./fact-expr.mjs"
+import { isRational } from "./fact-ledger-kinds.mjs"
+import { canonicalUnit, RuleError } from "./unit-algebra.mjs"
+import { nonEmpty, object } from "./unit-metadata.mjs"
+import { show } from "./unit-pairs.mjs"
+
+export const COMMON = ["operands null", "operands empty", "wrong arity", "missing operand id", "invalid rational", "no operation", "repeated operand", "self reference",
+	"kind operation", "audit fields", "precision field", "compatibility field", "metadata fields", "noncanonical operand"]
+export const shapes = (...own) => Object.freeze([...COMMON, ...own])
+export const needsContext = (row) => object(row.context) ? null : `${row.operation} rows carry a context object, got ${show(row.context)}`
+export const noContext = (row) => row.context === null ? null : `${row.operation} rows carry no context, got ${show(row.context)}`
+export const repeatedOperand = (ids) => new Set(ids).size !== ids.length ? `operand ${ids.find((id, i) => ids.indexOf(id) !== i)} is repeated: the operands of one row are distinct facts` : null
+
+export function sumShape(row) {
+	const missing = needsContext(row)
+	if (missing) return missing
+	const c = row.context
+	if (Object.keys(c).sort().join(",") !== "disjoint,reference" || typeof c.disjoint !== "boolean" || !(c.reference === null || nonEmpty(c.reference) || object(c.reference))) return "sum context needs exactly boolean disjoint and null, text, or map reference"
+	if (object(c.reference) && (Object.keys(c.reference).sort().join(",") !== [...row.operands].sort().join(",") || !Object.values(c.reference).every(nonEmpty))) return "reference map must name exactly the supplied operands"
+	return null
+}
+
+export function convertShape(row) {
+	const target = object(row.context) ? row.context.target : undefined
+	if (!nonEmpty(target)) return needsContext(row) ?? "a convert row carries its target in context.target"
+	if (Object.keys(row.context).join(",") !== "target") return "convert context has exactly target"
+	try {
+		const canonical = canonicalUnit(target)
+		return canonical === target ? null : `context.target ${show(target)} is not canonical unit text (canonical: ${show(canonical)})`
+	} catch (error) {
+		if (error instanceof RuleError) return `context.target ${show(target)} is not unit text: ${error.detail}`
+		throw error
+	}
+}
+
+export function exprShape(row) {
+	try {
+		const ids = leaves(parseExpr(row.formula)).ids
+		if (ids.length !== row.operands.length || ids.some((id) => !row.operands.includes(id))) return `formula ids ${ids.join(", ")} do not match operands ${row.operands.join(", ")}`
+		return null
+	} catch (error) {
+		if (error instanceof RuleError) return error.detail
+		throw error
+	}
+}
+
+export function rowShape(row, rules) {
+	if (!object(row)) return "the row is not an object"
+	if (!Object.hasOwn(rules, row.operation)) return `operation ${show(row.operation)} is not one of ${Object.keys(rules).join(", ")}`
+	const rule = rules[row.operation]
+	const { operands, exact } = row
+	if (!Array.isArray(operands) || !operands.length || !operands.every(nonEmpty)) return `operands must be a non-empty array of fact ids, got ${show(operands)}`
+	const repeated = repeatedOperand(operands)
+	if (repeated) return repeated
+	if (operands.includes(row.fact_id)) return `${row.fact_id} cites itself as an operand`
+	if (!rule.arity(operands.length)) return `${row.operation} takes ${rule.arityText}, got ${operands.length}`
+	if (!isRational(exact)) return `exact must be { num, den } reduced integer strings, got ${show(exact)}`
+	if (row.kind !== rule.kind) return `kind ${row.kind} must be ${rule.kind} for ${row.operation}`
+	const own = rule.shape(row)
+	if (own) return own
+	if (!nonEmpty(row.formula) || !Array.isArray(row.derived_from) || row.derived_from.length !== operands.length) return "formula and derived_from are required audit fields"
+	return null
+}

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

@@ -0,0 +1,173 @@
+// The sole per-operation registry: guards, context, arithmetic, precision, audit and compatibility.
+import { evaluate, leaves } from "./fact-expr.mjs"
+import { add, div, mul, sub, toDecimal } from "./rational.mjs"
+import { canonicalUnit, inputScale, isAffine, isCurrencyRate, isPercentish, refuse, RuleError, unitOver } from "./unit-algebra.mjs"
+import { checkMetadata, nonEmpty, object, propagatedMetadata } from "./unit-metadata.mjs"
+import { equalUnits, inferExpr, listed, minusUnit, notAffine, show } from "./unit-pairs.mjs"
+import { display, terminates, toBig } from "./unit-precision.mjs"
+import { convertShape, exprShape, noContext, repeatedOperand, rowShape, shapes, sumShape } from "./unit-rules-shapes.mjs"
+import { convertFactor, dimensionOf } from "./units.mjs"
+export { canonicalUnit, inferExpr, isAffine, RuleError }
+
+const EXPR_HINT = "currencies never convert by table: add a dated rate row and use --op expr"
+const compare = (a, b) => a.num * b.den - b.num * a.den
+const SNAPSHOT = ["population", "snapshot_window"]
+const ADDITIVE = [...SNAPSHOT, "accounting_basis"]
+const pair = (a, b) => (spec) => [spec[a], spec[b]]
+const listOf = (spec) => spec.operands
+const generated = (exact, formula, factor = null) => ({ exact, formula, factor })
+const idsOf = (rows) => rows.map((r) => r.fact_id)
+const valuesOf = (rows) => rows.map((r) => toBig(r.exact))
+const ordinary = {
+	kind: "derived", compatibility: "checked", context: () => null, shape: noContext,
+	precision: () => "sigfigs", render: (shown) => shown, metadataResult: propagatedMetadata,
+}
+const binary = { ...ordinary, arity: (n) => n === 2, arityText: "two operands" }
+
+function sharedReference(rows, reference) {
+	if (nonEmpty(reference)) return
+	if (object(reference)) {
+		const named = rows.map((r) => reference[r.fact_id])
+		if (Object.keys(reference).length === rows.length && named.every(nonEmpty) && named.every((v) => v === named[0])) return
+		refuse("% operands name different references or missing/extra ids", undefined, "reference", "one denominator for exactly the operands")
+	}
+	refuse("summing % operands needs one shared reference (denominator): pass reference")
+}
+
+/** Registry rows own every operation-specific choice; consumers only dispatch through these rows. */
+export const OPERATION_RULES = Object.freeze({
+	sum: Object.freeze({
+		...ordinary, arity: (n) => n >= 2, arityText: "two or more operands", operandIds: listOf,
+		inputFields: ["operands", "disjoint", "reference"],
+		context: (s) => ({ disjoint: Object.hasOwn(s, "disjoint") ? s.disjoint : false, reference: Object.hasOwn(s, "reference") ? s.reference : null }),
+		metadata: ADDITIVE, precision: () => "places", shape: sumShape,
+		resultUnit(rows, units, context) {
+			notAffine("sum", rows, units)
+			const unit = equalUnits(rows, units)
+			if (unit === "%") {
+				if (context.disjoint !== true) refuse("summing % operands needs disjoint shares: pass disjoint")
+				sharedReference(rows, context.reference)
+				if (!nonEmpty(context.rationale)) refuse("summing % operands needs a rationale for the disjoint shares")
+				const values = valuesOf(rows)
+				if (values.some((r) => r.num < 0n || r.num > 100n * r.den) || compare(values.reduce(add), { num: 100n, den: 1n }) > 0n) refuse("disjoint shares must each be in [0, 100] and total <= 100", undefined, "share_total", "valid disjoint shares totaling at most 100%")
+			}
+			return unit
+		},
+		calculate: (rows) => generated(valuesOf(rows).reduce(add), idsOf(rows).join(" + ")),
+		malformed: shapes("no context", "% without disjoint", "% without reference", "% without rationale", "unequal units", "affine units", "closed context", "share total"),
+	}),
+	diff: Object.freeze({
+		...binary, operandIds: listOf, metadata: ADDITIVE, precision: () => "places",
+		inputFields: ["operands"],
+		resultUnit: (rows, units) => minusUnit(units[0], units[1], `diff ${listed(rows, units)}`),
+		calculate: (rows) => generated(sub(...valuesOf(rows)), idsOf(rows).join(" - ")),
+		malformed: shapes("%p - % pair", "unit - other unit pair", "affine units", "stray context"),
+	}),
+	growth: Object.freeze({
+		...binary, arityText: "two operands (from, to)", operandIds: pair("from", "to"), metadata: ["population", "accounting_basis"],
+		inputFields: ["from", "to"],
+		resultUnit(rows, units) {
+			const [from, to] = rows
+			notAffine("growth", rows, units)
+			equalUnits(rows, units)
+			if (!nonEmpty(from.entity) || from.entity !== to.entity) refuse(`growth needs one declared entity: ${from.entity} vs ${to.entity}`)
+			if (!nonEmpty(from.valid_at) || !nonEmpty(to.valid_at) || from.valid_at === to.valid_at) refuse(`growth needs two different valid_at periods: ${from.valid_at} vs ${to.valid_at}`)
+			if (toBig(from.exact).num <= 0n) refuse(`growth needs a positive starting value in ${from.fact_id}`)
+			return "%"
+		},
+		calculate(rows) { const [a, b] = valuesOf(rows); const [x, y] = idsOf(rows); return generated(mul(div(sub(b, a), a), 100n), `(${y} - ${x}) / ${x} * 100`) },
+		malformed: shapes("affine units", "unequal units", "entity mismatch", "one period", "from <= 0", "stray context"),
+	}),
+	share: Object.freeze({
+		...binary, arityText: "two operands (part, whole)", operandIds: pair("part", "whole"), metadata: SNAPSHOT,
+		inputFields: ["part", "whole"],
+		resultUnit(rows, units) {
+			notAffine("share", rows, units)
+			equalUnits(rows, units)
+			const [part, whole] = valuesOf(rows)
+			if (whole.num <= 0n) refuse(`share needs a positive whole in ${rows[1].fact_id}`)
+			if (part.num < 0n || compare(part, whole) > 0n) refuse(`share needs 0 <= part <= whole: ${rows[0].fact_id} is outside [0, ${rows[1].fact_id}]`)
+			return "%"
+		},
+		calculate: (rows) => generated(mul(div(...valuesOf(rows)), 100n), `${idsOf(rows).join(" / ")} * 100`),
+		malformed: shapes("affine units", "unequal units", "whole <= 0", "part < 0", "part above whole", "stray context"),
+	}),
+	ratio: Object.freeze({
+		...binary, arityText: "two operands (num, den)", operandIds: pair("num", "den"), metadata: SNAPSHOT,
+		inputFields: ["num", "den"],
+		resultUnit(rows, units) {
+			notAffine("ratio", rows, units)
+			if (toBig(rows[1].exact).num === 0n) refuse(`ratio denominator ${rows[1].fact_id} is zero`)
+			if (units[0] === units[1]) return null
+			if (units.some(isPercentish)) refuse(`a ratio over % or %p needs equal units: ${listed(rows, units)}; use expr`)
+			return unitOver(units[0], units[1])
+		},
+		calculate: (rows) => generated(div(...valuesOf(rows)), idsOf(rows).join(" / ")),
+		malformed: shapes("affine units", "divides by zero", "stray context"),
+	}),
+	convert: Object.freeze({
+		...ordinary, kind: "converted", arity: (n) => n === 1, arityText: "one operand", operandIds: listOf, metadata: [],
+		inputFields: ["operands", "to"],
+		context: (s) => ({ target: canonicalUnit(s.to) }), shape: convertShape,
+		defaultUnit: (s) => s.to,
+		resultUnit(rows, units, context) {
+			if (!nonEmpty(context.target)) refuse("convert needs a target unit")
+			const [from] = units
+			const target = context.target
+			if (from === target) refuse(`${rows[0].fact_id} is already in ${target}`)
+			if ([from, target].some((u) => dimensionOf(u)?.startsWith("currency:"))) refuse(`${rows[0].fact_id} in ${show(from)} has no table conversion to ${target} (a currency)`, EXPR_HINT)
+			if (!convertFactor(from, target)) refuse(`${rows[0].fact_id} in ${show(from)} has no table conversion to ${target}`)
+			return target
+		},
+		calculate(rows, context) {
+			const row = rows[0]
+			const f = convertFactor(row.unit, context.target)
+			const scale = { num: f.num, den: f.den }
+			const text = terminates(scale) ? toDecimal(scale) : `${scale.num}/${scale.den}`
+			return generated(add(mul(toBig(row.exact), scale), f.offset ?? 0n), `${row.fact_id} * ${text}${f.offset ? ` + ${f.offset.num}/${f.offset.den}` : ""}`, terminates(scale) ? text : null)
+		},
+		render: (shown, rows) => `${shown} (${display(rows[0].value, rows[0].unit)})`,
+		malformed: shapes("no context", "empty target", "alias target", "currency target", "no factor to target", "closed context"),
+	}),
+	expr: Object.freeze({
+		...ordinary, arity: (n) => n >= 1, arityText: "one or more operands", compatibility: "unchecked",
+		expression: true, operandIds: (s, ast) => Object.hasOwn(s, "operands") ? s.operands : leaves(ast).ids,
+		inputFields: ["formula", "operands"],
+		metadata: [], precision: (ast) => ast?.op === "+" || ast?.op === "-" ? "places" : "sigfigs",
+		resultUnit(rows, units, _context, ast) {
+			for (const r of rows) if (isCurrencyRate(r.unit) && !nonEmpty(r.valid_at)) refuse(`FX rate ${r.fact_id} needs a dated valid_at; date compatibility remains unchecked`, EXPR_HINT, "undated_rate", "a dated FX rate row")
+			const inferred = inferExpr(ast, new Map(rows.map((r, i) => [r.fact_id, units[i]])), new Map(rows.map((r) => [r.fact_id, r]))).unit
+			notAffine("expr", rows, units)
+			return inferred
+		},
+		calculate(rows, _context, ast, formula) {
+			const { units } = inferExpr(ast, new Map(rows.map((r) => [r.fact_id, r.unit])))
+			return generated(evaluate(ast, new Map(rows.map((r) => [r.fact_id, toBig(r.exact)])), units), formula.trim())
+		},
+		shape: (row) => noContext(row) ?? exprShape(row),
+		malformed: shapes("formula id mismatch", "parse error", "divides by zero", "uninferable unit", "affine sum", "stray context", "undated rate"),
+	}),
+})
+
+export function ruleOf(op) {
+	if (!Object.hasOwn(OPERATION_RULES, op)) refuse(`unknown operation ${String(op)}; use one of ${Object.keys(OPERATION_RULES).join(", ")}`, undefined, "operation", Object.keys(OPERATION_RULES))
+	return OPERATION_RULES[op]
+}
+export function operandUnit(row) {
+	if (canonicalUnit(row.unit) !== row.unit || inputScale(row.unit)) refuse(`${row.fact_id} unit must be canonical stored text`, undefined, "noncanonical_operand", { unit: canonicalUnit(row.unit) })
+	return row.unit
+}
+export function expectedUnit(op, rows, { ast = null, context = null } = {}) {
+	const rule = ruleOf(op)
+	const repeated = repeatedOperand(idsOf(rows))
+	if (repeated) refuse(repeated, undefined, "repeated_operand", "distinct operand ids")
+	if (!rule.arity(rows.length)) refuse(`${op} takes ${rule.arityText}, got ${rows.length}`, undefined, "arity", rule.arityText)
+	const units = rows.map(operandUnit)
+	checkMetadata(rows, rule.metadata)
+	return rule.resultUnit(rows, units, context ?? {}, ast)
+}
+export function renderPrecision(op, unit, ast = null) {
+	return unit === "%p" ? "places" : ruleOf(op).precision(ast)
+}
+export const unitMismatch = (op, rows, unit, expected) => `unit ${show(unit)} does not follow from ${op} over ${rows.map((r) => `${r.fact_id} ${r.unit ?? "null"}`).join(", ")}: expected unit ${show(expected)}`
+export const malformed = (row) => rowShape(row, OPERATION_RULES)

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

@@ -10,10 +10,10 @@ import { div, fromDecimal, sub } from "./rational.mjs"
 
 /** [token, dimension, factor, reading, aliases, offset?]; the Korean reading is noted per row. */
 const TABLE = [
-	["mm", "length", "0.001", "open", ["millimeter", "millimeters", "\uBC00\uB9AC\uBBF8\uD130"]], // millimiteo
-	["cm", "length", "0.01", "open", ["centimeter", "centimeters", "\uC13C\uD2F0\uBBF8\uD130"]], // sentimiteo
+	["mm", "length", "0.001", "open", ["millimeter", "millimeters", "millimetre", "millimetres", "\uBC00\uB9AC\uBBF8\uD130"]], // millimiteo
+	["cm", "length", "0.01", "open", ["centimeter", "centimeters", "centimetre", "centimetres", "\uC13C\uD2F0\uBBF8\uD130"]], // sentimiteo
 	["m", "length", "1", "open", ["meter", "meters", "metre", "metres", "\uBBF8\uD130"]], // miteo
-	["km", "length", "1000", "open", ["kilometer", "kilometers", "\uD0AC\uB85C\uBBF8\uD130"]], // killomiteo
+	["km", "length", "1000", "open", ["kilometer", "kilometers", "kilometre", "kilometres", "\uD0AC\uB85C\uBBF8\uD130"]], // killomiteo
 	["g", "mass", "1", "closed", ["gram", "grams", "\uADF8\uB7A8"]], // geuraem
 	["kg", "mass", "1000", "closed", ["kilogram", "kilograms", "\uD0AC\uB85C\uADF8\uB7A8"]], // killogeuraem
 	["t", "mass", "1000000", "closed", ["ton", "tons", "tonne", "tonnes", "\uD1A4"]], // ton
@@ -65,7 +65,7 @@ for (const [token, dimension, factor, reading, aliases, offset] of TABLE) {
 	for (const alias of [token, ...aliases]) {
 		const key = squash(alias)
 		EXACT.set(key, entry)
-		if (key.length > 1 && /^[A-Za-z]+$/.test(key) && !WORD.has(key.toLowerCase())) WORD.set(key.toLowerCase(), entry)
+		if (alias !== token && key.length > 2 && /^[a-z]+$/.test(key) && !WORD.has(key.toLowerCase())) WORD.set(key.toLowerCase(), entry)
 	}
 }
 

package/packages/omo-codex/plugin/test/sync-skills-codex-compatibility.test.mjs

@@ -16,6 +16,7 @@ import {
 	ulwExecuteOriginalCompletion,
 	ulwExecuteOriginalHardRule,
 } from "../scripts/sync-skills.mjs";
+import { removeCodexSkillOverlays } from "./sync-skills-test-support.mjs";
 
 const frontmatter = "---\nname: fixture-sentinel\n---\n\n";
 const opencodeExample = "# SENTINEL_SECTION\ntask(SENTINEL_INPUT)\n";
@@ -177,3 +178,21 @@ test("#given the shared ulw-research skill #when the Codex overlay runs #then th
 	// then
 	assert.notEqual(actual, shared, "the ulw-research overlay anchor no longer matches the shared SKILL.md");
 });
+
+test("#given the ulw-research delivery gates are renumbered #when the Codex overlay runs #then only the proofread gate is dropped", async () => {
+	// given
+	const shared = await readFile(join(sharedSkillsRoot, "ulw-research", "SKILL.md"), "utf8");
+	const renumbered = shared
+		.replace(/^(\d+)(\. \*\*Proofread gate:)/m, (_, numeral, rest) => `${Number(numeral) + 1}${rest}`)
+		.replace(/^(\d+)(\. \*\*Visual QA\.\*\*)/m, (_, numeral, rest) => `${Number(numeral) + 1}${rest}`);
+	assert.notEqual(renumbered, shared, "the renumbering fixture must change the delivery gates");
+
+	// when
+	const actual = applyCodexSkillOverlays("ulw-research", renumbered);
+
+	// then: generated Codex edition contract (no `task(category="writing")` gate; tool-based gates kept)
+	assert.doesNotMatch(actual, /\*\*Proofread gate:/);
+	assert.match(actual, /\*\*Fidelity gate\.\*\*/);
+	assert.match(actual, /inspect the pixels\.\n\n/);
+	assert.equal(removeCodexSkillOverlays("ulw-research", actual), renumbered);
+});

package/packages/omo-codex/plugin/test/sync-skills-test-support.mjs

@@ -158,12 +158,16 @@ prefixes when identity is needed.
 `;
 const reviewWorkCodexGatePattern = new RegExp(reviewWorkCodexGate.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
 
-const ulwResearchOriginalDeliveryGates = "Reading the source markup is not visual QA; inspect the pixels.\n4. **Proofread gate: `task(category=\"writing\", ...)`.** Hand the final text to a dedicated `writing` worker whose only job is language: grammar, spelling, punctuation, terminology consistency, and whether the prose reads NATIVELY in the report's own language. It proofreads only and never composes. It returns a defect list; fix every item and re-run the gate on the delta. Deliver only on a clean pass. This gate runs BEFORE the first delivery, not after the user finds the typo.";
-const ulwResearchCodexDeliveryGate = "Reading the source markup is not visual QA; inspect the pixels.";
+const ulwResearchProofreadGate = "**Proofread gate: `task(category=\"writing\", ...)`.** Hand the final text to a dedicated `writing` worker whose only job is language: grammar, spelling, punctuation, terminology consistency, and whether the prose reads NATIVELY in the report's own language. It proofreads only and never composes, and it never edits the file: it returns `$SESSION_DIR/polish-edits.json`, an array of `{\"before\": ..., \"after\": ..., \"reason\": ...}` where `before` is the exact current text of one or more adjacent sentences. Edits change text only; an edit whose before/after would alter any tag, attribute, comment, or script/style content is rejected, and markup changes go through the full fidelity gates instead. Apply it with `node \"$SKILL_DIR/scripts/report-tools.mjs\" fact polish-apply \"$SESSION_DIR/report.html\" --edits \"$SESSION_DIR/polish-edits.json\" --out \"$SESSION_DIR/report.polished.html\" --session-dir \"$SESSION_DIR\"`: each edit is applied alone, and an edit that changes a fact span, a numeral, a link, or a claim id, or drops a hedge or qualifier the source carries, is `polish_edit_rejected` (a `before` not found exactly once is `polish_edit_unlocated`) and leaves its text unchanged. Send the rejected and unlocated edits back to the same worker with their reasons, plus `$SESSION_DIR/polish-defects.json` and the pre-polish `report.html` the backstop compared against, so the worker sees why each edit was refused; it returns either a rewritten sentence or a new edit list, and the repair round re-runs `fact polish-apply` with `\"$SESSION_DIR/report.polished.html\"` as both input and output, within the repair budget. Then run the backstop `fact polish-diff --before \"$SESSION_DIR/report.html\" --after \"$SESSION_DIR/report.polished.html\" --session-dir \"$SESSION_DIR\"` (exit `1` on `polish_diff_fail`), `fact verify` on `report.polished.html`, and `fact pairs \"$SESSION_DIR/report.polished.html\" --changed-since \"$SESSION_DIR/report.html.fill-map.json\" --session-dir \"$SESSION_DIR\"`, which keeps only the quote and claim pairs whose sentence text changed during polish; run the meaning readers above (cheap, then strong on the flagged pairs) on exactly those pairs and `fact meaning-check` before recording `outcome gate fidelity`. A rewording that keeps every number, hedge, qualifier, and link but swaps who did what to whom therefore still reaches a meaning reader on the delivered text. `report.polished.html` is the report that is delivered. Deliver only on a clean pass. This gate runs BEFORE the first delivery, not after the user finds the typo. Edits must not span entities (such as & or <) or markup; narrow the edit to the surrounding words instead, and a rejected edit comes back with the reason to act on.";
+// The shared skill numbers the proofread gate right after the Visual QA item the Codex edition ends on.
+const ulwResearchVisualQaItemPattern = /^(\d+)\. \*\*Visual QA\.\*\*[^\n]*inspect the pixels\.$/m;
 
 export function removeCodexSkillOverlays(skillName, content) {
 	if (skillName === "ulw-research") {
-		return content.replace(ulwResearchCodexDeliveryGate, ulwResearchOriginalDeliveryGates);
+		return content.replace(
+			ulwResearchVisualQaItemPattern,
+			(item, numeral) => `${item}\n${Number(numeral) + 1}. ${ulwResearchProofreadGate}`,
+		);
 	}
 	if (skillName === "ulw-execute") {
 		return content

package/packages/omo-codex/scripts/install-dist/install-local.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// omo-codex-install:a13cf7e9a95d881bd59c4cfee5cc6277e0ded2733a57e61020e6786ef72839f4:5b4bab0a0600c1ff722c498ab18fcef7cf291fd3a13f074cb2d5ca4db8ecbec4
+// omo-codex-install:3bfe60748136282b06d702bcba5697d924bfdeb7b8416acf24716fd7741de83d:1b18a3321d7501168ee91e2d0c0a937af0f36e681e8bfdfef274f2fc5ce9c26e
 var __esm = (fn, res, err) => () => {
   if (fn)
     try {
@@ -453,13 +453,13 @@ var init_event_id = __esm(() => {
 });
 
 // packages/telemetry-core/src/machine-id.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import os2 from "node:os";
 function getDefaultTelemetryOsProvider() {
   return os2;
 }
 function getTelemetryDistinctId(machineIdPrefix, osProvider = getDefaultTelemetryOsProvider()) {
-  return createHash4("sha256").update(`${machineIdPrefix}${osProvider.hostname()}`).digest("hex");
+  return createHash5("sha256").update(`${machineIdPrefix}${osProvider.hostname()}`).digest("hex");
 }
 var init_machine_id = () => {};
 
@@ -10123,7 +10123,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@oh-my-opencode/omo-codex",
-    version: "5.1.45",
+    version: "5.1.47",
     type: "module",
     private: true,
     description: "Codex harness adapter for oh-my-openagent. Vendored Codex plugin namespace (omo) + TypeScript installer + telemetry.",
@@ -10380,7 +10380,7 @@ function resolveStdio(options) {
   return [options.stdin ?? "ignore", options.stdout ?? "pipe", options.stderr ?? "inherit"];
 }
 function createBunSpawnOptions(options) {
-  return { ...options, windowsHide: true };
+  return { ...options, env: options.env ?? process.env, windowsHide: true };
 }
 function createNodeSpawnOptions(options, platform = process.platform) {
   const nodeOptions = {
@@ -10612,8 +10612,7 @@ function windowsNodeDiscoveryLines() {
     '  for /f "tokens=* delims= " %%N in ("!OMO_NODE_BINARY!") do set "OMO_NODE_BINARY=%%N"',
     `  if "!OMO_NODE_BINARY:~0,1!"=="'" set "OMO_NODE_BINARY=!OMO_NODE_BINARY:~1!"`,
     `  if "!OMO_NODE_BINARY:~-1!"=="'" set "OMO_NODE_BINARY=!OMO_NODE_BINARY:~0,-1!"`,
-    '  if "!OMO_NODE_BINARY:~0,1!"=="^"" set "OMO_NODE_BINARY=!OMO_NODE_BINARY:~1!"',
-    '  if "!OMO_NODE_BINARY:~-1!"=="^"" set "OMO_NODE_BINARY=!OMO_NODE_BINARY:~0,-1!"',
+    '  set "OMO_NODE_BINARY=!OMO_NODE_BINARY:"=!"',
     '  if defined OMO_NODE_BINARY if not exist "!OMO_NODE_BINARY!" set "OMO_NODE_BINARY="',
     ")",
     'if not defined OMO_NODE_BINARY where node >nul 2>nul && set "OMO_NODE_BINARY=node"'
@@ -19616,6 +19615,7 @@ var OmoMemoryReflectionSchema = object({
   merge: _enum(["auto", "integration"]).default("auto"),
   category: string2().min(1).default("quick"),
   timeout_minutes: number2().int().positive().default(15),
+  max_concurrent_runs: number2().int().positive().default(1),
   sandbox: _enum(["auto", "required", "off"]).default("auto")
 }).strict();
 var OmoMemorySyncSchema = object({
@@ -19687,6 +19687,7 @@ var OmoMemoryReflectionLayerSchema = object({
   merge: _enum(["auto", "integration"]).optional(),
   category: string2().min(1).optional(),
   timeout_minutes: number2().int().positive().optional(),
+  max_concurrent_runs: number2().int().positive().optional(),
   sandbox: _enum(["auto", "required", "off"]).optional()
 }).strict();
 var OmoMemorySyncLayerSchema = object({
@@ -19751,7 +19752,7 @@ var OmoMemoryProjectionLayerSchema = object({
 var OmoMemoryAgentOverridesSchema = object({
   enabled: boolean2().optional(),
   agent: string2().min(1).optional(),
-  reflection: OmoMemoryReflectionLayerSchema.optional(),
+  reflection: OmoMemoryReflectionLayerSchema.omit({ max_concurrent_runs: true }).optional(),
   nudge: OmoMemoryNudgeLayerSchema.optional(),
   facts: OmoMemoryFactsLayerSchema.optional(),
   dream: OmoMemoryDreamLayerSchema.optional(),
@@ -19776,6 +19777,7 @@ var OmoMemorySettingsSchema = object({
     merge: "auto",
     category: "quick",
     timeout_minutes: 15,
+    max_concurrent_runs: 1,
     sandbox: "auto"
   }),
   nudge: OmoMemoryNudgeSchema.default({ enabled: true, every_user_turns: 10 }),
@@ -20119,9 +20121,6 @@ var OmoFormatOnMutationSchema = OmoFormatOnMutationLayerSchema.extend({
   timeoutMs: number2().int().positive().default(3000)
 }).strict();
 
-// packages/omo-config-core/src/schema/dori.ts
-var OmoDoriSectionSchema = record(string2(), unknown()).describe("Chat-surface dori settings, owned and validated by a separately installed dori package. omo accepts the key and never reads it.");
-
 // packages/omo-config-core/src/schema/provenance.ts
 var OmoProvenanceSettingsSchema = object({
   workspaces: array(object({
@@ -20138,7 +20137,6 @@ var OmoExcludedModelsSchema = array(string2());
 var OmoTypedHarnessConfigSchema = object({
   provenance: OmoProvenanceSettingsSchema.optional(),
   formatOnMutation: OmoFormatOnMutationLayerSchema.optional(),
-  dori: OmoDoriSectionSchema.optional(),
   categories: OmoCategoriesConfigSchema.optional(),
   agents: OmoAgentsConfigSchema.optional(),
   git_master: OmoGitMasterSettingsLayerSchema.optional(),
@@ -20157,7 +20155,6 @@ var OmoTypedHarnessConfigSchema = object({
 var OmoConfigProfileSchema = object({
   provenance: OmoProvenanceSettingsSchema.optional(),
   formatOnMutation: OmoFormatOnMutationLayerSchema.optional(),
-  dori: OmoDoriSectionSchema.optional(),
   categories: OmoCategoriesConfigSchema.optional(),
   agents: OmoAgentsConfigSchema.optional(),
   git_master: OmoGitMasterSettingsLayerSchema.optional(),
@@ -20180,7 +20177,6 @@ var OmoConfigProfileSchema = object({
 var OmoConfigSchema = object({
   provenance: OmoProvenanceSettingsSchema.optional(),
   formatOnMutation: OmoFormatOnMutationSchema.optional(),
-  dori: OmoDoriSectionSchema.optional(),
   $schema: string2().optional(),
   categories: OmoCategoriesConfigSchema.optional(),
   agents: OmoAgentsConfigSchema.optional(),
@@ -20207,7 +20203,6 @@ var OmoConfigSchema = object({
 var OmoConfigLayerSchema = object({
   provenance: OmoProvenanceSettingsSchema.optional(),
   formatOnMutation: OmoFormatOnMutationLayerSchema.optional(),
-  dori: OmoDoriSectionSchema.optional(),
   $schema: string2().optional(),
   categories: OmoCategoriesConfigSchema.optional(),
   agents: OmoAgentsConfigSchema.optional(),
@@ -21231,6 +21226,9 @@ function printParseErrorCode(code) {
   return "<unknown ParseErrorCode>";
 }
 
+// packages/omo-config-core/src/loader/layer-validation.ts
+import { createHash as createHash2 } from "node:crypto";
+
 // packages/omo-config-core/src/loader/merge.ts
 var DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 function isUnsafeObjectKey(key) {
@@ -21404,6 +21402,14 @@ function unrecognizedKeyIssues(issues) {
 function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+var RETIRED_SECTION_DIGESTS = new Set([
+  "447f75a8ebdbdb79a57f0b8cebbfba183820cf54a8119ac01449b30499e5ef0e",
+  "4ea5ee68fea05586106890ded5733820bb77d919cda27bc4b8139b7cd33b8889"
+]);
+function isRetiredSection(key) {
+  return RETIRED_SECTION_DIGESTS.has(createHash2("sha256").update(key.toLowerCase()).digest("hex"));
+}
+var HARNESS_BLOCKS = new Set(["[opencode]", "[native]", "[senpi]", "[codex]"]);
 function sanitizeUnsafeKeys(value, path = []) {
   if (Array.isArray(value)) {
     const issues = [];
@@ -21422,6 +21428,9 @@ function sanitizeUnsafeKeys(value, path = []) {
   }
   const sanitized = {};
   for (const [key, entry] of Object.entries(value)) {
+    const isConfigContainer = path.length === 0 || path.length === 1 && HARNESS_BLOCKS.has(path[0] ?? "") || path.length === 2 && path[0] === "profiles" || path.length === 3 && path[0] === "profiles" && HARNESS_BLOCKS.has(path[2] ?? "");
+    if (isConfigContainer && isRetiredSection(key))
+      continue;
     if (isUnsafeObjectKey(key)) {
       issues.push({ keys: [key], path });
       continue;
@@ -22441,7 +22450,7 @@ function nodeErrorCode2(error) {
 }
 
 // packages/omo-codex/src/install/default-agent-role.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { lstat as lstat9, readFile as readFile16, rm as rm10 } from "node:fs/promises";
 import { join as join23 } from "node:path";
 var REGISTRATION = { name: "default", configFile: "./agents/default.toml" };
@@ -22497,7 +22506,7 @@ async function readIfPresent(path) {
   }
 }
 function hash(content) {
-  return createHash2("sha256").update(content).digest("hex");
+  return createHash3("sha256").update(content).digest("hex");
 }
 
 // packages/omo-codex/src/install/link-cached-plugin-agents.ts
@@ -23134,7 +23143,7 @@ function formatUnknownError(error) {
 }
 
 // packages/omo-codex/src/install/lsp-daemon-reaper.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { lstat as lstat12, readFile as readFile22, readdir as readdir10, rm as rm12 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join as join28, posix as posix2 } from "node:path";
@@ -23412,7 +23421,7 @@ async function readRegularTrimmedFile(path) {
   return content.length > 0 ? content : null;
 }
 function shortDigest(value) {
-  return createHash3("sha256").update(value).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(value).digest("hex").slice(0, 16);
 }
 async function removeVersionDir(path) {
   await rm12(path, { recursive: true, force: true });

package/packages/shared-skills/skills/ast-grep/AGENTS.md

@@ -4,7 +4,7 @@
 
 ## OVERVIEW
 
-Vendored skill teaching agents ast-grep (`sg`) structural search/rewrite, plus a stdlib-Python helper CLI that wraps the `sg` binary. Vendoring pin in `SOURCE`: upstream `code-yeongyu/ast-grep-skill @ 3148c69` (ast-grep 0.45.0), "vendored as a sync; do not fork-drift". Earned this file: own executable surface (749-LOC helper + installers + smoke tests) and a no-fork-drift upstream contract that has no analogue elsewhere in `shared-skills`.
+Vendored skill teaching agents ast-grep (`sg`) structural search/rewrite, plus a stdlib-Python helper CLI that wraps the `sg` binary. Upstream pin in `SOURCE`: upstream `code-yeongyu/ast-grep-skill @ 3148c69` (ast-grep 0.45.0), "vendored as a sync; do not fork-drift". Earned this file: own executable surface (749-LOC helper + installers + smoke tests) and a no-fork-drift upstream contract that has no analogue elsewhere in `shared-skills`.
 
 ## STRUCTURE
 

package/packages/shared-skills/skills/browser/runtime/omowright/manifest.json

@@ -5,5 +5,5 @@
     "index.js": "d67d3a847fe0bbc43e824feded48b280890d31879538309e671cd5f671133995",
     "page-bundle.js": "bfd51e8383cf47200d57387bbbed258bce5a3a3d00c38fc108034d2888e23f0c"
   },
-  "stagedAtUtc": "2026-10-24T12:04:38.003Z"
+  "stagedAtUtc": "2026-10-25T10:57:58.945Z"
 }

package/packages/shared-skills/skills/frontend/ATTRIBUTION.md

@@ -215,7 +215,7 @@ operating guide for consulting the beui.dev animated-component registry during i
 and motion work, written from live endpoint verification; no beui.dev source code,
 documentation text, or component implementations are vendored. beui.dev names remain the
 property of their owner, and the guide instructs reading component source for mechanism
-extraction only, not vendoring it into references or projects.
+extraction only, not copying it into references or projects.
 
 `frontend/references/design/ambience-skill.md` is a project-original, curl-only operating
 guide for consulting the react-bits (reactbits.dev) animated-component registry during hero
@@ -223,7 +223,7 @@ atmosphere, background, typographic-motion, and card-surface work, written from
 verification; no react-bits source code, documentation text, or component implementations are
 vendored. react-bits is distributed under MIT plus the Commons Clause, which permits use inside
 applications but forbids redistributing or porting the components themselves; the guide
-therefore instructs reading component source for mechanism extraction only and never vendoring
+therefore instructs reading component source for mechanism extraction only and never copying
 it into references, design documents, or this repository. React Bits names remain the property
 of their owner.
 

package/packages/shared-skills/skills/ultimate-browsing/engine/AGENTS.md

@@ -15,7 +15,7 @@ we run on is a deliberate choice, not an accident of neglect.
 | Fact | Value |
 |---|---|
 | Upstream project | `https://github.com/fivetaku/insane-search` |
-| Vendoring commit | `a4e4ed797` (2026-06-21) `feat(ultimate-browsing): vendor insane-search engine (junk-excluded)` |
+| Import commit | `a4e4ed797` (2026-06-21) `feat(ultimate-browsing): vendor insane-search engine (junk-excluded)` |
 | De-personalization | `4743199a5` (2026-06-21) |
 | Pinned upstream baseline | upstream state as of 2026-06-21, **pre-0.7.0** (0.7.0 is dated 2026-06-22) |
 | Re-vendors since | none — every later change here is ours |