oh-my-opencode 5.1.48 → 5.1.51

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/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;