lazycodex-ai 5.1.48 → 5.1.51

package/packages/shared-skills/skills/ulw-research/scripts/sources-citation.test.ts

@@ -0,0 +1,236 @@
+import { describe, expect, test } from "bun:test"
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { valueChecks } from "./fidelity-values.mjs"
+import { buildContext, checkStatic } from "./gates-static.mjs"
+import { parseHtml } from "./html-lite.mjs"
+import { isClaimSegment, numeralKinds, sourcesClaims } from "./sources-citation.mjs"
+import { type ClassRow, GLUED_LETTER_ROWS, SHAPE_ROWS } from "./tests/numeral-classes"
+
+const FIX = join(import.meta.dir, "tests", "fixtures")
+const EMPTY = { schemaVersion: 1, rows: [], events: [] }
+const GATED = new Set(["unsourced_number", "untraceable_number", "verification_claim_unmarked"])
+
+/** The codes the static gate, the number trace, and the claim check raise over one document. */
+function gated(html: string) {
+	const doc = parseHtml(html)
+	const fidelity = valueChecks(buildContext(doc, {}), EMPTY, null, null) as { code: string }[]
+	return [...(checkStatic(doc).defects as { code: string }[]), ...fidelity].map((d) => d.code).filter((code) => GATED.has(code))
+}
+const underSources = (body: string) => gated(`<h2>Official sources</h2>${body}`)
+
+// Round-4 ruling, guard: a digit run glued to a unit, multiplier, or currency stays a numeral, in a
+// reference-shaped line (EN, KO) and in a Korean sentence where a particle follows the unit.
+const QUANTITIES = ["50M", "10k", "3x", "5.4T", "12%", "2.5GB", "10ms", "320m", "40percent"]
+const GUARD = [
+	...QUANTITIES.flatMap((q) => [
+		`<li>Annual filing ${q}, https://example.com/filing</li>`,
+		`<li>\uC5F0\uAC04 \uACF5\uC2DC ${q}, https://example.com/filing</li>`,
+		`<p>\uADDC\uBAA8\uB294 ${q}\uB85C \uC9D1\uACC4\uB410\uB2E4.</p>`,
+	]),
+	"<li>Q3 revenue 12%, https://example.com/q3</li>",
+	"<li>Q3 \uB9E4\uCD9C 12%, https://example.com/q3</li>",
+	"<li>3\uBD84\uAE30 \uB9E4\uCD9C 12%, https://example.com/q3</li>",
+	"<li>Market data, USD5bn in 2025, https://example.com/fx</li>",
+]
+
+// Round-4 date ruling: a month/day is a date (a citation field), a day count is not.
+const DATES = [
+	"<li>Fed minutes 2026-09-16 (released 10/26), https://example.com/minutes</li>",
+	"<li>Press release, Oct 26, https://example.com/press</li>",
+	"<li>Press release, October 26, 2026, https://example.com/press</li>",
+	"<li>\uC5F0\uC900 \uC758\uC0AC\uB85D (10/26 \uACF5\uAC1C), https://example.com/minutes</li>",
+	"<li>\uBCF4\uB3C4\uC790\uB8CC 10\uC6D4 26\uC77C, https://example.com/press</li>",
+	"<li>\uBCF4\uB3C4\uC790\uB8CC 2026. 10. 26., https://example.com/press</li>",
+]
+const DAY_COUNTS = [
+	"<li>Trial period 30 days, https://example.com/trial</li>",
+	"<p>The pilot ran for 30 days.</p>",
+	"<li>\uC2DC\uBC94 \uC6B4\uC601 30\uC77C\uAC04, https://example.com/trial</li>",
+	"<p>\uC2DC\uBC94 \uC6B4\uC601\uC740 30\uC77C \uB3D9\uC548 \uC9C4\uD589\uB410\uB2E4.</p>",
+]
+
+// Round 5: a unit, multiplier, or percent on the right keeps a digit run a numeral even with letters
+// glued on its left (a Korean particle after the unit allowed), a multiplier glued on the left (x3) is a
+// numeral, mn / pct / yr(s) / mo are units, and a European digit grouping is a numeral (EN and KO).
+const GLUED_MEASURES = [
+	"<p>\uB9E4\uCD9C40% \uC99D\uAC00.</p>",
+	"<li>\uC804\uB144\uB300\uBE4430%, https://example.com/yoy</li>",
+	"<p>\uC57D300\uBA85\uC774 \uCC38\uC5EC\uD588\uB2E4.</p>",
+	"<p>Model B is x3 faster.</p>",
+	"<p>\uC18D\uB3C4\uB294 x3 \uBE68\uB790\uB2E4.</p>",
+	"<li>Churn rate40%, https://example.com/churn</li>",
+	"<p>Grew 5mn users.</p>",
+	"<p>Up 40pct.</p>",
+	"<p>5yrs of data.</p>",
+	"<li>Retention 18mo, https://example.com/retention</li>",
+	"<li>\uC5F0\uAC04 \uC131\uC7A5 40pct, https://example.com/growth</li>",
+	"<p>1.234.567 users signed up.</p>",
+	"<p>\uAC00\uC785\uC790\uB294 1.234.567\uBA85\uC774\uB2E4.</p>",
+	"<li>Annual report (10-K), https://example.com/filing</li>",
+]
+
+// Decision 25: under Sources a sentence is checked unless every numeral in it is a citation-field number.
+// Receipt cases from review rounds 1-3, EN and KO (Korean as \u escapes).
+const MUST_FLAG = [
+	"<p>[S4] says revenue rose 40% in 2025.</p>",
+	"<p>[S4] Revenue rose 40% in 2025, the highest on record.</p>",
+	"<li>Revenue rose 40% in 2025 according to https://example.com/report</li>",
+	"<p>[S4] Annual report 2024, https://example.com/report<br>The check found 42% of spans out of tolerance.</p>",
+	"<p>Revenue was 40% higher in 2025.</p>",
+	"<p>Revenue totaled 5 billion dollars in 2025.</p>",
+	"<p>Note: the market share is 42% as of 2025.</p>",
+	"<p>Exports surged 31% to 12 billion in 2025.</p>",
+	"<p>[S4] Revenue hit $5 billion in 2025.</p>",
+	"<p>[S4] The agency estimates 3.2 million users.</p>",
+	"<p>Revenue was 40 percent higher in 2025.</p>",
+	"<p>Market share is 42 percent.</p>",
+	"<p>Model B is 3x faster than model A.</p>",
+	"<p>The survey covered 1,200 firms in 2025.</p>",
+	"<p>The dataset includes 3412 reports.</p>",
+	"<p>We reviewed the filings. Market share reached 42% in 2025. Source: https://example.com/a</p>",
+	"<p>Note. Revenue grew 40% in 2025. Accessed 2025-10-01.</p>",
+	"<p>See the notes below. Unemployment was 4.1% in September. 2025.</p>",
+	"<li>[S5] Bloomberg (2025). Revenue grew 40% as AI demand reached record. https://example.com/bloomberg</li>",
+	"<p>[S19] Treasury buyback $94B 2026-10-08: https://example.com/2026/10/08/buybacks</p>",
+	"<li>Llama 3.1 model card, Meta, https://example.com/llama</li>",
+	"<li>Survey 2025, wave 2, https://example.com/survey</li>",
+	"<p>\uC810\uC720\uC728\uC740 42%\uC774\uB2E4.</p>",
+	"<p>\uB9E4\uCD9C\uC740 2025\uB144 40% \uB298\uC5B4 5\uC870\uC6D0\uC744 \uAE30\uB85D\uD588\uB2E4.</p>",
+	"<p>\uC9C1\uC6D0 \uC218\uB294 1,250\uBA85\uC774\uB2E4.</p>",
+	"<p>We ran the check and it reported 42%.</p>",
+	...GUARD,
+	...DAY_COUNTS,
+	...GLUED_MEASURES,
+]
+
+// Round-4 ruling, must-pass: a digit run glued to letters that are not a unit is a name (commit hashes,
+// #issue numbers, identifiers, quarter and filing codes); link text is a citation field; a year range is a date.
+const NAMES = [
+	"<li>letta-code @ a75f4d93ef / @ 701f2a53678, https://example.com/letta</li>",
+	"<li>\uACE0\uC815 \uCEE4\uBC0B 22c5684b983e, 424B4, https://example.com/repo</li>",
+	"<li>oh-my-openagent PR #6674\u2013#7906, https://example.com/prs</li>",
+	"<li>\uC774\uC288 #11302 \uB17C\uC758, https://example.com/issue</li>",
+	"<li>GPT-4 system card v2.3.1 (abc123), https://example.com/gpt</li>",
+	"<li>GPT-4 \uC2DC\uC2A4\uD15C \uCE74\uB4DC v2.3.1 (abc123), https://example.com/gpt</li>",
+	"<li>Cohort table Q3-2024, filing 2024-Q3-F1, Oracle Q1 FY27 (10-Q), S-1, https://example.com/cohort</li>",
+	"<li>\uCF54\uD638\uD2B8 Q3-2024 \uACF5\uC2DC 2024-Q3-F1, YC W26, H1 2026, https://example.com/cohort</li>",
+	"<li>FRED DGS10/DGS30, KOSPI200, Base44, CC0, 3D icons, https://example.com/data</li>",
+	"<li>github.com/letta-ai/letta-code @ a75f4d93ef(0.30.14); W3C PROV-DM; https://example.com/letta</li>",
+	"<li>\uC778\uC6A9 \uADDC\uC57D: \uACBD\uB85C:\uD589@b2105213234ab0c9762c7871611bf336dfb0eb2b (3.1.1), https://example.com/sha</li>",
+	"<li>\uC5F0\uC900 \uC790\uB8CC (2\uCC28 \uBCF4\uB3C4), https://example.com/fed</li>",
+	'<li><a href="https://example.com/hn">HN thread (90 points, 37 comments)</a></li>',
+	'<li><a href="https://example.com/notice">Spin-off notice (2025-12-02, \uACF5\uB3D9\uCC3D\uC5C5\uC790 20\uBA85 \uC11C\uBA85)</a></li>',
+	"<li>Survey archive 2019-2023, 2019~2023, 2019\u20132023, https://example.com/archive</li>",
+	"<li>2025\u20132026\uB144 \uADFC\uC6D4\uBB3C \uC790\uB8CC, 2019~2023\uB144, https://example.com/basis</li>",
+	"<p>2019\u20132023\uB144 \uD1B5\uACC4\uB97C 1\uCC28 \uC790\uB8CC\uB85C \uD655\uBCF4\uD558\uC9C0 \uBABB\uD588\uB2E4.</p>",
+	"<li>Build abc123, GPT-4, v2.3.1, #1234, Q3-2024 cohort, 0.30.14, https://example.com/build</li>",
+	"<li>\uBE4C\uB4DC abc123, GPT-4, v2.3.1, #1234, Q3-2024 \uCF54\uD638\uD2B8, 0.30.14, https://example.com/build</li>",
+	"<li>\uC81C3\uC790 \uC81C\uACF5 \uC790\uB8CC, https://example.com/third</li>",
+	"<li>Survey notes [w1:x02], https://example.com/survey</li>",
+]
+
+const MUST_PASS = [
+	'<li>[S3] Reuters, "China\'s exports rose 7% in September", 2025-10-13, https://example.com/reuters</li>',
+	'<li>[S6] \uC5F0\uD569\uB274\uC2A4, "\uC218\uCD9C 12% \uC99D\uAC00\uD588\uB2E4", 2025-10-01, https://example.com/yna</li>',
+	"<li>[S7] Nikkei, \u201CSales fell 3.5% in Q2\u201D, https://example.com/nikkei</li>",
+	"<li>[S9] \uC5F0\uD569\uB274\uC2A4, \u300C\uC218\uCD9C 12% \uC99D\uAC00\u300D, 2025\uB144 10\uC6D4 1\uC77C</li>",
+	"<li>[S8] LoCoMo arXiv 2402.17753; DOI 10.1145/1571941.1572114</li>",
+	"<li>Field guide, ISBN 978-0-306-40615-7, 3rd edition, pp. 12-15.</li>",
+	"<li><cite>Llama 3.1 model card</cite>, Meta, https://example.com/llama</li>",
+	'<li>"Python 3.12 release notes", 2024-10-07, https://example.com/python</li>',
+	"<li><em>WCAG 2.2</em>, 2023-10-05, https://example.com/wcag</li>",
+	"<li>Smith, J. (2024a). Annual report. https://example.com/annual-2024</li>",
+	"<li>Bridge Review, Vol. 2024/1, No. 3, https://example.com/review. Accessed 25 October 2026.</li>",
+	"<li>\uAD50\uB7C9 \uC5F0\uAC10 3\uAD8C 2\uD638, 45-52\uCABD, 2024\uB144</li>",
+	"<p>[S4] Annual report, 2024. https://example.com/report</p>",
+	'<p><a href="https://example.com/2024">Annual report 2024</a></p>',
+	"<li>Annual report 2024, https://example.com/report</li>",
+	'<li>Annual report 2024, <a href="https://example.com/report">source</a></li>',
+	"<h3>2024</h3>",
+	"<p>Publication cutoff and access date: October 25, 2026. Every linked source was read directly.</p>",
+	...NAMES,
+	...DATES,
+]
+
+describe("under Sources, a sentence with a numeral that is not a citation field is checked", () => {
+	for (const body of MUST_FLAG) test(`#given ${JSON.stringify(body)} #when checked #then untraceable_number`, () => expect(underSources(body)).toContain("untraceable_number"))
+
+	test("#given a citation, then a claim after <br> #when traced #then only the claim sentence's numbers are flagged", () => {
+		expect(underSources("<p>[S4] Annual report 2024, https://example.com/report<br>Revenue rose 42% in 2025.</p>").filter((code) => code === "untraceable_number")).toHaveLength(2)
+	})
+
+	test("#given a first-person cue with a claim number under Sources #when checked #then the claim check warns too", () => {
+		expect(underSources("<p>We confirmed that the rate is 42%.</p>")).toEqual(expect.arrayContaining(["unsourced_number", "untraceable_number", "verification_claim_unmarked"]))
+	})
+})
+
+describe("an element whose every numeral is a citation field is exempt", () => {
+	for (const body of MUST_PASS) test(`#given ${JSON.stringify(body)} #when checked #then nothing`, () => expect(underSources(body)).toEqual([]))
+
+	test("#given a report with every reference shape (APA, pages, volume, access dates, year subheading, dl, Sources table) #when checked #then no gated code", () => {
+		expect(gated(readFileSync(join(FIX, "sources-shapes.html"), "utf8"))).toEqual([])
+	})
+})
+
+// Mutation test: each heuristic the literal rule replaced, re-introduced as a gate on the predicate,
+// must miss at least one must-flag case, so restoring any of them in sources-citation.mjs fails above.
+const OLD_MEASURE = [/\d\s?(?:%|\u2030|\uD37C\uC13C\uD2B8)/, /[$\u20AC\u00A3\u00A5\u20A9]\s?\d/, /\d\s?(?:thousand|million|billion|trillion|bn)\b|\d(?:k|K|M|B)\b/, /\d\s?(?:\uC6D0|\uB2EC\uB7EC|\uBA85|\uAC74|\uAC1C|\uBC30|[\uCC9C\uB9CC\uC5B5\uC870])/, /\d\s?(?:km|kg|mm|ms|hours?|days?|users?|people|employees|customers?)\b/, /(?<![\d.,])(?!(?:19|20)\d{2}\.)\d+\.\d+(?![\d.])/]
+const OLD_VERBS = /\b(?:rose|rises|grew|increased|decreased|declined|dropped|reached|says|said|stated|reported|showed|found|estimated|according\s+to)\b|\uC99D\uAC00\uD588|\uAC10\uC18C\uD588|\uB298\uC5C8|\uC904\uC5C8|\uAE30\uB85D\uD588/
+const citationOnly = (text: string) => /https?:\/\/|\b(?:accessed|retrieved)\b/i.test(text)
+const root = (body: string) => parseHtml(`<div>${body}</div>`)
+/** The mutants' own sentence split of a case (line breaks, then sentence ends); the real predicate decides each piece. */
+const pieces = (body: string) =>
+	body
+		.replace(/<br>/g, "\n")
+		.replace(/<[^>]+>/g, " ")
+		.split("\n")
+		.flatMap((line) => line.split(/(?<=[.!?])\s+(?=[A-Z\uAC00-\uD7A3])/))
+		.map((piece) => piece.trim())
+		.filter(Boolean)
+const MUTANTS: Record<string, (body: string) => boolean> = {
+	"a measure-word allow-list": (body) => pieces(body).some((s) => isClaimSegment(s) && OLD_MEASURE.some((re) => re.test(s))),
+	"a claim-verb trigger": (body) => pieces(body).some((s) => isClaimSegment(s) && OLD_VERBS.test(s)),
+	"a name rule that ignores units": (body) => pieces(body).some((s) => isClaimSegment(s.replace(/\p{L}+\d[\d.,]*|\d[\d.,]*\p{L}+/gu, " "))),
+	"the middle-segment title heuristic": (body) => {
+		const all = pieces(body)
+		return all.some((s, at) => !(at > 0 && at + 1 < all.length && citationOnly(all[at + 1])) && isClaimSegment(s))
+	},
+}
+
+describe("mutation: no word list, verb list, or title heuristic decides a Sources sentence", () => {
+	test("#given the literal rule #when every must-flag case is read #then each yields a checked sentence and no must-pass case does", () => {
+		expect(MUST_FLAG.filter((body) => sourcesClaims(root(body)).length === 0)).toEqual([])
+		expect(MUST_PASS.filter((body) => sourcesClaims(root(body)).length > 0)).toEqual([])
+	})
+
+	for (const [name, mutant] of Object.entries(MUTANTS)) {
+		test(`#given ${name} re-introduced #when the must-flag cases run #then at least one is missed`, () => {
+			expect(MUST_FLAG.filter((body) => !mutant(body)).length).toBeGreaterThan(0)
+		})
+	}
+})
+
+// Lead order (round 5): one table-driven test per class. Each row names the class of every digit run,
+// and the gates must agree at the real boundary: an element under Sources is checked exactly when a
+// run is a numeral.
+function misread(rows: ClassRow[]) {
+	return rows.flatMap(({ input, expected }) => {
+		const kinds = numeralKinds(input).map(({ kind }: { kind: string }) => kind)
+		const want = Array.isArray(expected) ? expected : kinds.map(() => expected)
+		const flagged = underSources(`<p>${input}</p>`).includes("untraceable_number")
+		const ok = kinds.length === want.length && kinds.every((kind: string, at: number) => kind === want[at]) && flagged === want.includes("numeral")
+		return ok ? [] : [{ input, expected, kinds, flagged }]
+	})
+}
+
+describe("numeral classes under Sources, one row per form (EN + KO)", () => {
+	test(`#given ${GLUED_LETTER_ROWS.length} glued-letter forms (every unit, multiplier, percent, and currency token on the right and left, Hangul and Latin words, Korean particles) #when classified #then each reads as its row says`, () => {
+		expect(misread(GLUED_LETTER_ROWS)).toEqual([])
+	})
+
+	test(`#given ${SHAPE_ROWS.length} date, version, and code shapes (slashed, dotted, dashed, ranges, groupings, filing codes, citation markers) #when classified #then each reads as its row says`, () => {
+		expect(misread(SHAPE_ROWS)).toEqual([])
+	})
+})

