oh-my-opencode 5.1.48 → 5.1.54

package/packages/shared-skills/skills/frontend/scripts/detect/rules/color/support/placeholder-contrast.ts

@@ -0,0 +1,25 @@
+import { blend, contrastRatio, parseColor } from "../../../core/color"
+import { ancestors, fontSizePx, styleOf } from "../../../core/page"
+import type { PageHit } from "../../../rule"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+import { textPainted } from "./painted-text"
+import { textBackgrounds } from "./text-colors"
+
+export function placeholderContrast(snapshot: PageSnapshot, el: ElementSnapshot): readonly PageHit[] {
+	const text = (el.attributes["placeholder"] ?? "").trim()
+	if (!["input", "textarea"].includes(el.tag) || !el.placeholder || !text || !textPainted(snapshot, el)) return []
+	if ([el, ...ancestors(snapshot, el)].some((node) => node.attributes["disabled"] !== undefined || node.attributes["aria-disabled"] === "true")) return []
+	if (el.tag === "input" && ["hidden", "checkbox", "radio", "file", "submit", "button", "image", "reset", "range", "color"].includes((el.attributes["type"] ?? "text").toLowerCase())) return []
+	const ink = parseColor(el.placeholder.style["color"] ?? "")
+	if (!ink || ink.a <= 0.02) return []
+	const backgrounds = textBackgrounds(snapshot, el)
+	if (backgrounds.length === 0) return []
+	const size = fontSizePx(el)
+	if (size <= 0) return []
+	const words = (styleOf(el, "font-family").split(",")[0] ?? "").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/)
+	const namedBold = words.some((word) => ["bold", "semibold", "demibold", "extrabold", "ultrabold", "heavy", "black"].includes(word))
+	const weight = namedBold ? Math.max(700, Number.parseFloat(styleOf(el, "font-weight")) || 400) : Number.parseFloat(styleOf(el, "font-weight"))
+	const threshold = size >= 24 || (size >= 18.66 && weight >= 700) ? 3 : 4.5
+	const ratio = Math.min(...backgrounds.map((background) => contrastRatio(blend(ink, background), background)))
+	return ratio < threshold ? [{ element: el, message: `Placeholder contrast ${ratio.toFixed(2)}:1; needs ${threshold}:1`, snippet: text }] : []
+}

package/packages/shared-skills/skills/frontend/scripts/detect/rules/color/support/stock-accent.ts

@@ -0,0 +1,31 @@
+import { parseColor, type Rgba } from "../../../core/color"
+import { px, styleOf } from "../../../core/page"
+import { parseShadow } from "../../../core/shadow"
+import { cssBlocks } from "../../../core/source"
+import type { PageSnapshot } from "../../../types"
+import { matchesSelector } from "../../decoration/support/css-candidates"
+import { colorDistance, gradientStops } from "./gradients"
+import { paletteVisible } from "./palette-roles"
+
+const colors = ["#7c3aed", "#8b5cf6", "#a855f7", "#9333ea", "#7e22ce", "#6d28d9", "#6366f1", "#764ba2", "#667eea"]
+	.map(parseColor).filter((color) => color !== null)
+const stock = (color: Rgba | null): boolean => color !== null && color.a > 0.1 && colors.some((c) => colorDistance(c, color) <= 8)
+
+export function stockAccent(snapshot: PageSnapshot): boolean {
+	const trigger = /(?:^|;)\s*color\s*:[^;]*#(?:7c3aed|8b5cf6|a855f7|9333ea|7e22ce|6d28d9)\b|gradient[^;]*#(?:7c3aed|8b5cf6|a855f7|764ba2|667eea)\b/i
+	const declared = snapshot.elements.some((el) => trigger.test(el.attributes["style"] ?? "") && paletteVisible(snapshot, el))
+		|| snapshot.cssText.some((css) => cssBlocks(css).some((block) =>
+		trigger.test(block.body) && block.selector.split(",").some((selector) =>
+			snapshot.elements.some((el) => matchesSelector(snapshot, el, selector.trim()) && paletteVisible(snapshot, el)))))
+	if (!declared) return false
+	return snapshot.elements.some((el) => {
+		if (!paletteVisible(snapshot, el)) return false
+		if (el.ownText.trim() && stock(parseColor(styleOf(el, "color")))) return true
+		if (stock(parseColor(styleOf(el, "background-color"))) || gradientStops(styleOf(el, "background-image")).some((s) => stock(s.color))) return true
+		for (const side of ["top", "right", "bottom", "left"]) {
+			if ((px(styleOf(el, `border-${side}-width`)) ?? 0) > 0 && !["none", "hidden"].includes(styleOf(el, `border-${side}-style`)) && stock(parseColor(styleOf(el, `border-${side}-color`)))) return true
+		}
+		if ((px(styleOf(el, "outline-width")) ?? 0) > 0 && !["", "none"].includes(styleOf(el, "outline-style")) && stock(parseColor(styleOf(el, "outline-color")))) return true
+		return parseShadow(styleOf(el, "box-shadow")).some((s) => stock(s.color) && [s.x, s.y, s.blur, s.spread].some((n) => n !== 0))
+	})
+}

