oh-my-opencode 5.1.47 → 5.1.51

package/dist/skills/ulw-research/scripts/copy-returns-polish.test.ts

@@ -78,7 +78,7 @@ describe("the polish edit contract is polish-apply's", () => {
 					return "refused"
 				}
 			})()
-			const cli = outcome(() => runFactPolish("polish-apply", [reportPath, "--edits", editsPath, "--ledger", ledgerPath, "--out", join(dir, "out.html")]))
+			const cli = outcome(() => runFactPolish("polish-apply", [reportPath, "--edits", editsPath, "--ledger", ledgerPath, "--brief", BRIEF, "--out", join(dir, "out.html")]))
 			expect(cli === "ok" ? "ok" : "refused").toBe(direct)
 			if (cli !== "ok") expect(cli).toContain(editsPath)
 		})
@@ -87,7 +87,7 @@ describe("the polish edit contract is polish-apply's", () => {
 
 describe("the ledger loader is one shared helper", () => {
 	const pairs = (extra: string[]) => () => runFactMeaning("pairs", [reportPath, "--brief", BRIEF, "--out", join(dir, "pairs.json"), ...extra])
-	const diff = (extra: string[]) => () => runFactPolish("polish-diff", ["--before", reportPath, "--after", reportPath, ...extra])
+	const diff = (extra: string[]) => () => runFactPolish("polish-diff", ["--before", reportPath, "--after", reportPath, "--brief", BRIEF, ...extra])
 
 	test("#given the command modules #when read #then neither defines its own ledger loader or session resolver", () => {
 		expect(polishCommand.ledgerFrom).toBe(ledgerFrom)
@@ -122,7 +122,7 @@ describe("the edition format comes from verify's grammar", () => {
 		expect(source("fact-commands-polish.mjs")).not.toMatch(/md\|markdown/u)
 		for (const name of ["r.md", "R.MD", "r.markdown", "R.Markdown", "r.html", "r.HTML"]) {
 			const path = file(name, readFileSync(reportPath, "utf8"))
-			const result = outcome(() => runFactPolish("polish-apply", [path, "--edits", editsPath, "--ledger", ledgerPath, "--out", join(dir, "out.html")]))
+			const result = outcome(() => runFactPolish("polish-apply", [path, "--edits", editsPath, "--ledger", ledgerPath, "--brief", BRIEF, "--out", join(dir, "out.html")]))
 			expect(result.includes("takes the filled HTML edition"), name).toBe(editionFormatOf(path, undefined) === "md")
 		}
 	})
@@ -130,7 +130,7 @@ describe("the edition format comes from verify's grammar", () => {
 
 describe("polish-diff counts with contracts and exits on blockers only", () => {
 	type DiffRun = { exitCode: number; json: { counts: Record<string, number>; defects: { severity: string }[] } }
-	const run = (before: string, after: string) => runFactPolish("polish-diff", ["--before", file("b.html", doc(before)), "--after", file("a.html", doc(after)), "--ledger", ledgerPath]) as unknown as DiffRun
+	const run = (before: string, after: string) => runFactPolish("polish-diff", ["--before", file("b.html", doc(before)), "--after", file("a.html", doc(after)), "--ledger", ledgerPath, "--brief", BRIEF]) as unknown as DiffRun
 
 	test("#given every registry code #when polishDiffFails classifies it #then only registry blockers fail", () => {
 		for (const [code, entry] of Object.entries(DEFECT_CODES) as [string, { severity: string }][]) expect(polishDiffFails([{ code, severity: "minor" }]), code).toBe(entry.severity === "blocker")
@@ -161,7 +161,7 @@ describe("fact polish-apply prints every rejection reason verbatim", () => {
 	test("#given an edit holding & #when fact polish-apply runs #then the printed line carries polish-apply's own markup reason", () => {
 		const before = "Revenue & profit rose across the year"
 		const editsPath = file("edits-markup-ampersand.json", JSON.stringify([{ before, after: "Revenue and profit rose across the year", reason: "wording" }]))
-		const run = runFactPolish("polish-apply", [reportPath, "--edits", editsPath, "--ledger", ledgerPath, "--out", join(dir, "ampersand.html")]) as unknown as ApplyRun
+		const run = runFactPolish("polish-apply", [reportPath, "--edits", editsPath, "--ledger", ledgerPath, "--brief", BRIEF, "--out", join(dir, "ampersand.html")]) as unknown as ApplyRun
 
 		expect(run.exitCode).toBe(0)
 		expect(run.json.data.rejected).toBe(1)
@@ -173,7 +173,7 @@ describe("fact polish-apply prints every rejection reason verbatim", () => {
 })
 
 describe("--changed-since stays fail-closed", () => {
-	const { pairsChangedSince } = polishCommand as unknown as { pairsChangedSince: (pairs: unknown[], mapPath: string, ledger: unknown, claims: unknown) => unknown[] }
+	const { pairsChangedSince } = polishCommand as unknown as { pairsChangedSince: (pairs: unknown[], mapPath: string, ledger: unknown, claims: unknown) => unknown }
 	const artifact = file("pre-polish.html", doc("<p>The span is 320 m [S1].</p>"))
 
 	test("#given a fill map without artifact_sha256 #when --changed-since reads it #then it refuses", () => {
@@ -181,9 +181,10 @@ describe("--changed-since stays fail-closed", () => {
 		expect(outcome(() => pairsChangedSince([], mapPath, LEDGER, null))).toContain("fill map has no artifact_sha256")
 	})
 
-	test("#given a fill map whose artifact changed since fill #when read #then it still refuses", () => {
+	test("#given a fill map whose artifact changed since fill #when read #then nothing is filtered out: every pair is re-checked", () => {
 		const mapPath = file("fill-map-stale.json", JSON.stringify({ artifact, artifact_sha256: "0".repeat(64), format: "html", entries: [] }))
-		expect(outcome(() => pairsChangedSince([], mapPath, LEDGER, null))).toContain("changed after fill")
+		const pairs = [{ kind: "quote", sentence_key: "s1", claim_id: null, sentence: "The span is 320 m [S1]." }]
+		expect(pairsChangedSince(pairs, mapPath, LEDGER, null)).toEqual({ pairs, fill_map: mapPath, narrowed: false })
 	})
 })
 
@@ -203,7 +204,7 @@ describe("polish-apply writes atomically and honours --format", () => {
 
 	test("#given --format md on an .html report #when polish-apply runs #then it refuses the Markdown edition", () => {
 		const editsPath = file("edits-format.json", "[]")
-		const result = outcome(() => runFactPolish("polish-apply", [reportPath, "--edits", editsPath, "--ledger", ledgerPath, "--out", join(dir, "fmt.html"), "--format", "md"]))
+		const result = outcome(() => runFactPolish("polish-apply", [reportPath, "--edits", editsPath, "--ledger", ledgerPath, "--brief", BRIEF, "--out", join(dir, "fmt.html"), "--format", "md"]))
 		expect(result).toContain("takes the filled HTML edition")
 	})
 })

package/dist/skills/ulw-research/scripts/css-hiding.mjs

@@ -0,0 +1,158 @@
+// css-hiding.mjs - whether CSS hides an element of a page from every reader, from its inline style and
+// the page's own <style> rules (external stylesheets and scripts are not evaluated).
+//
+// Text counts as reader-visible when it is visible under at least one condition. So a rule can hide
+// only when it certainly applies: it sits outside every at-rule except @layer (and @media all), its
+// <style> element applies everywhere (no media other than all, CSS type, not in <noscript>), and its
+// selector is one tag (case-insensitive), one .class or one #id (case-sensitive). A rule that only
+// might apply (inside @media, @supports, @container, @scope, @starting-style, @document, @keyframes,
+// nested in another style rule, or with a compound, combinator, attribute or pseudo-class selector)
+// never hides, but it can make text visible when its subject could match and it outranks the hiding
+// declaration in the cascade (origin and importance, inline style, layer order, specificity, order).
+// Hiding properties: display:none and content-visibility:hidden remove the subtree;
+// visibility:hidden|collapse is inherited and a descendant's visibility:visible shows it again.
+// The hidden attribute (except hidden="until-found") and a closed <dialog> are the user-agent
+// display:none, which any author display declaration overrides. opacity, clip, zero size, font-size,
+// off-screen positions and colors do not hide: the text still renders or is read aloud.
+// Plain Node ESM, sibling imports only.
+
+import { scanRules } from "./css-lite.mjs"
+
+const PROPS = new Set(["display", "visibility", "content-visibility"])
+const INHERITED = new Set(["inherit", "unset", "revert", "revert-layer"])
+const IMPORTANT = /!\s*important\s*$/i
+const SIMPLE = /^(?:[.#][^\s.#:[\]>+~,()*"'\\]+|[a-z][a-z0-9-]*)$/iu
+const PSEUDO_ELEMENT = /::|:(?:before|after|first-line|first-letter)\b/i
+const NAME = "[^\\s.#:[\\]>+~,()*\"'\\\\]+"
+const STYLE_IN_SVG = /<style\b[^>]*>([\s\S]*?)<\/style\s*>/gi
+
+/** [tier (0 user agent, 1 author, 2 author !important), inline, layer, specificity, order]: higher wins. */
+const outranks = (a, b) => {
+	for (let k = 0; k < a.length; k++) if (a[k] !== b[k]) return a[k] > b[k]
+	return false
+}
+
+function specificity(selector) {
+	const core = selector.replace(/\[[^\]]*\]/g, " [] ")
+	const ids = core.match(new RegExp(`#${NAME}`, "gu"))?.length ?? 0
+	const classes = (core.match(new RegExp(`\\.${NAME}`, "gu"))?.length ?? 0) + (core.match(/\[\]|:(?!:)[\w-]+/g)?.length ?? 0)
+	const tags = core.match(/(?:^|[\s>+~(])[a-z][\w-]*/gi)?.length ?? 0
+	return ids * 10000 + classes * 100 + tags
+}
+
+/** The subject compound of a selector: its tag, classes and ids (attribute and pseudo-class parts dropped). */
+function subject(selector) {
+	const compound = selector.trim().match(/(?:[^\s>+~[\]()]|\[[^\]]*\]|\([^)]*\))+$/)?.[0] ?? ""
+	const core = compound.replace(/\([^)]*\)/g, "").replace(/\[[^\]]*\]/g, "").replace(/:+[\w-]+/g, "")
+	const tag = core.match(/^[a-z][a-z0-9-]*/i)?.[0].toLowerCase() ?? null
+	const classes = [...core.matchAll(new RegExp(`\\.(${NAME})`, "gu"))].map((match) => match[1])
+	const ids = [...core.matchAll(new RegExp(`#(${NAME})`, "gu"))].map((match) => match[1])
+	return { tag, classes, ids, key: ids[0] ? `#${ids[0]}` : classes[0] ? `.${classes[0]}` : tag ?? "*" }
+}
+
+const classList = (node) => String(node.attrs?.class ?? "").split(/[ \t\n\f\r]+/).filter(Boolean)
+
+function matches(sub, node) {
+	if (sub.tag !== null && sub.tag !== node.tag) return false
+	const names = classList(node)
+	return sub.classes.every((name) => names.includes(name)) && sub.ids.every((id) => id === node.attrs?.id)
+}
+
+/** Whether every enclosing at-rule leaves the rule unconditional (@layer, @media all), its layer name, and keyframe steps. */
+function context(atRule) {
+	const entries = atRule ? atRule.split(/\s(?=@)/) : []
+	const layers = entries.filter((entry) => /^@layer\b/i.test(entry)).map((entry) => entry.slice(6).trim())
+	const conditional = entries.some((entry) => !/^@layer\b/i.test(entry) && !/^@media(?:\s+all)?\s*$/i.test(entry))
+	return { conditional, layer: layers.length ? layers.join(".") : null, keyframe: entries.some((entry) => /^@(?:-[a-z]+-)?keyframes\b/i.test(entry)) }
+}
+
+const declaration = (value) => ({ value: value.replace(IMPORTANT, "").trim().toLowerCase(), important: IMPORTANT.test(value) })
+
+/** Every <style> text that applies to the page, with whether it applies only under a condition. */
+function sheets(root) {
+	const found = []
+	const visit = (node, conditional) => {
+		if (node.tag === "template") return
+		const inner = conditional || node.tag === "noscript"
+		if (node.tag === "style") {
+			const type = String(node.attrs?.type ?? "").trim().toLowerCase()
+			const media = String(node.attrs?.media ?? "").trim().toLowerCase()
+			if (type === "" || type === "text/css") found.push({ css: String(node.raw ?? ""), conditional: inner || (media !== "" && media !== "all") })
+		}
+		if (node.tag === "svg") for (const match of String(node.raw ?? "").matchAll(STYLE_IN_SVG)) found.push({ css: match[1], conditional: inner })
+		for (const child of node.children ?? []) visit(child, inner)
+	}
+	visit(root, false)
+	return found
+}
+
+/** Index every rule declaring display, visibility or content-visibility by its subject key. */
+function indexRules(root) {
+	const index = new Map()
+	const layers = []
+	const layerRank = (name, important) => {
+		if (name === null) return important ? -1 : 1e6
+		if (!layers.includes(name)) layers.push(name)
+		return important ? 1e6 - layers.indexOf(name) : layers.indexOf(name)
+	}
+	let order = 0
+	for (const sheet of sheets(root)) {
+		const css = sheet.css.replace(/<!--|-->/g, " ")
+		for (const match of css.replace(/\/\*[\s\S]*?(?:\*\/|$)/g, "").matchAll(/@layer\s+([^{;]*)[{;]/gi)) {
+			for (const name of match[1].split(",").map((part) => part.trim())) if (name && !layers.includes(name)) layers.push(name)
+		}
+		for (const rule of scanRules(css)) {
+			const decls = rule.declarations.filter((entry) => PROPS.has(entry.prop))
+			if (!decls.length || rule.selector.startsWith("@")) continue
+			const { conditional, layer, keyframe } = context(rule.atRule)
+			if (keyframe) continue
+			for (const selector of rule.selector.split(/,(?![^()[\]]*[)\]])/).map((part) => part.trim())) {
+				if (!selector || PSEUDO_ELEMENT.test(selector)) continue
+				const sub = subject(selector)
+				const certain = !sheet.conditional && !conditional && !rule.nested && SIMPLE.test(selector)
+				const spec = specificity(selector)
+				for (const entry of decls) {
+					const { value, important } = declaration(entry.value)
+					const rank = [important ? 2 : 1, 0, layerRank(layer, important), spec, order++]
+					if (!index.has(sub.key)) index.set(sub.key, [])
+					index.get(sub.key).push({ sub, prop: entry.prop, value, rank, certain })
+				}
+			}
+		}
+	}
+	return index
+}
+
+/** The values a property can take on the element: the certain winner, plus every possible rule that outranks it. */
+function possible(candidates, prop) {
+	let top = null
+	for (const entry of candidates) if (entry.prop === prop && entry.certain && (top === null || outranks(entry.rank, top.rank))) top = entry
+	const values = [top === null ? "unset" : top.value]
+	for (const entry of candidates) if (entry.prop === prop && !entry.certain && (top === null || outranks(entry.rank, top.rank))) values.push(entry.value)
+	return values
+}
+
+/**
+ * cssVisibility(root) -> (node, parentShown) => null when CSS removes the element and its subtree from every
+ * rendering, else whether its own text can be seen (visibility, inherited from parentShown).
+ */
+export function cssVisibility(root) {
+	const index = indexRules(root)
+	return (node, parentShown) => {
+		const attrs = node.attrs ?? {}
+		const keys = ["*", node.tag, ...classList(node).map((name) => `.${name}`), attrs.id === undefined ? null : `#${attrs.id}`]
+		const candidates = []
+		for (const key of new Set(keys)) for (const entry of index.get(key) ?? []) if (matches(entry.sub, node)) candidates.push(entry)
+		const hiddenAttr = attrs.hidden !== undefined && String(attrs.hidden).trim().toLowerCase() !== "until-found"
+		if (hiddenAttr || (node.tag === "dialog" && attrs.open === undefined)) candidates.push({ prop: "display", value: "none", rank: [0, 0, 0, 0, -1], certain: true })
+		const inline = attrs.style ? (scanRules(`x{${attrs.style}}`)[0]?.declarations ?? []) : []
+		inline.forEach((entry, at) => {
+			if (!PROPS.has(entry.prop)) return
+			const { value, important } = declaration(entry.value)
+			candidates.push({ prop: entry.prop, value, rank: [important ? 2 : 1, 1, 0, 0, at], certain: true })
+		})
+		if (possible(candidates, "display").every((value) => value === "none")) return null
+		if (possible(candidates, "content-visibility").every((value) => value === "hidden")) return null
+		return possible(candidates, "visibility").some((value) => (INHERITED.has(value) ? parentShown : value !== "hidden" && value !== "collapse"))
+	}
+}

package/dist/skills/ulw-research/scripts/css-lite.mjs

@@ -57,8 +57,9 @@ function parseDeclarations(text) {
 }
 
 /**
- * @returns {{ selector: string, declarations: { prop: string, value: string }[], atRule?: string }[]}
- * atRule is the chain of enclosing grouping at-rule preludes joined by a space.
+ * @returns {{ selector: string, declarations: { prop: string, value: string }[], atRule?: string, nested?: true }[]}
+ * atRule is the chain of enclosing grouping at-rule preludes joined by a space; nested is true for a
+ * rule written inside another style rule (CSS nesting).
  */
 export function scanRules(css) {
 	if (typeof css !== "string") return []
@@ -88,6 +89,7 @@ export function scanRules(css) {
 				const atChain = stack.filter((entry) => entry.group).map((entry) => entry.prelude)
 				const rule = { selector: frame.prelude, declarations: parseDeclarations(frame.body + buffer) }
 				if (atChain.length) rule.atRule = atChain.join(" ")
+				if (stack.some((entry) => !entry.group)) rule.nested = true
 				slots[frame.slot] = rule
 			}
 			buffer = ""

package/dist/skills/ulw-research/scripts/delivery-barrier-meaning.test.ts

@@ -0,0 +1,186 @@
+import { expect, test } from "bun:test"
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { sha256Of } from "./cli-support.mjs"
+import { MEANING_RECORD, writeFidelityRecord } from "./fidelity-records.mjs"
+import { delivered, expectRefused, fullyRecorded, LOCKED_BRIEF, meaningFile, type Recorded } from "./tests/delivery-barrier-session.ts"
+
+/** A delivered, fidelity-verified html edition in a session whose locked brief sets `meaning check`. */
+async function meaningSession(meaning: "on" | "off", codes: string[] | null) {
+	const session = await fullyRecorded(LOCKED_BRIEF.replace("meaning check: on", `meaning check: ${meaning}`))
+	if (codes === null) unlinkSync(session.recordPath.meaning)
+	else session.write("meaning", { defects: codes.map((code) => ({ code, severity: "major", message: code })) })
+	return session
+}
+
+for (const code of ["meaning_drift_confirmed", "meaning_unverified"]) {
+	test(`#given a meaning record with ${code} #when verified and finished #then delivery refuses`, async () => {
+		const session = await meaningSession("on", [code])
+		await expectRefused(session, { code: "fidelity_unresolved", codes: [code], path: session.recordPath.meaning })
+	})
+}
+
+test("#given the brief says meaning check on and the meaning step was skipped #when verified and finished #then delivery refuses: meaning gate not run", async () => {
+	const session = await meaningSession("on", null)
+	await expectRefused(session, { message: expect.stringContaining("meaning gate not run") })
+})
+
+test("#given a malformed ## Fidelity block that tries to turn meaning check off #when no meaning record exists #then delivery refuses: meaning gate not run", async () => {
+	const malformed = LOCKED_BRIEF.replace("meaning check: on (answered_by: default)", "meaning check: on (answered_by: default)\nmeaning check: off (answered_by: user)")
+	const session = await fullyRecorded(malformed)
+	unlinkSync(session.recordPath.meaning)
+	await expectRefused(session, { message: expect.stringContaining("meaning gate not run") })
+})
+
+test("#given the brief says meaning check off and no meaning record #when verified and finished #then delivery passes", async () => {
+	const session = await meaningSession("off", null)
+	expect((await session.outcomes()).map((result) => result.exitCode)).toEqual([0, 0])
+})
+
+test("#given a clean meaning record (warn only) under meaning check on #when verified #then delivery passes", async () => {
+	const { invoke } = await meaningSession("on", ["meaning_drift_warn"])
+	expect((await invoke(["verify"])).exitCode).toBe(0)
+})
+
+test("#given meaning check on, no fidelity evidence, and an explicit fidelity not_run #when verified #then the logged exemption covers the meaning step too", async () => {
+	const { dir, invoke } = await delivered()
+	writeFileSync(join(dir, "brief.md"), LOCKED_BRIEF)
+	await invoke(["gate", "fidelity", "not_run", "--reason", "No factual content in this edition"])
+	expect((await invoke(["verify"])).exitCode).toBe(0)
+})
+
+test("#given an edition meaning record but no fidelity record #when the fidelity gate is skipped with a reason #then delivery still refuses", async () => {
+	const { dir, path, invoke } = await delivered()
+	writeFileSync(join(dir, "brief.md"), LOCKED_BRIEF)
+	writeFidelityRecord(meaningFile(dir, "html"), "meaning", { artifact_sha256: sha256Of(readFileSync(path)), report: path, defects: [] })
+	await invoke(["gate", "fidelity", "not_run", "--reason", "This harness has no verifier"])
+	const result = await invoke(["verify"])
+	expect(result.exitCode).toBe(1)
+	expect(JSON.stringify(result.json.problems)).toContain("fidelity gate not run")
+})
+
+/** Deliver a second edition with byte-different text and its own clean fidelity record. */
+async function secondEdition(session: Recorded, format: string, text: string) {
+	const path = join(session.dir, `second.${format}`)
+	const record = join(session.dir, "second-fidelity.json")
+	writeFileSync(path, text)
+	writeFidelityRecord(record, "fidelity", { artifact_sha256: sha256Of(text), report: path, defects: [] })
+	await session.invoke(["set", format, "delivered", "--path", path, "--verified-by", record])
+	const meaning = meaningFile(session.dir, format)
+	const writeMeaning = (fields: Record<string, unknown> = {}) => writeFidelityRecord(meaning, "meaning", { artifact_sha256: sha256Of(text), report: path, defects: [], ...fields })
+	const problems = async () => (await session.invoke(["verify"])).json.problems
+	return { path, meaning, writeMeaning, problems }
+}
+
+for (const [format, text] of [["md", "Report in Markdown."], ["post", "Report in a post."]]) {
+	test(`#given html and ${format} delivered, each with its own meaning record #when verified and finished #then delivery passes`, async () => {
+		const session = await fullyRecorded()
+		const second = await secondEdition(session, format, text)
+		second.writeMeaning()
+		expect((await session.outcomes()).map((result) => result.exitCode)).toEqual([0, 0])
+	})
+
+	test(`#given html and ${format} delivered but only html has a meaning record #when verified #then only ${format} refuses: meaning gate not run`, async () => {
+		const session = await fullyRecorded()
+		const second = await secondEdition(session, format, text)
+		expect(await second.problems()).toEqual([expect.objectContaining({ code: "edition_unverified", format, path: second.meaning, message: expect.stringContaining(`meaning gate not run; run fact pairs and fact meaning-check --edition ${format}`) })])
+	})
+
+	test(`#given the ${format} meaning record is for other bytes #when verified #then only ${format} refuses: a different edition`, async () => {
+		const session = await fullyRecorded()
+		const second = await secondEdition(session, format, text)
+		second.writeMeaning({ artifact_sha256: sha256Of("an earlier draft") })
+		expect(await second.problems()).toEqual([expect.objectContaining({ code: "edition_unverified", format, path: second.meaning, message: expect.stringContaining("is for a different edition") })])
+	})
+
+	test(`#given the ${format} meaning record carries a confirmed drift #when verified #then only that record blocks`, async () => {
+		const session = await fullyRecorded()
+		const second = await secondEdition(session, format, text)
+		second.writeMeaning({ defects: [{ code: "meaning_drift_confirmed", severity: "major", message: "drift" }] })
+		expect(await second.problems()).toEqual([expect.objectContaining({ code: "fidelity_unresolved", format, codes: ["meaning_drift_confirmed"], path: second.meaning })])
+	})
+
+	test(`#given one legacy session meaning record checked on html and ${format} delivered #when verified #then ${format} refuses: a different edition`, async () => {
+		const session = await fullyRecorded()
+		unlinkSync(session.recordPath.meaning)
+		writeFidelityRecord(join(session.dir, MEANING_RECORD), "meaning", { artifact_sha256: sha256Of(readFileSync(session.path)), report: session.path, defects: [] })
+		const second = await secondEdition(session, format, text)
+		expect(await second.problems()).toEqual([expect.objectContaining({ code: "edition_unverified", format, path: join(session.dir, MEANING_RECORD), message: expect.stringContaining("is for a different edition") })])
+	})
+}
+
+test("#given a single edition and only the legacy session meaning record for its bytes #when verified and finished #then delivery passes", async () => {
+	const session = await fullyRecorded()
+	unlinkSync(session.recordPath.meaning)
+	writeFidelityRecord(join(session.dir, MEANING_RECORD), "meaning", { artifact_sha256: sha256Of(readFileSync(session.path)), report: session.path, defects: [] })
+	expect((await session.outcomes()).map((result) => result.exitCode)).toEqual([0, 0])
+})
+
+test("#given a pdf rendered from the html source #when only the html edition has a meaning record #then the pdf shares it and delivery passes", async () => {
+	const session = await fullyRecorded()
+	const pdf = join(session.dir, "report.pdf")
+	writeFileSync(pdf, "%PDF-1.7 rendered")
+	await session.invoke(["set", "pdf", "delivered", "--path", pdf, "--rendered-from", session.path, "--verified-by", session.record])
+	expect((await session.outcomes()).map((result) => result.exitCode)).toEqual([0, 0])
+})
+
+test("#given html and a byte-identical md copy at another path #when only the html edition has a meaning record #then the md binds to it by bytes and delivery passes", async () => {
+	const session = await fullyRecorded()
+	const second = await secondEdition(session, "md", readFileSync(session.path, "utf8"))
+	expect(await second.problems()).toEqual([])
+	expect((await session.outcomes()).map((result) => result.exitCode)).toEqual([0, 0])
+})
+
+// Reader runs on the same bytes are ordered by their records' written_at, never by file name.
+const EARLIER = new Date("2026-01-01T10:00:00.000Z")
+const LATER = new Date("2026-01-01T11:00:00.000Z")
+const DRIFT = [{ code: "meaning_drift_confirmed", severity: "major", message: "drift" }]
+
+/** Write a meaning record for the delivered html bytes at an explicit time. */
+const meaningAt = (session: Recorded, path: string, at: Date, defects: Record<string, unknown>[] = []) =>
+	writeFidelityRecord(path, "meaning", { artifact_sha256: sha256Of(readFileSync(session.path)), report: session.path, defects }, at)
+
+/** Deliver a pdf rendered from the html source; it has no meaning record of its own. */
+const deliverPdf = async (session: Recorded) => {
+	const pdf = join(session.dir, "report.pdf")
+	writeFileSync(pdf, "%PDF-1.7 rendered")
+	await session.invoke(["set", "pdf", "delivered", "--path", pdf, "--rendered-from", session.path, "--verified-by", session.record])
+}
+
+test("#given a clean own record written after a legacy record confirming drift on the same bytes #when verified and finished #then the newer clean run passes", async () => {
+	const session = await fullyRecorded()
+	meaningAt(session, join(session.dir, MEANING_RECORD), EARLIER, DRIFT)
+	meaningAt(session, session.recordPath.meaning, LATER)
+	expect((await session.outcomes()).map((result) => result.exitCode)).toEqual([0, 0])
+})
+
+test("#given a legacy record confirming drift written after a clean own record on the same bytes #when verified and finished #then the newer drift refuses", async () => {
+	const session = await fullyRecorded()
+	meaningAt(session, session.recordPath.meaning, EARLIER)
+	meaningAt(session, join(session.dir, MEANING_RECORD), LATER, DRIFT)
+	await expectRefused(session, { code: "fidelity_unresolved", codes: ["meaning_drift_confirmed"], path: join(session.dir, MEANING_RECORD) })
+})
+
+test("#given a clean own record and a legacy drift record written at the same time on the same bytes #when verified and finished #then the more severe verdict refuses", async () => {
+	const session = await fullyRecorded()
+	meaningAt(session, session.recordPath.meaning, LATER)
+	meaningAt(session, join(session.dir, MEANING_RECORD), LATER, DRIFT)
+	await expectRefused(session, { code: "fidelity_unresolved", codes: ["meaning_drift_confirmed"], path: join(session.dir, MEANING_RECORD) })
+})
+
+test("#given two edition records for the same bytes, the alphabetically-first clean and older #when a pdf of those bytes is verified and finished #then the newer drift refuses", async () => {
+	const session = await fullyRecorded()
+	await deliverPdf(session)
+	meaningAt(session, meaningFile(session.dir, "html"), EARLIER)
+	meaningAt(session, meaningFile(session.dir, "post"), LATER, DRIFT)
+	await expectRefused(session, { code: "fidelity_unresolved", codes: ["meaning_drift_confirmed"], path: meaningFile(session.dir, "post") })
+})
+
+test("#given two edition records for the same bytes, the alphabetically-first confirming drift and older #when verified and finished #then the newer clean run passes", async () => {
+	const session = await fullyRecorded()
+	await deliverPdf(session)
+	meaningAt(session, meaningFile(session.dir, "html"), EARLIER, DRIFT)
+	meaningAt(session, meaningFile(session.dir, "post"), LATER)
+	expect((await session.outcomes()).map((result) => result.exitCode)).toEqual([0, 0])
+})

package/dist/skills/ulw-research/scripts/delivery-barrier.test.ts

@@ -1,28 +1,12 @@
 import { describe, expect, onTestFinished, test } from "bun:test"
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs"
+import { mkdtempSync, readFileSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs"
 import { tmpdir } from "node:os"
-import { join } from "node:path"
+import { dirname, join } from "node:path"
 
 import { sha256Of } from "./cli-support.mjs"
 import { DEFECT_CODES } from "./contracts.mjs"
-import { FIDELITY_RECORDS, MEANING_RECORD, RECORD_ENVELOPE, writeFidelityRecord } from "./fidelity-records.mjs"
-import { blocksDelivery } from "./gates-fidelity.mjs"
-import { run } from "./report-tools.mjs"
-
-async function delivered(format = "html", codes: string[] | null = null) {
-	const root = mkdtempSync(join(tmpdir(), "delivery-barrier-"))
-	onTestFinished(() => rmSync(root, { recursive: true, force: true }))
-	const dir = join(root, "20260101-120000")
-	mkdirSync(dir)
-	const path = join(dir, `report.${format}`)
-	const record = join(dir, "fidelity-defects.json")
-	writeFileSync(path, "<p>Report</p>")
-	if (codes !== null) writeFidelityRecord(record, "fidelity", { artifact_sha256: sha256Of(readFileSync(path)), report: path, defects: codes.map((code) => ({ code, severity: "minor", message: code })) })
-	const invoke = (args: string[]) => run(["outcome", ...args, "--session-dir", dir])
-	await invoke(["init", "--promised", format])
-	expect((await invoke(["set", format, "delivered", "--path", path, ...(codes === null ? [] : ["--verified-by", record])])).exitCode).toBe(0)
-	return { dir, path, record, invoke }
-}
+import { fidelityProblems, FIDELITY_RECORDS, RECORD_ENVELOPE, writeFidelityRecord } from "./fidelity-records.mjs"
+import { BLOCKER, delivered, expectRefused, fullyRecorded } from "./tests/delivery-barrier-session.ts"
 
 // Enumerate the source registry, not a second list of today's fidelity codes.
 for (const [code, entry] of Object.entries(DEFECT_CODES)) {
@@ -113,32 +97,6 @@ test("#given an explicit skip and an existing blocker #when verified #then the s
 	expect((await invoke(["verify"])).exitCode).toBe(1)
 })
 
-const LOCKED_BRIEF = readFileSync(join(import.meta.dir, "tests", "fixtures", "fidelity-brief-locked.md"), "utf8")
-const BLOCKER = Object.keys(DEFECT_CODES).find((code) => blocksDelivery({ code })) as string
-
-/**
- * A delivered html edition whose locked brief requires every table record, each present, fresh for
- * the delivered bytes, and clean. recordPath is where the session keeps each row's record; a table
- * row with no entry here fails the coverage test below, so a new row brings its own cases.
- */
-async function fullyRecorded(brief = LOCKED_BRIEF) {
-	const session = await delivered("html", [])
-	writeFileSync(join(session.dir, "brief.md"), brief)
-	const recordPath: Record<string, string> = { fidelity: session.record, meaning: join(session.dir, MEANING_RECORD) }
-	const write = (kind: string, fields: Record<string, unknown> = {}) =>
-		writeFidelityRecord(recordPath[kind], kind, { artifact_sha256: sha256Of(readFileSync(session.path)), report: session.path, defects: [], ...fields })
-	write("meaning")
-	const outcomes = async () => Promise.all(["verify", "finish"].map((command) => session.invoke([command])))
-	return { ...session, recordPath, write, outcomes }
-}
-
-async function expectRefused(session: Awaited<ReturnType<typeof fullyRecorded>>, problem: Record<string, unknown>) {
-	for (const result of await session.outcomes()) {
-		expect(result.exitCode).toBe(1)
-		expect(result.json.problems).toContainEqual(expect.objectContaining(problem))
-	}
-}
-
 test("#given the record table #when every row is read #then each row has every rule column and an arranged session path", async () => {
 	const { recordPath } = await fullyRecorded()
 	expect(Object.keys(recordPath).sort()).toEqual(FIDELITY_RECORDS.map((entry) => entry.kind).sort())
@@ -148,7 +106,7 @@ test("#given the record table #when every row is read #then each row has every r
 	}
 })
 
-// The table is the barrier's spec: every row gets the same five cases.
+// The table is the barrier's spec: every row gets the same six cases.
 for (const entry of FIDELITY_RECORDS) {
 	describe(`record row ${entry.kind}`, () => {
 		test("#given the record is missing while required #when verified and finished #then delivery refuses", async () => {
@@ -157,6 +115,13 @@ for (const entry of FIDELITY_RECORDS) {
 			await expectRefused(session, { code: "edition_unverified", path: session.recordPath[entry.kind] })
 		})
 
+		test("#given the record is missing and the row names none #when verified and finished #then delivery refuses: the step was not run", async () => {
+			const session = await fullyRecorded()
+			unlinkSync(session.recordPath[entry.kind])
+			await session.invoke(["set", "html", "delivered", "--path", session.path])
+			await expectRefused(session, { code: "edition_unverified", message: expect.stringContaining(`${entry.step} not run`) })
+		})
+
 		test("#given the record is for other bytes #when verified and finished #then delivery refuses: a different edition", async () => {
 			const session = await fullyRecorded()
 			session.write(entry.kind, { artifact_sha256: sha256Of("an earlier draft") })
@@ -191,6 +156,12 @@ for (const entry of FIDELITY_RECORDS) {
 	})
 }
 
+test("#given a row whose --verified-by record is gone #when verified and finished #then delivery refuses: the record is missing", async () => {
+	const session = await fullyRecorded()
+	unlinkSync(session.record)
+	await expectRefused(session, { code: "edition_unverified", format: "html", path: session.record, message: `html: fidelity record ${session.record} is missing` })
+})
+
 test("#given a record kind outside the table or a malformed envelope #when written #then the writer refuses", () => {
 	const dir = mkdtempSync(join(tmpdir(), "delivery-barrier-writer-"))
 	onTestFinished(() => rmSync(dir, { recursive: true, force: true }))
@@ -200,46 +171,28 @@ test("#given a record kind outside the table or a malformed envelope #when writt
 	expect(() => writeFidelityRecord(join(dir, "c.json"), "meaning", { ...fields, gatesRun: [] })).toThrow("unknown field")
 })
 
-/** A delivered, fidelity-verified html edition in a session whose locked brief sets `meaning check`. */
-async function meaningSession(meaning: "on" | "off", codes: string[] | null) {
-	const session = await fullyRecorded(LOCKED_BRIEF.replace("meaning check: on", `meaning check: ${meaning}`))
-	if (codes === null) unlinkSync(session.recordPath.meaning)
-	else session.write("meaning", { defects: codes.map((code) => ({ code, severity: "major", message: code })) })
-	return session
-}
+test("#given an unattached session fidelity blocker and a clean attached record #when verified and finished #then the session blocker refuses", async () => {
+	const session = await fullyRecorded()
+	const other = join(session.dir, "other.json")
+	writeFidelityRecord(other, "fidelity", { artifact_sha256: sha256Of(readFileSync(session.path)), report: session.path, defects: [] })
+	await session.invoke(["set", "html", "delivered", "--path", session.path, "--verified-by", other])
+	session.write("fidelity", { defects: [{ code: BLOCKER }] })
+	await expectRefused(session, { code: "fidelity_unresolved", codes: [BLOCKER], path: session.record })
+})
 
-for (const code of ["meaning_drift_confirmed", "meaning_unverified"]) {
-	test(`#given a meaning record with ${code} #when verified and finished #then delivery refuses`, async () => {
-		const session = await meaningSession("on", [code])
-		await expectRefused(session, { code: "fidelity_unresolved", codes: [code], path: join(session.dir, MEANING_RECORD) })
+for (const [name, alias] of [
+	["a dot segment", (dir: string) => `${dir}/./fidelity-defects.json`],
+	["a directory link", (dir: string) => {
+		const link = join(dirname(dir), "alias")
+		symlinkSync(dir, link, "junction")
+		return join(link, "fidelity-defects.json")
+	}],
+] as const) {
+	test(`#given two target paths reaching one blocking record through ${name} #when the barrier runs #then it reports the blocker once`, async () => {
+		const session = await fullyRecorded()
+		session.write("fidelity", { defects: [{ code: BLOCKER }] })
+		const manifest = JSON.parse(readFileSync(join(session.dir, "outcome.json"), "utf8"))
+		manifest.deliverables.push({ ...manifest.deliverables[0], format: "md", verifiedBy: alias(session.dir) })
+		expect(fidelityProblems(session.dir, manifest).filter((problem) => problem.code === "fidelity_unresolved")).toHaveLength(1)
 	})
 }
-
-test("#given the brief says meaning check on and the meaning step was skipped #when verified and finished #then delivery refuses: meaning gate not run", async () => {
-	const session = await meaningSession("on", null)
-	await expectRefused(session, { message: expect.stringContaining("meaning gate not run") })
-})
-
-test("#given a malformed ## Fidelity block that tries to turn meaning check off #when no meaning record exists #then delivery refuses: meaning gate not run", async () => {
-	const malformed = LOCKED_BRIEF.replace("meaning check: on (answered_by: default)", "meaning check: on (answered_by: default)\nmeaning check: off (answered_by: user)")
-	const session = await fullyRecorded(malformed)
-	unlinkSync(session.recordPath.meaning)
-	await expectRefused(session, { message: expect.stringContaining("meaning gate not run") })
-})
-
-test("#given the brief says meaning check off and no meaning record #when verified and finished #then delivery passes", async () => {
-	const session = await meaningSession("off", null)
-	expect((await session.outcomes()).map((result) => result.exitCode)).toEqual([0, 0])
-})
-
-test("#given a clean meaning record (warn only) under meaning check on #when verified #then delivery passes", async () => {
-	const { invoke } = await meaningSession("on", ["meaning_drift_warn"])
-	expect((await invoke(["verify"])).exitCode).toBe(0)
-})
-
-test("#given meaning check on, no fidelity evidence, and an explicit fidelity not_run #when verified #then the logged exemption covers the meaning step too", async () => {
-	const { dir, invoke } = await delivered()
-	writeFileSync(join(dir, "brief.md"), LOCKED_BRIEF)
-	await invoke(["gate", "fidelity", "not_run", "--reason", "No factual content in this edition"])
-	expect((await invoke(["verify"])).exitCode).toBe(0)
-})