package/packages/shared-skills/skills/ulw-research/scripts/tests/contracts-support.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test"
+import {
+	ANSWERED_BY,
+	DEFECT_CODES,
+	DELIVERABLE_FORMATS,
+	DELIVERABLE_STATUSES,
+	DESIGN_SPEC_SECTIONS,
+	FIDELITY_CODES,
+	GATE_NAMES,
+	GATE_STATUSES,
+	INTEGRITY_CODES,
+	LANES,
+	LAYOUT_CODES,
+	LINEAGE_MODES,
+	MANIFEST_CODES,
+	REPAIR_DEFAULTS,
+	SCHEMA_VERSION,
+	STATES,
+	STATIC_CODES,
+	normalizeManifest,
+	validateOutcomeManifest,
+	validateRepairState,
+} from "../contracts.mjs"
+
+
+const SEVERITIES = new Set(["blocker", "major", "minor"])
+
+const STATIC_CODES_EXPECTED = [
+	"korean_no_keep_all",
+	"palette_off_token",
+	"emoji_in_prose",
+	"em_dash_in_prose",
+	"en_dash_in_prose",
+	"heading_too_long",
+	"heading_generic",
+	"unsourced_number",
+	"chart_without_figure",
+	"chart_svg_no_text",
+	"chart_svg_missing_labels",
+	"report_without_visual",
+	"image_missing_alt",
+	"korean_serif_font",
+	"section_without_citation",
+	"missing_closing_section",
+	"missing_citation_section",
+	"broken_asset_reference",
+	"missing_required_section",
+]
+
+const LAYOUT_CODES_EXPECTED = [
+	"layout_overflow",
+	"layout_text_clipped",
+	"layout_scroll_container",
+	"layout_image_distorted",
+	"layout_sibling_overlap",
+]
+
+// Fidelity vocabulary contract (#11009): severity and integrity per code are fixed here.
+const FIDELITY_BLOCKERS = [
+	"unresolved_placeholder",
+	"value_mismatch",
+	"unit_mismatch",
+	"quote_not_verbatim",
+	"claim_status_invalid",
+	"incompatible_operands",
+	"pointer_label_mismatch",
+	"quote_anchor_unresolved",
+	"unit_duplicated",
+	"polish_diff_fail",
+	"fidelity_interview_incomplete",
+	"derived_not_allowed",
+	"source_outside_floor",
+	"brief_changed",
+	"snapshot_hash_mismatch",
+	"chart_value_untraceable",
+	"quote_unbound",
+	"edition_unverified",
+	"snapshot_not_raw",
+]
+
+const FIDELITY_MAJORS = [
+	"untraceable_number",
+	"unsupported_verification",
+	"claim_kind_mismatch",
+	"conflicting_readings",
+	"hedge_dropped",
+	"direction_flipped",
+	"causality_added",
+	"qualifier_dropped",
+	"unbound_sentence",
+	"meaning_drift_confirmed",
+	"meaning_unverified",
+	"polish_edit_rejected",
+	"polish_hedging_decreased",
+	"polish_text_churn",
+	"snapshot_mismatch",
+	"join_integrity_fail",
+	"quote_stale_version",
+	"operand_timestamp_missing",
+	"operand_missing",
+]
+
+const FIDELITY_MINORS = [
+	"quote_fuzzy_match",
+	"name_outside_quote",
+	"verification_claim_unmarked",
+	"scope_widened_warn",
+	"particle_unverified",
+	"fallback_without_entity",
+	"meaning_drift_warn",
+	"polish_edit_unlocated",
+	"polish_link_changed",
+	"polish_name_changed",
+	"relocated",
+	"quote_converted_only",
+]
+
+const FIDELITY_CODES_EXPECTED = [...FIDELITY_BLOCKERS, ...FIDELITY_MAJORS, ...FIDELITY_MINORS]
+
+
+function fourGateManifest() {
+	const manifest = sampleManifest()
+	const { fidelity: _dropped, ...gates } = manifest.gates
+	return { ...manifest, gates }
+}
+
+
+function sampleManifest() {
+	return {
+		schemaVersion: SCHEMA_VERSION,
+		sessionDir: "/tmp/session/20260101-120000",
+		startedAt: "2026-01-01T12:00:00.000Z",
+		finishedAt: null,
+		elapsedMinutes: null,
+		lane: "no-format",
+		interview: null,
+		deliverables: [
+			{ format: "pdf", status: "pending", promised: true, updatedAt: "2026-01-01T12:00:00.000Z" },
+		],
+		renders: [],
+		gates: { static: "not_run", fidelity: "not_run", layout: "not_run", visual: "not_run", proofread: "not_run" },
+		residualDefects: [],
+		repair: null,
+		sources: null,
+	}
+}
+export { SEVERITIES, STATIC_CODES_EXPECTED, LAYOUT_CODES_EXPECTED, FIDELITY_BLOCKERS, FIDELITY_MAJORS, FIDELITY_MINORS, FIDELITY_CODES_EXPECTED, fourGateManifest, sampleManifest }

