oh-my-opencode 5.1.48 → 5.1.54

package/dist/skills/ulw-research/scripts/value-mode-unit.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, onTestFinished, test } from "bun:test"
+import { copyFileSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { derive } from "./fact-derive.mjs"
+import { valueChecks } from "./fidelity-values.mjs"
+import { buildContext } from "./gates-static.mjs"
+import { parseHtml } from "./html-lite.mjs"
+import { run } from "./report-tools.mjs"
+import { FIX, LEDGER, type Row, type VerifyResult, codes, filled, prose } from "./tests/value-mode-support"
+
+describe("value-mode unit binding through fact fill and verify", () => {
+	for (const format of ["html", "md"]) {
+		test(`#given ${format} value mode followed by meters #when edited to mm #then verify fails unit_mismatch`, async () => {
+			const body = format === "html" ? prose("{{F1:span_len:value}}", " meters") : "## Findings\n\nUp to {{F1:span_len:value}} meters [S4]."
+			const { verify, edit } = await filled(body, format)
+			expect((await verify()).exitCode).toBe(0)
+			edit(" meters", " mm")
+			const edited = await verify()
+			expect(codes(edited)).toContain("unit_mismatch")
+			expect(edited.exitCode).toBe(1)
+		})
+	}
+
+	for (const [pointer, tail] of [
+		["{{F1:span_len:value}}", " m in total length"],
+		["{{F20:gap_pp:value}}", " \uD37C\uC13C\uD2B8 \uD3EC\uC778\uD2B8\uB85C"],
+		["{{F21:rev_eok:value}}", " \uC5B5 \uC6D0\uC73C\uB85C"],
+	]) {
+		test(`#given ordinary prose ${JSON.stringify(tail)} after ${pointer} #when verified #then it binds the row's own unit, never a squashed join`, async () => {
+			const result = await (await filled(prose(pointer, tail))).verify()
+			expect(codes(result)).toEqual([])
+			expect(result.exitCode).toBe(0)
+		})
+	}
+
+	for (const [pointer, tail, from, to] of [
+		["{{F1:span_len:value}}", "m", "</data>m", "</data>mm"],
+		["{{F3:rate_yoy:value}}", "%", "</data>%", "</data>%p"],
+		["{{F1:span_len:value}}", " m\uC758", " m\uC758", " mm\uC758"],
+		["{{F21:rev_eok:value}}", "\uC5B5 \uC6D0\uC73C\uB85C", "\uC5B5 \uC6D0\uC73C\uB85C", "\uC5B5 \uB2EC\uB7EC\uB85C"],
+		["{{F22:staff:value}}", "\uBA85\uC774\uB2E4", "\uBA85\uC774\uB2E4", "\uAC74\uC774\uB2E4"],
+		["${{F23:price:value}}", "", "$<data", "\u20AC<data"],
+	]) {
+		test(`#given the documented form ${pointer}${tail} #when its unit is hand-edited #then unit_mismatch blocks`, async () => {
+			const { verify, edit } = await filled(prose(pointer, tail))
+			const clean = await verify()
+			expect(codes(clean)).toEqual([])
+			edit(from, to)
+			const edited = await verify()
+			expect(codes(edited)).toContain("unit_mismatch")
+			expect(edited.exitCode).toBe(1)
+		})
+	}
+
+	// A longer unit that starts with the row's unit (% -> %p): read whole, spaced or glued, EN and KO (peosenteu pointeu).
+	for (const to of ["% \uD3EC\uC778\uD2B8", " \uD37C\uC13C\uD2B8 \uD3EC\uC778\uD2B8", " percent points", " % p", " %p", "%\uD3EC\uC778\uD2B8", "\uD37C\uC13C\uD2B8\uD3EC\uC778\uD2B8"]) {
+		test(`#given {{F3:rate_yoy:value}}% #when hand-edited to ${JSON.stringify(to)} #then the longer unit is read and unit_mismatch blocks`, async () => {
+			const { verify, edit } = await filled(prose("{{F3:rate_yoy:value}}", "%"))
+			expect(codes(await verify())).toEqual([])
+			edit("</data>%", `</data>${to}`)
+			const edited = await verify()
+			expect(codes(edited)).toContain("unit_mismatch")
+			expect(edited.exitCode).toBe(1)
+		})
+	}
+
+	test("#given no following unit #when verified #then unit_unbound is a minor warning", async () => {
+		const result = await (await filled(prose("{{F1:span_len:value}}", " long"))).verify()
+		expect(result.exitCode).toBe(0)
+		expect(result.json.defects).toContainEqual(expect.objectContaining({ code: "unit_unbound", severity: "minor" }))
+		expect((result.json as { gatesRun?: string[] }).gatesRun).toContain("unit_unbound")
+	})
+
+	test("#given the documented split form :value then :unit #when verified #then the unit element binds", async () => {
+		expect(codes(await (await filled(prose("{{F1:span_len:value}} {{F1:span_len:unit}}", ""))).verify())).toEqual([])
+	})
+
+	test("#given a converted row in value mode followed by its unit #when verified #then display(value, unit) still verifies", async () => {
+		expect(codes(await (await filled(prose("{{F8:span_mm:value}}", " mm"))).verify())).not.toContain("unit_mismatch")
+	})
+
+	test("#given a converted row in value mode rendered with its original in brackets #when the unit beside it is hand-edited #then unit_mismatch blocks", async () => {
+		const ledger = structuredClone(LEDGER)
+		const { row } = derive(ledger, { op: "convert", operands: ["F1"], to: "mm", now: "2026-10-23T08:00:00Z", label: "span_conv" }) as { row: Row }
+		const { verify, edit, text } = await filled(prose(`{{${row.fact_id}:span_conv:value}}`, " mm"), "html", ledger)
+		expect(text).toContain(">320,000 mm (320 m)</data> mm")
+		expect(codes(await verify())).toEqual([])
+		edit("</data> mm", "</data> km")
+		const edited = await verify()
+		expect(codes(edited)).toContain("unit_mismatch")
+		expect(edited.exitCode).toBe(1)
+	})
+
+	test("#given the sign already inside a value-mode element (valueParts falling back to the raw text) #when checked #then it is bound", () => {
+		const element = (shown: string) => `<h2>Findings</h2><p><data class="fact" value="12" data-fact="F23" data-unit="USD" data-fact-mode="value" data-lineage="MEASURED">${shown}</data> [S4].</p>`
+		const found = (shown: string) => (valueChecks(buildContext(parseHtml(element(shown)), {}), LEDGER, null, null) as { code: string }[]).map((d) => d.code)
+		expect(found("$12")).not.toContain("unit_unbound")
+		expect(found("$12")).not.toContain("unit_mismatch")
+	})
+
+	test("#given a dimensionless value #when no unit follows #then no unit warning", async () => {
+		expect(codes(await (await filled("<p>{{F2:units_sold:value}} [S4].</p>")).verify())).not.toContain("unit_unbound")
+	})
+})
+
+describe("value-mode units in tables bind by visual column", () => {
+	const table = (head: string, rows: string) => `<h2>Findings</h2><table><thead>${head}</thead><tbody>${rows}</tbody></table>`
+	for (const [name, html, code] of [
+		["a matching header", table("<tr><th>Span (meters)</th></tr>", "<tr><td>{{F1:span_len:value}}</td></tr>"), null],
+		["a wrong header", table("<tr><th>Span (mm)</th></tr>", "<tr><td>{{F1:span_len:value}}</td></tr>"), "unit_mismatch"],
+		["a conflicting suffix", table("<tr><th>Span (m)</th></tr>", "<tr><td>{{F1:span_len:value}} mm</td></tr>"), "unit_mismatch"],
+		["a header disagreeing with a suffix", table("<tr><th>Span (mm)</th></tr>", "<tr><td>{{F1:span_len:value}} m</td></tr>"), "unit_mismatch"],
+		["a unit only in another column", table("<tr><th>Span</th><th>Offset (m)</th></tr>", "<tr><td>{{F1:span_len:value}}</td><td>unknown</td></tr>"), "unit_unbound"],
+		["a colspan earlier in the row", table("<tr><th>Bridge</th><th>Deck (km)</th><th>Span (m)</th></tr>", '<tr><td colspan="2">Bridge A</td><td>{{F1:span_len:value}}</td></tr>'), null],
+		["a rowspan from above", table("<tr><th>Bridge</th><th>Span (m)</th><th>Deck (km)</th></tr>", '<tr><td rowspan="2">A</td><td>x</td><td>y</td></tr><tr><td>{{F1:span_len:value}}</td><td>{{F24:deck_len:value}}</td></tr>'), "unit_unbound"],
+		["a headerless key/value table", "<h2>Findings</h2><table><tr><td>Deck</td><td>{{F24:deck_len}}</td></tr><tr><td>Span</td><td>{{F1:span_len:value}}</td></tr></table>", "unit_unbound"],
+		["a key/value table with row headers and a matching suffix", "<h2>Findings</h2><table><tr><th>Deck</th><td>{{F24:deck_len}}</td></tr><tr><th>Span</th><td>{{F1:span_len:value}} m</td></tr></table>", null],
+		["a body row header under a matching column header", table("<tr><th>Part</th><th>Length (m)</th></tr>", '<tr><th scope="row">Span</th><td>{{F1:span_len:value}}</td></tr>'), null],
+		["a body row header under a wrong column header", table("<tr><th>Part</th><th>Length (mm)</th></tr>", '<tr><th scope="row">Span</th><td>{{F1:span_len:value}}</td></tr>'), "unit_mismatch"],
+	] as const) {
+		test(`#given ${name} #when verified #then ${code ?? "it binds cleanly"}`, async () => {
+			const result = await (await filled(html)).verify()
+			if (code === null) expect(codes(result)).toEqual([])
+			else expect(codes(result)).toContain(code)
+			expect(result.exitCode).toBe(code === "unit_mismatch" ? 1 : 0)
+			if (code !== "unit_mismatch") expect(codes(result)).not.toContain("unit_mismatch")
+		})
+	}
+})
+
+// Rows as `fact add --find` writes them: the scale word stays in the value's render ("3,234\uC5B5", "12 million").
+const PAGE = "<html><body><p>\uB9E4\uCD9C\uC740 3,234\uC5B5 \uC6D0\uC774\uB2E4.</p><p>Revenue reached 12 million dollars.</p><p>The main span is 320 m long.</p></body></html>"
+
+async function located(pointers: string) {
+	const dir = mkdtempSync(join(tmpdir(), "value-mode-find-"))
+	onTestFinished(() => rmSync(dir, { recursive: true, force: true }))
+	copyFileSync(join(FIX, "fidelity-brief-locked.md"), join(dir, "brief.md"))
+	writeFileSync(join(dir, "page.html"), PAGE)
+	expect((await run(["source", "snapshot", "--id", "S1", "--html", join(dir, "page.html"), "--session-dir", dir])).exitCode).toBe(0)
+	const rows: Row[] = []
+	for (const [find, label] of [["\uB9E4\uCD9C\uC740", "won"], ["Revenue reached", "rev"], ["main span is", "sp"]]) {
+		const added = (await run(["fact", "add", "--source", "S1", "--find", find, "--label", label, "--session-dir", dir, "--json"])) as { exitCode: number; json: { data: { row: Row } } }
+		expect(added.exitCode).toBe(0)
+		rows.push(added.json.data.row)
+	}
+	writeFileSync(join(dir, "report.src.html"), `<h2>Findings</h2><p>The source states ${pointers} [S1].</p>`)
+	expect((await run(["fact", "fill", join(dir, "report.src.html"), "--out", join(dir, "report.html"), "--session-dir", dir])).exitCode).toBe(0)
+	const verify = async () => (await run(["fact", "verify", join(dir, "report.html"), "--session-dir", dir])) as VerifyResult
+	const edit = (from: string, to: string) => writeFileSync(join(dir, "report.html"), readFileSync(join(dir, "report.html"), "utf8").replace(from, to))
+	return { rows, verify, edit }
+}
+
+describe("value-mode facts whose render carries a scale word", () => {
+	test("#given rows from fact add --find #when located #then the scale is folded into an unscaled unit", async () => {
+		const { rows } = await located("{{F1:won}}")
+		expect(rows.map((row) => [row.value, row.unit])).toEqual([["323400000000", "KRW"], ["12000000", "USD"], ["320", "m"]])
+	})
+
+	for (const pointers of ["{{F1:won:value}} \uC6D0", "{{F1:won:value}}{{F1:won:unit}}", "{{F2:rev:value}} dollars", "{{F2:rev:value}} {{F2:rev:unit}}"]) {
+		test(`#given ${JSON.stringify(pointers)} right after fill #when verified #then the scale word is part of the value, not a unit`, async () => {
+			const result = await (await located(pointers)).verify()
+			expect(codes(result)).toEqual([])
+			expect(result.exitCode).toBe(0)
+		})
+	}
+
+	for (const [pointers, from, to] of [["{{F3:sp:value}}m", "</data>m", "</data>mm"], ["{{F1:won:value}} \uC6D0", "</data> \uC6D0", "</data> \uB2EC\uB7EC"]]) {
+		test(`#given ${JSON.stringify(pointers)} #when the unit outside the element is hand-edited #then unit_mismatch still blocks`, async () => {
+			const { verify, edit } = await located(pointers)
+			expect(codes(await verify())).toEqual([])
+			edit(from, to)
+			const edited = await verify()
+			expect(codes(edited)).toContain("unit_mismatch")
+			expect(edited.exitCode).toBe(1)
+		})
+	}
+})

package/dist/skills/ulw-research/scripts/value-rules-cli.test.ts

@@ -0,0 +1,157 @@
+// Node CLI cases of the #11290 fold: the pre-polish fill map stays authoritative for
+// `fact pairs --changed-since` (in place and out of place), a fill map that does not record the
+// polished bytes is refused, `fact derive` takes its time from --now only, and a missing fill map
+// is named by brief_changed.
+import { describe, expect, test } from "bun:test"
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { NOW, codesOf, fidelitySession, nodeJson, polishSession, sha256, verdicts, verify } from "./tests/report-tools-support"
+
+type Written = { pairs: { pair_id: string; sentence: string }[]; changed_since?: unknown }
+
+const WORDING = [{ before: "The operator wrote", after: "The operator stated", reason: "wording" }]
+
+function polish(dir: string, s: string[], out: string) {
+	const edits = join(dir, "wording.json")
+	writeFileSync(edits, JSON.stringify(WORDING))
+	return nodeJson(["fact", "polish-apply", join(dir, "report.html"), "--edits", edits, "--out", out, ...s])
+}
+
+/** A hand edit of F1's rendered value after polish (the converted row's "(320 m)" stays). */
+function editValue(path: string) {
+	const html = readFileSync(path, "utf8")
+	expect(html.split(">320 m</data>").length).toBe(2)
+	writeFileSync(path, html.replace(">320 m</data>", ">321 m</data>"))
+}
+
+function pairs(dir: string, s: string[], report: string, map: string) {
+	const out = join(dir, "pairs-changed.json")
+	rmSync(out, { force: true })
+	const run = nodeJson(["fact", "pairs", report, "--changed-since", map, "--out", out, ...s])
+	const written = (run.code === 0 ? JSON.parse(readFileSync(out, "utf8")) : { pairs: [] }) as Written
+	return { run, written, sentences: written.pairs.map((pair) => pair.sentence) }
+}
+
+describe("the pre-polish fill map stays authoritative for --changed-since", () => {
+	test("#given a report polished in place #when a value is edited and fact pairs runs --changed-since on the fill map #then the reworded and the edited sentences are re-checked and meaning-check runs", () => {
+		// given
+		const { dir, s } = polishSession()
+		const report = join(dir, "report.html")
+		const fillMap = `${report}.fill-map.json`
+		const before = readFileSync(fillMap, "utf8")
+		const applied = polish(dir, s, report)
+		// when
+		const reworded = pairs(dir, s, report, fillMap)
+		editValue(report)
+		const edited = pairs(dir, s, report, fillMap)
+		const ok = edited.written.pairs.map((pair) => ({ pair_id: pair.pair_id, verdict: "ok" }))
+		const readers = ["cheap", "strong"].flatMap((tier) => ["--verdicts", verdicts(dir, `${tier}.json`, tier, ok)])
+		const checked = nodeJson(["fact", "meaning-check", "--pairs", join(dir, "pairs-changed.json"), ...readers, ...s])
+		// then
+		expect([applied.code, applied.json.data.applied, applied.json.data.rejected]).toEqual([0, 1, 0])
+		expect(readFileSync(fillMap, "utf8")).toBe(before)
+		expect(reworded.run.code).toBe(0)
+		expect(reworded.sentences.some((text) => text.includes("The operator stated"))).toBe(true)
+		expect(edited.run.code).toBe(0)
+		expect(edited.sentences.some((text) => text.includes("321 m"))).toBe(true)
+		expect(edited.sentences.some((text) => text.includes("The operator stated"))).toBe(true)
+		expect(edited.written.changed_since).toEqual({ fill_map: fillMap, narrowed: false })
+		expect(checked.code).toBe(0)
+		const record = JSON.parse(readFileSync(join(dir, "fidelity-meaning-defects.json"), "utf8"))
+		expect(record).toMatchObject({ record_kind: "meaning", status: "pass", report, artifact_sha256: sha256(report) })
+	})
+
+	test("#given a report polished to a new file #when fact pairs runs --changed-since on either map #then only the reworded sentence, and after a value edit also the edited one", () => {
+		// given
+		const { dir, s } = polishSession()
+		const report = join(dir, "report.html")
+		const fillMap = `${report}.fill-map.json`
+		const out = join(dir, "report.polished.html")
+		const polishedMap = `${out}.polished.fill-map.json`
+		const before = readFileSync(fillMap, "utf8")
+		const applied = polish(dir, s, out)
+		// when
+		const viaPolished = pairs(dir, s, out, polishedMap)
+		const viaFill = pairs(dir, s, out, fillMap)
+		editValue(out)
+		const edited = pairs(dir, s, out, polishedMap)
+		// then
+		expect(applied.code).toBe(0)
+		expect(readFileSync(fillMap, "utf8")).toBe(before)
+		expect(existsSync(`${out}.fill-map.json`)).toBe(false)
+		expect(JSON.parse(readFileSync(polishedMap, "utf8"))).toMatchObject({
+			artifact: out,
+			brief_sha256: JSON.parse(before).brief_sha256,
+			polishedFrom: { map: fillMap, sha256: sha256(fillMap) },
+		})
+		for (const run of [viaPolished, viaFill]) {
+			expect(run.run.code).toBe(0)
+			expect(run.sentences).toEqual([expect.stringContaining("The operator stated")])
+			expect(run.written.changed_since).toEqual({ fill_map: fillMap, narrowed: true })
+		}
+		expect(edited.sentences).toEqual([expect.stringContaining("321 m"), expect.stringContaining("The operator stated")])
+	})
+
+	test("#given a fill map that does not record the report's bytes #when fact polish-apply runs #then it exits 2 and writes nothing", () => {
+		// given
+		const { dir, s } = polishSession()
+		const fillMap = join(dir, "report.html.fill-map.json")
+		const out = join(dir, "report.polished.html")
+		writeFileSync(fillMap, JSON.stringify({ ...JSON.parse(readFileSync(fillMap, "utf8")), artifact_sha256: "0".repeat(64) }))
+		// when
+		const tampered = polish(dir, s, out)
+		// then
+		expect(tampered.code).toBe(2)
+		expect(tampered.stderr).toContain(fillMap)
+		expect([out, `${out}.polished.fill-map.json`, `${out}.fill-map.json`].map(existsSync)).toEqual([false, false, false])
+	})
+
+	test("#given the pre-polish fill map rewritten after polish #when fact pairs follows the polished map #then it exits 2", () => {
+		// given
+		const { dir, s } = polishSession()
+		const fillMap = join(dir, "report.html.fill-map.json")
+		const out = join(dir, "report.polished.html")
+		polish(dir, s, out)
+		writeFileSync(fillMap, JSON.stringify({ ...JSON.parse(readFileSync(fillMap, "utf8")), entries: [] }))
+		// when
+		const followed = pairs(dir, s, out, `${out}.polished.fill-map.json`)
+		// then
+		expect(followed.run.code).toBe(2)
+		expect(followed.run.stderr).toContain(fillMap)
+	})
+})
+
+describe("fact derive takes its time from the caller", () => {
+	test("#given no --now #when fact derive runs #then it exits 2 with missing_now and appends nothing; with --now the row carries that time", () => {
+		// given
+		const { dir, s } = fidelitySession()
+		const rows = () => JSON.parse(readFileSync(join(dir, "fact-ledger.json"), "utf8")).rows.length
+		const count = rows()
+		// when
+		const missing = nodeJson(["fact", "derive", "--op", "convert", "F1", "--to", "km", "--label", "span_km", "--json", ...s])
+		const after = rows()
+		const stamped = nodeJson(["fact", "derive", "--op", "convert", "F1", "--to", "km", "--label", "span_km", "--now", NOW, "--json", ...s])
+		// then
+		expect(missing.code).toBe(2)
+		expect(missing.stderr).toContain("missing_now")
+		expect(after).toBe(count)
+		expect(stamped.code).toBe(0)
+		expect(stamped.json.data.row).toMatchObject({ observed_at: "2026-10-23T08:00:00.000Z" })
+	})
+})
+
+describe("fact verify names a missing fill map", () => {
+	test("#given an HTML edition with no fill map #when fact verify runs #then brief_changed says no fill map at its path", () => {
+		// given
+		const { dir, s } = fidelitySession()
+		nodeJson(["fact", "fill", join(dir, "report.src.html"), "--out", join(dir, "report.html"), ...s])
+		const map = join(dir, "report.html.fill-map.json")
+		rmSync(map)
+		// when
+		const checked = verify(dir, "report.html")
+		// then
+		expect([checked.code, codesOf(checked.json)]).toEqual([1, ["brief_changed"]])
+		expect((checked.json.defects[0] as { message?: string }).message).toContain(`no fill map at ${map}`)
+	})
+})

package/dist/skills/ulw-research/scripts/value-rules-followups.test.ts

@@ -0,0 +1,72 @@
+import { expect, onTestFinished, test } from "bun:test"
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { derive } from "./fact-derive.mjs"
+import { fill } from "./fact-fill.mjs"
+import { addRow, emptyLedger } from "./fact-ledger.mjs"
+import { kindRuleErrors, readFlaws } from "./fact-ledger-kinds.mjs"
+import { valueChecks } from "./fidelity-values.mjs"
+import { buildContext } from "./gates-static.mjs"
+import { parseHtml } from "./html-lite.mjs"
+import { parsePlaceholder, valueParts } from "./placeholder.mjs"
+import { checkMetadata } from "./unit-metadata.mjs"
+
+const NOW = "2026-10-23T08:00:00Z"
+const FIX = join(import.meta.dir, "tests", "fixtures", "fidelity")
+const fixture = () => JSON.parse(readFileSync(join(FIX, "ledger-verify.json"), "utf8"))
+const book = () => {
+	const ledger = emptyLedger() as { schemaVersion: number; rows: Record<string, unknown>[]; events: unknown[] }
+	for (const value of ["3", "1"]) addRow(ledger, { kind: "measured", value, unit: "m", raw: value + " m", quote: value + " m", source_id: "S1", locator: { artifact: "text.txt", char_start: 0, char_end: 3 }, snapshot_sha256: "a".repeat(64), extracted_by: "test", observed_at: NOW, label: "length-" + value })
+	return ledger
+}
+
+test("quoted CSV labels preserve fact_id plot_value and unit columns", () => {
+	const dir = mkdtempSync(join(tmpdir(), "value-csv-"))
+	onTestFinished(() => rmSync(dir, { recursive: true, force: true }))
+	writeFileSync(join(dir, "chart.csv"), 'fact_id,label,plot_value,unit\nF5,"a, b",12,%\n')
+	const ctx = buildContext(parseHtml('<figure data-chart-source="chart.csv"><svg><text>12%</text></svg></figure>'), { baseDir: dir })
+	expect(valueChecks(ctx, fixture(), null, null)).toEqual([])
+})
+
+test("quote exact with unknown keys still violates the quote null rule", () => {
+	const quote = fixture().rows.find((r: { fact_id: string }) => r.fact_id === "Q1")
+	expect(kindRuleErrors({ ...quote, exact: { num: "3", den: "1", note: "x" } }, "Q1")).toContain("Q1.exact must be null for a quote row")
+})
+
+test("negative decimal zero agrees with exact zero in dimension 32", () => {
+	const row = book().rows[0]
+	expect(readFlaws({ ...row, value: "-0.0", exact: { num: "0", den: "1" } })).toEqual([])
+})
+
+test("derive without caller time refuses without appending", () => {
+	const ledger = book()
+	expect(derive(ledger, { op: "diff", operands: ["F1", "F2"], unit: "m" })).toMatchObject({ error: "missing_now", shape: "missing_now" })
+	expect(ledger.rows).toHaveLength(2)
+})
+
+test("addRow validation errors are not incompatible operands", () => {
+	const ledger = book()
+	expect(() => derive(ledger, { op: "diff", operands: ["F1", "F2"], unit: "m", now: NOW, label: "invalid label" })).toThrow("invalid fact ledger")
+	expect(ledger.rows).toHaveLength(2)
+})
+
+test("prefix currency value uses the original source text", () => {
+	expect(valueParts({ raw: "$4.2m", unit: "USD", value: "4200000" }).valueText).toBe("$4.2m")
+})
+
+test("zero padded placeholder id is rejected during parsing", () => {
+	expect(parsePlaceholder("{{F012:x}}")).toMatchObject({ error: expect.stringContaining("id") })
+})
+
+test("literal opening braces fail with an actionable escape", () => {
+	const result = fill("Example: \u0060{{\u0060", { rows: [] }, { format: "md" })
+	expect(result.errors).toEqual([expect.objectContaining({ code: "unresolved_placeholder", message: expect.stringContaining("&#123;") })])
+})
+
+test("null metadata matches null but never a declared population", () => {
+	const a = book().rows[0]
+	expect(() => checkMetadata([a, { ...a }], ["population"])).not.toThrow()
+	expect(() => checkMetadata([a, { ...a, population: "all" }], ["population"])).toThrow("population differs")
+})

package/dist/skills/ulw-research/scripts/value-rules-priority.test.ts

@@ -0,0 +1,80 @@
+import { expect, onTestFinished, test } from "bun:test"
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { sha256Of } from "./cli-support.mjs"
+import { runFactPolish } from "./fact-commands-polish.mjs"
+import { runFactVerify } from "./fact-commands-verify.mjs"
+import { valueChecks } from "./fidelity-values.mjs"
+import { buildContext } from "./gates-static.mjs"
+import { parseHtml } from "./html-lite.mjs"
+import { briefHashOf } from "./fidelity-policy.mjs"
+import { parseFidelityBlock } from "./fidelity-brief.mjs"
+
+const FIX = join(import.meta.dir, "tests", "fixtures")
+const ledger = () => JSON.parse(readFileSync(join(FIX, "fidelity", "ledger-verify.json"), "utf8"))
+// Source-backed rows are checked against their pinned snapshots; a missing sources dir blocks them.
+const check = (html: string, book: ReturnType<typeof ledger>, options = {}) => valueChecks(buildContext(parseHtml(html), {}), book, null, join(FIX, "fidelity", "sources"), options)
+const codes = (defects: { code: string }[]) => defects.map((d) => d.code)
+
+test("revision v1 does not match the brief's v12", () => {
+	const book = ledger()
+	book.rows.find((r: { fact_id: string }) => r.fact_id === "Q1").revision = "v1"
+	const html = '<p><q data-fact="Q1">we estimate completion no earlier than 2027</q></p>'
+	expect(check(html, book, { asOf: "v12 release" }).map((d: { code: string }) => d.code)).toContain("quote_stale_version")
+	expect(check(html, book, { asOf: "v1 release" })).toEqual([])
+})
+
+test("a sentence-final period after the brief's revision still matches it", () => {
+	const book = ledger()
+	book.rows.find((r: { fact_id: string }) => r.fact_id === "Q1").revision = "v1.2"
+	const html = '<p><q data-fact="Q1">we estimate completion no earlier than 2027</q></p>'
+	expect(check(html, book, { asOf: "release v1.2." })).toEqual([])
+	expect(codes(check(html, book, { asOf: "release v1.2.3." }))).toContain("quote_stale_version")
+	expect(codes(check(html, book, { asOf: "release v1.20." }))).toContain("quote_stale_version")
+})
+
+test("an operand id absent from the ledger is operand_missing, not a missing timestamp", () => {
+	const book = ledger()
+	const row = book.rows.find((r: { fact_id: string }) => r.fact_id === "F8")
+	row.snapshot_window = { dataset_id: "d1", start: "2026-09-01T00:00:00Z", end: "2026-11-01T00:00:00Z" }
+	row.operands = ["F99"]
+	const found = codes(check('<p><data data-fact="F8">320,000 mm (320 m)</data></p>', book))
+	expect(found).toContain("operand_missing")
+	expect(found).not.toContain("operand_timestamp_missing")
+	expect(found).not.toContain("snapshot_mismatch")
+})
+
+test("missing operand observed_at is not a snapshot window mismatch", () => {
+	const book = ledger()
+	const row = book.rows.find((r: { fact_id: string }) => r.fact_id === "F8")
+	row.snapshot_window = { dataset_id: "d1", start: "2026-11-01T00:00:00Z", end: "2026-12-01T00:00:00Z" }
+	delete book.rows.find((r: { fact_id: string }) => r.fact_id === row.operands[0]).observed_at
+	const defects = check('<p><data data-fact="F8">320,000 mm (320 m)</data></p>', book)
+	expect(defects.map((d: { code: string }) => d.code)).toContain("operand_timestamp_missing")
+	expect(defects.map((d: { code: string }) => d.code)).not.toContain("snapshot_mismatch")
+	expect(defects.find((d: { code: string }) => d.code === "operand_timestamp_missing").message).toContain("observed_at")
+})
+
+test("polished edition retains original brief binding after brief changes", () => {
+	const dir = mkdtempSync(join(tmpdir(), "polish-binding-"))
+	onTestFinished(() => rmSync(dir, { recursive: true, force: true }))
+	const brief = readFileSync(join(FIX, "fidelity-brief-locked.md"), "utf8")
+	const report = join(dir, "report.html")
+	const output = join(dir, "polished.html")
+	const html = '<html><body><p>The overview remains clear.</p></body></html>'
+	writeFileSync(join(dir, "brief.md"), brief)
+	writeFileSync(join(dir, "fact-ledger.json"), JSON.stringify({ schemaVersion: 1, rows: [], events: [] }))
+	writeFileSync(report, html)
+	writeFileSync(report + ".fill-map.json", JSON.stringify({ format: "html", artifact: report, artifact_sha256: sha256Of(html), entries: [], brief_sha256: briefHashOf(parseFidelityBlock(brief)) }))
+	writeFileSync(join(dir, "edits.json"), "[]")
+	expect(runFactPolish("polish-apply", [report, "--session-dir", dir, "--edits", join(dir, "edits.json"), "--out", output]).exitCode).toBe(0)
+	const verified = () => codes((runFactVerify({ positionals: [output], flags: { "session-dir": dir } }) as { json: { defects: { code: string }[] } }).json.defects)
+	expect(verified()).not.toContain("brief_changed")
+	writeFileSync(join(dir, "brief.md"), brief.replace("derived numbers: allowed", "derived numbers: none"))
+	expect(verified()).toContain("brief_changed")
+	expect(existsSync(output + ".fill-map.json")).toBe(false)
+	const map = JSON.parse(readFileSync(output + ".polished.fill-map.json", "utf8"))
+	expect(map.brief_sha256).toBe(briefHashOf(parseFidelityBlock(brief)))
+})

package/dist/skills/visual-qa/SKILL.md

@@ -42,6 +42,10 @@ The verdict is per page. One failing page fails the whole surface, so "most page
 
 Every gate runs on captures produced AFTER the last edit to the rendered source. If any screenshot, PDF, capture, or QA JSON is older than the source file it claims to verify, it is stale and invalid - regenerate it before trusting it. Never report a PASS from an artifact you did not just produce against the current build. Between review rounds, re-capture only the pages a fix touched; the final approving round always judges a complete fresh set. The one deliberately old artifact is the `before` set of Step 6, which is dated to the pre-edit build on purpose.
 
+### Machine pre-check - the detect SDK before any reviewer
+
+On a web surface, run the `frontend` skill's detect SDK on every enumerated page before capturing for reviewers (`frontend/references/perfection/detect.md`: `detectPage({ kind: "url", url }, { reflow: true })`, or `bun <frontend skill dir>/scripts/detect/cli.ts --reflow --json <url>`). It reads the rendered page and reports contrast against the painted background, the type scale and heading order, overflow at 320-1440 px under an unbroken stress string, and decoration and copy tells. An error or warning is a FAIL on the matching checklist item (E2 contrast, B8 type scale, A9 or A13 layout, F8/F9 surfaces and scaffolds, C4 wrapping) before either reviewer looks; fix it and rerun. Keep the JSON beside the captures and hand it to both reviewers as evidence. Advisories go to the verdict's taste findings.
+
 ### Capture hygiene - validate before dispatching reviewers
 
 Before any reviewer sees an image, verify each capture yourself: the file signature matches its extension (a JPEG named `.png` is invalid), the frame is fully composited (no black or missing regions from the screenshot compositor), dimensions match the requested viewport, and the frame holds only the page - a capture showing the browser's tabs or address bar, or the capture tool's own UI, is a window grab, not evidence. A defective capture wastes an entire review round on the pipeline instead of the product - fix the capture tooling and re-shoot before dispatch, and record the tooling defect in the QA log instead of looping the reviewer on it.
@@ -116,7 +120,7 @@ This is the platform baseline, distilled from Apple's Human Interface Guidelines
 **A. Layout and alignment**
 - A1 Content is anchored by intent, centred or on the layout grid; nothing sits in the top-left of an otherwise empty canvas.
 - A2 Backgrounds and scrolling layouts run full-bleed to the display edges; no stray inset margin.
-- A3 Margins are symmetric; prose sits in a 45-75 character measure.
+- A3 Margins are symmetric; prose sits in a 65-75 character measure on desktop and at least 45 on a phone.
 - A4 (phone) Safe areas respected: bars and content inset for the home indicator, notch and status bar.
 - A5 (phone) Scrollbars are overlay; no reserved right-hand gutter.
 - A6 One scroll owner per region, no nested same-direction scrolling; a sticky or floating bar stays legible over whatever scrolls under it.
@@ -126,6 +130,7 @@ This is the platform baseline, distilled from Apple's Human Interface Guidelines
 - A10 Content that continues out of view shows a cue (partial item, fade, chevron).
 - A11 (mac) Nothing important lives only at the window's bottom edge; the minimum window size keeps toolbar and content legible; the sidebar collapses when the window narrows.
 - A12 (web and app screens; N/A for a TUI, a printed page, or a figure) Layout contract: every changed screen or region has a `Layout:` line (in `DESIGN.md`, or in the change description when the project has none; the `frontend` skill's Brief step); the capture shows that pattern's structure; the logged owner is the region's main scroller in the probe output, every other scroller listed is nested inside it for its own content (a code block, a dropdown, a composer) or is named in the line too; none of the line's anti-patterns appear. A missing line, a different main scroller, an unexplained sibling scroller, or a present anti-pattern is a FAIL; a logged skip still owes the scroll-owner check.
+- A13 Spacing rhythm, read from computed values: the space above a section heading is at least 1.5x the space below it, and the gap between groups is at least 2x the gap inside a group (the `frontend` skill's `references/perfection/craft-floor.md`).
 
 **B. Hierarchy**
 - B1 One primary action per view, in the prominent style (accent on its background, not its glyph); peers differ by style, never by size.
@@ -135,6 +140,7 @@ This is the platform baseline, distilled from Apple's Human Interface Guidelines
 - B5 One or two accents per screen; toolbars and tab bars stay monochrome over colourful content; nothing decorative carries accent.
 - B6 Type hierarchy comes from weight, size and colour, holds in both themes, and uses at most two typefaces.
 - B7 (web and app screens; N/A for a TUI, a printed page, or a figure) The screen matches its brief (the `frontend` skill's Brief step): the named primary action is the single prominent control, priorities 1-3 appear in that order in reading order on the first viewport, and nothing listed under "left out on purpose" is on the screen. A screen built or changed in this session with no brief is a FAIL; a pre-existing screen under audit with no brief is N/A.
+- B8 Type scale floor, read from computed values: each heading step in use (display to h3, and the smallest heading to body) differs by at least 1.25x in size, and body-family roles (lead, body, small, caption, label) that sit closer also differ by weight, colour or case, a display heading stays at or under 6rem, and letter spacing never goes below -0.04em, unless the brief's chosen style route sets its own display scale or tracking (then that value is the check).
 
 **C. Text and copy**
 - C1 Body text is at least 17 pt-equivalent at 390 (15 pt for secondary text) and 14 px on desktop; no thin weights at small sizes.
@@ -159,6 +165,7 @@ This is the platform baseline, distilled from Apple's Human Interface Guidelines
 - E4 One colour never means two things; status colours are consistent across the surface.
 - E5 Translucent surfaces keep text legible over any scrolled content: blur or vibrancy, not a plain alpha fill.
 - E6 The theme follows the system; an in-app theme control also offers "system".
+- E7 Secondary text on a tinted or coloured surface is a shade of that hue or the foreground at reduced alpha, never neutral gray; a shadow carries a y-offset and a soft blur, never a zero-offset coloured glow unless the brief asked for glowing-border cards (the `frontend` skill's ambience route).
 
 **F. Consistency and brand**
 - F1 One icon set with one stroke, weight and size; icon weight matches adjacent text; no emoji used as an icon.
@@ -168,6 +175,10 @@ This is the platform baseline, distilled from Apple's Human Interface Guidelines
 - F5 Selected or active state is a wash plus a glyph; focus is a focus-visible ring on fields and a row highlight in lists; no coloured accent side-border marks state.
 - F6 Standard glyphs for standard actions (share, close, back, search, more) in their standard places.
 - F7 Windows, sheets and popovers use system shapes; one sheet or popover at a time; a popover's arrow points at its source; only an alert may appear over a popover.
+- F8 Browser surfaces carry the palette in both themes: text selection, caret, visible scrollbars, focus ring, link underline offset, and tabular numerals in changing or aligned numbers; none shows the browser default (select text and focus a field in the capture to prove it).
+- F9 None of the generated scaffolds: a kicker label above a heading, an icon tile stacked over a heading in a grid of same-size cards, a hero metric with no decision behind it, a card nested in a card, monospace used as a "technical" costume. One the brief or its chosen route asked for, recorded as such, passes.
+
+A13, B8, E7, F8 and F9 are adapted from the craft floor of [pbakaus/impeccable](https://github.com/pbakaus/impeccable) (Apache-2.0, Copyright 2025 Paul Bakaus); the license and the list of changes are in the `frontend` skill's `ATTRIBUTION.md` section 6.
 
 **G. Motion and feedback**
 - G1 Every animation has a cause - an interaction, a state change, an arrival; no motion on non-interactive elements, no hover that changes nothing, no permanent loop.

package/dist/tools/delegate-task/executor-types.d.ts

@@ -20,6 +20,7 @@ export interface ExecutorContext {
         title: string;
     }) => Promise<void>;
     syncPollTimeoutMs?: number;
+    taskCleanupDelayMs?: number;
 }
 export interface ParentContext {
     sessionID: string;

package/dist/tools/delegate-task/sync-session-existence.d.ts

@@ -0,0 +1,4 @@
+import type { OpencodeClient } from "./types";
+export declare function isDefiniteSessionNotFound(error: unknown): boolean;
+export declare function isSyncSessionDeleted(client: OpencodeClient, sessionID: string): Promise<boolean>;
+export declare function formatDeletedSyncSessionError(sessionID: string): string;

package/dist/tools/delegate-task/types.d.ts

@@ -129,6 +129,7 @@ export interface DelegateTaskToolOptions {
     modelFallbackControllerAccessor?: ModelFallbackControllerAccessor;
     onSyncSessionCreated?: (event: SyncSessionCreatedEvent) => Promise<void>;
     syncPollTimeoutMs?: number;
+    taskCleanupDelayMs?: number;
     /** OpenCode native skill accessor for skills registered via config.skills.paths. Same shape as SkillLoadOptions.nativeSkills. */
     nativeSkills?: {
         all(): {

package/dist/tools/skill/description-formatter.d.ts

@@ -1,7 +1,8 @@
-import type { SkillInfo } from "./types";
+import type { CoreListedSkill, SkillInfo } from "./types";
 import type { CommandInfo } from "../slashcommand/types";
 interface CombinedDescriptionOptions {
     includeSkills?: boolean;
+    coreListedSkills?: readonly CoreListedSkill[];
 }
 export declare function deduplicatePathAliasedSkills(skills: SkillInfo[]): SkillInfo[];
 export declare function formatCombinedDescription(skills?: SkillInfo[], commands?: CommandInfo[], options?: CombinedDescriptionOptions): string;

package/dist/tools/skill/types.d.ts

@@ -16,6 +16,12 @@ export interface SkillInfo {
     metadata?: Record<string, string>;
     allowedTools?: string[];
 }
+/** One entry of OpenCode core's own skill list (Skill.all()), as returned by SkillLoadOptions.nativeSkills.all(). */
+export interface CoreListedSkill {
+    name: string;
+    description?: string;
+    location: string;
+}
 export interface SkillLoadOptions {
     /** When true, only load from OpenCode paths (.opencode/skills/, ~/.config/opencode/skills/) */
     opencodeOnly?: boolean;