@3xhaust/oh-my-design 0.16.1

package/core/rules/attribution.ts

@@ -0,0 +1,159 @@
+import type { Ir, Violation } from '../types.ts';
+
+/**
+ * Token group names that attribution.md must cover.
+ *
+ * A group is "present" when the page's token map contains at least one key whose
+ * prefix belongs to that group. Two formats are supported:
+ *
+ *   Flat CSS custom property map (runtime, from dom.ts):
+ *     { "color-brand-primary": "#FF5A1F", "spacing-md": "16", ... }
+ *     — keys are CSS variable names with the leading `--` stripped.
+ *
+ *   Nested Figma-style map (fixture / hand-written):
+ *     { color: { "brand/primary": "#FF5A1F" }, spacing: { md: 16 } }
+ *     — top-level key is already the group name.
+ */
+const GROUP_PREFIXES: Record<string, string[]> = {
+  color: ['color', 'fill', 'bg', 'surface', 'foreground', 'background'],
+  type: ['font', 'type', 'heading', 'body'],
+  spacing: ['spacing', 'space', 'gap', 'padding', 'margin', 'inset'],
+  radius: ['radius', 'corner', 'rounded'],
+  motion: ['motion', 'duration', 'ease', 'transition', 'timing', 'animation', 'delay'],
+};
+
+const ALL_GROUPS = Object.keys(GROUP_PREFIXES);
+
+/** Returns the set of token groups that are actually present in the IR. */
+function tokenGroups(tokens: Record<string, unknown>): Set<string> {
+  const groups = new Set<string>();
+
+  for (const [key, value] of Object.entries(tokens)) {
+    const lower = key.toLowerCase();
+
+    // Nested format: the top-level key IS the group name.
+    if (typeof value === 'object' && value !== null && ALL_GROUPS.includes(lower)) {
+      groups.add(lower);
+      continue;
+    }
+
+    // Flat CSS custom property format: match by prefix.
+    for (const [group, prefixes] of Object.entries(GROUP_PREFIXES)) {
+      if (prefixes.some((p) => lower === p || lower.startsWith(`${p}-`) || lower.startsWith(`${p}/`))) {
+        groups.add(group);
+        break;
+      }
+    }
+  }
+
+  return groups;
+}
+
+/** One row from the attribution.md table: { group, source }. */
+interface AttributionRow {
+  group: string;
+  source: string;
+}
+
+/**
+ * Parse an attribution.md Markdown table.
+ *
+ * Expected format (header name is case-insensitive; leading/trailing whitespace ignored):
+ *
+ *   | Group | Source |
+ *   |---|---|
+ *   | color | linear-com.hero |
+ *   | type  | theory/typography |
+ */
+function parseAttributionRows(md: string): AttributionRow[] {
+  const rows: AttributionRow[] = [];
+  for (const line of md.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('|') || !trimmed.endsWith('|')) continue;
+    const cells = trimmed.slice(1, -1).split('|').map((c) => c.trim());
+    if (cells.length < 2) continue;
+    const [group, source] = cells as [string, string];
+    if (!group || !source) continue;
+    // Skip the header row and separator rows.
+    if (group.toLowerCase() === 'group' || /^[-: ]+$/.test(group)) continue;
+    rows.push({ group: group.toLowerCase(), source });
+  }
+  return rows;
+}
+
+/**
+ * Verify that a row's source is a known reference: either a capture slug stored in
+ * `.omd/refs/` or a theory-pack file referenced as `theory/<name>`.
+ *
+ * @param source    The source string from the attribution row.
+ * @param captureNames  Slugs (filenames without .json) found in .omd/refs/.
+ * @param theoryNames   Base names (without .md) of files in the theory pack.
+ */
+function isKnownSource(source: string, captureNames: string[], theoryNames: string[]): boolean {
+  if (captureNames.includes(source)) return true;
+  if (source.startsWith('theory/')) {
+    const name = source.slice('theory/'.length);
+    return theoryNames.includes(name);
+  }
+  return false;
+}
+
+/**
+ * Attribution audit — the deterministic complement to the attribution.md prompt contract.
+ *
+ * Only called when `.omd/attribution.md` exists (the caller is responsible for that guard).
+ *
+ * Two violation codes:
+ *
+ *   ATTR-MISSING         A token group is present on the page but has no row in
+ *                        attribution.md. The designer borrowed a token family and did not
+ *                        say where it came from.
+ *
+ *   ATTR-UNKNOWN-SOURCE  A row's source is neither a capture name in .omd/refs/ nor a
+ *                        theory/<name> reference. The attribution points to something the
+ *                        tool cannot verify — a typo, a deleted reference, or a free-form
+ *                        note that slipped in where a slug belongs.
+ */
+export function checkAttribution(
+  ir: Ir,
+  attributionMd: string,
+  captureNames: string[],
+  theoryNames: string[],
+): Violation[] {
+  const violations: Violation[] = [];
+  const rows = parseAttributionRows(attributionMd);
+  const attributedGroups = new Set(rows.map((r) => r.group));
+  const presentGroups = tokenGroups((ir.tokens ?? {}) as Record<string, unknown>);
+
+  // ATTR-MISSING: token group on the page, no row in attribution.md.
+  for (const group of [...presentGroups].sort()) {
+    if (attributedGroups.has(group)) continue;
+    violations.push({
+      id: 'ATTR-MISSING',
+      severity: 'warn',
+      layer: 1,
+      category: 'system',
+      nodeId: 'page',
+      path: 'attribution',
+      value: group,
+      message: `Token group "${group}" is used on this page but has no row in .omd/attribution.md. Record where this ${group} system came from before the decision disappears.`,
+    });
+  }
+
+  // ATTR-UNKNOWN-SOURCE: row exists, but the source cannot be verified.
+  for (const { group, source } of rows) {
+    if (isKnownSource(source, captureNames, theoryNames)) continue;
+    violations.push({
+      id: 'ATTR-UNKNOWN-SOURCE',
+      severity: 'warn',
+      layer: 1,
+      category: 'system',
+      nodeId: 'page',
+      path: 'attribution',
+      value: `${group}: ${source}`,
+      message: `Attribution row for "${group}" names source "${source}", which is neither a capture slug in .omd/refs/ nor a theory/<name> reference. Fix the slug or re-run omd ref add for that source.`,
+    });
+  }
+
+  return violations;
+}