package/packages/shared-skills/skills/frontend/scripts/detect/rules/color/support/text-colors.ts

@@ -0,0 +1,80 @@
+import { blend, parseColor, WHITE, type Rgba } from "../../../core/color"
+import { ancestors, fontSizePx, styleOf } from "../../../core/page"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+import { effectiveOpacity, gradientStops } from "./gradients"
+import { gradientSamples } from "./gradient-samples"
+import { contains, pseudoCovers, siblingGrounds, textPainted, textRect } from "./painted-text"
+import { textOpacity } from "./animation-opacity"
+
+export const clipsText = (el: ElementSnapshot): boolean =>
+	[styleOf(el, "background-clip"), styleOf(el, "-webkit-background-clip")].some((v) => v.split(",").some((s) => s.trim() === "text"))
+
+export function textInk(snapshot: PageSnapshot, el: ElementSnapshot): Rgba | null {
+	if (!textPainted(snapshot, el) || !/[\p{L}\p{N}]/u.test(el.ownText)) return null
+	if (fontSizePx(el) <= 0 || [el, ...ancestors(snapshot, el)].some((node) => ["video", "audio", "canvas", "iframe"].includes(node.tag))) return null
+	if (["script", "style", "title", "option", "noscript", "template"].includes(el.tag)) return null
+	const fill = styleOf(el, "-webkit-text-fill-color")
+	const color = parseColor(fill || styleOf(el, "color"))
+	if (!color || color.a <= 0.02) return null
+	return { ...color, a: color.a * textOpacity(snapshot, el) }
+}
+
+export function textBackgrounds(snapshot: PageSnapshot, el: ElementSnapshot): readonly Rgba[] {
+	const layers: Rgba[] = []
+	const rect = textRect(el)
+	const nodes = [el, ...ancestors(snapshot, el)].flatMap((node) => [node, ...siblingGrounds(snapshot, node, rect)])
+	for (const node of nodes) {
+		if (["img", "video", "canvas"].includes(node.tag)) return []
+		const paired = node.before && node.after && contains(node.rect, rect)
+			&& node.before.style["background-color"] === node.after.style["background-color"]
+			&& node.before.style["background-image"] === node.after.style["background-image"]
+			&& [node.before, node.after].every((p) => Number.parseFloat(p.style["opacity"] ?? "1") >= 0.9)
+		for (const pseudo of [node.after, node.before]) {
+			if (!pseudo || (!paired && !pseudoCovers(pseudo.style, node, rect))) continue
+			const hostFill = parseColor(styleOf(node, "background-color"))
+			if (Number.parseFloat(pseudo.style["z-index"] ?? "") < 0 && styleOf(node, "z-index") === "auto" && (hostFill?.a ?? 0) >= 1) continue
+			const fill = parseColor(pseudo.style["background-color"] ?? "")
+			const stops = gradientStops(pseudo.style["background-image"] ?? "")
+			if (stops.length > 0 && fill && fill.a >= 0.9) {
+				return stops.map((s) => layers.reduceRight((under, top) => blend(top, under), blend(s.color, fill)))
+			}
+			if (fill && fill.a >= 0.9) return [layers.reduceRight((under, top) => blend(top, under), fill)]
+		}
+		const image = styleOf(node, "background-image")
+		if (image.includes("url(")) return []
+		const tile = styleOf(node, "background-size").split(/\s+/)
+		const tileWidth = Number.parseFloat(tile[0] ?? "")
+		const tileHeight = Number.parseFloat(tile[1] ?? tile[0] ?? "")
+		const stops = gradientStops(image)
+		const radius = /([\d.]+)px/.exec(stops[0]?.raw ?? "")
+		const sparseDots = image.startsWith("radial-gradient(") && radius !== null && tileWidth > 0 && tileHeight > 0 && Math.PI * Number(radius[1]) ** 2 / (tileWidth * tileHeight) < 0.5 && (stops[0]?.color.a ?? 0) > 0
+		const parkedImage = tile.some((v) => /^0(?:px|%)?$/.test(v))
+		if (image.includes("gradient") && !clipsText(node) && !sparseDots && !parkedImage) {
+			const ground = solidGround(snapshot, node)
+			const samples = gradientSamples(node, rect)
+			if (samples?.every((color) => color.a < 0.005)) continue
+			return (samples ?? stops.map((s) => s.color)).map((color) => layers.reduceRight((under, top) => blend(top, under), blend(color, ground)))
+		}
+		const rawFill = styleOf(node, "background-color")
+		const fill = parseColor(rawFill)
+		if (rawFill !== "" && !fill) return []
+		if (fill && fill.a > 0) {
+			const a = fill.a * (nodes.includes(node) && ![el, ...ancestors(snapshot, el)].includes(node) ? effectiveOpacity(snapshot, node) : 1)
+			layers.push({ ...fill, a })
+			if (a >= 1) break
+		}
+	}
+	return [layers.reduceRight((under, top) => blend(top, under), WHITE)]
+}
+
+export function solidGround(snapshot: PageSnapshot, el: ElementSnapshot): Rgba {
+	const layers: Rgba[] = []
+	for (const node of [el, ...ancestors(snapshot, el)]) {
+		const c = parseColor(styleOf(node, "background-color"))
+		if (c) {
+			layers.push(c)
+			if (c.a >= 1) break
+		}
+	}
+	return layers.reduceRight((under, top) => blend(top, under), WHITE)
+}

