From a8c8ba9c136a0ec57ceabac06e599bc4adfda600 Mon Sep 17 00:00:00 2001
From: WilcoLouwerse <wilco@conduction.nl>
Date: Mon, 21 Sep 2026 11:09:12 +0200
Subject: [PATCH 1/2] =?UTF-8?q?fix(gate-45):=20a=20reduced-motion=20block?=
 =?UTF-8?q?=20that=20exists=20is=20not=20a=20fallback=20=E2=80=94=20judge?=
 =?UTF-8?q?=20every=20motion=20selector=20under=20the=20cascade?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Gate-45 asked one question per file: is there a `@media (prefers-reduced-motion …)`
block in it? thematiq css/systems/nldesign/theme.css had one, so the gate said PASS
at 6dcbbaf9 — where c495c99c had added `:not(.action-button)` to four `!important`
motion selectors while the reset kept the bare `.button-vue, button, .button`.
Equal specificity before (reset wins on source order), strictly less after (reset
loses on every button in the app). PASS again at 67caeb85, once the selectors were
mirrored back. Same verdict on the broken and the fixed file.

The checker now flattens the stylesheet into rules, resolves nesting (`&`), and
requires every selector carrying motion to be overridden by a rule inside a
reduced-motion block under the cascade's actual rules: equal importance → more
specific wins, then source order; unequal → `!important` wins. The repo-wide
universal reset the pre-pass detects is therefore a `*` guard fed into the same
check instead of an early exit: it covers every plain motion declaration and no
`!important` one, which is what thematiq's own comment above its reset block says.

Recognised without a matching selector: `no-preference` motion, and a duration
token zeroed inside the reduced-motion block (the atom-design convention).
Brace-less .sass falls back to the presence question.

Measured with the package runner at full scope:
  theme.css @ 6dcbbaf9   FAIL — 3 finding(s), naming exactly the three narrowed selectors
  theme.css @ 67caeb85   PASS
  thematiq @ 7466a5a, openregister @ cabd4106, portaliq @ aa6dc05   PASS (no fleet noise)

test_gate_45_selector_parity.sh pins the thematiq shape as the failing arm and every
correct idiom as a control (mirrored selectors, `!important` guard over plain motion,
`*` over plain vs `!important` motion, `no-preference`, duration token, `&`-nesting,
`:is(.a, .b)`, `html`-prefixed guard, the repo-wide reset in another file).
test_gate_45_stylesheet_scope.sh, test_gate_a11y_markup_scope.sh,
test_gate_45_to_55_acceptance.sh and tests/test-hydra-gates-bin.sh stay green.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../lib/test_gate_45_selector_parity.sh       | 376 ++++++++++++++++++
 hydra-gates/scripts/run-hydra-gates.sh        | 220 +++++++++-
 .../gate-acceptance/COVERED-ELSEWHERE.md      |   2 +-
 3 files changed, 578 insertions(+), 20 deletions(-)
 create mode 100644 hydra-gates/scripts/lib/test_gate_45_selector_parity.sh