package/packages/shared-skills/skills/ulw-research/scripts/tests/delivery-barrier-session.ts

@@ -0,0 +1,59 @@
+// Shared sessions for the delivery barrier tests (../delivery-barrier.test.ts and
+// ../delivery-barrier-meaning.test.ts): a delivered edition, a fully recorded session, and the refusal
+// assertion both files use.
+import { expect, onTestFinished } from "bun:test"
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { sha256Of } from "../cli-support.mjs"
+import { DEFECT_CODES } from "../contracts.mjs"
+import { writeFidelityRecord } from "../fidelity-records.mjs"
+import { blocksDelivery } from "../gates-fidelity.mjs"
+import { run } from "../report-tools.mjs"
+
+export 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 }
+}
+
+export const LOCKED_BRIEF = readFileSync(join(import.meta.dir, "fixtures", "fidelity-brief-locked.md"), "utf8")
+export const BLOCKER = Object.keys(DEFECT_CODES).find((code) => blocksDelivery({ code })) as string
+
+/** The meaning record of one delivered edition, by its outcome format. */
+export const meaningFile = (dir: string, format: string) => join(dir, `fidelity-meaning-defects.${format}.json`)
+
+/**
+ * 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, so a new row brings its own cases.
+ */
+export 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: meaningFile(session.dir, "html") }
+	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 }
+}
+
+export type Recorded = Awaited<ReturnType<typeof fullyRecorded>>
+
+export async function expectRefused(session: Recorded, problem: Record<string, unknown>) {
+	for (const result of await session.outcomes()) {
+		expect(result.exitCode).toBe(1)
+		expect(result.json.problems).toContainEqual(expect.objectContaining(problem))
+	}
+}

