lazycodex-ai 5.0.0-beta.9 → 5.0.0

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

@@ -0,0 +1,265 @@
+import { describe, expect, test } from "bun:test"
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { DEFECT_CODES, STATIC_CODES } from "./contracts.mjs"
+import { parseLineageMode, parsePalette } from "./design-spec.mjs"
+import { checkStatic } from "./gates-static.mjs"
+import { parseHtml } from "./html-lite.mjs"
+
+type Defect = { code: string; severity: string; selector: string; line: number; message: string; hint: string }
+type Result = { defects: Defect[]; gatesRun: string[]; gatesSkipped: string[] }
+type FakeStat = { size: number }
+
+const FIXTURES = join(import.meta.dir, "tests", "fixtures")
+const GOOD = readFileSync(join(FIXTURES, "good-report.html"), "utf8")
+const BAD = readFileSync(join(FIXTURES, "bad-report.html"), "utf8")
+const SPEC = readFileSync(join(FIXTURES, "design-spec.md"), "utf8")
+const PALETTE = parsePalette(SPEC)
+
+function run(html: string, options: Record<string, unknown> = {}): Result {
+	return checkStatic(parseHtml(html), {
+		palette: PALETTE,
+		lineageMode: parseLineageMode(SPEC),
+		requireSections: [],
+		baseDir: FIXTURES,
+		...options,
+	}) as Result
+}
+
+const codes = (result: Result) => result.defects.map((defect) => defect.code)
+const has = (html: string, code: string, options: Record<string, unknown> = {}) => codes(run(html, options)).includes(code)
+
+describe("checkStatic fixtures", () => {
+	test("#given the passing fixture report #when every gate runs #then no defect is raised", () => {
+		// given
+		const options = { requireSections: [/sources/i, /review/i] }
+		// when
+		const result = run(GOOD, options)
+		// then
+		expect(codes(result)).toEqual([])
+		expect(result.gatesSkipped).toEqual([])
+		expect([...result.gatesRun].sort()).toEqual([...STATIC_CODES].sort())
+	})
+
+	test("#given the failing fixture report #when every gate runs #then each static code is raised exactly once", () => {
+		// given
+		const options = { requireSections: [/risks/i] }
+		// when
+		const result = run(BAD, options)
+		// then
+		expect([...codes(result)].sort()).toEqual([...STATIC_CODES].sort())
+		expect(STATIC_CODES).toHaveLength(17)
+		expect(codes(result)).not.toContain("missing_promised_deliverable")
+	})
+
+	test("#given the failing fixture report #when defects are read #then each carries contract severity, selector, line, token message and hint", () => {
+		// given
+		const result = run(BAD, { requireSections: [/risks/i] })
+		// when
+		const byCode = new Map(result.defects.map((defect) => [defect.code, defect]))
+		// then
+		for (const defect of result.defects) {
+			const contract = DEFECT_CODES[defect.code as keyof typeof DEFECT_CODES]
+			expect(defect.severity).toBe(contract.severity)
+			expect(defect.hint).toBe(contract.hint)
+			expect(typeof defect.selector).toBe("string")
+			expect(defect.selector.length).toBeGreaterThan(0)
+			expect(Number.isInteger(defect.line)).toBe(true)
+		}
+		expect(byCode.get("palette_off_token")?.message).toContain("#123456")
+		expect(byCode.get("unsourced_number")?.message).toContain("12.5%")
+		expect(byCode.get("broken_asset_reference")?.message).toContain("missing-figure.png")
+		expect(byCode.get("korean_serif_font")?.message).toContain("Nanum Myeongjo")
+		expect(byCode.get("emoji_in_prose")?.message).toContain("\u{1F680}")
+	})
+})
+
+describe("mutation proofs on the passing fixture", () => {
+	test("#given keep-all removed #when checked #then only korean_no_keep_all is raised", () => {
+		// given
+		const mutated = GOOD.replace("word-break: keep-all;", "")
+		// when
+		const result = run(mutated, { requireSections: [/sources/i] })
+		// then
+		expect(codes(result)).toEqual(["korean_no_keep_all"])
+	})
+
+	test("#given the closing heading renamed #when checked #then the missing_closing_section blocker is raised", () => {
+		// given
+		const mutated = GOOD.replace("<h2>How this report was made</h2>", "<h2>Notes on the data</h2>")
+		// when
+		const result = run(mutated)
+		// then
+		const defect = result.defects.find((entry) => entry.code === "missing_closing_section")
+		expect(defect?.severity).toBe("blocker")
+	})
+
+	test("#given the sources heading renamed #when checked #then the missing_citation_section blocker is raised", () => {
+		// given
+		const mutated = GOOD.replace("<h2>Sources</h2>", "<h2>Further reading</h2>")
+		// when
+		const result = run(mutated)
+		// then
+		const defect = result.defects.find((entry) => entry.code === "missing_citation_section")
+		expect(defect?.severity).toBe("blocker")
+	})
+
+	test("#given no sources heading but three [S<n>] definition lines #when checked #then no citation-section blocker", () => {
+		// given
+		const html = "<h2>Notes</h2><p>[S1] First source title</p><p>[S2] Second source title</p><p>[Source 3] Third source title</p>"
+		// when
+		const found = has(html, "missing_citation_section")
+		// then
+		expect(found).toBe(false)
+	})
+})
+
+describe("unsourced_number", () => {
+	const claim = "\uB9E4\uCD9C\uC774 12.5% \uC99D\uAC00\uD588\uB2E4"
+
+	test("#given a bare revenue claim #when checked #then unsourced_number is raised", () => {
+		// given
+		const html = `<p>${claim}</p>`
+		// when
+		const found = has(html, "unsourced_number")
+		// then
+		expect(found).toBe(true)
+	})
+
+	test.each([
+		["a [S3] marker", `<p>${claim} [S3]</p>`],
+		["a MEASURED token", `<p>${claim} MEASURED</p>`],
+		["a data-lineage attribute", `<p data-lineage="DERIVED">${claim}</p>`],
+		["a #s3 anchor", `<p>${claim} <a href="#s3">3</a></p>`],
+	])("#given the claim with %s #when checked #then it is not flagged", (_label, html) => {
+		// given / when
+		const found = has(html, "unsourced_number")
+		// then
+		expect(found).toBe(false)
+	})
+
+	test("#given dates, versions, figure refs and bare years only #when checked #then no claim is found", () => {
+		// given
+		const html = "<p>Released 2024-03-01 as v2.3.1 in 2019, see Figure 3 and Table 2.</p>"
+		// when
+		const found = has(html, "unsourced_number")
+		// then
+		expect(found).toBe(false)
+	})
+
+	test("#given inline and section lineage modes #when the same claim is checked #then severity is major then minor", () => {
+		// given
+		const html = `<p>${claim}</p>`
+		// when
+		const inline = run(html, { lineageMode: "inline" }).defects.find((d) => d.code === "unsourced_number")
+		const section = run(html, { lineageMode: "section" }).defects.find((d) => d.code === "unsourced_number")
+		// then
+		expect(inline?.severity).toBe(DEFECT_CODES.unsourced_number.severity)
+		expect(section?.severity).toBe("minor")
+	})
+
+	test("#given a claim inside a figure, a table and the closing section #when checked #then none is flagged", () => {
+		// given
+		const html = `<figure><p>${claim}</p><figcaption>x</figcaption></figure><table><tr><td><p>${claim}</p></td></tr></table><h2>How it was made</h2><p>${claim}</p>`
+		// when
+		const found = has(html, "unsourced_number")
+		// then
+		expect(found).toBe(false)
+	})
+})
+
+describe("dashes and emoji", () => {
+	test("#given an en dash between years #when checked #then it is allowed", () => {
+		// given / when
+		const found = has("<p>2019\u20132024</p>", "en_dash_in_prose")
+		// then
+		expect(found).toBe(false)
+	})
+
+	test("#given an en dash between letters #when checked #then en_dash_in_prose is raised", () => {
+		// given / when
+		const found = has("<p>a\u2013b</p>", "en_dash_in_prose")
+		// then
+		expect(found).toBe(true)
+	})
+
+	test("#given em dashes in a td and in the sources section #when checked #then they are out of prose scope", () => {
+		// given
+		const html = "<table><tr><td>\u2014</td></tr></table><h2>Sources</h2><ol><li>Title \u2014 subtitle</li></ol>"
+		// when
+		const found = has(html, "em_dash_in_prose")
+		// then
+		expect(found).toBe(false)
+	})
+
+	test("#given a check-mark emoji in prose #when checked #then emoji_in_prose is raised", () => {
+		// given / when
+		const found = has("<p>\u2705 done</p>", "emoji_in_prose")
+		// then
+		expect(found).toBe(true)
+	})
+
+	test("#given a plain check mark in a td #when checked #then no emoji is raised", () => {
+		// given / when
+		const found = has("<table><tr><td>\u2713</td></tr></table>", "emoji_in_prose")
+		// then
+		expect(found).toBe(false)
+	})
+})
+
+describe("figures and charts", () => {
+	test("#given a 16px svg inside an h2 #when checked #then it is not treated as a chart", () => {
+		// given
+		const html = '<h2>Title <svg width="16" height="16" viewBox="0 0 16 16"><path d="M0 0h16"/></svg></h2>'
+		// when
+		const found = codes(run(html)).filter((code) => code.startsWith("chart_"))
+		// then
+		expect(found).toEqual([])
+	})
+
+	test("#given a figure svg with title, three ticks and a label #when checked #then no chart defect", () => {
+		// given
+		const svg = '<svg width="400" height="200"><title>Deploys</title><text>0</text><text>5</text><text>10</text><text>Weeks</text></svg>'
+		// when
+		const found = codes(run(`<figure>${svg}<figcaption>Deploys per week</figcaption></figure>`)).filter((code) => code.startsWith("chart_"))
+		// then
+		expect(found).toEqual([])
+	})
+})
+
+describe("gate bookkeeping", () => {
+	test("#given a spec with an empty palette #when checked #then palette_off_token is skipped, not run", () => {
+		// given
+		const palette = parsePalette("# Design spec\n\n## Citations\n- Lineage: inline\n")
+		// when
+		const result = run('<p style="color: #123456">x</p>', { palette })
+		// then
+		expect(palette.size).toBe(0)
+		expect(result.gatesSkipped).toContain("palette_off_token")
+		expect(result.gatesRun).not.toContain("palette_off_token")
+		expect(codes(result)).not.toContain("palette_off_token")
+	})
+
+	test("#given an injected fs with a zero-byte and a missing asset #when checked #then both are broken and remote ones are ignored", () => {
+		// given
+		const sizes = new Map<string, number>([[join("base", "empty.png"), 0], [join("base", "ok.css"), 10]])
+		const fs = {
+			statSync(file: string): FakeStat {
+				const size = sizes.get(file)
+				if (size === undefined) throw Object.assign(new Error("ENOENT"), { code: "ENOENT" })
+				return { size }
+			},
+		}
+		const html = '<link rel="stylesheet" href="ok.css"><img src="empty.png"><script src="gone.js"></script><img src="https://example.org/a.png">'
+		// when
+		const broken = run(html, { baseDir: "base", fs }).defects.filter((d) => d.code === "broken_asset_reference")
+		// then
+		expect(broken.map((d) => d.message.includes("empty.png") || d.message.includes("gone.js"))).toEqual([true, true])
+	})
+
+	test("#given an unknown lineage mode #when checked #then it throws instead of guessing a severity", () => {
+		// given / when / then
+		expect(() => run("<p>x</p>", { lineageMode: "loose" })).toThrow(TypeError)
+	})
+})