diff --git a/hydra-gates/scripts/lib/test_gate_45_selector_parity.sh b/hydra-gates/scripts/lib/test_gate_45_selector_parity.sh
new file mode 100644
index 00000000..12127aac
--- /dev/null
+++ b/hydra-gates/scripts/lib/test_gate_45_selector_parity.sh
@@ -0,0 +1,376 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: EUPL-1.2
+#
+# test_gate_45_selector_parity.sh — gate-45 must judge the SELECTORS that carry
+# motion, not the presence of a reduced-motion block somewhere in the file.
+#
+# WHAT THIS GUARDS (thematiq#604, 2026-09-17)
+# --------------------------------------------
+# Until 2026-09-21 the checker asked one question per file: is there a
+# `@media (prefers-reduced-motion …)` block in it? thematiq's
+# css/systems/nldesign/theme.css had one, so the gate said PASS — at `6dcbbaf9`,
+# where `c495c99c` had added `:not(.action-button)` to four `!important` motion
+# selectors while the reset kept the bare `.button-vue, button, .button`. Equal
+# specificity before (reset wins on source order); strictly less after (reset
+# loses on every button). The gate said PASS again at `67caeb85`, after the
+# selectors were mirrored back.
+#
+# Measured 2026-09-21 with the package runner at full scope, one variable:
+#   theme.css @ 6dcbbaf9  (reset no longer names the motion selectors)  PASS  <- the defect
+#   theme.css @ 67caeb85  (reset names them again)                      PASS
+#
+# Same verdict on the broken and the fixed file: the gate did not observe the
+# property it is named after. The arms below are that file's shape reduced to
+# its cascade essentials, plus the anti-widening controls for every correct
+# idiom the fleet writes — the change turns a file-level question into a
+# per-selector one, and that is precisely the kind of change that turns a gate
+# into a noise generator if the controls are not pinned.
+#
+#   P1  the thematiq shape: !important motion on `.btn:not(.x)`, reset on bare `.btn` → FAIL, names the selector
+#   P2  CONTROL: the same file with the reset mirroring the selectors                → PASS
+#   P3  a LESS specific guard covers a plain motion when the guard is !important    → PASS  (.card covers .card:hover)
+#   P3b …and does NOT when both are plain: `.card:hover` beats `.card` by specificity → FAIL
+#   P4  a universal `*` reset covers plain motion (ARM 6 of the scope suite)         → PASS
+#   P4b …and does NOT cover !important motion: `*` has specificity 0                  → FAIL
+#   P5  `@media (prefers-reduced-motion: no-preference) { …motion… }` is guarded by construction → PASS
+#   P6  a duration token zeroed inside the reduced-motion block covers its users    → PASS
+#   P7  the markup arm judges per selector too: a scoped <style> guarding `.other` does not guard `.m` → FAIL; guarding `.m` → PASS
+#   P8  SCSS nesting: `&:hover` resolves against its parent before matching          → PASS / FAIL
+#   P9  `:is(.a, .b)` keeps its comma — the selector is matched whole                 → PASS
+#   P10 `html .btn` (ancestor boost) is a MORE specific guard for `.btn`              → PASS
+#   P11 the repo-wide universal reset in ANOTHER file covers plain motion, not !important motion → PASS / FAIL
+
+set -u
+
+_here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+_scripts="$(cd "${_here}/.." && pwd)"
+_runner="${HYDRA_GATES_RUNNER_UNDER_TEST:-${_scripts}/run-hydra-gates.sh}"
+
+_failures=0
+_ok()  { echo "  ok   — $1"; }
+_bad() { echo "  FAIL — $1"; _failures=$((_failures + 1)); }
+
+echo "test_gate_45_selector_parity.sh"
+
+_tmp="$(mktemp -d "${TMPDIR:-/tmp}/hydra-g45-parity.XXXXXX")"
+trap 'rm -rf "${_tmp}"' EXIT
+
+_mkapp() {  # _mkapp <dir> — an app with a css/ and a CLEAN .vue
+    mkdir -p "$1/css" "$1/src"
+    printf '{"name":"fx","menu":[]}\n' > "$1/src/manifest.json"
+    cat > "$1/src/Clean.vue" <<'VUE'
+<template>
+	<div class="x">hi</div>
+</template>
+<script>
+export default { name: 'Clean' }
+</script>
+<style scoped>
+.x { color: red; }
+</style>
+VUE
+    (
+        cd "$1" || exit 1
+        git init -q .
+        git add -A
+        git -c user.email=t@t -c user.name=t commit -qm init
+    ) >/dev/null 2>&1
+}
+
+# Written to a FILE, not a variable: `$(_run45 …)` is a subshell and an
+# assignment made inside it never reaches the caller.
+_LAST_LOG_PTR="${_tmp}/last-log-path"
+_run45() {  # _run45 <appdir> -> echoes the gate-45 verdict line
+    local logs="${_tmp}/logs.$$.${RANDOM}"
+    mkdir -p "${logs}"
+    printf '%s' "${logs}/hydra-gate-prefers-reduced-motion.log" > "${_LAST_LOG_PTR}"
+    (
+        cd "$1" || exit 1
+        git add -A >/dev/null 2>&1
+        git -c user.email=t@t -c user.name=t commit -qm wip >/dev/null 2>&1
+        HYDRA_GATE_LOG_DIR="${logs}" bash "${_runner}" . 2>/dev/null
+    ) | grep -E '^\[gate-45\]' || true
+}
+
+_assert() {  # _assert <label> <expected-substring> <actual>
+    case "$3" in
+        *"$2"*) _ok "$1" ;;
+        *)      _bad "$1 — got: $3" ;;
+    esac
+}
+
+_log_has() {  # _log_has <label> <substring> — the finding must NAME the selector
+    if grep -qF -- "$2" "$(cat "${_LAST_LOG_PTR}")" 2>/dev/null; then
+        _ok "$1"
+    else
+        _bad "$1 — log does not contain '$2': $(cat "$(cat "${_LAST_LOG_PTR}")" 2>/dev/null)"
+    fi
+}
+
+# ---------------------------------------------------------------------------
+# P1 — the thematiq shape. This is theme.css:419 and :1024 at 6dcbbaf9 with the
+# non-button selectors removed; the file's own comment above the reset block
+# explains why `*` was not an option and why the selectors must be repeated.
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p1"
+_mkapp "${_app}"
+cat > "${_app}/css/theme.css" <<'CSS'
+.button-vue:not(.action-button),
+.button-vue:not(.action-button) .button-vue__text,
+button:not(.action-button),
+.button {
+	transition:
+		background-color var(--nldesign-animation-quick) ease,
+		border-color var(--nldesign-animation-quick) ease,
+		color var(--nldesign-animation-quick) ease !important;
+}
+
+/* Every motion declaration in this file is `!important` and carries class- or
+   attribute-level specificity. A universal `*` reset therefore does NOT
+   override them. So the selectors are repeated verbatim below — equal
+   specificity, later in source order. Keep this block in step. */
+@media (prefers-reduced-motion: reduce) {
+	.button-vue,
+	button,
+	.button {
+		transition: none !important;
+		animation: none !important;
+	}
+}
+CSS
+_assert "P1  reset that stopped naming the !important motion selectors → FAIL" "FAIL" "$(_run45 "${_app}")"
+_log_has "P1  the finding names the uncovered selector" "selector=.button-vue:not(.action-button)"
+_log_has "P1  …and the descendant one" "selector=.button-vue:not(.action-button) .button-vue__text"
+_log_has "P1  …and the bare-element one" "selector=button:not(.action-button)"
+if grep -qF -- "selector=.button " "$(cat "${_LAST_LOG_PTR}")" 2>/dev/null || grep -qE -- 'selector=\.button$' "$(cat "${_LAST_LOG_PTR}")" 2>/dev/null; then
+    _bad "P1  .button IS covered by the reset and must not be reported"
+else
+    _ok "P1  .button, which the reset still names, is not reported"
+fi
+
+# P2 — CONTROL. Same file, reset mirrors the selectors (this is 67caeb85's shape).
+_app="${_tmp}/p2"
+_mkapp "${_app}"
+cat > "${_app}/css/theme.css" <<'CSS'
+.button-vue:not(.action-button),
+.button-vue:not(.action-button) .button-vue__text,
+button:not(.action-button),
+.button {
+	transition: background-color 0.2s ease, color 0.2s ease !important;
+}
+@media (prefers-reduced-motion: reduce) {
+	.button-vue:not(.action-button),
+	.button-vue:not(.action-button) .button-vue__text,
+	button:not(.action-button),
+	.button {
+		transition: none !important;
+		animation: none !important;
+	}
+}
+CSS
+_assert "P2  control: the reset names every motion selector → PASS" "PASS" "$(_run45 "${_app}")"
+
+# ---------------------------------------------------------------------------
+# P3 — importance beats specificity: a plain `.card:hover` motion is overridden
+# by `.card { transition: none !important }` even though `.card` is less specific.
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p3"
+_mkapp "${_app}"
+cat > "${_app}/css/card.css" <<'CSS'
+.card:hover { transition: box-shadow 0.3s ease; }
+@media (prefers-reduced-motion: reduce) {
+	.card { transition: none !important; }
+}
+CSS
+_assert "P3  a less specific !important guard covers a plain motion → PASS" "PASS" "$(_run45 "${_app}")"
+
+# P3b — and with both plain, `.card:hover` (0,2,0) beats `.card` (0,1,0): the
+# motion stays on screen with the fallback right there in the file.
+_app="${_tmp}/p3b"
+_mkapp "${_app}"
+cat > "${_app}/css/card.css" <<'CSS'
+.card:hover { transition: box-shadow 0.3s ease; }
+@media (prefers-reduced-motion: reduce) {
+	.card { transition: none; }
+}
+CSS
+_assert "P3b a less specific PLAIN guard does not cover a more specific plain motion → FAIL" "FAIL" "$(_run45 "${_app}")"
+
+# ---------------------------------------------------------------------------
+# P4 — the universal reset: covers plain motion (ARM 6 of the scope suite,
+# unchanged), covers NO !important motion (`*` has specificity 0).
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p4"
+_mkapp "${_app}"
+cat > "${_app}/css/main.css" <<'CSS'
+.spinner { animation: spin 1s linear infinite; }
+.btn { transition: background-color 0.3s ease; }
+@media (prefers-reduced-motion: reduce) {
+	*, *::before, *::after {
+		animation-duration: 0.01ms !important;
+		transition-duration: 0.01ms !important;
+	}
+}
+CSS
+_assert "P4  a universal !important reset covers plain motion → PASS" "PASS" "$(_run45 "${_app}")"
+
+_app="${_tmp}/p4b"
+_mkapp "${_app}"
+cat > "${_app}/css/main.css" <<'CSS'
+.spinner { animation: spin 1s linear infinite !important; }
+@media (prefers-reduced-motion: reduce) {
+	*, *::before, *::after {
+		animation-duration: 0.01ms !important;
+		transition-duration: 0.01ms !important;
+	}
+}
+CSS
+_assert "P4b a universal reset does NOT cover an !important motion → FAIL" "FAIL" "$(_run45 "${_app}")"
+_log_has "P4b the finding says why" "(!important"
+
+# ---------------------------------------------------------------------------
+# P5 — the inverse idiom: motion that only exists when motion is wanted.
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p5"
+_mkapp "${_app}"
+cat > "${_app}/css/main.css" <<'CSS'
+@media (prefers-reduced-motion: no-preference) {
+	.drawer { transition: transform 0.3s ease; }
+	.spinner { animation: spin 1s linear infinite; }
+}
+CSS
+_assert "P5  motion declared inside no-preference is guarded by construction → PASS" "PASS" "$(_run45 "${_app}")"
+
+# ---------------------------------------------------------------------------
+# P6 — the duration-token convention (atom-design): the reduced-motion block
+# zeroes the token every motion declaration reads, and names no selector.
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p6"
+_mkapp "${_app}"
+cat > "${_app}/css/tokens.css" <<'CSS'
+:root { --am-dur: 300ms; }
+.mock { transition: opacity var(--am-dur) ease; }
+.mock__bar { animation: slide var(--am-dur) linear infinite; }
+@media (prefers-reduced-motion: reduce) {
+	:root { --am-dur: 0ms; }
+}
+CSS
+_assert "P6  a duration token zeroed in the reduced-motion block covers its users → PASS" "PASS" "$(_run45 "${_app}")"
+
+# ---------------------------------------------------------------------------
+# P7 — the markup arm judges per selector too.
+# ---------------------------------------------------------------------------
+_vue_with_guard() {  # _vue_with_guard <appdir> <guard-selector>
+    cat > "$1/src/Motion.vue" <<VUE
+<template>
+	<div class="m">hi</div>
+</template>
+<script>
+export default { name: 'Motion' }
+</script>
+<style scoped>
+.m { transition: opacity 0.4s ease; }
+@media (prefers-reduced-motion: reduce) {
+	$2 { transition: none; }
+}
+</style>
+VUE
+}
+_app="${_tmp}/p7a"
+_mkapp "${_app}"
+_vue_with_guard "${_app}" ".other"
+_assert "P7  a <style> block guarding .other does not guard .m → FAIL" "FAIL" "$(_run45 "${_app}")"
+_log_has "P7  the finding is attributed to the <style> block" "<style> rule=motion-selector-not-overridden"
+
+_app="${_tmp}/p7b"
+_mkapp "${_app}"
+_vue_with_guard "${_app}" ".m"
+_assert "P7b the same block guarding .m → PASS" "PASS" "$(_run45 "${_app}")"
+
+# ---------------------------------------------------------------------------
+# P8 — SCSS nesting: `&:hover` is `.btn:hover`, and is matched as such.
+# ---------------------------------------------------------------------------
+_scss_app() {  # _scss_app <appdir> <guard-selector>
+    mkdir -p "$1/src/styles"
+    cat > "$1/src/styles/btn.scss" <<SCSS
+.btn {
+	color: red;
+	&:hover { transition: background-color 0.2s ease; }
+}
+@media (prefers-reduced-motion: reduce) {
+	$2 { transition: none; }
+}
+SCSS
+}
+_app="${_tmp}/p8a"
+_mkapp "${_app}"
+_scss_app "${_app}" ".btn:hover"
+_assert "P8  nested &:hover resolves to .btn:hover and matches the guard → PASS" "PASS" "$(_run45 "${_app}")"
+
+_app="${_tmp}/p8b"
+_mkapp "${_app}"
+_scss_app "${_app}" ".btn"
+_assert "P8b a plain .btn guard does not override the more specific .btn:hover → FAIL" "FAIL" "$(_run45 "${_app}")"
+_log_has "P8b the resolved selector is what gets reported" "selector=.btn:hover"
+
+# ---------------------------------------------------------------------------
+# P9 — a comma inside :is() / :not() is not a selector separator.
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p9"
+_mkapp "${_app}"
+cat > "${_app}/css/is.css" <<'CSS'
+.x:is(.a, .b) { transition: color 0.2s ease; }
+@media (prefers-reduced-motion: reduce) {
+	.x:is(.a, .b) { transition: none; }
+}
+CSS
+_assert "P9  :is(.a, .b) is matched whole → PASS" "PASS" "$(_run45 "${_app}")"
+
+# ---------------------------------------------------------------------------
+# P10 — the ancestor boost: `html .btn` is more specific than `.btn`, so it
+# overrides even an !important motion when it is !important itself.
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p10"
+_mkapp "${_app}"
+cat > "${_app}/css/boost.css" <<'CSS'
+.btn { transition: color 0.2s ease !important; }
+@media (prefers-reduced-motion: reduce) {
+	html .btn { transition: none !important; }
+}
+CSS
+_assert "P10 an html-prefixed !important guard covers an !important motion → PASS" "PASS" "$(_run45 "${_app}")"
+
+# ---------------------------------------------------------------------------
+# P11 — the repo-wide universal reset (pre-pass flag) is a `*` guard, not an
+# exemption: it covers plain motion in another file and no !important motion.
+# ---------------------------------------------------------------------------
+_reset_file() {
+    cat > "$1/css/reset.css" <<'CSS'
+@media (prefers-reduced-motion: reduce) {
+	*, *::before, *::after {
+		animation-duration: 0.01ms !important;
+		transition-duration: 0.01ms !important;
+	}
+}
+CSS
+}
+_app="${_tmp}/p11a"
+_mkapp "${_app}"
+_reset_file "${_app}"
+printf '.spinner { animation: spin 1s linear infinite; }\n' > "${_app}/css/motion.css"
+_assert "P11 a universal reset in another file covers plain motion elsewhere → PASS" "PASS" "$(_run45 "${_app}")"
+
+_app="${_tmp}/p11b"
+_mkapp "${_app}"
+_reset_file "${_app}"
+printf '.spinner { animation: spin 1s linear infinite !important; }\n' > "${_app}/css/motion.css"
+_assert "P11b …and does not cover !important motion elsewhere → FAIL" "FAIL" "$(_run45 "${_app}")"
+_log_has "P11b the finding lands on the motion file, not the reset" "css/motion.css"
+
+echo ""
+if [ "${_failures}" -eq 0 ]; then
+    echo "test_gate_45_selector_parity.sh: ALL GREEN"
+    exit 0
+fi
+echo "test_gate_45_selector_parity.sh: ${_failures} FAILURE(S)"
+exit 1
diff --git a/hydra-gates/scripts/run-hydra-gates.sh b/hydra-gates/scripts/run-hydra-gates.sh
index e076a68a..f6161468 100755
--- a/hydra-gates/scripts/run-hydra-gates.sh
+++ b/hydra-gates/scripts/run-hydra-gates.sh
@@ -7719,14 +7719,56 @@ try:
 except Exception:
     sys.exit(0)
 