package/packages/shared-skills/skills/frontend/scripts/detect/rules/copy/aphoristic-cadence.test.ts

@@ -0,0 +1,18 @@
+import { expect, test } from "bun:test"
+import { buildSnapshot } from "../../testing/build-snapshot"
+import { aphoristicCadence } from "./aphoristic-cadence"
+
+test("#given two versus three rebuttal constructions #then the three-construction floor applies", () => {
+	const phrases = ["Not a dashboard. Your command center.", "Not an app. Your working memory.", "Not a tool. Your daily companion."]
+	const check = (count: number) => aphoristicCadence.check({
+		snapshot: buildSnapshot(phrases.slice(0, count).map((text) => ({ tag: "p", text }))), config: {},
+	})
+	expect(check(3)).toHaveLength(1)
+	expect(check(2)).toHaveLength(0)
+})
+
+test("#given short no and just rebuttals #then ordinary sentences remain clear", () => {
+	const check = (text: string) => aphoristicCadence.check({ snapshot: buildSnapshot([{ text }]), config: {} })
+	expect(check("Everything you need. No friction. All your work. Just results. Bring your team. No limits.")).toHaveLength(1)
+	expect(check("The invoice is ready. Send it to your customer. Track the payment.")).toHaveLength(0)
+})

package/packages/shared-skills/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/shared-skills/skills/frontend/scripts/detect/rules/copy/broken-image.test.ts