package/core/rules/builtin/contrast.yaml

@@ -0,0 +1,8 @@
+id: CONTRAST-001
+layer: 1
+category: a11y
+severity: error
+when: "node.type === 'TEXT'"
+value: "node.computed.contrastWithParent"
+assert: "value >= 4.5"
+message: "Contrast ratio {value} is below the WCAG AA minimum of 4.5"

package/core/rules/builtin/focus.yaml

@@ -0,0 +1,8 @@
+id: FOCUS-001
+layer: 1
+category: a11y
+severity: warn
+when: "node.parent === null && ir.meta && ir.meta.interaction && ir.meta.interaction.tabStops >= 3"
+value: "Math.round((ir.meta.interaction.focusVisible / ir.meta.interaction.tabStops) * 100)"
+assert: "value >= 50"
+message: "Only {value}% of tab stops show a visible focus indicator. Keyboard users navigate blind."

package/core/rules/builtin/hit-area.yaml

@@ -0,0 +1,8 @@
+id: HIT-002
+layer: 1
+category: a11y
+severity: error
+when: "node.computed.isInteractive && !node.inline"
+value: "node.computed.hitArea"
+assert: "value.w >= 44 && value.h >= 44"
+message: "Hit area {value} is smaller than the 44x44 minimum"

package/core/rules/builtin/ko.yaml

@@ -0,0 +1,6 @@
+# Korean line breaking is intentionally not a deterministic rule. W3C KLREQ documents
+# word-based and character-based Hangul breaking practices, and the IR cannot judge whether
+# a contextual wrap is acceptable from `word-break` alone. `KO-KEEP-ALL` was therefore
+# removed. Route Korean wrapping to the actual-copy desktop/mobile typography proof, where
+# visible breaks, container width, copy, face, and hierarchy can be reviewed together.
+[]

package/core/rules/builtin/motion.yaml