-# A repo-wide universal reduced-motion reset covers every stylesheet AND every
-# scoped <style> block (it is `*` + `!important`), so it globally guards. See
-# the pre-pass in the runner for why this is not diff-scoped.
-if os.environ.get('HYDRA_RM_GLOBAL_GUARD') == '1':
-    sys.exit(0)
+# PRESENCE IS NOT COVERAGE (thematiq#604, 2026-09-17).
+#
+# Until 2026-09-21 this checker asked one question per file: does a
+# `@media (prefers-reduced-motion …)` block exist anywhere in it? One did in
+# thematiq's css/systems/nldesign/theme.css, so the gate said PASS — at
+# `6dcbbaf9`, where a commit had added `:not(.action-button)` to four
+# `!important` motion selectors while the reset block below them kept the
+# bare `.button-vue, button, .button`. Equal specificity before, so the reset
+# won on source order; strictly less specific after, so it lost the cascade
+# on every button in the app while the block that was supposed to stop the
+# motion sat right there in the file. The gate said PASS again at `67caeb85`,
+# after the selectors were mirrored. Same verdict on the broken and the fixed
+# file: the gate was not observing the property it is named after.
+#
+# So the question is now asked per SELECTOR. Every selector that carries a
+# motion declaration must be overridden by some rule inside a reduced-motion
+# block, under the cascade's actual rules:
+#
+#   * equal importance → the MORE SPECIFIC selector wins, then source order
+#     (the guard is later in the file, so equal specificity is enough);
+#   * unequal importance → `!important` wins regardless of specificity.
+#
+# Which gives the four shapes below (`M` = motion selector, `G` = guard):
+#
+#   G == M                       covered, unless M is !important and G is not
+#   G extends M (`.btn:not(.x)`) covered, same condition — G is more specific
+#   M extends G (`.btn:hover`)   covered only when G is !important and M is not
+#   G is `*`                     covered only when G is !important and M is not
+#
+# `*` has specificity 0. The repo-wide universal reset the pre-pass detects
+# (HYDRA_RM_GLOBAL_GUARD) is therefore a `*` guard fed into the same check,
+# not an early exit: it silences every plain motion declaration in the repo
+# and NONE of the `!important` ones — which is exactly what thematiq's own
+# comment above its reset block says, and why that file repeats its selectors
+# verbatim instead of writing `*`.
+#
+# Two idioms that are correct without a matching selector are recognised as
+# such: `@media (prefers-reduced-motion: no-preference) { …motion… }` (the
+# motion itself is conditional), and a duration token —
+# `transition: opacity var(--dur)` with `--dur: 0ms` redefined inside the
+# reduced-motion block (the atom-design convention). Nested selectors (SCSS,
+# CSS Nesting) resolve `&` against their parent before matching.
+GLOBAL_GUARD = os.environ.get('HYDRA_RM_GLOBAL_GUARD') == '1'
 
 STYLESHEET = re.compile(r'\.(css|scss|sass|less)$', re.IGNORECASE)
 MOTION = re.compile(r'\b(transition|animation)\s*:\s*([^;}]*)', re.IGNORECASE)
+# Any motion-family property inside a reduced-motion block makes that rule a
+# guard for its selectors — `transition-duration: 0.01ms !important` is how
+# the universal reset is written, and it never spells `transition:` in full.
+MOTION_PROP = re.compile(r'\b(transition|animation)(?:-[a-z-]+)?\s*:', re.IGNORECASE)
 
 # THE GUARD MUST RECOGNISE THE MEDIA QUERIES PEOPLE ACTUALLY WRITE (#287).
 #
@@ -7737,6 +7779,8 @@ MOTION = re.compile(r'\b(transition|animation)\s*:\s*([^;}]*)', re.IGNORECASE)
 # All three are correct, and all three would have been reported as findings the
 # moment stylesheets came into scope — a false-positive engine.
 GUARD = re.compile(r'@media[^{]*prefers-reduced-motion', re.IGNORECASE)
+CUSTOM_PROP = re.compile(r'(--[\w-]+)\s*:')
+VAR_REF = re.compile(r'var\(\s*(--[\w-]+)')
 
 # A COMMENTED-OUT DECLARATION IS NOT A DECLARATION (#294, same lesson).
 def _mask_comments(text, scss):