@@ -0,0 +1,25 @@
+import { expect, test } from "bun:test"
+import { buildSnapshot } from "../../testing/build-snapshot"
+import { brokenImage } from "./broken-image"
+
+test("#given absent empty and hash sources #then real source aliases and responsive images pass", () => {
+	const snapshot = buildSnapshot([
+		{ tag: "img", id: "absent" }, { tag: "img", id: "empty", attributes: { src: " " } },
+		{ tag: "img", id: "hash", attributes: { src: "#" } },
+		{ tag: "img", id: "real", attributes: { src: "photo.png" } },
+		{ tag: "img", id: "set", attributes: { src: "", srcset: "photo.png 1x" } },
+		{ tag: "img", id: "lazy", attributes: { "data-src": "photo.png" } },
+		{ tag: "img", id: "misleading", attributes: { alt: "src=photo.png" } },
+		{ tag: "div", id: "other" },
+	])
+	expect(brokenImage.check({ snapshot, config: {} }).map((hit) => hit.element?.selector)).toEqual(["#absent", "#empty", "#hash", "#misleading"])
+})
+
+test("#given placeholder srcset and valid alternate sources #then either usable attribute is enough", () => {
+	const snapshot = buildSnapshot([
+		{ tag: "img", id: "placeholder", attributes: { src: "#", srcset: " " } },
+		{ tag: "img", id: "inline", attributes: { src: "data:image/svg+xml,<svg/>" } },
+		{ tag: "img", id: "lazyset", attributes: { "data-srcset": "/small.png 300w" } },
+	])
+	expect(brokenImage.check({ snapshot, config: {} }).map((hit) => hit.element?.selector)).toEqual(["#placeholder"])
+})

package/packages/shared-skills/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/shared-skills/skills/frontend/scripts/detect/rules/copy/em-dash-overuse.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from "bun:test"
+import { buildSnapshot } from "../../testing/build-snapshot"
+import { emDashOveruse } from "./em-dash-overuse"
+
+test("#given dash floor and density boundaries #then only dense prose with eight marks reports", () => {
+	const check = (text: string) => emDashOveruse.check({ snapshot: buildSnapshot([{ tag: "p", text }]), config: {} })
+	expect(check("a — b — c — d — e — f — g — h — i")).toHaveLength(1)
+	expect(check("a — b — c — d — e — f — g — h")).toHaveLength(0)
+	expect(check(`${"—".repeat(8)}${"x".repeat(3992)}`)).toHaveLength(1)
+	expect(check(`${"—".repeat(8)}${"x".repeat(3993)}`)).toHaveLength(0)
+})
+
+test("#given alternate dash spellings and table rules #then punctuation alone is counted", () => {
+	const check = (text: string) => emDashOveruse.check({ snapshot: buildSnapshot([{ text }]), config: {} })
+	expect(check("word---word ".repeat(8))).toHaveLength(1)
+	expect(check("word--next ".repeat(8))).toHaveLength(1)
+	expect(check("word —— next ".repeat(8))).toHaveLength(1)
+	expect(check("word —— next ".repeat(7))).toHaveLength(0)
+	expect(check("|-------| ------- rule ----x -- space ".repeat(10))).toHaveLength(0)
+})
+
+test("#given matrix markers choices and list separators #then actual prose remains counted", () => {
+	const check = (prose: string) => emDashOveruse.check({ snapshot: buildSnapshot([
+		{ tag: "p", text: prose },
+		...Array.from({ length: 10 }, () => ({ tag: "td", text: "—" })),
+		{ tag: "select", children: Array.from({ length: 10 }, () => ({ tag: "option", text: "USD — US Dollar" })) },
+		{ tag: "ul", children: Array.from({ length: 8 }, (_, n) => ({ tag: "li", text: `Feature ${n} — Description` })) },
+	]), config: {} })
+	expect(check("a — b — c — d — e — f — g — h — i")).toHaveLength(1)
+	expect(check("Read the feature list.")).toHaveLength(0)
+})
+
+test("#given lowercase prose list items #then their dashes are not treated as separators", () => {
+	const check = (ending: string) => emDashOveruse.check({
+		snapshot: buildSnapshot([{ tag: "ul", children: Array.from({ length: 8 }, () => ({ tag: "li", text: `We ship every week — ${ending}` })) }]), config: {},
+	})
+	expect(check("and every update is free.")).toHaveLength(1)
+	expect(check("Current updates")).toHaveLength(0)
+})

