lazycodex-ai 5.1.44 → 5.1.46

package/packages/shared-skills/skills/ulw-research/scripts/contracts.mjs

@@ -6,6 +6,16 @@
 
 export const SCHEMA_VERSION = 1
 
+/** The severity vocabulary in rank order; every DEFECT_CODES entry uses one of these. */
+export const SEVERITIES = Object.freeze(["blocker", "major", "minor"])
+
+/** Defect counts per severity, then total. */
+export function countDefects(defects) {
+	const counts = Object.fromEntries(SEVERITIES.map((severity) => [severity, 0]))
+	for (const defect of defects) counts[defect.severity] += 1
+	return { ...counts, total: defects.length }
+}
+
 function deepFreeze(value) {
 	if (value === null || typeof value !== "object") return value
 	for (const key of Object.keys(value)) deepFreeze(value[key])
@@ -39,12 +49,72 @@ export const DEFECT_CODES = deepFreeze({
 	layout_scroll_container: { severity: "minor", integrity: false, hint: "Scrolling content prints clipped; make the content fit or wrap the table in a scroll wrapper only for HTML deliverables." },
 	layout_image_distorted: { severity: "major", integrity: false, hint: "Preserve the image aspect ratio (object-fit: contain inside a fixed container)." },
 	layout_sibling_overlap: { severity: "major", integrity: false, hint: "Separate the overlapping elements (margins, grid, or a slide split)." },
+	unresolved_placeholder: { severity: "blocker", integrity: true, hint: "Register the fact with fact add or remove the sentence; a placeholder is never filled with a guess." },
+	value_mismatch: { severity: "blocker", integrity: true, hint: "Re-run fact fill; never edit a filled value by hand." },
+	unit_mismatch: { severity: "blocker", integrity: true, hint: "Re-run fact fill, or derive a converted row with fact derive --op convert." },
+	quote_not_verbatim: { severity: "blocker", integrity: true, hint: "Re-insert the quote through its {{Q<n>}} placeholder; after a second failure the sentence is replaced by the quote." },
+	claim_status_invalid: { severity: "blocker", integrity: true, hint: "The claim id is unknown, refuted, unresolved, or not in verified-claims; move the sentence to Gaps or Contradictions, or remove it." },
+	incompatible_operands: { severity: "blocker", integrity: true, hint: "The operands differ in unit, population, period, or basis for this operation; fix the rows or declare the operation that fits." },
+	pointer_label_mismatch: { severity: "blocker", integrity: true, hint: "The placeholder's label is not the row's label; check the id, then the label." },
+	quote_anchor_unresolved: { severity: "blocker", integrity: true, hint: "A from or to anchor is missing or occurs more than once in the quote; pick unique anchor words." },
+	unit_duplicated: { severity: "blocker", integrity: true, hint: "The unit after the placeholder repeats the row's unit; use :value or remove the unit." },
+	polish_diff_fail: { severity: "blocker", integrity: true, hint: "The polish pass changed numbers, tickers, table rows, claim ids, markup, or hidden content; revert to the pre-polish artifact and apply the language fixes only." },
+	fidelity_interview_incomplete: { severity: "blocker", integrity: true, hint: "A fidelity field is pending or missing in brief.md; answer the open question or record its default, then rerun." },
+	derived_not_allowed: { severity: "blocker", integrity: true, hint: "The brief allows no derived or assumed numbers; cite a source row directly or change the brief with the requester." },
+	source_outside_floor: { severity: "blocker", integrity: true, hint: "The row's source is outside the source floor the brief records; use a source the brief allows or remove the fact." },
+	snapshot_hash_mismatch: { severity: "blocker", integrity: true, hint: "The source snapshot changed after it was pinned; re-snapshot the source and re-register its rows." },
+	chart_value_untraceable: { severity: "blocker", integrity: true, hint: "A chart value, tick, or data file does not match its ledger-backed data source; re-render the chart from the exported data." },
+	quote_unbound: { severity: "blocker", integrity: true, hint: "A direct quotation has no ledger quote row; register it with fact quote and insert it through its placeholder." },
+	edition_unverified: { severity: "blocker", integrity: true, hint: "The delivered file has no matching fact verify record; run fact verify on that edition and record it with --verified-by." },
+	untraceable_number: { severity: "major", integrity: false, hint: "Replace the typed number with a {{F<n>}} placeholder backed by a ledger row, or register it as assumed with a rationale." },
+	unsupported_verification: { severity: "major", integrity: false, hint: "A sentence marked verified (data-claim-kind=\"verified\") cites a row that is not recorded command output; cite the recorded output row or drop the verified mark." },
+	claim_kind_mismatch: { severity: "major", integrity: false, hint: "An element marked with a claim kind (data-claim-kind) cites a row that kind does not accept, or the kind is unknown; cite a row of that kind or fix the mark (references/fidelity-claim-kinds.md)." },
+	conflicting_readings: { severity: "major", integrity: false, hint: "Two ledger rows with different periods or qualifiers are cited as one fact; split the sentence or retire one row." },
+	hedge_dropped: { severity: "major", integrity: false, hint: "Restore the qualifier the source uses (estimated, about, not yet)." },
+	direction_flipped: { severity: "major", integrity: false, hint: "The source states the opposite direction; rewrite from the quote." },
+	causality_added: { severity: "major", integrity: false, hint: "The source states no cause; state the correlation or quote the source." },
+	qualifier_dropped: { severity: "major", integrity: false, hint: "The source bounds this value (up to, at least, about); restore the qualifier or use :q." },
+	unbound_sentence: { severity: "major", integrity: false, hint: "Bind the sentence to a fact, a quote, a citation, or a claim-graph node with data-claim." },
+	meaning_drift_confirmed: { severity: "major", integrity: false, hint: "Two independent readers found the same drift; rewrite from the quote or dispute with a reason." },
+	meaning_unverified: { severity: "major", integrity: false, hint: "No meaning reader judged this pair, or no strong reader judged a force_strong pair; run the missing reader on pairs.json and rerun fact meaning-check." },
+	polish_edit_rejected: { severity: "major", integrity: false, hint: "The edit changed a number, a hedge, a qualifier, a link, or a claim id, or contained <, > or &; re-propose the language fix only, narrowed to the words around any entity or tag." },
+	polish_hedging_decreased: { severity: "major", integrity: false, hint: "The polish pass removed qualifiers; restore them." },
+	polish_text_churn: { severity: "major", integrity: false, hint: "More than half the text changed during polish; the pass composed instead of proofreading." },
+	snapshot_mismatch: { severity: "major", integrity: false, hint: "The operands come from different collection windows; use rows from one window or state the windows separately." },
+	join_integrity_fail: { severity: "major", integrity: false, hint: "A table row combines facts from different source observations; keep each row to one observation or split it." },
+	quote_stale_version: { severity: "major", integrity: false, hint: "The quoted source revision differs from the revision the report targets; re-snapshot the target revision or date the quote." },
+	quote_fuzzy_match: { severity: "minor", integrity: false, hint: "The source text is OCR-noisy; confirm the snapshot and prefer the raw document." },
+	name_outside_quote: { severity: "minor", integrity: false, hint: "A name in the sentence is not in the cited quote; add the source or remove the name." },
+	verification_claim_unmarked: { severity: "minor", integrity: false, hint: "The sentence reads as a check we ran but carries no verified mark; mark it {{V:F<n>:label}} on a recorded command-output row, or reword it." },
+	scope_widened_warn: { severity: "minor", integrity: false, hint: "The sentence uses a broader scope word than the quote; confirm the scope or narrow it." },
+	particle_unverified: { severity: "minor", integrity: false, hint: "The particle after this value could not be checked; read it aloud and fix it by hand if wrong." },
+	fallback_without_entity: { severity: "minor", integrity: false, hint: "The replacement quote has no entity for attribution; set one on the row." },
+	meaning_drift_warn: { severity: "minor", integrity: false, hint: "A separate reader found the sentence changes scope, subject, or certainty; rewrite from the quote." },
+	polish_edit_unlocated: { severity: "minor", integrity: false, hint: "The edit's before-text was not found exactly once; re-propose against the current text." },
+	polish_link_changed: { severity: "minor", integrity: false, hint: "A link was altered or removed during polish; restore it." },
+	polish_name_changed: { severity: "minor", integrity: false, hint: "A proper noun changed during polish; restore it." },
 })
 
+/** Codes only the fidelity verifier raises (fact ledger, fill, verify, meaning, polish). */
+export const FIDELITY_CODES = Object.freeze([
+	"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", "snapshot_hash_mismatch",
+	"chart_value_untraceable", "quote_unbound", "edition_unverified", "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", "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",
+])
+const FIDELITY_SET = new Set(FIDELITY_CODES)
+
 const LAYOUT_PREFIX = "layout_"
 /** Codes checkStatic can raise (G1-G17). */
 export const STATIC_CODES = Object.freeze(
-	Object.keys(DEFECT_CODES).filter((code) => !code.startsWith(LAYOUT_PREFIX) && code !== "missing_promised_deliverable"),
+	Object.keys(DEFECT_CODES).filter(
+		(code) => !code.startsWith(LAYOUT_PREFIX) && code !== "missing_promised_deliverable" && !FIDELITY_SET.has(code),
+	),
 )
 /** Codes checkLayout can raise (L1-L5). */
 export const LAYOUT_CODES = Object.freeze(Object.keys(DEFECT_CODES).filter((code) => code.startsWith(LAYOUT_PREFIX)))
@@ -59,10 +129,10 @@ export const LANES = Object.freeze(["template-strict", "template-vibe", "no-form
 export const STATES = Object.freeze(["none", "partial", "complete"])
 export const DELIVERABLE_FORMATS = Object.freeze(["pdf", "docx", "html", "md", "latex", "slides", "post"])
 export const DELIVERABLE_STATUSES = Object.freeze(["pending", "delivered", "blocked_capability", "skipped", "failed"])
-export const GATE_NAMES = Object.freeze(["static", "layout", "visual", "proofread"])
+export const GATE_NAMES = Object.freeze(["static", "fidelity", "layout", "visual", "proofread"])
 export const GATE_STATUSES = Object.freeze(["pass", "fail", "not_run"])
 export const LINEAGE_MODES = Object.freeze(["inline", "section"])
-export const ANSWERED_BY = Object.freeze(["user", "default", "request"])
+export const ANSWERED_BY = Object.freeze(["user", "default", "request", "pending"])
 export const REPAIR_DEFAULTS = Object.freeze({ maxAttempts: 3, plateauLimit: 2, wallClockMs: 15 * 60 * 1000 })
 export const DESIGN_SPEC_SECTIONS = Object.freeze([
 	"Extracted from",
@@ -127,6 +197,14 @@ export function validateOutcomeManifest(manifest) {
 	if (isObject(manifest.gates)) {
 		for (const gate of GATE_NAMES) check(errors, GATE_STATUSES.includes(manifest.gates[gate]), `gates.${gate} must be one of ${GATE_STATUSES.join(", ")}`)
 	} else errors.push("gates must be an object")
+	if (manifest.gateHistory !== undefined) {
+		if (!Array.isArray(manifest.gateHistory)) errors.push("gateHistory must be an array")
+		else for (const entry of manifest.gateHistory) {
+			check(errors, isObject(entry) && GATE_NAMES.includes(entry.gate) && GATE_STATUSES.includes(entry.status)
+				&& typeof entry.at === "string" && ISO_DATE.test(entry.at)
+				&& (entry.reason === undefined || typeof entry.reason === "string"), "gateHistory entries must have a known gate, status, timestamp, and optional reason")
+		}
+	}
 	if (Array.isArray(manifest.residualDefects)) manifest.residualDefects.forEach((defect, index) => validateDefect(defect, `residualDefects[${index}]`, errors))
 	else errors.push("residualDefects must be an array")
 	check(errors, manifest.repair === null || isObject(manifest.repair), "repair must be null or an object")
@@ -134,6 +212,14 @@ export function validateOutcomeManifest(manifest) {
 	return { ok: errors.length === 0, errors }
 }
 
+/** A copy of a manifest written before a gate existed: every absent gate key becomes not_run. */
+export function normalizeManifest(manifest) {
+	if (!isObject(manifest) || !isObject(manifest.gates)) return manifest
+	const gates = { ...manifest.gates }
+	for (const gate of GATE_NAMES) if (!Object.hasOwn(gates, gate)) gates[gate] = "not_run"
+	return { ...manifest, gates }
+}
+
 function isMeasure(value) {
 	return Array.isArray(value) && value.length === 3 && value.every((n) => Number.isInteger(n) && n >= 0)
 }

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

@@ -1,10 +1,12 @@
 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,
@@ -16,6 +18,7 @@ import {
 	SCHEMA_VERSION,
 	STATES,
 	STATIC_CODES,
+	normalizeManifest,
 	validateOutcomeManifest,
 	validateRepairState,
 } from "./contracts.mjs"
@@ -49,6 +52,64 @@ const LAYOUT_CODES_EXPECTED = [
 	"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",
+	"snapshot_hash_mismatch",
+	"chart_value_untraceable",
+	"quote_unbound",
+	"edition_unverified",
+]
+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",
+]
+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",
+]
+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 {
@@ -63,7 +124,7 @@ function sampleManifest() {
 			{ format: "pdf", status: "pending", promised: true, updatedAt: "2026-01-01T12:00:00.000Z" },
 		],
 		renders: [],
-		gates: { static: "not_run", layout: "not_run", visual: "not_run", proofread: "not_run" },
+		gates: { static: "not_run", fidelity: "not_run", layout: "not_run", visual: "not_run", proofread: "not_run" },
 		residualDefects: [],
 		repair: null,
 		sources: null,
@@ -72,7 +133,9 @@ function sampleManifest() {
 
 describe("DEFECT_CODES", () => {
 	test("#given the code table #when every code is inspected #then it has a severity, a hint, and an integrity flag", () => {
-		expect(Object.keys(DEFECT_CODES).sort()).toEqual([...STATIC_CODES_EXPECTED, "missing_promised_deliverable", ...LAYOUT_CODES_EXPECTED].sort())
+		expect(Object.keys(DEFECT_CODES).sort()).toEqual(
+			[...STATIC_CODES_EXPECTED, "missing_promised_deliverable", ...LAYOUT_CODES_EXPECTED, ...FIDELITY_CODES_EXPECTED].sort(),
+		)
 		for (const [code, entry] of Object.entries(DEFECT_CODES)) {
 			expect(SEVERITIES.has(entry.severity), `${code} severity`).toBe(true)
 			expect(typeof entry.hint).toBe("string")
@@ -81,14 +144,17 @@ describe("DEFECT_CODES", () => {
 		}
 	})
 
-	test("#given the code table #when integrity codes are derived #then they are exactly the five blocker codes", () => {
-		expect([...INTEGRITY_CODES].sort()).toEqual([
-			"broken_asset_reference",
-			"missing_citation_section",
-			"missing_closing_section",
-			"missing_promised_deliverable",
-			"missing_required_section",
-		])
+	test("#given the code table #when integrity codes are derived #then they are exactly the blocker codes", () => {
+		expect([...INTEGRITY_CODES].sort()).toEqual(
+			[
+				"broken_asset_reference",
+				"missing_citation_section",
+				"missing_closing_section",
+				"missing_promised_deliverable",
+				"missing_required_section",
+				...FIDELITY_BLOCKERS,
+			].sort(),
+		)
 		for (const code of INTEGRITY_CODES) expect(DEFECT_CODES[code].severity).toBe("blocker")
 		for (const [code, entry] of Object.entries(DEFECT_CODES)) {
 			if (entry.severity === "blocker") expect(INTEGRITY_CODES.has(code), `${code} must be integrity`).toBe(true)
@@ -104,6 +170,13 @@ describe("DEFECT_CODES", () => {
 		}).toThrow()
 		expect(DEFECT_CODES.korean_no_keep_all.severity).toBe("major")
 	})
+
+	test("#given the fidelity codes #when inspected #then each carries its fixed severity and integrity flag", () => {
+		for (const code of FIDELITY_BLOCKERS) expect([code, DEFECT_CODES[code]?.severity, DEFECT_CODES[code]?.integrity]).toEqual([code, "blocker", true])
+		for (const code of FIDELITY_MAJORS) expect([code, DEFECT_CODES[code]?.severity, DEFECT_CODES[code]?.integrity]).toEqual([code, "major", false])
+		for (const code of FIDELITY_MINORS) expect([code, DEFECT_CODES[code]?.severity, DEFECT_CODES[code]?.integrity]).toEqual([code, "minor", false])
+		expect(DEFECT_CODES).not.toHaveProperty("incompatible_populations")
+	})
 })
 
 describe("code groups", () => {
@@ -111,10 +184,12 @@ describe("code groups", () => {
 		expect([...STATIC_CODES].sort()).toEqual(STATIC_CODES_EXPECTED.slice().sort())
 		expect([...LAYOUT_CODES].sort()).toEqual(LAYOUT_CODES_EXPECTED.slice().sort())
 		expect([...MANIFEST_CODES]).toEqual(["missing_promised_deliverable"])
-		const union = [...STATIC_CODES, ...LAYOUT_CODES, ...MANIFEST_CODES].sort()
+		expect([...FIDELITY_CODES].sort()).toEqual(FIDELITY_CODES_EXPECTED.slice().sort())
+		const union = [...STATIC_CODES, ...LAYOUT_CODES, ...MANIFEST_CODES, ...FIDELITY_CODES].sort()
 		expect(union).toEqual(Object.keys(DEFECT_CODES).sort())
 		expect(new Set(union).size).toBe(union.length)
 		expect(Object.isFrozen(STATIC_CODES)).toBe(true)
+		expect(Object.isFrozen(FIDELITY_CODES)).toBe(true)
 	})
 })
 
@@ -124,7 +199,8 @@ describe("enums", () => {
 		expect(STATES).toEqual(["none", "partial", "complete"])
 		expect(DELIVERABLE_FORMATS).toEqual(["pdf", "docx", "html", "md", "latex", "slides", "post"])
 		expect(DELIVERABLE_STATUSES).toEqual(["pending", "delivered", "blocked_capability", "skipped", "failed"])
-		expect(GATE_NAMES).toEqual(["static", "layout", "visual", "proofread"])
+		expect(GATE_NAMES).toEqual(["static", "fidelity", "layout", "visual", "proofread"])
+		expect(ANSWERED_BY).toEqual(["user", "default", "request", "pending"])
 		expect(GATE_STATUSES).toEqual(["pass", "fail", "not_run"])
 		expect(LINEAGE_MODES).toEqual(["inline", "section"])
 		expect(DESIGN_SPEC_SECTIONS).toEqual([
@@ -155,6 +231,18 @@ describe("validateOutcomeManifest", () => {
 		expect(result.errors.join("\n")).toMatch(/deliverables\[0\]\.status/)
 	})
 
+	test("#given a manifest written before the fidelity gate #when validated raw and after normalizeManifest #then only the normalized copy passes, with fidelity not_run", () => {
+		const old = fourGateManifest()
+		expect(validateOutcomeManifest(old).ok).toBe(false)
+		const normalized = normalizeManifest(old)
+		expect(normalized.gates.fidelity).toBe("not_run")
+		expect(normalized.gates.static).toBe("not_run")
+		expect(validateOutcomeManifest(normalized)).toEqual({ ok: true, errors: [] })
+		expect(old.gates).not.toHaveProperty("fidelity")
+		const failed = { ...old, gates: { ...old.gates, visual: "fail" } }
+		expect(normalizeManifest(failed).gates.visual).toBe("fail")
+	})
+
 	test("#given a gate with an unknown value #when validated #then it fails", () => {
 		const m = sampleManifest()
 		m.gates.static = "ok"

package/packages/shared-skills/skills/ulw-research/scripts/copy-returns.test.ts

@@ -0,0 +1,183 @@
+// Architecture contract (retention bar): each shared table, list, regex, or classifier has one owner
+// export, so a reintroduced local copy in a consumer fails one of these tests (#11156 sweep).
+import { describe, expect, test } from "bun:test"
+import { readdirSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { sha256Of } from "./cli-support.mjs"
+import { countDefects, DEFECT_CODES, SEVERITIES } from "./contracts.mjs"
+import { meaningStatus, PROMOTION, promotionEligibility } from "./fact-commands-meaning.mjs"
+import { editionFormatOf, MD_HTML_BLOCK_RULES, markdownAsHtml, projectMarkdownInline } from "./fact-commands-verify.mjs"
+import { EXEMPT_KINDS, isExemptKind } from "./fidelity-binding.mjs"
+import { blocksDelivery } from "./gates-fidelity.mjs"
+import { MD_BLOCK_PATTERNS, parseMarkdown } from "./md-lite.mjs"
+import { DRIFT_KINDS, isDriftKind, MODEL_TIERS, VERDICT_SCHEMA, VERDICTS } from "./meaning-check.mjs"
+import { parseRenderedQuote, renderQuote } from "./placeholder.mjs"
+
+const source = (name: string) => readFileSync(join(import.meta.dir, name), "utf8")
+
+describe("severity vocabulary comes from contracts", () => {
+	test("#given DEFECT_CODES #when its severities are collected #then they are exactly SEVERITIES", () => {
+		const used = new Set(Object.values(DEFECT_CODES).map((entry) => entry.severity))
+		expect([...used].sort()).toEqual([...SEVERITIES].sort())
+		expect(Object.isFrozen(SEVERITIES)).toBe(true)
+	})
+
+	test("#given defects of every severity #when counted #then the buckets are SEVERITIES plus total", () => {
+		const defects = SEVERITIES.map((severity) => ({ severity }))
+		expect(Object.keys(countDefects(defects))).toEqual([...SEVERITIES, "total"])
+		expect(countDefects(defects)).toEqual({ ...Object.fromEntries(SEVERITIES.map((severity) => [severity, 1])), total: SEVERITIES.length })
+	})
+
+	test("#given every registry code and an unknown code #when the meaning status is computed #then it follows blocksDelivery", () => {
+		for (const code of [...Object.keys(DEFECT_CODES), "not_a_registered_code"]) {
+			expect(meaningStatus([{ code, severity: "minor" }]), code).toBe(blocksDelivery({ code }) ? "fail" : "pass")
+		}
+		expect(meaningStatus([])).toBe("pass")
+	})
+
+	test("#given the command modules #when read #then none restates the severity buckets, the pair kinds, or a window literal", () => {
+		for (const name of ["fact-commands-meaning.mjs", "fact-commands-verify.mjs"]) {
+			const text = source(name)
+			expect(text, name).not.toMatch(/blocker:\s*0/u)
+			expect(text, name).not.toMatch(/\["quote",\s*"claim",\s*"translation"\]/u)
+			expect(text, name).not.toMatch(/slice\(-\d+\)/u)
+			expect(text, name).not.toMatch(/counts\.blocker \+ counts\.major/u)
+		}
+	})
+})
+
+describe("one sha256 helper", () => {
+	test("#given every runtime module #when read #then only cli-support builds a hash, so records and receipts share sha256Of", () => {
+		const modules = readdirSync(import.meta.dir).filter((name) => name.endsWith(".mjs") && name !== "cli-support.mjs")
+		expect(modules.length).toBeGreaterThan(0)
+		for (const name of modules) expect(source(name), name).not.toMatch(/createHash\(/u)
+		expect(sha256Of("abc")).toBe("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad")
+		expect(sha256Of(Buffer.from("abc"))).toBe(sha256Of("abc"))
+	})
+})
+
+describe("calibration policy is the exported PROMOTION", () => {
+	const confirmedRun = (run: string, disputed: boolean) => ({ run_id: run, confirmed: true, disputed })
+
+	test("#given false blocks only before the window #when eligibility is computed #then they are not counted", () => {
+		const window = PROMOTION.false_block_window
+		expect(Number.isInteger(window) && window > 0).toBe(true)
+		const old = [0, 1, 2].map((n) => confirmedRun(`old${n}`, true))
+		const recent = Array.from({ length: window }, (_, n) => confirmedRun(`new${n}`, false))
+		expect(promotionEligibility([...old, ...recent]).report_false_blocks_in_window).toBe(0)
+		expect(promotionEligibility([...recent, ...old]).report_false_blocks_in_window).toBe(3)
+	})
+
+	test("#given false blocks at the policy maximum #when eligibility is computed #then the threshold read from PROMOTION decides", () => {
+		const limit = PROMOTION.max_report_false_blocks_in_window
+		const clean = Array.from({ length: PROMOTION.min_runs * 20 }, (_, n) => confirmedRun(`c${n}`, false))
+		const blocks = (count: number) => Array.from({ length: count }, (_, n) => confirmedRun(`b${n}`, true))
+		expect(promotionEligibility([...clean, ...blocks(limit)]).eligible).toBe(true)
+		expect(promotionEligibility([...clean, ...blocks(limit + 1)]).eligible).toBe(false)
+	})
+})
+
+describe("verdict schema comes from the meaning-check registries", () => {
+	test("#given VERDICT_SCHEMA #when read #then its vocabularies are the owner exports", () => {
+		expect(VERDICT_SCHEMA.verdict).toBe(VERDICTS)
+		expect(VERDICT_SCHEMA.model_tier).toBe(MODEL_TIERS)
+		expect(VERDICT_SCHEMA.drift_kind).toBe(DRIFT_KINDS)
+		expect(Object.isFrozen(VERDICTS)).toBe(true)
+	})
+
+	test("#given every drift kind and a stranger #when checked #then isDriftKind is membership in DRIFT_KINDS", () => {
+		for (const kind of DRIFT_KINDS) expect(isDriftKind(kind)).toBe(true)
+		expect(isDriftKind("not_a_kind")).toBe(false)
+		expect(source("meaning-check.mjs")).not.toMatch(/new Set\(DRIFT_KINDS\)|new Set\(\["drift"/u)
+	})
+})
+
+describe("inherited lexical tables come from their owners", () => {
+	test("#given fact-pairs #when read #then it holds no Hangul range, exempt-kind set, or hand-built hedge regex", () => {
+		const text = source("fact-pairs.mjs")
+		expect(text).not.toMatch(/\\uAC00-\\uD7A3/u)
+		expect(text).not.toMatch(/\["opinion",\s*"recommendation"\]/u)
+		expect(text).not.toMatch(/new RegExp\(/u)
+	})
+
+	test("#given EXEMPT_KINDS #when checked #then isExemptKind is membership in it", () => {
+		for (const kind of EXEMPT_KINDS) expect(isExemptKind(kind)).toBe(true)
+		expect(isExemptKind("finding")).toBe(false)
+		expect(isExemptKind(undefined)).toBe(false)
+	})
+
+	test("#given md-lite #when its block grammar is read #then MD_BLOCK_PATTERNS names every block regex", () => {
+		expect(Object.keys(MD_BLOCK_PATTERNS).sort()).toEqual(["BLOCKQUOTE", "CLOSING_HASHES", "FENCE", "HEADING", "LIST_ITEM", "TABLE_SEPARATOR", "THEMATIC_BREAK"])
+		for (const pattern of Object.values(MD_BLOCK_PATTERNS)) expect(pattern).toBeInstanceOf(RegExp)
+		expect(Object.isFrozen(MD_BLOCK_PATTERNS)).toBe(true)
+	})
+})
+
+describe("markdown projection rules", () => {
+	const EVERY_KIND = ["# Title", "", "Para text.", "", "- item", "", "> quoted", "", "| a | b |", "| - | - |", "| 1 | 2 |", "", "```", "code", "```", ""].join("\n")
+
+	test("#given every block kind md-lite emits #when projected #then each kind has a projection rule", () => {
+		const kinds = [...new Set(parseMarkdown(EVERY_KIND).blocks.map((block: { kind: string }) => block.kind))].sort()
+		expect(kinds).toEqual(["blockquote", "code", "heading", "list_item", "paragraph", "table_row"])
+		for (const kind of kinds) expect(Object.hasOwn(MD_HTML_BLOCK_RULES, kind), kind).toBe(true)
+		expect(Object.keys(MD_HTML_BLOCK_RULES).sort()).toEqual(kinds)
+		const { html } = markdownAsHtml(EVERY_KIND, [], { rows: [] })
+		expect(html).toContain("<h1>Title</h1>")
+		expect(html).toContain("<ul><li>item</li></ul>")
+		expect(html).toMatch(/<table><tr><td>a<\/td><td>b<\/td><\/tr>\s*<tr><td>1<\/td><td>2<\/td><\/tr><\/table>/u)
+	})
+
+	test("#given an unterminated fence #when projected #then it is refused naming the line", () => {
+		expect(() => markdownAsHtml("Intro.\n\n```\nno close\n", [], { rows: [] })).toThrow(/unterminated_fence at line 3/u)
+	})
+
+	test("#given inline links and code #when projected #then they stay elements and the rest is escaped", () => {
+		expect(projectMarkdownInline("a <b> [x](https://e.x) `c`")).toBe('a &lt;b&gt; <a href="https://e.x">x</a> <code>c</code>')
+	})
+
+	test("#given a fill map with quotes in translates and fact_id #when projected #then the attributes are escaped", () => {
+		const md = "Before X after.\n\n> Quoted block.\n"
+		const span = { fact_id: 'F"1', start: 7, end: 8, rendered: "X", translates: 'T"1' }
+		const block = { fact_id: 'Q"2', start: md.indexOf(">"), end: md.length - 1, rendered: "", replaced: "a" }
+		const { html } = markdownAsHtml(md, [span, block], { rows: [] })
+		expect(html).toContain('data-translates="T&quot;1"')
+		expect(html).toContain('data-fact="Q&quot;2"')
+		expect(markdownAsHtml("Before X after.\n", [{ ...span, translates: undefined }], { rows: [] }).html).toContain('data-fact="F&quot;1"')
+		expect(html).not.toMatch(/="[^"]*"1"/u)
+	})
+
+	test("#given paths of each case #when the format is inferred #then md and markdown are Markdown and a flag wins", () => {
+		expect(["r.md", "R.MD", "r.markdown", "r.html", "r.txt"].map((path) => editionFormatOf(path, undefined))).toEqual(["md", "md", "md", "html", "html"])
+		expect(editionFormatOf("r.md", "html")).toBe("html")
+	})
+})
+
+describe("rendered quotes round-trip through the placeholder owner", () => {
+	const row = { fact_id: "Q1", kind: "quote", source_id: "S4", quote: "We estimate completion no earlier than 2027." }
+	const selections = [
+		["full", row.quote],
+		["lead=2", "We estimate"],
+		["from=completion,to=2027", "completion no earlier than 2027"],
+	]
+
+	for (const [selector, text] of selections) {
+		test(`#given a ${selector} quote rendered for md #when projected #then the quote element and marker survive`, () => {
+			const rendered = renderQuote(row, selector, text, "md")
+			expect(parseRenderedQuote(rendered)).toEqual({ text, marker: "[S4]" })
+			const md = `The operator wrote ${rendered}.\n`
+			const entry = { fact_id: "Q1", start: md.indexOf(rendered), end: md.indexOf(rendered) + rendered.length, rendered, selector }
+			const projected = markdownAsHtml(md, [entry], { rows: [row] })
+			expect(projected.html).toContain(renderQuote(row, selector, text, "html"))
+			expect(projected.stale).toEqual([])
+			const edited = md.replace(text, `${text} indeed`)
+			const stale = markdownAsHtml(edited, [{ ...entry, end: entry.end + " indeed".length }], { rows: [row] })
+			expect(stale.html).not.toContain("<q ")
+			expect(stale.stale).toHaveLength(1)
+		})
+	}
+
+	test("#given bytes that are not the md quote layout #when parsed #then null", () => {
+		expect(parseRenderedQuote("plain text [S4]")).toBeNull()
+	})
+})