@@ -7747,19 +7791,118 @@ def _mask_comments(text, scss):
         text = re.sub(r'(?<!:)//[^\n]*', lambda m: ' ' * len(m.group(0)), text)
     return text
 
-def _motion_without_guard(block):
-    """True when the block animates something and never guards it.
+def _split_commas(s):
+    """Split a selector list on top-level commas only.
+
+    `:not(.a, .b)` and `:is(.a, .b)` keep theirs — splitting inside the
+    parentheses would manufacture two selectors that exist nowhere."""
+    parts, depth, cur = [], 0, []
+    for ch in s:
+        if ch == '(':
+            depth += 1
+        elif ch == ')':
+            depth = max(0, depth - 1)
+        if ch == ',' and depth == 0:
+            parts.append(''.join(cur))
+            cur = []
+        else:
+            cur.append(ch)
+    parts.append(''.join(cur))
+    return [p.strip() for p in parts if p.strip()]
+
+def _resolve(head, parents):
+    """Nested selectors: `&:hover` under `.btn` is `.btn:hover`; a bare `.icon`
+    under `.btn` is `.btn .icon`. A top-level rule has no parents."""
+    children = _split_commas(head)
+    if not parents:
+        return children
+    out = []
+    for p in parents:
+        for c in children:
+            out.append(c.replace('&', p) if '&' in c else p + ' ' + c)
+    return out
+
+def _rules(text):
+    """Flatten a (comment-masked) stylesheet into (selectors, declarations, state).
+
+    `state` is 'reduce' inside a `prefers-reduced-motion: reduce` block,
+    'nopref' inside the `no-preference` idiom, '' otherwise. Media / supports /
+    layer / container blocks pass their contents through; every other at-rule
+    body (`@keyframes`, `@font-face`, …) is parsed and discarded — `from {}` and
+    `50% {}` are not selectors."""
+    results = []
+    n = len(text)
+
+    def block(pos, parents, state):
+        decls, prelude = [], []
+        while pos < n:
+            ch = text[pos]
+            if ch == '}':
+                return pos + 1, ''.join(decls) + ''.join(prelude)
+            if ch == '{':
+                head = ''.join(prelude).strip()
+                prelude = []
+                low = head.lower()
+                if low.startswith('@'):
+                    inner_state = state
+                    if 'prefers-reduced-motion' in low:
+                        inner_state = 'nopref' if 'no-preference' in low else 'reduce'
+                    if low.startswith(('@media', '@supports', '@layer', '@container')):
+                        pos, inner = block(pos + 1, parents, inner_state)
+                        if parents and inner.strip():
+                            # `.a { @media (prefers-reduced-motion: reduce) { transition: none } }`
+                            results.append((parents, inner, inner_state))
+                    else:
+                        mark = len(results)
+                        pos, _ = block(pos + 1, None, inner_state)
+                        del results[mark:]
+                else:
+                    sels = _resolve(head, parents)
+                    pos, inner = block(pos + 1, sels, state)
+                    results.append((sels, inner, state))
+                continue
+            if ch == ';':
+                decls.append(''.join(prelude) + ';')
+                prelude = []
+            else:
+                prelude.append(ch)
+            pos += 1
+        return pos, ''.join(decls) + ''.join(prelude)
+
+    block(0, None, '')
+    return results
+
+def _motion_decls(decls):
+    """Yield (important, value) per declaration that animates something.
 
     `transition: none` / `animation: none` are how a reduced-motion fallback
     is WRITTEN. Counting them as motion would make every correct guard block
     its own finding."""
-    if GUARD.search(block):
-        return False
-    for m in MOTION.finditer(block):
-        value = m.group(2).strip().lower()
-        if value.split()[0:1] in ([], ['none'], ['unset'], ['initial'], ['inherit']):
+    for m in MOTION.finditer(decls):
+        value = m.group(2).strip()
+        if value.lower().split()[0:1] in ([], ['none'], ['unset'], ['initial'], ['inherit']):
             continue
-        return True
+        yield ('!important' in value.lower(), value)
+
+def _norm(sel):
+    sel = re.sub(r'\s+', ' ', sel.strip())
+    return re.sub(r'\s*([>+~])\s*', r'\1', sel)
+
+def _extends(longer, shorter):
+    """`.btn:hover` and `button:not(.x)` extend `.btn` / `button` — same compound,
+    one more simple selector. `.btn-primary` (a different class) and `.btn .icon`
+    (a descendant — a different element) do not."""
+    return longer.startswith(shorter) and len(longer) > len(shorter) and longer[len(shorter)] in ':.[#'
+
+def _covered(m, mi, guards):
+    """Does some guard override motion selector `m` (important=`mi`) under the cascade?"""
+    for g, gi in guards:
+        if mi and not gi:
+            continue                     # an !important motion beats every plain guard
+        if g == m or _extends(g, m) or g in ('html ' + m, 'body ' + m, ':root ' + m, 'html body ' + m):
+            return True                  # at least as specific, not less important → later in source wins
+        if gi and not mi and (g == '*' or _extends(m, g)):
+            return True                  # less specific, but !important against a plain declaration
     return False
 
 def _is_minified(text):
@@ -7773,18 +7916,57 @@ def _is_minified(text):
     something no hand-written stylesheet has and every minified one does."""
     return any(len(line) > 500 for line in text.split('\n'))
 
+def _check(block_text, scss, where):
+    text = _mask_comments(block_text, scss)
+    rules = _rules(text)
+    guards, tokens, motion = [], set(), []
+    for sels, decls, state in rules:
+        if state == 'reduce':
+            tokens.update(CUSTOM_PROP.findall(decls))
+            if MOTION_PROP.search(decls):
+                gi = '!important' in decls.lower()
+                guards.extend((_norm(s), gi) for s in sels)
+        elif state == '':
+            for mi, value in _motion_decls(decls):
+                motion.append((sels, mi, VAR_REF.findall(value)))
+    if not rules and MOTION.search(text):
+        # Brace-less syntax (indented .sass): no selectors to match, so fall
+        # back to the presence question this checker asked before 2026-09-21.
+        motion.append((['<indented syntax>'], False, []))
+        if GUARD.search(text) or GLOBAL_GUARD:
+            return []
+    if not motion:
+        return []
+    if not GUARD.search(text) and not GLOBAL_GUARD:
+        return [f'{fname}: {where} rule=motion-without-reduced-motion-fallback']
+    if GLOBAL_GUARD:
+        guards.append(('*', True))
+    findings, seen = [], set()
+    for sels, mi, refs in motion:
+        if refs and all(r in tokens for r in refs):
+            continue                     # every duration token it uses is zeroed in the reduced-motion block
+        for s in sels:
+            s = _norm(s)
+            if s in seen:
+                continue
+            if not _covered(s, mi, guards):
+                seen.add(s)
+                findings.append(f'{fname}: {where} rule=motion-selector-not-overridden-by-reduced-motion-fallback'
+                                f' selector={s}' + (' (!important — the fallback needs equal or higher specificity, also !important)' if mi else ''))
+    return findings
+
 if STYLESHEET.search(fname):
     if _is_minified(src):
         sys.exit(0)
     scss = not fname.lower().endswith('.css')
-    if _motion_without_guard(_mask_comments(src, scss)):
-        print(f'{fname}: stylesheet rule=motion-without-reduced-motion-fallback')
+    for line in _check(src, scss, 'stylesheet'):
+        print(line)
 else:
     for m in re.finditer(r'<style\b([^>]*)>(.*?)</style>', src, re.IGNORECASE | re.DOTALL):
-        attrs, block = m.group(1), m.group(2)
+        attrs, blk = m.group(1), m.group(2)
         scss = bool(re.search(r'lang\s*=\s*["\']?(scss|sass|less)', attrs, re.IGNORECASE))
-        if _motion_without_guard(_mask_comments(block, scss)):
-            print(f'{fname}: <style> rule=motion-without-reduced-motion-fallback')
+        for line in _check(blk, scss, '<style>'):
+            print(line)
 PYRM
         # `$?` immediately after a heredoc-fed command is the command's status;
         # captured into a named variable rather than tested inline so
@@ -7802,7 +7984,7 @@ PYRM
     elif [ "${_rm_fail}" -eq 0 ]; then
         _pass 45 "prefers-reduced-motion"
     else