@@ -0,0 +1,80 @@
+# MOTION-* rules: deterministic checks for motion implementation quality.
+# Every rule warns — never errors. A deliberate choice can overrule any with `omd decision`.
+#
+# Category 'motion' is separate from 'slop': these are craft defects in animation
+# execution (missing reduced-motion support, layout thrash, uniform rhythm), not
+# design-mean convergence failures. Separate category means `omd check --category motion`
+# runs only these, leaving slop and a11y unaffected.
+#
+# Data sources available to rules:
+#   node.motion.properties  — CSS transition-property values (static IR, from dom.ts)
+#   ir.meta.motion          — live probe data (probeMotion in core/render/index.ts)
+#
+# PROBE LIMIT: GSAP and rAF-driven animation libraries are NOT visible to
+# document.getAnimations(). A GSAP-only page reads as zero live animations here —
+# that is a correct measurement of what the API can see, not a probe failure.
+# Rules that read ir.meta.motion check defensively for probe presence (ir.meta.motion
+# exists and has the expected fields) before asserting. They skip gracefully when the
+# probe was not run or returned null.
+#
+# BLIND SPOT CLOSURE: core/motion/energy.ts (computeEnergy) closes this gap. It
+# computes pixel-diff scores between filmstrip frames and sees ALL motion including
+# GSAP/rAF — a non-zero EnergyCurve.peakEnergy confirms motion occurred even when
+# ir.meta.motion.animatedProperties is []. The MOTION-SPEC-DRIFT and MOTION-NO-ENTRANCE
+# rules in core/rules/motion-spec.ts use the energy curve as a supplementary signal.
+#
+# MOTION-SLOW-HOVER was studied and dropped: node.motion.durations lists ALL transition
+# durations (entrance animations + hover transitions) without distinguishing between them.
+# A rule firing on any interactive node with duration > 200ms would have false positives
+# from entrance animations. No deterministic path exists; the rule is omitted rather than
+# faked. See Plan.md #11c for the analysis.
+
+# A page with live animations but no prefers-reduced-motion media query exposes every
+# user who prefers reduced motion to the full animation load. The fix is a single media
+# query block wrapping the entire motion layer. The rule only fires when the live probe
+# measured at least one animated property — a page with no live animations is fine either
+# way, and a pre-probe IR (no ir.meta.motion) cannot be checked.
+- id: MOTION-NO-REDUCED
+  layer: 1
+  category: motion
+  severity: warn
+  when: "node.parent === null && ir.meta && ir.meta.motion && Array.isArray(ir.meta.motion.animatedProperties) && ir.meta.motion.animatedProperties.length > 0"
+  assert: "ir.meta.motion.hasReducedMotion === true"
+  message: "Animations present but no prefers-reduced-motion media query found. Users who opt out of motion see the full animation load. Wrap the entire motion layer: @media (prefers-reduced-motion: reduce) { *, *::before, *::after { transition-duration: 0.01ms !important; animation-duration: 0.01ms !important; animation-iteration-count: 1 !important; } }"
+
+# Animating layout properties (width, height, top, left, margin, padding) forces the
+# browser to recalculate layout on every frame — a full layout pass that triggers
+# cascading reflow through the subtree. Animate transform and opacity instead: they run
+# on the compositor thread, never touch layout, and are the only two properties that can
+# be GPU-accelerated without a layout recalculation.
+#
+# The rule reads node.motion.properties (static IR) which lists the CSS transition-property
+# values on this node, excluding 'all' and 'none'. If transition-property is 'all', the
+# specific properties are unknown and the rule does not fire — this is the conservative
+# (non-faking) path. Only explicitly named layout properties are flagged.
+- id: MOTION-LAYOUT-THRASH
+  layer: 1
+  category: motion
+  severity: warn
+  when: "node.motion && Array.isArray(node.motion.properties) && node.motion.properties.length > 0"
+  value: "node.motion.properties.filter(p => ['width','height','top','right','bottom','left','margin','margin-top','margin-right','margin-bottom','margin-left','padding','padding-top','padding-right','padding-bottom','padding-left'].includes(p))"
+  assert: "value.length === 0"
+  message: "Layout property animated: {value}. Animating width/height/top/left/margin/padding forces a full layout recalculation on every frame. Animate transform (translate, scale) and opacity instead — they run on the compositor thread and never touch layout."
+
+# Three or more animated nodes, every one with the same duration, and the easing
+# vocabulary contains only CSS keyword defaults (ease, ease-in, ease-out, ease-in-out,
+# linear). This is the signature of generated work: "500ms ease-in-out on everything."
+# A considered motion system varies duration by role (entrance is slower than hover;
+# exit is faster than entrance) and uses a measured easing curve from the motion study.
+#
+# Fires on the root node (once per page). Null return from the IIFE means "condition not
+# met" — either fewer than 3 animated nodes, or durations vary, or a real cubic-bezier
+# is in use. Any of those is sufficient to silence the rule.
+- id: MOTION-UNIFORM
+  layer: 1
+  category: motion
+  severity: warn
+  when: "node.parent === null"
+  value: "(() => { const animated = ir.nodes.filter(n => n.motion && n.motion.durations && n.motion.durations.length > 0); if (animated.length < 3) return null; const allDurations = animated.flatMap(n => n.motion.durations); const unique = [...new Set(allDurations)]; if (unique.length !== 1) return null; const allEasings = [...new Set(animated.flatMap(n => n.motion.easings))]; const defaults = new Set(['ease','linear','ease-in','ease-out','ease-in-out','step-start','step-end']); if (!allEasings.every(e => defaults.has(e))) return null; return { count: animated.length, duration: unique[0], easings: allEasings }; })()"
+  assert: "value === null"
+  message: "Motion uniform signature: {value}. Every animated node shares one duration and only CSS keyword easings. This is the generated-work signature. Vary duration by role (entrance ≠ hover ≠ exit) and use a measured easing curve (cubic-bezier) from the motion study rather than keyword defaults."

package/core/rules/builtin/slop.yaml