package/packages/shared-skills/skills/ulw-research/scripts/tests/derive-clock.ts

@@ -0,0 +1,4 @@
+import { derive as deriveAt } from "../fact-derive.mjs"
+
+// All successful test derivations use caller-owned, fixed observation time.
+export const derive = (ledger: unknown, spec: unknown) => deriveAt(ledger, spec !== null && typeof spec === "object" && !Array.isArray(spec) ? { now: "2026-10-23T08:00:00Z", ...spec } : spec)

package/packages/shared-skills/skills/ulw-research/scripts/tests/fact-derive-support.ts

@@ -0,0 +1,65 @@
+import { describe, expect, onTestFinished, test } from "bun:test"
+import { mkdtempSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { recompute } from "../fact-derive.mjs"
+import { derive } from "./derive-clock"
+import { addRow, emptyLedger, readLedger, writeLedger } from "../fact-ledger.mjs"
+
+
+const HASH = "a".repeat(64)
+
+const EOK_WON = "\uC5B5\uC6D0"
+
+
+type Row = Record<string, unknown>
+
+type Ledger = { schemaVersion: number; rows: Row[]; events: unknown[] }
+
+
+function measured(factId: string, value: string, unit: string, extra: Row = {}): Row {
+	return {
+		fact_id: factId,
+		kind: "measured",
+		value,
+		unit,
+		raw: `${value} ${unit}`,
+		quote: `The figure is ${value} ${unit}.`,
+		source_id: "S1",
+		locator: { artifact: "sources/S1/text.txt", char_start: 0, char_end: 20 },
+		snapshot_sha256: HASH,
+		extracted_by: "fact add --find",
+		observed_at: "2026-10-23T08:00:00Z",
+		label: factId.toLowerCase(),
+		...extra,
+	}
+}
+
+
+function ledgerOf(rows: Row[]): Ledger {
+	const ledger = emptyLedger() as Ledger
+	for (const row of rows) addRow(ledger, row)
+	return ledger
+}
+
+
+function fixture(): Ledger {
+	return ledgerOf([
+		measured("F5", "100", EOK_WON, { population: "all" }),
+		measured("F6", "200", EOK_WON, { population: "all" }),
+		measured("F7", "200", EOK_WON, { population: "subset" }),
+		measured("F8", "15", "%"),
+		measured("F9", "20", "%"),
+		measured("F12", "320", "m"),
+		measured("F19", "100", "case", { valid_at: "2025-Q3", entity: "acme" }),
+		measured("F20", "112", "case", { valid_at: "2026-Q3", entity: "acme" }),
+		measured("F30", "3.2", "m"),
+	])
+}
+
+
+function rowOf(result: { row?: Row; error?: string; detail?: string }): Row {
+	if (!result.row) throw new Error(`expected a row, got ${result.error}: ${result.detail}`)
+	return result.row
+}
+export { HASH, EOK_WON, Row, Ledger, measured, ledgerOf, fixture, rowOf }

package/packages/shared-skills/skills/ulw-research/scripts/tests/fact-unit-dimensions-support.ts

@@ -0,0 +1,41 @@
+import { expect, test } from "bun:test"
+import { recompute } from "../fact-derive.mjs"
+import { derive } from "./derive-clock"
+import { addRow, emptyLedger, retractRow, validateLedger } from "../fact-ledger.mjs"
+import { canonicalUnit } from "../unit-rules.mjs"
+import { convertFactor } from "../units.mjs"
+
+
+type Row = Record<string, unknown>
+
+type Book = { schemaVersion: number; rows: Row[]; events: unknown[] }
+
+const now = "2026-10-23T08:00:00Z"
+
+function book(values: string[] = ["1", "3"], units: Array<string | null> = ["m", "m"], extras: Row[] = []): Book {
+	const ledger = emptyLedger() as Book
+	values.forEach((value, i) => addRow(ledger, {
+		kind: "measured", value, unit: units[i], raw: value, quote: value, source_id: "S1",
+		locator: { artifact: "sources/S1/text.txt", char_start: 0, char_end: 1 },
+		snapshot_sha256: "a".repeat(64), extracted_by: "test", observed_at: now, label: `f${i + 1}`,
+		...extras[i],
+	}))
+	return ledger
+}
+
+function row(ledger: Book, spec: Row): Row {
+	const result = derive(ledger, { ...spec, now })
+	if (!("row" in result)) throw Error(JSON.stringify(result))
+	return result.row as Row
+}
+
+const sum = { op: "sum", operands: ["F1", "F2"], unit: "m" }
+
+function refused(ledger: Book, spec: unknown) {
+	const before = structuredClone(ledger)
+	const result = derive(ledger, spec)
+	expect(result).toMatchObject({ error: "incompatible_operands" })
+	expect(ledger).toEqual(before)
+	return result
+}
+export { Row, Book, now, book, row, sum, refused }