-        _fail 45 "prefers-reduced-motion" "${_rm_fail} <style> block(s)/stylesheet(s) with motion but no reduced-motion fallback — see ${_rm_log}"
+        _fail 45 "prefers-reduced-motion" "${_rm_fail} finding(s): motion with no reduced-motion fallback, or a motion selector the fallback does not override under the cascade — see ${_rm_log}"
     fi
 fi
 
diff --git a/hydra-gates/scripts/test-fixtures/gate-acceptance/COVERED-ELSEWHERE.md b/hydra-gates/scripts/test-fixtures/gate-acceptance/COVERED-ELSEWHERE.md
index e5103d3d..8bc50c31 100644
--- a/hydra-gates/scripts/test-fixtures/gate-acceptance/COVERED-ELSEWHERE.md
+++ b/hydra-gates/scripts/test-fixtures/gate-acceptance/COVERED-ELSEWHERE.md
@@ -87,7 +87,7 @@ with the missing half named.
 | gate-42 | link-text-quality | `test_gate_a11y_markup_scope.sh` | same 12-gate planted/clean pair; subject: non-descriptive link text. Second planted arm in `test_gate_a11y_helper_wiring.sh` |
 | gate-43 | table-headers | `test_gate_a11y_markup_scope.sh` | same 12-gate planted/clean pair; subject: a table with no `th scope`. Second planted arm in `test_gate_a11y_helper_wiring.sh` |
 | gate-44 | autocomplete-attr | `test_gate_a11y_markup_scope.sh` | same 12-gate planted/clean pair; subject: a semantic input with no `autocomplete`. Second planted arm in `test_gate_a11y_helper_wiring.sh` |