@@ -0,0 +1,365 @@
+# Nothing in this file describes a defect. Every rule here describes work that a model
+# produced from pattern alone, without the position of an author who built the thing and
+# speaks the language. Two families live here:
+#
+# 1. Visual convergence-to-the-mean — the gradient band, the identical radius, the triple
+#    card grid. Correct, competent, indistinguishable from ten thousand others. That is the
+#    failure this tool was first built for.
+#
+# 2. Prose that could not have been written by a person who speaks the language natively
+#    and owns the product — register drift, translation punctuation (spaced em-dash inside
+#    Korean copy), speech-level mixing within a paragraph, explainer cadence on a product
+#    page. These are not grammar errors. A fluent reader knows, immediately, that no native
+#    speaker wrote them. The IR cannot always see layout-level signals (a hard <br> inside
+#    a sentence is invisible once the DOM collapses text nodes), but it can see the text
+#    itself — and the text is where generated work gives itself away first.
+#
+# Each is a heuristic and each can be wrong about a deliberate choice. So they warn, they
+# never error, and every message says what to do instead rather than merely what is wrong.
+#
+# Whole-page rules fire once, on the root node, and read ir.stats.
+
+# Matched by hue, not by a list of hex codes: a blocklist of Tailwind's indigo-500 misses
+# the same idea expressed one shade over. Both stops must sit in the 230–300° band at real
+# saturation — that covers indigo (239°) through violet (258°) to purple (271°) while
+# leaving an honest blue brand (#3B82F6, 217°) alone.
+#
+# The band was first written as 240–300 and missed #6366F1 by one degree — the exact colour
+# it was written to catch. Hand-picked thresholds are brittle; widen only with a case.
+- id: SLOP-GRADIENT
+  layer: 1
+  category: slop
+  severity: warn
+  when: "node.parent === null"
+  value: "ir.stats.gradients.filter(g => (g.match(/#[0-9a-f]{6}/gi) ?? []).map(x => { const r = parseInt(x.slice(1,3),16)/255, gr = parseInt(x.slice(3,5),16)/255, b = parseInt(x.slice(5,7),16)/255; const mx = Math.max(r,gr,b), mn = Math.min(r,gr,b), d = mx - mn; if (d === 0 || mx === 0 || d/mx < 0.35) return -1; let h = mx === r ? ((gr-b)/d) % 6 : mx === gr ? (b-r)/d + 2 : (r-gr)/d + 4; h *= 60; return h < 0 ? h + 360 : h; }).filter(h => h >= 230 && h <= 300).length >= 2)"
+  assert: "value.length === 0"
+  message: "Indigo-to-violet gradient: {value}. It is the signature of every landing page generated since 2023. Unless the brand really is violet, this is not a point of view — it is a default."
+
+- id: SLOP-RADIUS-MONOCULTURE
+  layer: 1
+  category: slop
+  severity: warn
+  when: "node.parent === null"
+  value: "Object.entries(ir.stats.radiusHistogram).sort((a,b) => b[1]-a[1])[0] ?? null"
+  assert: "value === null || value[1] < 8 || Object.keys(ir.stats.radiusHistogram).length > 1"
+  message: "Every corner on the page shares one radius ({value}). Without hierarchy the eye cannot rank anything: a card, a button and an input should not feel like the same material."
+
+- id: SLOP-SHADOW-MONOCULTURE
+  layer: 1
+  category: slop
+  severity: warn
+  when: "node.parent === null"
+  value: "Object.entries(ir.stats.shadowHistogram).filter(([s, n]) => s !== 'none' && n >= 5)"
+  assert: "value.length === 0"
+  message: "One shadow repeated: {value}. A shadow means elevation. If everything floats at the same height, nothing floats."
+
+- id: SLOP-EVERYTHING-CENTERED
+  layer: 1
+  category: slop
+  severity: warn
+  when: "node.parent === null && ir.stats.centeredTextRatio > 0"
+  value: "Math.round(ir.stats.centeredTextRatio * 100)"
+  assert: "value < 60"
+  message: "{value}% of text blocks are centred. Centring is emphasis, not a default. Emphasise everything and you emphasise nothing — and only a left-aligned paragraph gives the eye somewhere to return to on each line."
+
+# Widened from headings-only to also cover interactive nodes (buttons,
+# links). A CTA that opens with 🚀 borrows excitement it has not earned as much as a heading
+# that does. The check fires only on the starting emoji — a functional arrow or chevron
+# (Unicode Arrows block U+2190–U+21FF) is NOT in either emoji range and does not fire.
+- id: SLOP-EMOJI-HEADING
+  layer: 1
+  category: slop
+  severity: warn
+  when: "(Boolean(node.heading) || Boolean(node.interactive)) && Boolean(node.text)"
+  value: "node.text"
+  assert: "!/^\\s*[\\u{1F300}-\\u{1FAFF}\\u{2600}-\\u{27BF}]/u.test(value)"
+  message: "Heading or button opens with an emoji: {value}. An emoji borrows emotional charge it has not earned. If it is doing a job your typography or copy failed to do, fix those instead."
+
+- id: SLOP-COPY
+  layer: 1
+  category: slop
+  severity: warn
+  when: "Boolean(node.text) && node.text.length > 8"
+  value: "node.text"
+  # F2: removed four trigger-happy branches that fired on ordinary prose — `~?를 통해 알 수 있`
+  # (matches mid-word inside the common neutral construction "이를 통해 알 수 있다"), `매우 중요한`
+  # ("very important" — everyday, not slop), `we (?:don't|do not|never) (?:use|do|write)`
+  # (fires on legitimate privacy/policy copy like "we don't use trackers"; the self-negating
+  # meta-brag case it was meant for is already covered by `no (?:fluff|jargon|nonsense) here`),
+  # and the unanchored `이 (?:페이지|사이트|글)(?:에서)?는 .*(?:없습니다|않습니다)` (its greedy `.*`
+  # swallowed ordinary 404s, empty states, and privacy copy). F3: moved the narrow Korean
+  # self-negating pattern `이런 내용은 없` to SLOP-PINK-ELEPHANT, which covers the full family.
+  # F2 widening: added three phrases with near-zero false-positive risk.
+  # "say goodbye to" — textbook AI marketing opener; never appears in honest product copy.
+  # "it['’]s not just.*it['’]s" — the classic AI antithesis formula "It's not just X — it's Y".
+  # "blazing.?fast" — stock performance adjective; real benchmarks use numbers.
+  assert: "!/\\b(seamlessly|effortlessly|unlock the power|elevate your|supercharge|game.?chang|take .* to the next level|revolutioniz|cutting.?edge|unleash|no (?:fluff|jargon|nonsense) here|say goodbye to|blazing.?fast)\\b|it[\\u2019']s not just|결론적으로|시사하는 바가 크|주목할 만하|첫째[,，]/i.test(value)"
+  message: "Marketing filler or AI stock phrase: \"{value}\". It fits any product and says nothing about this one. Write what this product specifically gives, costs, or does."
+
+# The pink-elephant failure: a page told "no clutter" that writes "No clutter here."
+# Copy must state what IS — the positive fact the negation was hiding. This rule catches
+# the structural pattern: announcing what the page refuses to do, which is always the model
+# quoting its own instructions back to the user. Narrow patterns only; broad negation ("we
+# don't use") hits privacy and 404 copy that are entirely legitimate. Negative tests are
+# mandatory: "we don't use trackers", empty states, 404s, out-of-stock must never fire.
+- id: SLOP-PINK-ELEPHANT
+  layer: 1
+  category: slop
+  severity: warn
+  when: "Boolean(node.text) && node.text.length > 8"
+  value: "node.text"
+  assert: "!/you won't find [^.]{0,40} here|we (?:won't|will never) (?:bore|spam|waste)|\\b(?:no|zero) (?:ads|clutter|distractions|gimmicks)[,.]? just\\b|이런 (?:내용|것)[은는] 없|(?:여기|이 페이지)에는 [가-힣 ]{0,15}(?:광고|잡동사니|군더더기)[가는은]? 없/i.test(value)"
+  message: "Self-negating meta-copy: \"{value}\". The page is announcing what it refuses to do — the model quoting its own brief. Delete this sentence and write the positive fact it was hiding: what the reader gets, what it costs, what happens next."
+
+# Korean AI writing patterns promoted from the im-not-ai taxonomy.
+#
+# Three classes, all S1 (deterministically AI-flavoured in UI copy):
+#
+# C-11 — a sentence-opening connective directly followed by a comma (그러나, / 하지만, /
+# 또한, / 따라서, / 즉,). Standard Korean prose does not punctuate these with a comma;
+# the comma is a direct trace of English "However," and "Therefore," translated by a model.
+# Narrow by design: only the exact five connectives fire; the comma+space pair is required so
+# "또한 그날 밤" (ordinary adverb) passes cleanly.
+#
+# D류 — 알아보겠습니다 / 살펴보겠습니다. The "let us now examine" structural openers that
+# appear in AI-generated explanatory content. On a product page they expose the model's
+# essay skeleton. A human copywriter writes what the product does, not that we will look at
+# what the product does.
+#
+# F2 rule: drop a pattern rather than ship one that fires on legitimate prose. A-19 겹조사
+# (-에서의/-으로의) was studied and dropped: "서울에서의 하루" is unambiguous legitimate Korean
+# so the pattern is too trigger-happy to promote. "둘째,/셋째," was also studied and retained
+# in this rule rather than SLOP-COPY because it completes the 첫째-둘째-셋째 enumeration
+# family already flagged by SLOP-COPY.
+- id: SLOP-COPY-KO
+  layer: 1
+  category: slop
+  severity: warn
+  when: "Boolean(node.text) && node.text.length > 8"
+  value: "node.text"
+  assert: "!/(?:그러나|하지만|또한|따라서|즉),[ \\t]|살펴보겠습니다|알아보겠습니다|둘째[,，]|셋째[,，]/u.test(value)"
+  message: "Korean AI writing pattern: \"{value}\". A connective followed by a comma (그러나,/또한,), a structural 살펴보겠습니다/알아보겠습니다opener, or a 둘째/셋째 enumeration all trace the model's essay skeleton, not the product's actual claim. Write the specific fact this sentence was hiding."
+
+# Korean translation-punctuation tell: a spaced em-dash ( — ) or en-dash ( – ) inside a
+# sentence that contains Hangul. The spaced em-dash is standard English typography and is
+# legitimate in English copy; it is not standard in Korean product writing. It appears in
+# Korean AI output because the model learned the pattern from English text and transfers it
+# directly. A native Korean copywriter uses a comma, a colon, a dash without surrounding
+# spaces, or starts a new sentence — never the spaced European em-dash construction.
+#
+# Gated on Hangul presence in the same node so English copy is never touched.
+- id: SLOP-KO-EMDASH
+  layer: 1
+  category: slop
+  severity: warn
+  when: "Boolean(node.text) && node.text.length > 8 && /[가-힣]/u.test(node.text)"
+  value: "node.text"
+  assert: "!/ [—–] /.test(value)"
+  message: "Spaced em-dash or en-dash inside Korean copy: \"{value}\". The spaced em-dash ( — ) is an English typography convention; it appears in Korean AI output as a direct transfer from English training data. Rewrite as a comma, colon, or a new sentence — the construction Korean product copy actually uses."
+
+# Korean speech-level mixing within a single text block. Korean has two formal registers
+# that must not alternate in the same paragraph outside of quoted dialogue:
+#
+#   해요체 — ALL forms end in 요 followed by sentence-final punctuation (. ! ?):
+#             아요, 어요, 예요, 에요, 해요, 봐요, 줘요, 쉬워요, and every other contracted form.
+#   합니다체 — ALL forms end in 니다 followed by sentence-final punctuation (. ! ?):
+#              습니다, and the ㅂ-absorbed forms 합니다, 됩니다, 만듭니다, 갑니다, etc.
+#              (In Unicode, the ㅂ attaches to the preceding syllable as a 받침 —
+#              "만듭니다" is 만+듭+니+다, not 만+들+ㅂ+니+다. The text "ㅂ니다" never
+#              appears; 니다[.!?] is the correct detector for the full family.)
+#
+# A native speaker writing product copy commits to one level and holds it. A model assembles
+# sentences across registers because each sentence is generated independently. The result
+# reads immediately as machine-made to any fluent reader — not as a grammar error but as
+# a sign that no single human voice was present.
+#
+# False positive guard: if the node contains quotation marks (straight or curly, Korean
+# angle brackets), stay silent — dialogue attribution legitimately mixes registers.
+#
+# Positive test: "모델은 정답을 만들지 않아요. 훈련 데이터의 평균을 만듭니다." (해요체 + 합니다체)
+# Negatives: all-해요체 block, all-합니다체 block, any block containing 따옴표.
+- id: SLOP-KO-REGISTER-MIX
+  layer: 1
+  category: slop
+  severity: warn
+  when: "Boolean(node.text) && node.text.length > 8 && /[가-힣]/u.test(node.text)"
+  value: "node.text"
+  assert: "!(/요[.!?]/.test(value) && /니다[.!?]/.test(value)) || /[\"'\\u201C\\u201D\\u2018\\u2019\\u300C\\u300D]/.test(value)"
+  message: "Mixed speech levels in one text block: \"{value}\". 해요체 endings (요.) and 합니다체 endings (니다.) alternate inside one paragraph — a sign that sentences were assembled across generation passes rather than written by one voice. Choose one level, held for the whole page, and state which in the voice study."
+
+- id: SLOP-TRIPLE-CARD
+  layer: 1
+  category: slop
+  severity: warn
+  when: "node.computed.identicalSiblings >= 3 && Boolean(node.shadow) && Boolean(node.radius)"
+  value: "node.computed.identicalSiblings"
+  assert: "false"
+  message: "{value} structurally identical cards sit side by side. Three feature cards are not an information architecture; they are a confession that nobody decided what matters most. Decide, then make that one bigger."
+
+# Korean document-structure narration. These phrases announce the document's own organisation
+# rather than communicating what the product does: "아래는 그 기록이에요" (below is the record),
+# "다음은 기능 목록입니다" (the following is the feature list). On a product page, this cadence
+# exposes the model's essay or README skeleton — the AI introducing its own bullet list instead
+# of writing the bullet list. A human copywriter presents the content; they do not narrate
+# that content is about to appear.
+#
+# Two patterns, both gated on Korean text presence:
+#
+# Pattern 1: 아래는 <words> <기록|내용|목록|정리>
+#   "아래는 그 기록이에요" → fires
+#   "아래는 변경 내용이에요" → fires
+#   "아래 버튼을 누르세요" → passes (아래 without 는 particle; spatial adverb not a structure marker)
+#   "아래에서 다운로드하세요" → passes (아래에서, not 아래는)
+#
+# Pattern 2: 다음은 <words> <입니다|이에요>
+#   "다음은 기능 목록입니다" → fires
+#   "다음은 그 이유이에요" → fires
+#   "다음에 다시 시도해주세요" → passes (다음에, not 다음은)
+#
+# The .{0,30} span is deliberately short: a sentence that says "아래는 그 기록이에요" has
+# the structure word within 30 characters of 아래는. A longer span risks matching sentences
+# that happen to contain 기록 as part of an unrelated clause.
+- id: SLOP-KO-SIGNPOST
+  layer: 1
+  category: slop
+  severity: warn
+  when: "Boolean(node.text) && node.text.length > 8 && /[가-힣]/u.test(node.text)"
+  value: "node.text"
+  assert: "!/아래는\\s+.{0,30}(?:기록|내용|목록|정리)|다음은\\s+.{0,30}(?:입니다|이에요)/u.test(value)"
+  message: "Document-structure narration copy: \"{value}\". '아래는 … 기록/내용/목록' and '다음은 … 입니다/이에요' introduce the document's structure in essay cadence. On a product page, write what the product does — not that we will now look at what the product does. Delete the announcing sentence and replace it with the specific fact or action it was narrating."
+
+# ── the machine-default aesthetic, measured ────────────────────────────────────────────
+#
+# These rules remain only where rendered IR supports a narrow, repeatable warning. Source
+# compounds and contextual visual judgments follow `protocol/slop-review.md`: `omd slop scan`
+# reports candidates for triage, not linter verdicts, severity, score, history, coach data, or
+# an AI-authorship claim. Unsafe source cues do not become broad YAML regexes. Rendered IR is
+# authoritative when source and render evidence overlap.
+
+# Gradient-clipped text: background-clip: text combined with a gradient. The effect
+# sacrifices legibility for an appearance that every generated landing page now shows.
+# The IR sets node.clipText when the browser reports background-clip:text (or the
+# -webkit- prefix) alongside a gradient on the same node.
+# Gradient headline text.
+- id: SLOP-GRADIENT-TEXT
+  layer: 1
+  category: slop
+  severity: warn
+  when: "Boolean(node.clipText)"
+  assert: "false"
+  message: "Gradient-clipped text on this node. background-clip:text renders text in a gradient, sacrificing legibility for an effect that every generated landing page now shares. Establish hierarchy through size, weight, and position; use a single legible text colour. Use omd decision to record a brand reason if this hue band is genuinely the brand's."
+
+# Invented stat row: round heroic numbers (10k+, 99.9%, 24/7) clustered on a page.
+# Real metrics are odd and specific — "847 teams migrated in Q1" carries more weight than
+# any 10× claim because nobody lies that specifically. The rule fires when two or more
+# text nodes each independently match an invented-stat pattern.
+# The invented stat row.
+- id: SLOP-FAKE-STAT
+  layer: 1
+  category: slop
+  severity: warn
+  when: "node.parent === null"
+  value: "(() => { const p = [/\\b\\d+[kK]\\+/, /\\b9[89](?:\\.\\d)?%/, /\\b24\\/7\\b/]; const hits = ir.nodes.filter(n => n.text && p.some(r => r.test(n.text))).map(n => n.text.slice(0, 40)); return hits.length >= 2 ? hits : null; })()"
+  assert: "value === null"
+  message: "Invented stat row: {value}. Round heroic numbers (10k+, 99.9%, 24/7) on a new product are decoration — the user has no reason to believe them. Write odd, specific, sourced numbers ('847 teams migrated in Q1') or nothing."
+
+# Oversized drop shadow: shadow blur ≥40px on a node whose smaller dimension is less than
+# or equal to the blur. A shadow that large maps to no real surface — it is fog. Elevation
+# shadows have blur proportional to their step: a card 2dp high gets ~4px, not 40px.
+# Parsed from the computed box-shadow string: browser returns offsets in px order after
+# the colour (Chrome/Firefox: "rgba(…) Xpx Ypx BLURpx SPREADpx").
+# The oversized drop shadow.
+- id: SLOP-OVERSIZED-SHADOW
+  layer: 1
+  category: slop
+  severity: warn
+  when: "Boolean(node.shadow) && node.shadow.value !== 'none'"
+  value: "(() => { const nums = (node.shadow.value.match(/-?\\d+(?:\\.\\d+)?(?=px)/g) || []).map(Number); const blur = nums[2] ?? 0; const smaller = Math.min(node.box.w, node.box.h); return blur >= 40 && smaller > 0 && blur >= smaller ? { blur, size: smaller } : null; })()"
+  assert: "value === null"
+  message: "Oversized shadow: {value}. A blur radius ≥40px on an element this small is fog, not elevation. Shadow blur should stay below half the element's smaller dimension. Use a tight elevation scale: 0/2/4/8/16px blur where each step is a real layer."
+
+# Card inside a card: a surfaced node (radius + shadow) whose nearest ancestor is also
+# surfaced. Every nested container adds material depth without information. The fix is
+# one surface per region; group related content with spacing and hairline dividers.
+# Cards inside cards.
+- id: SLOP-NESTED-CARDS
+  layer: 1
+  category: slop
+  severity: warn
+  when: "Boolean(node.radius) && Boolean(node.shadow)"
+  value: "(() => { let p = node.parent; while (p) { const par = ir.nodes.find(n => n.id === p); if (!par) break; if (par.radius && par.shadow) return true; p = par.parent; } return false; })()"
+  assert: "value !== true"
+  message: "Card nested inside a card: a surfaced node (radius + shadow) sits inside another surfaced ancestor. Every nested container adds material depth without information. Use one surface per region; group related content with spacing and hairline dividers instead."
+
+# Non-concentric corners: child radius ≥ parent radius when the child is inset by padding.
+# The rule is inner = outer − padding. When inner ≥ outer, the corners do not nest
+# optically — they arc at the same rate and the containment looks wrong. A card with
+# 16px radius and 16px padding should hold children with radius 0 to ~12px, not 16px+.
+# Only fires when parent radius > 4px (not micro-radii) and parent has non-zero padding
+# (confirming the child is genuinely inset, not floating adjacent to the parent).
+# Corners that don't nest.
+- id: SLOP-NESTED-RADIUS
+  layer: 1
+  category: slop
+  severity: warn
+  when: "Boolean(node.radius) && Boolean(node.parent)"
+  value: "(() => { const par = ir.nodes.find(n => n.id === node.parent); if (!par?.radius) return null; const outer = typeof par.radius.value === 'number' ? par.radius.value : 0; const inner = typeof node.radius.value === 'number' ? node.radius.value : 0; const pads = par.layout?.padding ? par.layout.padding.filter(v => v > 0) : []; const minPad = pads.length > 0 ? Math.min(...pads) : 0; return outer > 4 && inner >= outer && minPad > 0 ? { outer, inner, padding: minPad } : null; })()"
+  assert: "value === null"
+  message: "Non-concentric corners: {value}. When a child is inset by padding, its radius should be outer minus padding. Inner radius ≥ outer: the surfaces do not nest — the inner element appears to float rather than sit inside. Correct inner radius = outer − min(padding)."
+
+# Spacing monoculture: one spacing value dominates ≥80% of all padding and gap on the
+# page. When proximity carries no information, nothing is grouped — the layout is a grid
+# of equidistant objects. Fires on pages with ≥20 non-zero spacing samples.
+# Zero is excluded: on a real page it represents ~80% of all values and is not a decision.
+# One gap everywhere.
+- id: SLOP-MONO-SPACING
+  layer: 1
+  category: slop
+  severity: warn
+  when: "node.parent === null"
+  value: "(() => { const h = ir.stats.spacingHistogram; const entries = Object.entries(h).filter(([k]) => Number(k) !== 0); const total = entries.reduce((s, [,n]) => s + n, 0); if (total < 20) return null; const top = entries.sort((a, b) => b[1] - a[1])[0]; if (!top) return null; const pct = Math.round(top[1] / total * 100); return pct >= 80 ? { value: top[0], pct } : null; })()"
+  assert: "value === null"
+  message: "Spacing monoculture: {value}. One spacing value accounts for 80%+ of all padding and gap. When proximity carries no information, nothing is grouped. Use a scale with at least three non-zero distinct steps (e.g. 8/16/32/64px) applied asymmetrically — tight within groups, generous between."
+
+# Glassmorphism monoculture: three or more nodes use backdrop-filter: blur, the frozen
+# 2021 Dribbble aesthetic. A single frosted-glass surface can be a deliberate choice;
+# applying it to every card is a pattern inherited from training data.
+# The IR captures node.backdropFilter when the computed backdrop-filter is not 'none'.
+# Max radius + glassmorphism.
+- id: SLOP-GLASSMORPHISM
+  layer: 1
+  category: slop
+  severity: warn
+  when: "node.parent === null"
+  value: "ir.nodes.filter(n => n.backdropFilter && /blur/.test(n.backdropFilter)).length"
+  assert: "value < 3"
+  message: "{value} nodes use backdrop-filter:blur (glassmorphism). A single frosted-glass surface is a deliberate choice; {value} of them is a pattern from 2021 Dribbble. Replace repeated blur surfaces with opaque ones — one material, defined. Use omd decision to record why multiple blur surfaces are required."
+
+# Manufactured status badges: small text nodes whose entire content is a badge-like term
+# (New / Beta / Hot / Popular / Trending / Soon / Pro) with optional leading emoji.
+# Real badges carry time-bounded or count-backed information; decoration badges erode
+# trust by the third one. Gated to short text (≤30 chars) on small nodes (height ≤36px).
+# Badge and pill spam.
+- id: SLOP-BADGE-SPAM
+  layer: 1
+  category: slop
+  severity: warn
+  when: "Boolean(node.text) && node.text.length <= 30 && node.box.h <= 36"
+  value: "node.text"
+  assert: "!/^[\\s\\u{1F300}-\\u{1FAFF}\\u{2600}-\\u{27BF}]*\\b(?:new|beta|hot|popular|trending|pro|soon)\\b[\\s!]*$/iu.test(value)"
+  message: "Manufactured badge: \"{value}\". New / Beta / Hot / Popular tags manufacture buzz. Use badge treatments only for genuine, time-bounded status: a feature launched this week, an actual version number, a real availability flag. Decoration badges erode trust by the third one."
+
+# Flat type hierarchy: when three or more distinct font sizes cluster between 13–19px, or
+# adjacent steps differ by less than 1.15×, size stops carrying hierarchy. The eye cannot
+# rank headings from body copy when the sizes are too close to distinguish.
+# Fires at the page level; requires ≥3 distinct sizes (a two-size page may be intentionally
+# minimal). A scale of 14/18/24px or 12/16/28px passes; 13/14/15/17px fails.
+# The flat type hierarchy.
+- id: SLOP-FLAT-TYPE
+  layer: 1
+  category: slop
+  severity: warn
+  when: "node.parent === null"
+  value: "(() => { const sizes = [...new Set(ir.nodes.filter(n => n.fontSize && n.fontSize > 0).map(n => n.fontSize))].sort((a, b) => a - b); if (sizes.length < 3) return null; const allFlat = sizes.every(s => s >= 13 && s <= 19); const ratios = sizes.slice(1).map((s, i) => s / sizes[i]); const minR = ratios.reduce((a, b) => Math.min(a, b), 99); const flatCount = ratios.filter(r => r < 1.15).length; return (allFlat || flatCount >= 2) ? { sizes, minRatio: Math.round(minR * 100) / 100 } : null; })()"
+  assert: "value === null"
+  message: "Flat type hierarchy: {value}. Font sizes all cluster between 13–19px or adjacent steps differ by less than 1.15×. Size stops carrying hierarchy. Establish at least three steps at 1.25× minimum (e.g. 14/18/24px). Use weight — not colour shade — to differentiate content at the same size."