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..148d5759
--- /dev/null
+++ b/hydra-gates/scripts/lib/test_gate_45_selector_parity.sh
@@ -0,0 +1,515 @@
+#!/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
+#
+# 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
+
+_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"
+
+# ---------------------------------------------------------------------------
+# 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"
+    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..0dc59691 100755
--- a/hydra-gates/scripts/run-hydra-gates.sh
+++ b/hydra-gates/scripts/run-hydra-gates.sh
@@ -7719,14 +7719,79 @@ 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; 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 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
+# 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 +7802,42 @@ 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*:\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):
@@ -7747,19 +7848,139 @@ 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, 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 /
+    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 == '{':
+                start = pos
+                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, start))
+                    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, start))
+                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 (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
     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 (m.group(1).lower(), '!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 _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:
+            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
 
 def _is_minified(text):
@@ -7773,18 +7994,69 @@ 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, pos in rules:
+        if state == 'reduce':
+            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 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>'], 'transition', False, 0, [], ''))
+        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:
+        # 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, 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, 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 ''))
+    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 +8074,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..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_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, 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 |