package/packages/shared-skills/skills/ulw-research/scripts/gates-structure.mjs

@@ -0,0 +1,118 @@
+// gates-structure.mjs - structure gates: G11 section without citation, G12 closing section,
+// G13 citation section, G14 broken asset reference, G15 required sections.
+//
+// Each gate is { codes, skip?(ctx), run(ctx) -> Defect[] } over the context built by
+// gates-static.mjs. Plain Node ESM, node: builtins and siblings only.
+
+import { join } from "node:path"
+
+import { proseText } from "./html-lite.mjs"
+
+const MIN_SECTION_PROSE = 120
+const UNCHECKED_KINDS = new Set(["closing", "sources", "toc", "appendix", "glossary"])
+const DEFINITION_TAGS = new Set(["p", "li", "dd", "dt", "td"])
+const DEFINITION_LINE = /^\[(S|Source\s*)(\d+)\]/i
+const MIN_DEFINITIONS = 3
+const NOT_RELATIVE = /^(?:[a-z][a-z\d+.-]*:|\/\/|\/|#)/i
+
+function headingNodes(ctx, tags) {
+	return ctx.elements.map(({ node }) => node).filter((node) => tags.includes(node.tag))
+}
+
+/** Local references an asset gate checks: img src, source srcset, stylesheet href, script src. */
+function assetReferences(ctx) {
+	const refs = []
+	for (const node of ctx.all) {
+		const { attrs } = node
+		if (node.tag === "img" && attrs.src) refs.push({ node, url: attrs.src })
+		else if (node.tag === "script" && attrs.src) refs.push({ node, url: attrs.src })
+		else if (node.tag === "link" && attrs.href && /(?:^|\s)stylesheet(?:\s|$)/i.test(attrs.rel ?? "")) refs.push({ node, url: attrs.href })
+		else if (node.tag === "source" && attrs.srcset) {
+			for (const candidate of attrs.srcset.split(",")) {
+				const url = candidate.trim().split(/\s+/)[0]
+				if (url) refs.push({ node, url })
+			}
+		}
+	}
+	return refs.filter(({ url }) => url.trim() && !NOT_RELATIVE.test(url.trim()))
+}
+
+function localPath(baseDir, url) {
+	const bare = url.trim().replace(/[?#].*$/, "")
+	let decoded = bare
+	try {
+		decoded = decodeURIComponent(bare)
+	} catch {
+		// a malformed %-escape is kept verbatim; the stat below reports it as missing
+	}
+	return join(baseDir, ...decoded.split("/"))
+}
+
+function assetProblem(fs, file) {
+	try {
+		const stat = fs.statSync(file)
+		return stat.size === 0 ? "is 0 bytes" : null
+	} catch (error) {
+		return `is missing (${error?.code ?? "stat failed"})`
+	}
+}
+
+export const structureGates = [
+	{
+		codes: ["section_without_citation"],
+		run(ctx) {
+			const defects = []
+			for (const section of ctx.sections) {
+				if (UNCHECKED_KINDS.has(section.kind)) continue
+				const prose = section.prose.join(" ").replace(/\s+/g, " ").trim()
+				if (prose.length < MIN_SECTION_PROSE || section.anchors > 0 || ctx.util.citationMarker.test(prose)) continue
+				const title = proseText(section.heading)
+				defects.push(ctx.defect("section_without_citation", section.heading, `section "${title}" has ${prose.length} prose characters and no citation marker or anchor`))
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["missing_closing_section"],
+		run(ctx) {
+			if (headingNodes(ctx, ["h2", "h3"]).some((node) => ctx.isClosing(proseText(node)))) return []
+			return [ctx.defect("missing_closing_section", ctx.body, "no h2/h3 heading names how the report was made (method / how)")]
+		},
+	},
+	{
+		codes: ["missing_citation_section"],
+		run(ctx) {
+			if (ctx.sections.some((section) => section.kind === "sources")) return []
+			const ids = new Set()
+			for (const { node } of ctx.elements) {
+				if (!DEFINITION_TAGS.has(node.tag)) continue
+				const match = DEFINITION_LINE.exec(proseText(node))
+				if (match) ids.add(`${match[1].trim().toLowerCase()}${match[2]}`)
+			}
+			if (ids.size >= MIN_DEFINITIONS) return []
+			return [ctx.defect("missing_citation_section", ctx.body, `no references/sources h2 and ${ids.size} [S<n>] definition line(s) (< ${MIN_DEFINITIONS})`)]
+		},
+	},
+	{
+		codes: ["broken_asset_reference"],
+		skip: (ctx) => !ctx.baseDir,
+		run(ctx) {
+			const defects = []
+			for (const { node, url } of assetReferences(ctx)) {
+				const problem = assetProblem(ctx.fs, localPath(ctx.baseDir, url))
+				if (problem) defects.push(ctx.defect("broken_asset_reference", node, `<${node.tag}> asset "${url}" ${problem}`))
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["missing_required_section"],
+		skip: (ctx) => ctx.requireSections.length === 0,
+		run(ctx) {
+			const titles = headingNodes(ctx, ["h1", "h2", "h3", "h4", "h5", "h6"]).map((node) => proseText(node))
+			return ctx.requireSections
+				.filter((re) => !titles.some((title) => re.test(title)))
+				.map((re) => ctx.defect("missing_required_section", ctx.body, `no heading matches the required section ${re}`))
+		},
+	},
+]

package/packages/shared-skills/skills/ulw-research/scripts/gates-text.mjs

@@ -0,0 +1,190 @@
+// gates-text.mjs - prose gates: G1 keep-all, G3 emoji, G4 dashes, G5/G6 headings, G7 unsourced numbers.
+//
+// Each gate is { codes, run(ctx) -> Defect[] } over the context built by gates-static.mjs.
+// Plain Node ESM, sibling imports only.
+
+import { proseText } from "./html-lite.mjs"
+
+const HANGUL = /[\uAC00-\uD7A3]/g
+const KEEP_ALL = /word-break\s*:\s*keep-all/i
+const MIN_HANGUL = 20
+/** Dingbats (2700-27BF) that render as emoji without FE0F (Emoji_Presentation=Yes). */
+const DINGBAT_EMOJI = new Set([0x2705, 0x270a, 0x270b, 0x2728, 0x274c, 0x274e, 0x2753, 0x2754, 0x2755, 0x2757, 0x2795, 0x2796, 0x2797, 0x27b0, 0x27bf])
+const EM_DASH = "\u2014"
+const EN_DASH = "\u2013"
+const HEADING_NUMBER = /^\s*(?:\d+(?:[.-]\d+)*[.):]?|[IVXLC]+[.)]|[A-Z][.)])\s+/
+const GENERIC = new Set(["overview", "introduction", "background", "summary", "conclusion", "conclusions", "results", "discussion", "methodology"])
+const MAX_HEADING_HANGUL = 26
+const MAX_HEADING_WORDS = 12
+const LINEAGE_TOKEN = /\b(?:MEASURED|ASSUMED|DERIVED)\b/
+const NUMBER_CONTAINERS = new Set(["figure", "table", "nav", "header", "footer"])
+const MAX_UNSOURCED = 50
+const MONTH = "(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\\.?"
+/** Stripped before claim detection: dates, versions, figure refs, times, bare years. */
+const NOT_CLAIMS = [
+	/\b\d{4}[-./]\d{1,2}(?:[-./]\d{1,2})?\b/g,
+	/\b\d{2}\.\d{2}\.\d{2}\b/g,
+	/\d{2,4}\s*\uB144\s*\d{1,2}\s*\uC6D4(?:\s*\d{1,2}\s*\uC77C)?/g,
+	/\d{1,2}\s*\uC6D4(?:\s*\d{1,2}\s*\uC77C)?/g,
+	/(?:19|20)\d{2}\s*\uB144/g,
+	new RegExp(`\\b${MONTH}\\s+\\d{1,2}(?:st|nd|rd|th)?(?:,?\\s+\\d{4})?`, "gi"),
+	new RegExp(`\\b\\d{1,2}(?:st|nd|rd|th)?\\s+${MONTH}(?:\\s+\\d{4})?`, "gi"),
+	/\bv\d+(?:\.\d+)*\b|\b\d+(?:\.\d+){2,}\b/gi,
+	/\b(?:version|ver\.?|release)\s*\d+(?:\.\d+)*/gi,
+	/\b(?:fig(?:ure)?\.?|table|chart|section|step|phase|wave|part)\s*\d+(?:\.\d+)*/gi,
+	/(?:\uADF8\uB9BC|\uB3C4\uD45C|\uD45C|\uBC84\uC804)\s*\d+(?:\.\d+)*/g,
+	/\b\d{1,2}:\d{2}\b/g,
+	/\b(?:19|20)\d{2}s?\b/g,
+]
+const NUM = "(?<![\\p{L}\\d.,])\\d+(?:[.,]\\d+)*"
+const UNIT =
+	"(?:%|\\u2030|\\u00D7|\\uD37C\\uC13C\\uD2B8|\\uB2EC\\uB7EC|\\uC720\\uB85C|\\uC5D4|\\uC6D0|\\uB9CC|\\uC5B5|\\uC870|\\uCC9C|\\uCD08|\\uBD84|\\uC2DC\\uAC04|\\uC77C|\\uC8FC|\\uAC1C\\uC6D4|\\uB144|\\uBA85|\\uAC74|\\uAC1C|\\uD68C|\\uBC88|\\uBC30" +
+	"|(?:percent|pp|bps?|x|k|m|b|bn|million|billion|thousand|trillion|usd|krw|eur|ms|s|secs?|seconds?|mins?|minutes?|h|hrs?|hours?|days?|weeks?|months?|years?|kb|mb|gb|tb|users?|people|employees|engineers|tokens?|requests?|stars?|downloads?|customers?)(?![\\p{L}\\d]))"
+const CLAIMS = [
+	new RegExp(`[$\\u20AC\\u00A3\\u00A5\\u20A9]\\s?${NUM}`, "u"),
+	new RegExp(`${NUM}\\s?${UNIT}`, "iu"),
+	/(?<![\d.,])\d{1,3}(?:,\d{3})+(?![\d,])/,
+	/(?<![\d.])\d+\.\d+(?![\d.])/,
+]
+
+function snippet(text, index, span = 24) {
+	return text.slice(Math.max(0, index - span), index + span).trim()
+}
+
+/** Concatenated prose per owning element, in document order; `keep` filters text entries. */
+function ownerTexts(ctx, keep) {
+	const byOwner = new Map()
+	for (const entry of ctx.texts) {
+		if (!keep(entry)) continue
+		byOwner.set(entry.owner, (byOwner.get(entry.owner) ?? "") + entry.node.text)
+	}
+	return [...byOwner].map(([owner, text]) => ({ owner, text: text.replace(/\s+/g, " ") }))
+}
+
+function firstEmoji(text) {
+	const chars = [...text]
+	for (let i = 0; i < chars.length; i++) {
+		const cp = chars[i].codePointAt(0)
+		if (chars[i + 1] === "\uFE0F" && cp !== 0xfe0f) return chars[i] + chars[i + 1]
+		if ((cp >= 0x1f000 && cp <= 0x1faff) || (cp >= 0x2600 && cp <= 0x26ff) || DINGBAT_EMOJI.has(cp)) return chars[i]
+	}
+	return null
+}
+
+const isDigit = (ch) => ch >= "0" && ch <= "9"
+
+/** En dash allowed only when both neighbors (one optional space) are digits. */
+function badEnDash(text) {
+	for (let at = text.indexOf(EN_DASH); at !== -1; at = text.indexOf(EN_DASH, at + 1)) {
+		const before = text[at - 1] === " " ? text[at - 2] : text[at - 1]
+		const after = text[at + 1] === " " ? text[at + 2] : text[at + 1]
+		if (!isDigit(before ?? "") || !isDigit(after ?? "")) return at
+	}
+	return -1
+}
+
+const stripNumbering = (text) => text.replace(HEADING_NUMBER, "").trim()
+
+function headings(ctx, max) {
+	return ctx.elements.filter(({ node }) => /^h[1-6]$/.test(node.tag) && Number(node.tag[1]) <= max).map(({ node }) => node)
+}
+
+/** Citation markers need no stripping: an element carrying one is skipped before this runs. */
+function claimIn(text) {
+	let rest = text
+	for (const re of NOT_CLAIMS) rest = rest.replace(re, " ")
+	for (const re of CLAIMS) {
+		const match = re.exec(rest)
+		if (match) return match[0].trim()
+	}
+	return null
+}
+
+function numberCandidates(ctx) {
+	const { closest, classTokens, descendants } = ctx.util
+	return ctx.elements.filter(({ node, scope }) => {
+		if (node.tag !== "p" && node.tag !== "li") return false
+		if (node.tag === "li" && descendants(node).some((child) => child.tag === "p" || child.tag === "li")) return false
+		const kind = ctx.kindOf(scope)
+		if (kind === "closing" || kind === "sources") return false
+		return !closest(node, (cur) => NUMBER_CONTAINERS.has(cur.tag) || classTokens(cur).includes("fig"))
+	})
+}
+
+export const textGates = [
+	{
+		codes: ["korean_no_keep_all"],
+		run(ctx) {
+			const syllables = ctx.texts.reduce((sum, entry) => sum + (entry.node.text.match(HANGUL)?.length ?? 0), 0)
+			if (syllables < MIN_HANGUL) return []
+			if ([...ctx.styleBlocks, ...ctx.styleAttrs].some((entry) => KEEP_ALL.test(entry.css))) return []
+			return [ctx.defect("korean_no_keep_all", ctx.body, `${syllables} Hangul syllables in prose and no "word-break: keep-all" in any style block or style attribute`)]
+		},
+	},
+	{
+		codes: ["emoji_in_prose"],
+		run(ctx) {
+			const defects = []
+			for (const { owner, text } of ownerTexts(ctx, () => true)) {
+				const emoji = firstEmoji(text)
+				if (emoji) defects.push(ctx.defect("emoji_in_prose", owner, `emoji "${emoji}" in <${owner.tag}>: "${snippet(text, text.indexOf(emoji))}"`))
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["em_dash_in_prose", "en_dash_in_prose"],
+		run(ctx) {
+			const defects = []
+			const inScope = (entry) => !entry.cell && ctx.kindOf(entry.scope) !== "sources"
+			for (const { owner, text } of ownerTexts(ctx, inScope)) {
+				const em = text.indexOf(EM_DASH)
+				if (em !== -1) defects.push(ctx.defect("em_dash_in_prose", owner, `em dash "${EM_DASH}" in <${owner.tag}>: "${snippet(text, em)}"`))
+				const en = badEnDash(text)
+				if (en !== -1) defects.push(ctx.defect("en_dash_in_prose", owner, `en dash "${EN_DASH}" outside a numeric range in <${owner.tag}>: "${snippet(text, en)}"`))
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["heading_too_long"],
+		run(ctx) {
+			const defects = []
+			for (const node of headings(ctx, 4)) {
+				const text = stripNumbering(proseText(node))
+				const hangul = /[\uAC00-\uD7A3]/.test(text)
+				const size = hangul ? [...text].length : text.split(/\s+/).filter(Boolean).length
+				if (size > (hangul ? MAX_HEADING_HANGUL : MAX_HEADING_WORDS)) {
+					defects.push(ctx.defect("heading_too_long", node, `<${node.tag}> "${text}" is ${size} ${hangul ? "characters (> 26)" : "words (> 12)"}`))
+				}
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["heading_generic"],
+		run(ctx) {
+			const defects = []
+			for (const node of headings(ctx, 3)) {
+				const text = stripNumbering(proseText(node))
+				if (GENERIC.has(text.toLowerCase().replace(/[.:]+$/, ""))) defects.push(ctx.defect("heading_generic", node, `generic <${node.tag}> "${text}"`))
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["unsourced_number"],
+		run(ctx) {
+			const defects = []
+			for (const { node } of numberCandidates(ctx)) {
+				if (defects.length >= MAX_UNSOURCED) break
+				const text = proseText(node)
+				if (LINEAGE_TOKEN.test(text) || ctx.util.hasCitation(node)) continue
+				if (node.attrs["data-lineage"] !== undefined || ctx.util.descendants(node).some((child) => child.attrs["data-lineage"] !== undefined)) continue
+				const claim = claimIn(text)
+				if (claim) defects.push(ctx.defect("unsourced_number", node, `number "${claim}" without a lineage tag or citation: "${snippet(text, text.indexOf(claim))}"`))
+			}
+			return defects
+		},
+	},
+]

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

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test"
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { DEFECT_CODES, GATE_STATUSES, LINEAGE_MODES } from "./contracts.mjs"
+
+describe("report-gates glossary vocabulary parity", () => {
+	test("#given the defect codes #when the glossary is loaded #then every exported code appears as a backticked table cell", () => {
+		const glossaryPath = join(import.meta.dir, "../references/report-gates.md")
+		const glossary = readFileSync(glossaryPath, "utf8")
+
+		const missing: string[] = []
+		for (const code of Object.keys(DEFECT_CODES)) {
+			if (!glossary.includes(`\`${code}\``)) {
+				missing.push(code)
+			}
+		}
+
+		expect(missing, `Missing codes: ${missing.join(", ")}`).toEqual([])
+	})
+
+	test("#given the glossary #when scanned for backticked tokens #then no extra defect code appears that is not exported", () => {
+		const glossaryPath = join(import.meta.dir, "../references/report-gates.md")
+		const glossary = readFileSync(glossaryPath, "utf8")
+
+		const defectCodeSet = new Set(Object.keys(DEFECT_CODES))
+		const validTokens = new Set([...defectCodeSet, ...GATE_STATUSES, ...LINEAGE_MODES])
+		const backtickRegex = /`([a-z_][a-z0-9_]*)`/g
+		const extras: string[] = []
+
+		let match
+		while ((match = backtickRegex.exec(glossary)) !== null) {
+			const token = match[1]
+			// Only flag tokens that look like defect codes (underscore-separated)
+			// and aren't already exported from contracts
+			if (!validTokens.has(token) && token.includes("_") && token.length > 3) {
+				if (!extras.includes(token)) extras.push(token)
+			}
+		}
+
+		expect(extras, `Extra codes not in contracts: ${extras.join(", ")}`).toEqual([])
+	})
+})