-| gate-45 | prefers-reduced-motion | `test_gate_45_stylesheet_scope.sh` + `test_gate_45_to_55_acceptance.sh` + `test_gate_a11y_markup_scope.sh` | planted: *"a css/ stylesheet with motion and no guard → FAIL"*, *"a `<style>` block with unguarded motion is still a FAIL"*, *"gate-45 sees a `<style>` transition in a PHP template with no src/ → FAIL"*. Clean: *"gate-45 accepts a template that ships the fallback → PASS"*, and a universal-`*`-reset control (*"without the reset, that file is a finding"*) |
+| gate-45 | prefers-reduced-motion | `test_gate_45_stylesheet_scope.sh` + `test_gate_45_selector_parity.sh` + `test_gate_45_to_55_acceptance.sh` + `test_gate_a11y_markup_scope.sh` | planted: *"a css/ stylesheet with motion and no guard → FAIL"*, *"a `<style>` block with unguarded motion is still a FAIL"*, *"gate-45 sees a `<style>` transition in a PHP template with no src/ → FAIL"*, and — the per-selector arm — *"reset that stopped naming the !important motion selectors → FAIL"* with the finding required to name `.button-vue:not(.action-button)` (thematiq#604's shape). Clean: *"gate-45 accepts a template that ships the fallback → PASS"*, a universal-`*`-reset control (*"without the reset, that file is a finding"*), and the parity suite's controls for every correct idiom: mirrored selectors, an `!important` guard over a plain motion, `no-preference`, a zeroed duration token, `&`-nesting, `:is(.a, .b)`, an `html`-prefixed guard |
 | gate-46 | spec-anchor-existence | `test_gate_46_tests_scope.sh` | scaffolded in-suite — planted: *"a dangling #T14 anchor in tests/ → FAIL"* + *"the finding NAMES the test file"*, *"a target file that never existed, tagged in tests/ → FAIL"* classified as `target file not found`, *"a dangling anchor in lib/ is still a FAIL"*. Clean: *"a REAL #T02 anchor, resolved through the date-prefixed archive → PASS"* |
 | gate-50 | security-config-fail-mode | `test_gate_45_to_55_acceptance.sh` | thirteen scaffolded arms — planted: an unguarded read whose app id is a class constant, one whose id is a literal, a multi-line read with no guard, the opencatalogi#86 `$this->appName` shape, and an arrow closure's `=>`. Clean: a compound `if ($a === '' \|\| $b === '')` guard, a boolean-return guard, a PHPCS-formatted multi-line read, an on-line emptiness check, a variable app id, and the array-literal value position (demotion asserted by `wc -c` on the `.notes` sidecar, so "demoted" is distinguishable from "never looked") |
 | gate-53 | effective-manifest-crossref | `test_gate_45_to_55_acceptance.sh` | `test-fixtures/effective-manifest` driven through the wrapper — planted: *"gate-53 blocks the PR that removes the last reference to a registered component → FAIL"* + *"gate-53 NAMES the orphaned component"*. Clean: *"accepts removing the component and its registry entry together → PASS"*, *"leaves a PRE-EXISTING orphan advisory (WARN), not blocking → PASS"*. ⚠️ the suite PREFLIGHTS ajv and aborts rather than reporting a wiring fault as a gate defect |

From 0c1c449a051059f57a8fc86f8d7dceaeda6544c7 Mon Sep 17 00:00:00 2001
From: WilcoLouwerse <wilco@louwerse.com>
Date: Mon, 21 Sep 2026 12:15:52 +0200
Subject: [PATCH 2/2] fix(gate-45): the cascade model disagreed with the
 cascade in six places
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Round two of #788, all six from the review of the first round. Each one is a
case where the checker that was written to stop asserting a property and start
observing it was still asserting one.

- Source order is carried through `_rules` instead of assumed. The comment said
  "the guard is later in the file, so equal specificity is enough"; `_covered`
  compared no positions, so a reduced-motion block placed ABOVE its motion at
  equal specificity and importance counted as an override. It does not — the
  later declaration wins, which is the thematiq#604 shape produced by ordering
  rather than by specificity.

- An ancestor-scoped guard is a guard whatever the ancestor is named.
  `html`/`body`/`:root` were the only ones accepted, so `:root .btn` and
  `.app-wrapper .btn` — the same shape, the same specificity — disagreed, and
  the second was reported although it wins the cascade outright. `_descends`
  replaces the four special cases with one combinator-boundary test; `.xbtn`
  does not end on a boundary and stays unrelated to `.btn`. This credits a
  guard whose ancestor the checker cannot prove every element sits under. That
  is the deliberate trade: gate-45 has no `exclude` hatch, so a false positive
  on a working guard is unappealable.

- Importance is read per declaration, and a guard covers only its own property
  family. `gi = '!important' in decls.lower()` was per RULE, so a block pairing
  a plain `transition: none` with an `animation: none !important` lent the
  transition an importance it did not have — and an animation guard was
  credited with stopping a transition it cannot touch.

- A duration token counts as an override only when it is redefined to a
  duration that does not animate. Only the property NAME was read, so
  `--dur: 250ms` inside a reduced-motion block silenced its users. `0.01ms`,
  the universal reset's deliberate hair over zero, still counts.

- A literal duration beside a tokenised one is not covered by the token:
  `transition: opacity var(--dur) ease, transform 0.4s ease` still animates the
  transform however `--dur` is redefined.

- Guards are file-local and that is now written down, next to the universal
  reset that is the one thing crossing files. Behaviour is unchanged; a reader
  told the question is asked per selector will otherwise assume the selector is
  looked up repo-wide.

The suite grows from 24 assertions to 35: P12/P12b, P13, P14/P14b, P15,
P16/P16b, P17. Each new arm was mutation-tested against the runner at a8c8ba9c
— exactly P12, P13, P14, P15, P16 and P17 go red there and every pre-existing
arm stays green, so each control discriminates rather than decorating.

test_gate_45_stylesheet_scope.sh 13/13 and test_gate_a11y_markup_scope.sh stay
green.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../lib/test_gate_45_selector_parity.sh       | 139 ++++++++++++++++
 hydra-gates/scripts/run-hydra-gates.sh        | 150 ++++++++++++++----
 .../gate-acceptance/COVERED-ELSEWHERE.md      |   2 +-
 3 files changed, 260 insertions(+), 31 deletions(-)

diff --git a/hydra-gates/scripts/lib/test_gate_45_selector_parity.sh b/hydra-gates/scripts/lib/test_gate_45_selector_parity.sh
index 12127aac..148d5759 100644
--- a/hydra-gates/scripts/lib/test_gate_45_selector_parity.sh
+++ b/hydra-gates/scripts/lib/test_gate_45_selector_parity.sh
@@ -39,6 +39,21 @@
 #   P9  `:is(.a, .b)` keeps its comma — the selector is matched whole                 → PASS
 #   P10 `html .btn` (ancestor boost) is a MORE specific guard for `.btn`              → PASS
 #   P11 the repo-wide universal reset in ANOTHER file covers plain motion, not !important motion → PASS / FAIL
+#
+# P12-P17 pin the review findings on this suite's own first round (#788), each
+# one a case where the checker disagreed with the cascade it claims to model:
+#
+#   P12 an ancestor-scoped guard is a guard whatever the ancestor is named      → PASS
+#   P12b …but only on a combinator boundary: `.xbtn` does not guard `.btn`      → FAIL
+#   P13 importance is read per DECLARATION: a plain `transition: none` beside an
+#       `animation: none !important` does not inherit its importance            → FAIL
+#   P14 EQUAL specificity and importance is decided by source order — a guard
+#       block placed ABOVE the motion does not override it                      → FAIL
+#   P14b …the same file with the block below the motion                         → PASS
+#   P15 a literal duration beside a zeroed token still animates                 → FAIL
+#   P16 a token redefined to a duration that still animates is not an override  → FAIL
+#   P16b …and `0.01ms`, the universal reset's hair-over-zero, still is          → PASS
+#   P17 a guard only covers its OWN family: `animation` stops no `transition`   → FAIL
 
 set -u
 
@@ -367,6 +382,130 @@ printf '.spinner { animation: spin 1s linear infinite !important; }\n' > "${_app
 _assert "P11b …and does not cover !important motion elsewhere → FAIL" "FAIL" "$(_run45 "${_app}")"
 _log_has "P11b the finding lands on the motion file, not the reset" "css/motion.css"
 
+# ---------------------------------------------------------------------------
+# P12 — an ancestor boost is more specific whatever the ancestor is called.
+# `html`, `body` and `:root` used to be the only ones accepted, so `:root .btn`
+# and `.app-wrapper .btn` — identical in shape and in specificity — disagreed.
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p12"
+_mkapp "${_app}"
+cat > "${_app}/css/scoped.css" <<'CSS'
+.btn { transition: background-color 0.3s ease; }
+@media (prefers-reduced-motion: reduce) {
+	.app-wrapper .btn { transition: none; }
+}
+CSS
+_assert "P12 a guard scoped by an arbitrary ancestor still guards → PASS" "PASS" "$(_run45 "${_app}")"
+
+# P12b — CONTROL for the boundary: `.xbtn` ends with `btn` but is a different
+# class, not an ancestor-scoped `.btn`. Without the combinator test this passes.
+_app="${_tmp}/p12b"
+_mkapp "${_app}"
+cat > "${_app}/css/scoped.css" <<'CSS'
+.btn { transition: background-color 0.3s ease; }
+@media (prefers-reduced-motion: reduce) {
+	.xbtn { transition: none; }
+}
+CSS
+_assert "P12b a guard that merely ENDS in the same letters is not a guard → FAIL" "FAIL" "$(_run45 "${_app}")"
+_log_has "P12b the finding names the unguarded selector" "selector=.btn"
+
+# ---------------------------------------------------------------------------
+# P13 — importance is a property of a DECLARATION, not of the block it sits in.
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p13"
+_mkapp "${_app}"
+cat > "${_app}/css/mixed.css" <<'CSS'
+.btn:hover { transition: background-color 0.3s ease; }
+@media (prefers-reduced-motion: reduce) {
+	.btn { transition: none; animation: none !important; }
+}
+CSS
+_assert "P13 a plain guard does not borrow the !important of its neighbour → FAIL" "FAIL" "$(_run45 "${_app}")"
+_log_has "P13 the finding names the still-animating selector" "selector=.btn:hover"
+
+# ---------------------------------------------------------------------------
+# P14 — equal specificity AND equal importance: the later declaration wins, so
+# a reduced-motion block placed above the motion overrides nothing.
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p14"
+_mkapp "${_app}"
+cat > "${_app}/css/order.css" <<'CSS'
+@media (prefers-reduced-motion: reduce) {
+	.btn { transition: none; }
+}
+.btn { transition: background-color 0.3s ease; }
+CSS
+_assert "P14 a guard block ABOVE the motion loses on source order → FAIL" "FAIL" "$(_run45 "${_app}")"
+_log_has "P14 the finding names the selector" "selector=.btn"
+
+# P14b — CONTROL: the identical file with the two rules swapped.
+_app="${_tmp}/p14b"
+_mkapp "${_app}"
+cat > "${_app}/css/order.css" <<'CSS'
+.btn { transition: background-color 0.3s ease; }
+@media (prefers-reduced-motion: reduce) {
+	.btn { transition: none; }
+}
+CSS
+_assert "P14b …and below it, wins → PASS" "PASS" "$(_run45 "${_app}")"
+
+# ---------------------------------------------------------------------------
+# P15 — the token convention covers a declaration only when the token is the
+# ONLY thing setting its duration.
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p15"
+_mkapp "${_app}"
+cat > "${_app}/css/partial.css" <<'CSS'
+:root { --dur: 300ms; }
+.mock { transition: opacity var(--dur) ease, transform 0.4s ease; }
+@media (prefers-reduced-motion: reduce) {
+	:root { --dur: 0ms; }
+}
+CSS
+_assert "P15 a literal duration beside a zeroed token still animates → FAIL" "FAIL" "$(_run45 "${_app}")"
+
+# ---------------------------------------------------------------------------
+# P16 — redefining the token is not the same as zeroing it.
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p16"
+_mkapp "${_app}"
+cat > "${_app}/css/token.css" <<'CSS'
+:root { --dur: 300ms; }
+.mock { transition: opacity var(--dur) ease; }
+@media (prefers-reduced-motion: reduce) {
+	:root { --dur: 250ms; }
+}
+CSS
+_assert "P16 a token redefined to 250ms is not a reduced-motion override → FAIL" "FAIL" "$(_run45 "${_app}")"
+
+# P16b — CONTROL: the universal reset's canonical `0.01ms` must keep counting.
+_app="${_tmp}/p16b"
+_mkapp "${_app}"
+cat > "${_app}/css/token.css" <<'CSS'
+:root { --dur: 300ms; }
+.mock { transition: opacity var(--dur) ease; }
+@media (prefers-reduced-motion: reduce) {
+	:root { --dur: 0.01ms; }
+}
+CSS
+_assert "P16b …and the reset's hair-over-zero 0.01ms still is → PASS" "PASS" "$(_run45 "${_app}")"
+
+# ---------------------------------------------------------------------------
+# P17 — a guard covers its own property family and no other.
+# ---------------------------------------------------------------------------
+_app="${_tmp}/p17"
+_mkapp "${_app}"
+cat > "${_app}/css/family.css" <<'CSS'
+.btn { transition: background-color 0.3s ease; }
+@media (prefers-reduced-motion: reduce) {
+	.btn { animation: none !important; }
+}
+CSS
+_assert "P17 an animation guard stops no transition → FAIL" "FAIL" "$(_run45 "${_app}")"
+_log_has "P17 the finding names the selector" "selector=.btn"
+
+
 echo ""
 if [ "${_failures}" -eq 0 ]; then
     echo "test_gate_45_selector_parity.sh: ALL GREEN"
diff --git a/hydra-gates/scripts/run-hydra-gates.sh b/hydra-gates/scripts/run-hydra-gates.sh
index f6161468..0dc59691 100755
--- a/hydra-gates/scripts/run-hydra-gates.sh
+++ b/hydra-gates/scripts/run-hydra-gates.sh
@@ -7737,17 +7737,40 @@ except Exception:
 # motion declaration must be overridden by some rule inside a reduced-motion
 # block, under the cascade's actual rules:
 #
-#   * equal importance → the MORE SPECIFIC selector wins, then source order
-#     (the guard is later in the file, so equal specificity is enough);
+#   * equal importance → the MORE SPECIFIC selector wins; on EQUAL specificity
+#     the later declaration wins, so `G == M` additionally requires the guard
+#     to sit after the motion in the file (source position is carried through
+#     `_rules`, not assumed — the assumption was this checker's own residue of
+#     the defect it exists to catch);
 #   * unequal importance → `!important` wins regardless of specificity.
 #
 # Which gives the four shapes below (`M` = motion selector, `G` = guard):
 #
-#   G == M                       covered, unless M is !important and G is not
-#   G extends M (`.btn:not(.x)`) covered, same condition — G is more specific
-#   M extends G (`.btn:hover`)   covered only when G is !important and M is not
+#   G == M                       covered when G is later in the file, unless M
+#                                is !important and G is not
+#   G extends M (`.btn:not(.x)`) covered, order-independent — G is more specific
+#   G descends to M (`.wrap .btn`, `html .btn`, `.wrap>.btn`)
+#                                same — an ancestor boost is more specific
+#   M extends/descends to G      covered only when G is !important and M is not
 #   G is `*`                     covered only when G is !important and M is not
 #
+# An ancestor-scoped guard is credited although this checker cannot know that
+# every element the motion selector matches sits under that ancestor. That is
+# deliberate: specificity is what the cascade weighs, the gate has no `exclude`
+# hatch, and a false positive on a working guard is unappealable. `html`,
+# `body` and `:root` used to be the only ancestors accepted, which made two
+# guards of identical shape — `:root .btn` and `.app-wrapper .btn` — disagree.
+#
+# A guard only ever covers its OWN property family: `animation: none !important`
+# in a reduce block stops no transition, so guards and motion are matched on
+# `transition` vs `animation` and importance is read per declaration, not per
+# rule.
+#
+# Guards are FILE-LOCAL. The only guard that crosses files is the universal
+# reset below; a repo that centralises its overrides in a dedicated stylesheet
+# naming real selectors is still judged file by file, and each motion file is
+# reported under the presence rule exactly as it was before 2026-09-21.
+#
 # `*` has specificity 0. The repo-wide universal reset the pre-pass detects
 # (HYDRA_RM_GLOBAL_GUARD) is therefore a `*` guard fed into the same check,
 # not an early exit: it silences every plain motion declaration in the repo
@@ -7779,8 +7802,42 @@ MOTION_PROP = re.compile(r'\b(transition|animation)(?:-[a-z-]+)?\s*:', re.IGNORE
 # All three are correct, and all three would have been reported as findings the
 # moment stylesheets came into scope — a false-positive engine.
 GUARD = re.compile(r'@media[^{]*prefers-reduced-motion', re.IGNORECASE)
-CUSTOM_PROP = re.compile(r'(--[\w-]+)\s*:')
+CUSTOM_PROP = re.compile(r'(--[\w-]+)\s*:\s*([^;}]*)')
 VAR_REF = re.compile(r'var\(\s*(--[\w-]+)')
+# A duration, in the two units CSS accepts for one. Used twice: a custom
+# property only counts as a reduced-motion override when it is redefined to a
+# duration that does not animate, and a motion declaration only rides on that
+# override when it has no literal duration of its own beside the `var()`.
+TIME = re.compile(r'(\d*\.?\d+)\s*(ms|s)\b', re.IGNORECASE)
+
+def _ms(num, unit):
+    return float(num) * (1000.0 if unit.lower() == 's' else 1.0)
+
+def _nonzero_time(value):
+    """True when the value spells a duration that actually animates."""
+    for num, unit in TIME.findall(value):
+        try:
+            if _ms(num, unit) > 1.0:
+                return True
+        except ValueError:
+            pass
+    return False
+
+def _zeroish(value):
+    """`0`, `0s`, `0ms` and the `0.01ms` of the canonical universal reset — the
+    reset uses a hair over zero on purpose, so that animation events still
+    fire. `--dur: 250ms` inside a reduced-motion block is NOT an override; it
+    used to count as one because only the property NAME was read."""
+    v = value.strip().lower().replace('!important', '').strip()
+    if v in ('0', '0s', '0ms'):
+        return True
+    times = TIME.findall(v)
+    if not times:
+        return False
+    try:
+        return all(_ms(n, u) <= 1.0 for n, u in times)
+    except ValueError:
+        return False
 
 # A COMMENTED-OUT DECLARATION IS NOT A DECLARATION (#294, same lesson).
 def _mask_comments(text, scss):
@@ -7823,7 +7880,10 @@ def _resolve(head, parents):
     return out
 
 def _rules(text):
-    """Flatten a (comment-masked) stylesheet into (selectors, declarations, state).
+    """Flatten a (comment-masked) stylesheet into (selectors, declarations, state, pos).
+
+    `pos` is the offset of the rule's opening brace — source order, which the
+    cascade needs whenever specificity and importance tie.
 
     `state` is 'reduce' inside a `prefers-reduced-motion: reduce` block,
     'nopref' inside the `no-preference` idiom, '' otherwise. Media / supports /
@@ -7840,6 +7900,7 @@ def _rules(text):
             if ch == '}':
                 return pos + 1, ''.join(decls) + ''.join(prelude)
             if ch == '{':
+                start = pos
                 head = ''.join(prelude).strip()
                 prelude = []
                 low = head.lower()
@@ -7851,7 +7912,7 @@ def _rules(text):
                         pos, inner = block(pos + 1, parents, inner_state)
                         if parents and inner.strip():
                             # `.a { @media (prefers-reduced-motion: reduce) { transition: none } }`
-                            results.append((parents, inner, inner_state))
+                            results.append((parents, inner, inner_state, start))
                     else:
                         mark = len(results)
                         pos, _ = block(pos + 1, None, inner_state)
@@ -7859,7 +7920,7 @@ def _rules(text):
                 else:
                     sels = _resolve(head, parents)
                     pos, inner = block(pos + 1, sels, state)
-                    results.append((sels, inner, state))
+                    results.append((sels, inner, state, start))
                 continue
             if ch == ';':
                 decls.append(''.join(prelude) + ';')
@@ -7873,7 +7934,7 @@ def _rules(text):
     return results
 
 def _motion_decls(decls):
-    """Yield (important, value) per declaration that animates something.
+    """Yield (family, important, value) per declaration that animates something.
 
     `transition: none` / `animation: none` are how a reduced-motion fallback
     is WRITTEN. Counting them as motion would make every correct guard block
@@ -7882,7 +7943,7 @@ def _motion_decls(decls):
         value = m.group(2).strip()
         if value.lower().split()[0:1] in ([], ['none'], ['unset'], ['initial'], ['inherit']):
             continue
-        yield ('!important' in value.lower(), value)
+        yield (m.group(1).lower(), '!important' in value.lower(), value)
 
 def _norm(sel):
     sel = re.sub(r'\s+', ' ', sel.strip())
@@ -7894,14 +7955,31 @@ def _extends(longer, shorter):
     (a descendant — a different element) do not."""
     return longer.startswith(shorter) and len(longer) > len(shorter) and longer[len(shorter)] in ':.[#'
 
-def _covered(m, mi, guards):
-    """Does some guard override motion selector `m` (important=`mi`) under the cascade?"""
-    for g, gi in guards:
+def _descends(longer, shorter):
+    """`.app-wrapper .btn`, `html .btn` and `.wrap>.btn` all add an ancestor to
+    `.btn`: strictly more specific, and they match `.btn` elements under that
+    ancestor. `.xbtn` does not end on a combinator boundary and is unrelated."""
+    return (longer.endswith(shorter) and len(longer) > len(shorter)
+            and longer[-len(shorter) - 1] in ' >+~')
+
+def _more_specific(g, m):
+    return _extends(g, m) or _descends(g, m)
+
+def _covered(m, fam, mi, mpos, guards):
+    """Does some guard override motion selector `m` (family=`fam`, important=`mi`,
+    declared at `mpos`) under the cascade?"""
+    for g, gfam, gi, gpos in guards:
+        if gfam != fam:
+            continue                     # an animation guard stops no transition
         if mi and not gi:
             continue                     # an !important motion beats every plain guard
-        if g == m or _extends(g, m) or g in ('html ' + m, 'body ' + m, ':root ' + m, 'html body ' + m):
-            return True                  # at least as specific, not less important → later in source wins
-        if gi and not mi and (g == '*' or _extends(m, g)):
+        if g == m:
+            if gi == mi and gpos < mpos:
+                continue                 # same weight, but the motion is declared later
+            return True
+        if _more_specific(g, m):
+            return True                  # strictly more specific, not less important
+        if gi and not mi and (g == '*' or _more_specific(m, g)):
             return True                  # less specific, but !important against a plain declaration
     return False
 
@@ -7920,19 +7998,24 @@ def _check(block_text, scss, where):
     text = _mask_comments(block_text, scss)
     rules = _rules(text)
     guards, tokens, motion = [], set(), []
-    for sels, decls, state in rules:
+    for sels, decls, state, pos in rules:
         if state == 'reduce':
-            tokens.update(CUSTOM_PROP.findall(decls))
-            if MOTION_PROP.search(decls):
-                gi = '!important' in decls.lower()
-                guards.extend((_norm(s), gi) for s in sels)
+            tokens.update(name for name, value in CUSTOM_PROP.findall(decls) if _zeroish(value))
+            # Per DECLARATION, not per rule: a block that pairs a plain
+            # `transition: none` with an `animation: none !important` grants
+            # importance to the animation guard only.
+            for part in decls.split(';'):
+                mp = MOTION_PROP.search(part)
+                if mp:
+                    gi = '!important' in part.lower()
+                    guards.extend((_norm(s), mp.group(1).lower(), gi, pos) for s in sels)
         elif state == '':
-            for mi, value in _motion_decls(decls):
-                motion.append((sels, mi, VAR_REF.findall(value)))
+            for fam, mi, value in _motion_decls(decls):
+                motion.append((sels, fam, mi, pos, VAR_REF.findall(value), value))
     if not rules and MOTION.search(text):
         # Brace-less syntax (indented .sass): no selectors to match, so fall
         # back to the presence question this checker asked before 2026-09-21.
-        motion.append((['<indented syntax>'], False, []))
+        motion.append((['<indented syntax>'], 'transition', False, 0, [], ''))
         if GUARD.search(text) or GLOBAL_GUARD:
             return []
     if not motion:
@@ -7940,16 +8023,23 @@ def _check(block_text, scss, where):
     if not GUARD.search(text) and not GLOBAL_GUARD:
         return [f'{fname}: {where} rule=motion-without-reduced-motion-fallback']
     if GLOBAL_GUARD:
-        guards.append(('*', True))
+        # The repo-wide reset zeroes both families, and sits in another file —
+        # source order across files is not knowable, so it is placed before
+        # everything and only ever wins on importance, never on order.
+        guards.extend(('*', f, True, -1) for f in ('transition', 'animation'))
     findings, seen = [], set()
-    for sels, mi, refs in motion:
-        if refs and all(r in tokens for r in refs):
-            continue                     # every duration token it uses is zeroed in the reduced-motion block
+    for sels, fam, mi, mpos, refs, value in motion:
+        if refs and all(r in tokens for r in refs) and not _nonzero_time(value):
+            # Every duration token it reads is zeroed in the reduced-motion
+            # block AND it spells no literal duration of its own — a
+            # `transition: opacity var(--dur) ease, transform 0.4s ease` still
+            # animates the transform however the token is redefined.
+            continue
         for s in sels:
             s = _norm(s)
             if s in seen:
                 continue
-            if not _covered(s, mi, guards):
+            if not _covered(s, fam, mi, mpos, guards):
                 seen.add(s)
                 findings.append(f'{fname}: {where} rule=motion-selector-not-overridden-by-reduced-motion-fallback'
                                 f' selector={s}' + (' (!important — the fallback needs equal or higher specificity, also !important)' if mi else ''))
diff --git a/hydra-gates/scripts/test-fixtures/gate-acceptance/COVERED-ELSEWHERE.md b/hydra-gates/scripts/test-fixtures/gate-acceptance/COVERED-ELSEWHERE.md
index 8bc50c31..b110e6a0 100644
--- a/hydra-gates/scripts/test-fixtures/gate-acceptance/COVERED-ELSEWHERE.md
+++ b/hydra-gates/scripts/test-fixtures/gate-acceptance/COVERED-ELSEWHERE.md
@@ -87,7 +87,7 @@ with the missing half named.
 | gate-42 | link-text-quality | `test_gate_a11y_markup_scope.sh` | same 12-gate planted/clean pair; subject: non-descriptive link text. Second planted arm in `test_gate_a11y_helper_wiring.sh` |
 | gate-43 | table-headers | `test_gate_a11y_markup_scope.sh` | same 12-gate planted/clean pair; subject: a table with no `th scope`. Second planted arm in `test_gate_a11y_helper_wiring.sh` |
 | gate-44 | autocomplete-attr | `test_gate_a11y_markup_scope.sh` | same 12-gate planted/clean pair; subject: a semantic input with no `autocomplete`. Second planted arm in `test_gate_a11y_helper_wiring.sh` |
-| gate-45 | prefers-reduced-motion | `test_gate_45_stylesheet_scope.sh` + `test_gate_45_selector_parity.sh` + `test_gate_45_to_55_acceptance.sh` + `test_gate_a11y_markup_scope.sh` | planted: *"a css/ stylesheet with motion and no guard → FAIL"*, *"a `<style>` block with unguarded motion is still a FAIL"*, *"gate-45 sees a `<style>` transition in a PHP template with no src/ → FAIL"*, and — the per-selector arm — *"reset that stopped naming the !important motion selectors → FAIL"* with the finding required to name `.button-vue:not(.action-button)` (thematiq#604's shape). Clean: *"gate-45 accepts a template that ships the fallback → PASS"*, a universal-`*`-reset control (*"without the reset, that file is a finding"*), and the parity suite's controls for every correct idiom: mirrored selectors, an `!important` guard over a plain motion, `no-preference`, a zeroed duration token, `&`-nesting, `:is(.a, .b)`, an `html`-prefixed guard |
+| gate-45 | prefers-reduced-motion | `test_gate_45_stylesheet_scope.sh` + `test_gate_45_selector_parity.sh` + `test_gate_45_to_55_acceptance.sh` + `test_gate_a11y_markup_scope.sh` | planted: *"a css/ stylesheet with motion and no guard → FAIL"*, *"a `<style>` block with unguarded motion is still a FAIL"*, *"gate-45 sees a `<style>` transition in a PHP template with no src/ → FAIL"*, and — the per-selector arm — *"reset that stopped naming the !important motion selectors → FAIL"* with the finding required to name `.button-vue:not(.action-button)` (thematiq#604's shape). Clean: *"gate-45 accepts a template that ships the fallback → PASS"*, a universal-`*`-reset control (*"without the reset, that file is a finding"*), and the parity suite's controls for every correct idiom: mirrored selectors, an `!important` guard over a plain motion, `no-preference`, a zeroed duration token, `&`-nesting, `:is(.a, .b)`, an `html`-prefixed guard, an ancestor-scoped guard under any ancestor, a guard block below its motion, and the universal reset's `0.01ms`. Second round (#788 review) adds the cascade arms the first round got wrong: *"a guard block ABOVE the motion loses on source order → FAIL"*, *"a plain guard does not borrow the !important of its neighbour → FAIL"*, *"an animation guard stops no transition → FAIL"*, *"a literal duration beside a zeroed token still animates → FAIL"*, *"a token redefined to 250ms is not an override → FAIL"*, and the boundary control *"a guard that merely ENDS in the same letters is not a guard → FAIL"* |
 | gate-46 | spec-anchor-existence | `test_gate_46_tests_scope.sh` | scaffolded in-suite — planted: *"a dangling #T14 anchor in tests/ → FAIL"* + *"the finding NAMES the test file"*, *"a target file that never existed, tagged in tests/ → FAIL"* classified as `target file not found`, *"a dangling anchor in lib/ is still a FAIL"*. Clean: *"a REAL #T02 anchor, resolved through the date-prefixed archive → PASS"* |
 | gate-50 | security-config-fail-mode | `test_gate_45_to_55_acceptance.sh` | thirteen scaffolded arms — planted: an unguarded read whose app id is a class constant, one whose id is a literal, a multi-line read with no guard, the opencatalogi#86 `$this->appName` shape, and an arrow closure's `=>`. Clean: a compound `if ($a === '' \|\| $b === '')` guard, a boolean-return guard, a PHPCS-formatted multi-line read, an on-line emptiness check, a variable app id, and the array-literal value position (demotion asserted by `wc -c` on the `.notes` sidecar, so "demoted" is distinguishable from "never looked") |
 | gate-53 | effective-manifest-crossref | `test_gate_45_to_55_acceptance.sh` | `test-fixtures/effective-manifest` driven through the wrapper — planted: *"gate-53 blocks the PR that removes the last reference to a registered component → FAIL"* + *"gate-53 NAMES the orphaned component"*. Clean: *"accepts removing the component and its registry entry together → PASS"*, *"leaves a PRE-EXISTING orphan advisory (WARN), not blocking → PASS"*. ⚠️ the suite PREFLIGHTS ajv and aborts rather than reporting a wiring fault as a gate defect |