package/packages/shared-skills/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/shared-skills/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/shared-skills/skills/frontend/scripts/detect/rules/copy/marketing-buzzword.test.ts

@@ -0,0 +1,18 @@
+import { expect, test } from "bun:test"
+import { buildSnapshot } from "../../testing/build-snapshot"
+import { marketingBuzzword } from "./marketing-buzzword"
+
+test("#given repeated stock phrases and concrete copy #then only stock phrases count", () => {
+	const check = (text: string) => marketingBuzzword.check({ snapshot: buildSnapshot([{ tag: "p", text }]), config: {} })
+	expect(check("STREAMLINE YOUR workflow and streamline your day. World-class enterprise-grade tools.")).toHaveLength(1)
+	expect(check("Export an invoice as PDF in two clicks.")).toHaveLength(0)
+	expect(check("revolutionize revolutionary")).toHaveLength(1)
+})
+
+test("#given hidden buzzwords beside visible concrete copy #then only painted copy contributes", () => {
+	const check = (display: string) => marketingBuzzword.check({
+		snapshot: buildSnapshot([{ style: { display }, children: [{ tag: "p", text: "Empower your team" }] }, { tag: "p", text: "Send invoices." }]), config: {},
+	})
+	expect(check("block")).toHaveLength(1)
+	expect(check("none")).toHaveLength(0)
+})

package/packages/shared-skills/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/shared-skills/skills/frontend/scripts/detect/rules/copy/numbered-section-labels.test.ts

@@ -0,0 +1,58 @@
+import { expect, test } from "bun:test"
+import { buildSnapshot, type NodeSpec } from "../../testing/build-snapshot"
+import { numberedSectionLabels } from "./numbered-section-labels"
+
+const section = (id: string, text: string, style: Readonly<Record<string, string>> = {}): NodeSpec => ({
+	tag: "section", children: [
+		{ id, tag: "span", text, style: { "font-size": "11px", "font-family": "monospace", ...style } },
+		{ tag: "h2", text: `Section ${id}`, style: { "font-size": "28px" } },
+	],
+})
+const flagged = (nodes: readonly NodeSpec[]) => numberedSectionLabels.check({ snapshot: buildSnapshot(nodes), config: {} }).map((hit) => hit.element?.selector)
+
+test("#given distinct tiny indices and false positive shapes #then only styled section numbers report", () => {
+	expect(flagged([
+		section("first", "01"), section("second", "02 / ROLLOUT"),
+		section("large", "03", { "font-size": "16px" }),
+		section("plain", "12 · minute read", { "font-size": "12px", "font-family": "Georgia", color: "rgb(100, 100, 100)" }),
+		section("step", "Step 6"), section("single", "7"), section("rank", "#1 Rated"), section("over-limit", "41"),
+		{ tag: "nav", children: [section("navigation", "08")] },
+		{ tag: "ol", children: [section("list", "09")] },
+		{ tag: "article", style: { "background-color": "rgb(240, 240, 240)" }, children: [section("card", "10")] },
+	])).toEqual(["#first", "#second"])
+})
+
+test("#given a single index or repeated equal indices #then no section scaffold is inferred", () => {
+	expect(flagged([section("first", "01"), section("second", "02")])).toEqual(["#first", "#second"])
+	expect(flagged([section("only", "01")])).toEqual([])
+	expect(flagged([section("first", "01"), section("same", "01")])).toEqual([])
+})
+
+test("#given wrapper labels and large headings #then relative label sizing follows the actual text node", () => {
+	const wrapped = (id: string, text: string): NodeSpec => ({
+		children: [
+			{ children: [{ id, tag: "span", text, style: { "font-family": "monospace", "font-size": "15px" } }] },
+			{ children: [{ children: [{ tag: "h3", text: "Large feature", style: { "font-size": "44px" } }] }] },
+		],
+	})
+	const snapshot = buildSnapshot([wrapped("first", "01"), wrapped("second", "02"), section("too-large", "03", { "font-size": "17px" })])
+	expect(numberedSectionLabels.check({ snapshot, config: {} }).map((hit) => hit.snippet.split(" / ")[0])).toEqual(["01", "02"])
+})
+
+test("#given hash sections bare articles and hidden labels #then ranks cards and hidden scaffolds pass", () => {
+	expect(flagged([
+		{ tag: "article", children: [section("first", "#1 Connect")] },
+		{ tag: "article", children: [section("second", "#2 Remember")] },
+		{ style: { display: "none" }, children: [section("hidden", "03")] },
+		{ tag: "a", children: [{ tag: "article", children: [section("linked-card", "04")] }] },
+		section("rank", "#2 Best seller"),
+	])).toEqual(["#first", "#second"])
+})
+
+test("#given same-surface articles and page-scale frames #then only real cards are exempt", () => {
+	expect(flagged([
+		{ tag: "article", style: { "background-color": "rgb(255, 255, 255)" }, children: [section("same-surface", "01")] },
+		{ tag: "article", rect: { height: 2000 }, style: { "background-color": "rgb(240, 240, 240)" }, children: [section("page-frame", "02")] },
+		{ tag: "article", style: { "background-color": "rgb(240, 240, 240)" }, children: [section("card", "03")] },
+	])).toEqual(["#same-surface", "#page-frame"])
+})

