lazycodex-ai 5.1.48 → 5.1.54

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/copy/aphoristic-cadence.ts

@@ -0,0 +1,20 @@
+import type { PageRule } from "../../rule"
+import { pageText } from "./support/page-text"
+
+export const aphoristicCadence: PageRule = {
+	meta: {
+		id: "aphoristic-cadence", name: "Aphoristic-cadence copy", category: "slop", severity: "warning", engine: "page",
+		description: "Three or more short rebuttals give unrelated sections the same cadence.",
+		fixHint: "Replace repeated rebuttals with specific information and vary sentence structure.",
+	},
+	check: ({ snapshot }) => {
+		const text = pageText(snapshot)
+		const matches = [
+			...text.matchAll(/\bNot an? [a-z][^.!?]{1,40}[.!]\s+[A-Z][^.!?]{1,60}[.!]/g),
+			...text.matchAll(/\b[A-Z][^.!?]{4,80}[.!]\s+(No|Just)\s+[a-z][^.!?]{2,60}[.!]/g),
+		]
+		return matches.length < 3 ? [] : [{
+			element: null, message: `${matches.length} aphoristic constructions`, snippet: (matches[0]?.[0] ?? "").trim().slice(0, 80),
+		}]
+	},
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/copy/broken-image.ts

@@ -0,0 +1,17 @@
+import { shortSnippet } from "../../core/page"
+import type { PageRule } from "../../rule"
+
+export const brokenImage: PageRule = {
+	meta: {
+		id: "broken-image", name: "Broken or placeholder image", category: "quality", severity: "warning", engine: "page",
+		description: "An image has no usable source attribute.",
+		fixHint: "Provide a real src or srcset, or remove the unused image element.",
+	},
+	check: ({ snapshot }) => snapshot.elements.flatMap((el) => {
+		if (el.tag !== "img") return []
+		const hasSource = Object.entries(el.attributes).some(([name, value]) =>
+			/(?:^|[:-])(?:src|srcset)$/i.test(name.split(".")[0] ?? "")
+			&& value.trim() !== "" && value.trim() !== "#")
+		return hasSource ? [] : [{ element: el, message: "Image source is missing, empty or a placeholder", snippet: shortSnippet(el) }]
+	}),
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/copy/em-dash-overuse.ts

@@ -0,0 +1,46 @@
+import { EM_DASH } from "../../core/characters"
+import { ancestors, descendants, parentOf } from "../../core/page"
+import type { PageRule } from "../../rule"
+import { lineage, visibleText } from "./support/page-text"
+
+export const emDashOveruse: PageRule = {
+	meta: {
+		id: "em-dash-overuse", name: "Em-dash overuse", category: "slop", severity: "advisory", engine: "page",
+		description: "At least eight prose dashes appear at a density of one per 500 characters or more.",
+		fixHint: "Use sentence breaks or commas where the copy repeatedly interrupts itself.",
+	},
+	check: ({ snapshot }) => {
+		const runs = snapshot.elements.filter((el) => visibleText(snapshot, el)
+			&& !lineage(snapshot, el).some((a) => ["select", "option", "datalist"].includes(a.tag)))
+			.map((el) => el.ownText).filter((text) => text !== "" && !/^[\u2014–\s-]+$/.test(text))
+		const text = runs.join(" ").replace(/\s+/g, " ")
+		let count = 0
+		for (const match of text.matchAll(/\u2014+|-+/g)) {
+			const run = match[0]
+			if (run.startsWith(EM_DASH)) count += run.length === 2 ? 1 : run.length
+			else {
+				const next = text[match.index + run.length] ?? ""
+				const previous = text[match.index - 1] ?? ""
+				if (run.length === 2 && next !== "" && !/\s/.test(next)) count++
+				else if (run.length === 3 && /[\p{L}\p{N}]/u.test(previous) && /[\p{L}\p{N}]/u.test(next)) count++
+			}
+		}
+		const groups = new Map<number | null, number>()
+		for (const li of snapshot.elements.filter((el) => el.tag === "li").slice(0, 2000)) {
+			if (!visibleText(snapshot, li) || [...descendants(snapshot, li)].some((d) => d.tag === "li")) continue
+			const parts = li.text.replace(/^[^\p{L}\p{N}]+/u, "").split(EM_DASH)
+			const term = (parts[0] ?? "").trim()
+			const rest = (parts[1] ?? "").trim()
+			if (term === "" || [...term].length > 60 || term.split(/\s+/).length > 6 || /[.!?。！？]/.test(term) || rest === "") continue
+			const first = [...rest][0] ?? ""
+			const label = [...descendants(snapshot, li)].some((d) => [...ancestors(snapshot, d)].findIndex((a) => a.index === li.index) < 3 && d.text === term)
+			if (!(first.toUpperCase() === first && /\p{L}/u.test(first)) && !label) continue
+			const key = parentOf(snapshot, parentOf(snapshot, li) ?? li)?.index ?? null
+			groups.set(key, (groups.get(key) ?? 0) + 1)
+		}
+		count = Math.max(0, count - [...groups.values()].filter((n) => n >= 3).reduce((sum, n) => sum + n, 0))
+		return count < 8 || text.length > count * 500 ? [] : [{
+			element: null, message: `${count} em-dashes in body text`, snippet: `${count} em-dashes in body text`,
+		}]
+	},
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/copy/index.ts

@@ -0,0 +1,15 @@
+import type { PageRule } from "../../rule"
+import { aphoristicCadence } from "./aphoristic-cadence"
+import { brokenImage } from "./broken-image"
+import { emDashOveruse } from "./em-dash-overuse"
+import { marketingBuzzword } from "./marketing-buzzword"
+import { numberedSectionLabels } from "./numbered-section-labels"
+import { repeatedContainerText } from "./repeated-container-text"
+import { scriptError } from "./script-error"
+import { skippedHeading } from "./skipped-heading"
+import { theaterSlopPhrase } from "./theater-slop-phrase"
+
+export const COPY_RULES: readonly PageRule[] = [
+	emDashOveruse, marketingBuzzword, aphoristicCadence, theaterSlopPhrase, numberedSectionLabels,
+	repeatedContainerText, skippedHeading, brokenImage, scriptError,
+]

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/copy/marketing-buzzword.ts

@@ -0,0 +1,33 @@
+import type { PageRule } from "../../rule"
+import { pageText } from "./support/page-text"
+
+const PHRASES = [
+	"streamline your", "empower your", "supercharge your", "unleash your", "unleash the power", "leverage the power",
+	"built for the modern", "trusted by leading", "trusted by the world", "best-in-class", "industry-leading",
+	"world-class", "enterprise-grade", "next-generation", "cutting-edge", "transform your business", "revolutionize",
+	"game-changer", "game changing", "mission-critical", "best of breed", "future-proof", "future proof",
+	"seamless experience", "seamlessly integrate", "drive engagement", "drive growth", "drive results", "harness the power",
+] as const
+
+export const marketingBuzzword: PageRule = {
+	meta: {
+		id: "marketing-buzzword", name: "Marketing buzzword", category: "slop", severity: "warning", engine: "page",
+		description: "Generic promotion replaces a concrete description of the product.",
+		fixHint: "Name the action, benefit or measured result instead of a stock marketing phrase.",
+	},
+	check: ({ snapshot }) => {
+		const text = pageText(snapshot)
+		const lower = text.toLowerCase()
+		let count = 0
+		let sample = ""
+		for (const phrase of PHRASES) {
+			let from = 0
+			for (let at = lower.indexOf(phrase, from); at >= 0; at = lower.indexOf(phrase, from)) {
+				count++
+				if (sample === "") sample = text.slice(Math.max(0, at - 12), at + phrase.length + 12).trim()
+				from = at + phrase.length
+			}
+		}
+		return count === 0 ? [] : [{ element: null, message: `${count} buzzword phrases`, snippet: sample }]
+	},
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/copy/numbered-section-labels.ts

@@ -0,0 +1,34 @@
+import { descendants } from "../../core/page"
+import type { PageRule } from "../../rule"
+import { labelBefore, labelContext, labelType, parsedIndex, styledLabel } from "./support/numbered-label"
+
+export const numberedSectionLabels: PageRule = {
+	meta: {
+		id: "numbered-section-labels", name: "Tiny numbered section labels", category: "slop", severity: "advisory", engine: "page",
+		description: "Multiple headings carry tiny styled numeric indices that add scaffolding rather than information.",
+		fixHint: "Remove decorative section numbers or make necessary numbering part of the heading.",
+	},
+	check: ({ snapshot }) => {
+		const seen = new Set<number>()
+		const candidates = snapshot.elements.flatMap((heading) => {
+			if (!["h2", "h3", "h4"].includes(heading.tag) || heading.text.length < 3) return []
+			const label = labelBefore(snapshot, heading)
+			if (!label || seen.has(label.index) || !labelContext(snapshot, heading, label) || !labelContext(snapshot, label, heading)
+				|| !["span", "p", "div", "small", "em", "strong", "b"].includes(label.tag)) return []
+			const text = (label.ownText || label.text).replace(/\s+/g, " ").trim()
+			const index = parsedIndex(text)
+			if (index === null || !styledLabel(labelType(snapshot, label), heading)) return []
+			if ([...descendants(snapshot, label)].some((el) => ["img", "picture", "video", "canvas"].includes(el.tag)
+				|| el.tag === "svg" && snapshot.elements[el.parent ?? -1]?.ownText.match(/^\d{2}$/))) return []
+			seen.add(label.index)
+			return [{ label, heading, text, index }]
+		})
+		const hashWords = candidates.filter((c) => c.text.startsWith("#")).map((c) => /^#\d+\s+(\S+)/.exec(c.text)?.[1]?.toLowerCase())
+		const matchingHashes = hashWords.length >= 2 && hashWords[0] !== undefined && hashWords.every((w) => w === hashWords[0])
+		const filtered = matchingHashes ? candidates.filter((c) => !c.text.startsWith("#")) : candidates
+		if (filtered.length < 2 || new Set(filtered.map((c) => c.index)).size < 2) return []
+		return filtered.map(({ label, heading, text }) => ({
+			element: label, message: `${filtered.length} tiny numeric labels beside section headings`, snippet: `${text.slice(0, 24)} / ${heading.text.slice(0, 60)}`,
+		}))
+	},
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/copy/repeated-container-text.ts

@@ -0,0 +1,56 @@
+import { ancestors, descendants, px, styleOf } from "../../core/page"
+import { parseColor } from "../../core/color"
+import type { PageHit, PageRule } from "../../rule"
+import type { ElementSnapshot, PageSnapshot } from "../../types"
+import { lineage, paintedText } from "./support/page-text"
+
+const skip = (snapshot: PageSnapshot, el: ElementSnapshot): boolean => lineage(snapshot, el).some((a) =>
+	["table", "select", "datalist", "nav", "menu"].includes(a.tag)
+	|| ["navigation", "menu", "menubar", "listbox", "grid", "tablist", "radiogroup"].includes(a.attributes["role"] ?? "")
+	|| a.attributes["aria-hidden"] === "true")
+
+export const repeatedContainerText: PageRule = {
+	meta: {
+		id: "repeated-container-text", name: "Same text repeated inside one container", category: "quality", severity: "warning", engine: "page",
+		description: "One card repeats a short string in at least three different structural slots.",
+		fixHint: "State the status once; remove redundant labels from the other slots.",
+	},
+	check: ({ snapshot }) => {
+		const containers = snapshot.elements.filter((el) => {
+			if (!["div", "section", "article", "aside", "main", "figure", "form", "fieldset", "details", "li"].includes(el.tag) || skip(snapshot, el)) return false
+			const shadow = styleOf(el, "box-shadow")
+			const border = ["top", "right", "bottom", "left"].filter((side) => (px(styleOf(el, `border-${side}-width`)) ?? 0) >= 1).length >= 3
+			const radius = (px(styleOf(el, "border-top-left-radius")) ?? 0) > 0
+			const background = (parseColor(styleOf(el, "background-color"))?.a ?? 0) > 0.1
+			return (shadow !== "" && shadow !== "none" || border) && (radius || background)
+		})
+		const containerIds = new Set(containers.map((el) => el.index))
+		const hits: PageHit[] = []
+		for (const container of containers) {
+			if (!paintedText(snapshot, container)) continue
+			const nodes = [...descendants(snapshot, container)]
+			if (nodes.length > 250) continue
+			const groups = new Map<string, string[]>()
+			for (const el of nodes) {
+				const path = [...ancestors(snapshot, el)]
+				const owned = path.slice(0, path.findIndex((a) => a.index === container.index))
+				if (owned.some((a) => containerIds.has(a.index)) || skip(snapshot, el) || !paintedText(snapshot, el)) continue
+				if (/icon|material-symbols|(?:^|\s)fa[srlbd]?(?:\s|-|$)/i.test(el.attributes["class"] ?? "")) continue
+				const text = el.ownText.trim()
+				if (text.length < 4 || text.length > 48 || !/[a-zA-Z]/.test(text)) continue
+				const signature = [el, ...owned].map((a) => {
+					const classes = (a.attributes["class"] ?? "").split(/\s+/).filter((c) => c !== ""
+						&& !c.split(/[-_]/).some((part) => part.length >= 4 && /^[a-f\d]+$/i.test(part) && /\d/.test(part))).sort().join(".")
+					return `${a.tag}${classes === "" ? "" : `.${classes}`}`
+				}).join(">")
+				const signatures = groups.get(text) ?? []
+				signatures.push(signature)
+				groups.set(text, signatures)
+			}
+			for (const [text, signatures] of groups) if (signatures.length >= 3 && new Set(signatures).size >= 3) hits.push({
+				element: container, message: `Same text rendered ${signatures.length} times in distinct slots`, snippet: text.slice(0, 40),
+			})
+		}
+		return hits
+	},
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/copy/script-error.ts

@@ -0,0 +1,38 @@
+import type { PageHit, PageRule } from "../../rule"
+
+export const scriptError: PageRule = {
+	meta: {
+		id: "script-error", name: "Uncaught script error on load", category: "quality", severity: "error", engine: "page",
+		description: "An uncaught exception or rejected promise occurred while the page loaded.",
+		fixHint: "Fix the failing script or handle its rejected promise, then verify the page loads without uncaught errors.",
+	},
+	check: ({ snapshot }) => {
+		if (!snapshot.scriptErrorsCaptured) {
+			return [{
+				element: null,
+				message: "Script errors were not captured: this renderer could not install its error probe before the page's scripts",
+				snippet: snapshot.url,
+				severity: "advisory",
+				severityFixed: true,
+			}]
+		}
+		const counts = new Map<string, number>()
+		const hits: PageHit[] = []
+		for (const error of new Set(snapshot.scriptErrors)) {
+			const hydration = /Minified React error #(418|419|422|423|425)(?!\d)/.test(error)
+			const media = error.includes("AbortError") && error.includes("The play() request was interrupted")
+			const adTech = /browsingTopics|joinAdInterestGroup|runAdAuction|adsbygoogle|_prebidjs/.test(error)
+			const kind = adTech ? "ad-tech" : hydration || media ? "recoverable" : "uncaught"
+			const count = counts.get(kind) ?? 0
+			if (error.trim() === "" || count >= 3) continue
+			counts.set(kind, count + 1)
+			hits.push({
+				element: null,
+				message: kind === "uncaught" ? "Uncaught page script error" : `Page script error (${kind})`,
+				snippet: error,
+				severity: kind === "uncaught" ? "error" : "advisory",
+			})
+		}
+		return hits
+	},
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/copy/skipped-heading.ts

@@ -0,0 +1,81 @@
+import { childrenOf, descendants, headingLevel, parentOf } from "../../core/page"
+import type { PageHit, PageRule } from "../../rule"
+import { displayed, lineage } from "./support/page-text"
+
+export const skippedHeading: PageRule = {
+	meta: {
+		id: "skipped-heading", name: "Skipped heading level", category: "quality", severity: "warning", engine: "page",
+		description: "A heading jumps over a level in the visible content outline.",
+		fixHint: "Use the next heading level and style it independently of its semantic rank.",
+	},
+	check: ({ snapshot }) => {
+		const hits: PageHit[] = []
+		let previous = 0
+		let previousText = ""
+		let previousFooter: number | undefined
+		let previousOpensFooter = false
+		const squash = (text: string): string => text.replace(/\s/g, "")
+		const sourceTags = ["script", "style", "noscript", "template"]
+		const textChars = snapshot.elements.filter((el) => displayed(snapshot, el) && el.style["visibility"] !== "hidden" && !sourceTags.includes(el.tag))
+			.reduce((total, el) => total + [...squash(el.ownText)].length, 0)
+		const hidden = (el: typeof snapshot.elements[number]): boolean =>
+			el.attributes["inert"] !== undefined || el.attributes["aria-hidden"]?.trim().toLowerCase() === "true"
+		const modals = snapshot.elements.filter((el) =>
+			(el.attributes["aria-modal"] === "true" || ["dialog", "alertdialog"].includes(el.attributes["role"] ?? "")
+				|| el.tag === "dialog" && el.attributes["open"] !== undefined)
+			&& !hidden(el) && displayed(snapshot, el) && el.rect.width > 0 && el.rect.height > 0 && el.style["visibility"] !== "hidden")
+		const mockups = new Set(snapshot.elements.filter((root) => {
+			if (!hidden(root) || root.rect.width < 120 || root.rect.height < 80) return false
+			if (["html", "body", "main", "header", "footer", "nav", "aside", "section", "article", "form", "dialog", "li", "tr", "td", "th", "tbody", "thead", "table", "details", "summary"].includes(root.tag)) return false
+			if ((root.attributes["role"] ?? "").trim().split(/\s+/).some((r) => r !== "" && !["presentation", "none", "img", "figure", "group"].includes(r))) return false
+			if (root.attributes["aria-modal"] !== undefined || root.attributes["data-aria-hidden"] !== undefined || ["fixed", "sticky"].includes(root.style["position"] ?? "")) return false
+			const names = `${root.attributes["class"] ?? ""} ${root.attributes["id"] ?? ""}`
+			if (/(?:^|[\s_-])(clones?|cloned|copy|duplicate|dup|carousel|embla|flicking|glide|keen|slick|slides?|slider|splide|swiper|marquee|ticker|menu|submenu|dropdown|popup|popover|modal|drawer|dialog|tooltip|toast|offcanvas|overlay|nav|navbar|navigation|panel|tab|tabpanel|accordion|collapse|collapsible|intro|splash|loader|preloader|loading|banner|cookies?|consent|sidebar|sidenav|toc)(?:$|[\s_-])/i.test(names)) return false
+			const ancestors = lineage(snapshot, root).slice(1)
+			if (ancestors.some((a) => ["h1", "h2", "h3", "h4", "h5", "h6", "p", "a", "button", "label", "summary", "legend", "caption", "figcaption", "blockquote", "q"].includes(a.tag))) return false
+			const nodes = [root, ...descendants(snapshot, root)]
+			if (nodes.length > 3000 || nodes.some((el) => el.tag === "h1")) return false
+			const runs = nodes.filter((el) => displayed(snapshot, el) && el.style["visibility"] !== "hidden"
+				&& !sourceTags.includes(el.tag) && squash(el.ownText) !== "")
+			const chars = runs.reduce((total, el) => total + [...squash(el.ownText)].length, 0)
+			if (runs.length < 3 || textChars === 0 || chars * 2 >= textChars) return false
+			const fields = nodes.filter((el) => ["input", "select", "textarea"].includes(el.tag) && !(el.tag === "input" && el.attributes["type"]?.toLowerCase() === "hidden"))
+			const linkedRuns = runs.filter((el) => lineage(snapshot, el).some((a) => a.tag === "a" && (a.attributes["href"] ?? "").trim() !== ""))
+			if (fields.length >= 2 || fields.length > 0 && nodes.some((el) => el.tag === "label") || linkedRuns.length * 2 >= runs.length) return false
+			if (modals.some((modal) => !nodes.includes(modal) && !lineage(snapshot, root).includes(modal))) return false
+			const text = squash(root.text)
+			if (text !== "" && ancestors.some((a) => squash(a.attributes["aria-label"] ?? "").includes(text))) return false
+			const parent = parentOf(snapshot, root)
+			const peers = parent ? childrenOf(snapshot, parent).filter((el) => el.index !== root.index) : []
+			const classes = (root.attributes["class"] ?? "").split(/\s+/).filter(Boolean)
+			return !peers.some((peer) => {
+				const peerClasses = (peer.attributes["class"] ?? "").split(/\s+/).filter(Boolean)
+				const sameShape = peer.tag === root.tag && (classes.length === 0) === (peerClasses.length === 0) && classes.every((c) => peerClasses.includes(c))
+				const shown = displayed(snapshot, peer) && peer.style["visibility"] !== "hidden" && !hidden(peer)
+				if (shown && (sameShape && peer.rect.width > 0 && peer.rect.height > 0 || text !== "" && squash(peer.text) === text)) return true
+				const alternative = peer.rect.width <= 1 || peer.rect.height <= 1 || /sr-only|visually-?hidden|screen-?reader|a11y-hidden|hidden-visually/i.test(peer.attributes["class"] ?? "")
+				return shown && alternative && peer.text.trim() !== "" && !/\b(demo|demonstration|illustrat\w*|interface|screen ?shots?|mock-?ups?|graphic|animation|animated|preview|image|video|visual|diagram|depict\w*|shows|showing|displayed)\b/i.test(peer.text)
+			})
+		}).map((el) => el.index))
+		for (const el of snapshot.elements) {
+			const level = headingLevel(el)
+			if (level === null || !displayed(snapshot, el) || el.rect.width <= 0 || el.rect.height <= 0) continue
+			const path = lineage(snapshot, el)
+			if (path.some((a) => mockups.has(a.index))) continue
+			if (path.some((a) => a.style["visibility"] === "hidden" || (a.tag === "dialog" && a.attributes["open"] === undefined))) continue
+			const footer = path.find((a) => a.tag === "footer" || a.attributes["role"] === "contentinfo" || a.attributes["id"] === "footer")?.index
+			const opensFooter = footer !== undefined && footer !== previousFooter
+			const intoFooter = footer !== undefined && (opensFooter || previousOpensFooter)
+			const skips = previous > 0 && level > previous + 1
+			if (skips && !intoFooter) hits.push({
+				element: el, message: `h${previous} followed by h${level}; missing h${previous + 1}`,
+				snippet: `${previousText.slice(0, 60)} / ${el.text.slice(0, 60)}`,
+			})
+			previousOpensFooter = opensFooter && previous > 0 && !skips
+			previousFooter = footer
+			previous = level
+			previousText = el.text
+		}
+		return hits
+	},
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/copy/support/numbered-label.ts

@@ -0,0 +1,94 @@
+import { childrenOf, descendants, effectiveBackground, fontSizePx, parentOf, px, styleOf } from "../../../core/page"
+import { parseColor } from "../../../core/color"
+import { parseShadow } from "../../../core/shadow"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+import { displayed, lineage } from "./page-text"
+
+export const parsedIndex = (text: string): number | null => {
+	if (text.length > 40) return null
+	const hash = /^#([0-9]{1,2})(?: [^ ].*)?$/.exec(text)
+	if (hash && /^#\d+ (rated|ranked|rank|best|top|in|pick|choice|overall|seller|bestseller|selling|voted|place|trending)\b/i.test(text)) return null
+	const match = hash ?? /^([0-9]{2})$/.exec(text) ?? /^([0-9]{1,2})\s*[^0-9A-Za-z_\s]\s*\S/.exec(text)
+	return match?.[1] !== undefined && Number(match[1]) <= 40 ? Number(match[1]) : null
+}
+
+export const labelBefore = (snapshot: PageSnapshot, heading: ElementSnapshot): ElementSnapshot | null => {
+	let current = heading
+	for (let level = 0; level <= 4; level++) {
+		const parent = parentOf(snapshot, current)
+		if (!parent) return null
+		const siblings = childrenOf(snapshot, parent)
+		const label = siblings[siblings.findIndex((s) => s.index === current.index) - 1]
+		if (label) {
+			const l = label.rect
+			const h = heading.rect
+			if (level > 1 && (l.width <= 0 || l.height <= 0 || h.width <= 0 || h.height <= 0 || l.y >= h.y + h.height
+				|| Math.max(h.y - l.y - l.height, h.x - l.x - l.width, 0) > 96)) return null
+			return label
+		}
+		if (["body", "html"].includes(parent.tag)) return null
+		current = parent
+	}
+	return null
+}
+
+export const labelType = (snapshot: PageSnapshot, label: ElementSnapshot): ElementSnapshot => {
+	let el = label
+	for (let level = 0; level < 3; level++) {
+		if (el.ownText !== "") return el
+		const children = childrenOf(snapshot, el).filter((c) => c.text.trim() !== "")
+		const only = children[0]
+		if (children.length !== 1 || !only) return el
+		el = only
+	}
+	return el
+}
+
+const drawsBox = (snapshot: PageSnapshot, el: ElementSnapshot): boolean => {
+	const parent = parentOf(snapshot, el)
+	const under = parent ? effectiveBackground(snapshot, parent) : { r: 255, g: 255, b: 255 }
+	const fill = effectiveBackground(snapshot, el)
+	const image = styleOf(el, "background-image")
+	const border = ["top", "right", "bottom", "left"].filter((side) =>
+		(px(styleOf(el, `border-${side}-width`)) ?? 0) >= 0.5
+		&& !["none", "hidden", ""].includes(styleOf(el, `border-${side}-style`))
+		&& (parseColor(styleOf(el, `border-${side}-color`))?.a ?? 0) > 0).length >= 3
+	return Math.max(Math.abs(fill.r - under.r), Math.abs(fill.g - under.g), Math.abs(fill.b - under.b)) > 3
+		|| image !== "" && image !== "none" || border
+		|| parseShadow(styleOf(el, "box-shadow")).some((layer) => layer.color.a >= 0.03
+			&& (layer.x !== 0 || layer.y !== 0 || layer.blur > 0 || layer.spread !== 0))
+}
+
+export const labelContext = (snapshot: PageSnapshot, el: ElementSnapshot, partner: ElementSnapshot = el): boolean => {
+	const path = lineage(snapshot, el)
+	if (!displayed(snapshot, el) || path.some((a) => ["nav", "form", "table", "thead", "tbody", "tfoot", "figure", "figcaption", "ol", "ul", "li"].includes(a.tag)
+		|| a.attributes["role"] === "navigation" || a.attributes["aria-hidden"] === "true"
+		|| a.attributes["data-impeccable-allow-kickers"] !== undefined
+		|| /breadcrumb/i.test(`${a.attributes["class"] ?? ""} ${a.attributes["aria-label"] ?? ""}`))) return false
+	const context = path.find((a) => ["article", "button", "a", "li"].includes(a.tag) || ["listitem", "option"].includes(a.attributes["role"] ?? ""))
+	if (!context || context.rect.height > snapshot.viewport.height * 2 || !lineage(snapshot, partner).includes(context)) return true
+	if (context.tag !== "article") return false
+	const above = lineage(snapshot, context).slice(1)
+	if (above.some((a) => ["a", "button", "li"].includes(a.tag) || ["listitem", "option"].includes(a.attributes["role"] ?? ""))) return false
+	if (path.slice(1, path.findIndex((a) => a.index === context.index) + 1).some((a) =>
+		lineage(snapshot, partner).includes(a) && drawsBox(snapshot, a))) return false
+	let below = context
+	for (const up of above.slice(0, 3)) {
+		if (up.tag === "body") break
+		const otherArticle = [...descendants(snapshot, up)].some((a) => a.tag === "article" && a.index !== context.index)
+		if (!otherArticle && drawsBox(snapshot, up)) return false
+		if (up.children.length !== 1 || up.children[0] !== below.index) break
+		below = up
+	}
+	return true
+}
+
+export const styledLabel = (label: ElementSnapshot, heading: ElementSnapshot): boolean => {
+	const size = fontSizePx(label)
+	const headingSize = fontSizePx(heading)
+	if (size <= 0 || size > Math.max(13, Math.min(16, headingSize * 0.45)) || headingSize > 0 && headingSize < size * 1.3) return false
+	const color = parseColor(styleOf(label, "color"))
+	return /mono/i.test(styleOf(label, "font-family")) || Number(styleOf(label, "font-weight")) >= 600
+		|| (px(styleOf(label, "letter-spacing")) ?? 0) >= 0.5 || styleOf(label, "text-transform") === "uppercase"
+		|| (color !== null && Math.max(color.r, color.g, color.b) - Math.min(color.r, color.g, color.b) >= 40)
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/copy/support/page-text.ts

@@ -0,0 +1,37 @@
+import { ancestors, isRendered, styleOf } from "../../../core/page"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+
+export const lineage = (snapshot: PageSnapshot, el: ElementSnapshot): readonly ElementSnapshot[] =>
+	[el, ...ancestors(snapshot, el)]
+
+export const displayed = (snapshot: PageSnapshot, el: ElementSnapshot): boolean =>
+	lineage(snapshot, el).every((a) => styleOf(a, "display") !== "none" && styleOf(a, "content-visibility") !== "hidden")
+
+export const visibleText = (snapshot: PageSnapshot, el: ElementSnapshot): boolean => {
+	if (!isRendered(snapshot, el) || !displayed(snapshot, el)) return false
+	return lineage(snapshot, el).every((a) => styleOf(a, "visibility") !== "hidden"
+		&& !(a.tag === "dialog" && a.attributes["open"] === undefined))
+}
+
+export const pageText = (snapshot: PageSnapshot): string =>
+	snapshot.elements.filter((el) => visibleText(snapshot, el) && !["script", "style", "template", "noscript"].includes(el.tag))
+		.map((el) => el.ownText).filter(Boolean).join(" ").replace(/\s+/g, " ").trim()
+
+export const paintedText = (snapshot: PageSnapshot, el: ElementSnapshot): boolean => {
+	if (!visibleText(snapshot, el)) return false
+	let left = el.rect.x
+	let top = el.rect.y
+	let right = left + el.rect.width
+	let bottom = top + el.rect.height
+	for (const a of ancestors(snapshot, el)) {
+		if (["hidden", "clip", "auto", "scroll"].includes(styleOf(a, "overflow-x"))) {
+			left = Math.max(left, a.rect.x)
+			right = Math.min(right, a.rect.x + a.rect.width)
+		}
+		if (["hidden", "clip", "auto", "scroll"].includes(styleOf(a, "overflow-y"))) {
+			top = Math.max(top, a.rect.y)
+			bottom = Math.min(bottom, a.rect.y + a.rect.height)
+		}
+	}
+	return right > left && bottom > top
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/copy/theater-slop-phrase.ts

@@ -0,0 +1,21 @@
+import type { PageRule } from "../../rule"
+import { pageText } from "./support/page-text"
+
+const HEADS = [
+	"accessibility", "accountability", "agile", "alignment", "compliance", "diversity", "engagement", "governance", "growth",
+	"hiring", "hygiene", "innovation", "inclusion", "kindness", "leadership", "metrics", "privacy", "process", "productivity",
+	"quality", "safety", "security", "strategy", "sustainability", "transparency", "trust", "wellness",
+] as const
+
+export const theaterSlopPhrase: PageRule = {
+	meta: {
+		id: "theater-slop-phrase", name: "Theater framing copy", category: "slop", severity: "advisory", engine: "page",
+		description: "Calling a practice theater dismisses it without explaining the defect.",
+		fixHint: "Describe the missing behavior or evidence instead of dismissing it as theater.",
+	},
+	check: ({ snapshot }) => {
+		const match = [...pageText(snapshot).matchAll(/\b(\w+)\s+theater\b/gi)]
+			.find((m) => HEADS.some((head) => head === m[1]?.toLowerCase()))
+		return match ? [{ element: null, message: "Dismissive theater framing", snippet: match[0] }] : []
+	},
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/decoration/blinking-cursor.ts

@@ -0,0 +1,48 @@
+import type { PageRule } from "../../rule"
+import { parseColor } from "../../core/color"
+import { ancestors, shortSnippet, styleOf } from "../../core/page"
+import { context, radii, visible } from "./support/appearance"
+import { infiniteNames, keyframes, toggles } from "./support/keyframes"
+export const blinkingCursor: PageRule = {
+	meta: {
+		id: "blinking-cursor",
+		name: "Decorative blinking cursor",
+		category: "slop",
+		severity: "advisory",
+		engine: "page",
+		description: "A fake caret blinks in non-editable landing content.",
+		fixHint: "Remove the decorative cursor and let actual editable fields draw their caret.",
+	},
+	check: ({ snapshot }) =>
+		snapshot.elements.flatMap((e) => {
+			if (
+				e.rect.width <= 0 || e.rect.height <= 0 ||
+				styleOf(e, "display") === "none" || e.attributes["hidden"] !== undefined ||
+				[...ancestors(snapshot, e)].some(a => !visible(snapshot, a)) ||
+				["input", "textarea", "select", "img", "svg", "script", "style"].includes(e.tag) ||
+				e.rect.y > 1200 ||
+				context(
+					snapshot,
+					e,
+					(a) => a.attributes["role"] === "textbox" || ["", "true", "plaintext-only"].includes(a.attributes["contenteditable"] ?? "false"),
+				)
+			)
+				return []
+			const animated = infiniteNames(e.style).some((n) => /blink|caret|cursor/i.test(n) || toggles(keyframes(snapshot, n) ?? []))
+			if (!animated) return []
+			const text = e.text.trim(),
+				{ width: w, height: h } = e.rect
+			const glyph = /^[_|\u2580-\u259f\u25a0\u25ae\u2759\u275a\uff5c]$/.test(text)
+			const bg = parseColor(styleOf(e, "background-color"))
+			const filled =
+				(bg !== null && bg.a > 0.2) ||
+				["left", "right", "bottom"].some((side) => Number.parseFloat(styleOf(e, "border-" + side + "-width")) >= 1)
+			const block =
+				text === "" &&
+				e.children.length === 0 &&
+				filled &&
+				((w >= 1 && w <= 24 && h >= 6 && h <= 48 && h >= w) || (h >= 1 && h <= 6 && w >= 4 && w <= 24)) &&
+				Math.max(...radii(e)) < 0.4 * Math.min(w, h)
+			return glyph || block ? [{ element: e, message: "Blinking decorative cursor in the landing region", snippet: shortSnippet(e) }] : []
+		}),
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/decoration/border-accent-on-rounded.ts

@@ -0,0 +1,14 @@
+import type { PageRule } from "../../rule"
+import { borderHits } from "./support/borders"
+export const borderAccentOnRounded: PageRule = {
+	meta: {
+		id: "border-accent-on-rounded",
+		name: "Border accent on rounded element",
+		category: "slop",
+		severity: "warning",
+		engine: "page",
+		description: "A heavy accent band competes with rounded corners.",
+		fixHint: "Remove the accent border or square the container.",
+	},
+	check: ({ snapshot }) => snapshot.elements.flatMap((e) => borderHits(snapshot, e, "border-accent-on-rounded")),
+}