package/packages/shared-skills/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/shared-skills/skills/frontend/scripts/detect/rules/copy/repeated-container-text.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } from "bun:test"
+import { buildSnapshot, type NodeSpec } from "../../testing/build-snapshot"
+import { repeatedContainerText } from "./repeated-container-text"
+
+const card = (id: string, children: readonly NodeSpec[]): NodeSpec => ({
+	id, style: { "border-top-width": "1px", "border-right-width": "1px", "border-bottom-width": "1px", "border-top-left-radius": "10px" }, children,
+})
+const slots = (text: string): readonly NodeSpec[] => [
+	{ tag: "span", text }, { tag: "em", text }, { tag: "strong", text },
+]
+const flagged = (nodes: readonly NodeSpec[]) => repeatedContainerText.check({ snapshot: buildSnapshot(nodes), config: {} }).map((hit) => hit.element?.selector)
+
+test("#given repeated text in distinct slots versus templated rows #then only redundant slots report", () => {
+	expect(flagged([
+		card("flag", slots("Suspended")),
+		card("parallel", Array.from({ length: 3 }, () => ({ tag: "div", attributes: { class: "row" }, children: [{ tag: "span", text: "Suspended" }] }))),
+		card("short", slots("Off")), card("numbers", slots("2026")), card("two", slots("Unavailable").slice(0, 2)),
+		card("table", [{ tag: "table", children: slots("Suspended") }]),
+		card("nav", [{ tag: "nav", children: slots("Suspended") }]),
+		card("grid", [{ attributes: { role: "grid" }, children: slots("Suspended") }]),
+	])).toEqual(["#flag"])
+})
+
+test("#given nested cards and unbounded containers #then the nearest bounded card owns its repeats", () => {
+	expect(flagged([
+		card("outer", [card("inner", slots("Unavailable"))]),
+		{ id: "unbounded", children: slots("Unavailable") },
+		...["one", "two", "three"].map((id) => card(id, [{ tag: "span", text: "Standby mode" }])),
+	])).toEqual(["#inner"])
+})
+
+test("#given carousel id classes and clipped slides #then parked or structurally identical copies pass", () => {
+	const slides = (generated: boolean): readonly NodeSpec[] => [0, 1, 2].map((n) => ({
+		attributes: { class: generated ? `slide post-${43000 + n}` : `slide slot-${n}` },
+		rect: { x: n * 320, width: 320 },
+		children: [{ tag: "a", text: "Servidor VPS", rect: { x: n * 320, width: 100 } }],
+	}))
+	expect(flagged([
+		card("visible", slots("Servidor VPS")),
+		card("generated", slides(true)),
+		card("parked", [{ style: { "overflow-x": "hidden" }, rect: { width: 320 }, children: slides(false) }]),
+	])).toEqual(["#visible"])
+})

package/packages/shared-skills/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
+	},
+}