diff --git a/.github/workflows/quality.yml b/.github/workflows/quality.yml
index 59b44804..8e2c370a 100644
--- a/.github/workflows/quality.yml
+++ b/.github/workflows/quality.yml
@@ -402,6 +402,11 @@ on:
         required: false
         type: string
         default: "[]"
+      e2e-skip-blocking:
+        description: "Make the E2E skip-discipline check a hard failure for this app. It reads the RUN's Playwright report — the only place a runtime `test.skip(cond, reason)` is visible — and reports three things: a spec file that executed ZERO tests, a skip deferring to a deploy state CI itself decides ('not deployed', 'deploy drift', 'predates'), and a skip carrying no reason. A skip naming a genuinely absent optional app or external service is allowed. Default false because eight apps carry findings today (measured 2026-08-24: 298/3210 tests skipped fleet-wide, 27 zero-test spec files) and a gate that turns them all red at once is a gate nobody can turn on — same reasoning as check-code-blocking. Flip it per app once that app is worked down; it can then only stay clean."
+        required: false
+        type: boolean
+        default: false
       enable-coverage-guard:
         description: "Enforce the coverage ratchet — READ-ONLY, never commits. On a PULL REQUEST the merge base is measured in the phpunit job and the change must not reduce coverage against it; the floor is measured, not typed, so it cannot go stale and there is nothing for an author to keep up to date. On a PUSH the committed .coverage-baseline is enforced as a conservative fail-safe floor (below it fails; above it is fine). PRs may raise that floor but never lower it. Requires scripts/coverage-guard.php supporting --against; the workflow probes for it and fails loudly rather than silently downgrading the check."
         required: false
@@ -4856,6 +4861,70 @@ jobs:
           SPEC_COVERAGE_JS
           node /tmp/spec-coverage.js
 
+      # ── e2e skip discipline: read the REPORT, not the source ───────────────
+      #
+      # Every other e2e check in this file reads `tests/e2e/**` source. gate-19
+      # parses `test.skip(...)` statically and is careful about it. What no
+      # source reader can settle is the form the fleet actually uses:
+      #
+      #     const present = await someLiveQuery(page)
+      #     test.skip(!present, 'Members tab not deployed on this instance')
+      #
+      # At source level that is indistinguishable from a test that runs. Only
+      # the report of an actual run knows. Nothing read the report, so measured
+      # 2026-08-24 across 20 apps' latest GREEN `development` runs: 298 of 3210
+      # tests skipped (9.3%), 27 spec files executing ZERO tests, 61 skips
+      # deferring to a deploy state CI itself decides, and 142 carrying no
+      # reason at all. decidiq 29.8%, dossiq 27.7%, buildiq 26.3%.
+      #
+      # A zero-test spec file is still accepted by gate-19 as the `@e2e` anchor
+      # for an openspec scenario, so a scenario can be "covered" by a file that
+      # never runs.
+      #
+      # `!cancelled()` and not `always()`: a cancelled run has no verdict to
+      # explain, and a capture hung off a cancelled job produces nothing exactly
+      # when you need it. It deliberately runs when the suite PASSED — a green
+      # suite is where skips hide, and running only on failure would reproduce
+      # the blindness this step exists to remove.
+      #
+      # REPORT, NOT FAIL, on day one, exactly as app:check-code above: eight
+      # apps carry findings today, and turning them all red at once makes it a
+      # gate nobody can turn on. `e2e-skip-blocking` flips it per app as that
+      # app is worked down.
+      - name: E2E skip discipline
+        if: ${{ !cancelled() }}
+        continue-on-error: ${{ !inputs.e2e-skip-blocking }}
+        run: |
+          set -euo pipefail
+          GATE=""
+          for candidate in \
+            "server/apps/${{ inputs.app-name }}/vendor/conduction/hydra-gates/scripts/lib/check_e2e_skips.py" \
+            "hydra-gates/scripts/lib/check_e2e_skips.py"; do
+            if [ -f "${candidate}" ]; then GATE="${candidate}"; break; fi
+          done
+          if [ -z "${GATE}" ]; then
+            echo "::warning::check_e2e_skips.py not found (hydra-gates not vendored here yet) — skip discipline NOT measured on this run."
+            exit 0
+          fi
+
+          REPORT=""
+          for candidate in \
+            "server/apps/${{ inputs.app-name }}/playwright-report" \
+            "server/apps/${{ inputs.app-name }}/tests/e2e/playwright-report"; do
+            if [ -f "${candidate}/index.html" ]; then REPORT="${candidate}"; break; fi
+          done
+          if [ -z "${REPORT}" ]; then
+            # An absent report is an absent measurement, never a pass. Said
+            # loudly, because this is the one failure mode that would quietly
+            # turn the whole gate into a no-op.
+            echo "::error::no Playwright HTML report found — skip discipline could not be measured. Ensure the 'html' reporter is configured."
+            exit 1
+          fi
+
+          MODE=report
+          if [ "${{ inputs.e2e-skip-blocking }}" = "true" ]; then MODE=enforce; fi
+          python3 "${GATE}" --report "${REPORT}" --mode "${MODE}" --summary "${GITHUB_STEP_SUMMARY}"
+
       - name: Upload Playwright report
         if: always()
         # `tests/e2e/…` is included because that is where the scaffolded config
diff --git a/hydra-gates/scripts/lib/check_e2e_skips.py b/hydra-gates/scripts/lib/check_e2e_skips.py
new file mode 100644
index 00000000..1deee693
--- /dev/null
+++ b/hydra-gates/scripts/lib/check_e2e_skips.py
@@ -0,0 +1,387 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: EUPL-1.2
+"""E2E skip discipline — reads the RUN's Playwright report, not the source.
+
+Every other e2e gate in this repo reads `tests/e2e/**` source. That is exactly
+what this gate cannot do, and why it exists.
+
+`check_e2e_coverage.py` (gate-19) already parses `test.skip(...)` statically and
+is careful about it: it separates an unconditional `test.skip(true)` from a
+conditional `test.skip(cond, reason)`, and issue #239 tightened the case of an
+unconditional skip hidden inside an `if` guard. What no source reader can settle
+is the form the fleet actually uses:
+
+    const present = await someLiveQuery(page)
+    test.skip(!present, 'Members tab not deployed on this instance')
+
+At source level that is indistinguishable from a test that runs. Only the report
+of an actual run knows whether it executed. Nothing read the report, so the
+fleet accumulated 298 skipped tests across 3210 (9.3%) and 27 spec files that
+execute ZERO tests — every one of them on a GREEN run.
+
+MEASURED 2026-08-24 by this script, against the latest green `development` run
+of each of 20 fleet apps. Fleet totals: 298/3210 skipped, V1=27, V2=61, V3=142.
+The eight apps carrying it:
+
+    buildiq   68/259 (26.3%)   6 zero-test specs
+    decidiq   57/191 (29.8%)   1
+    dossiq    38/137 (27.7%)   5
+    pipelinq  40/324 (12.3%)   3
+    learniq   27/457  (5.9%)   6
+    shillinq  21/345  (6.1%)   3
+    integriq  16/191  (8.4%)   2
+    filinq     9/124  (7.3%)   1
+
+(An earlier hand-rolled count of mine read double these, by summing the
+report's own `report.json` roll-up alongside the per-file entries. This script
+skips `report.json` for that reason — the per-file entries are the whole truth
+and the roll-up repeats them.)
+
+Three findings, in the order they matter.
+
+**V1 — a spec file that executed zero tests.** It contributes nothing and reads
+as coverage. Worse, gate-19 accepts it as the `@e2e` anchor for an openspec
+scenario, so a scenario can be "covered" by a file that never runs.
+
+**V2 — a skip that defers to a deploy state CI fully determines.** These are
+real, copied verbatim from green runs:
+
+    "decidiq not deployed on the shared instance — live-run deferred"
+    "Members tab not deployed on this instance"
+    "Deploy drift: the deployed decidiq predates minutes-ui-v1"
+    "Sub-cases tab not present in the deployed build (deploy mismatch)"
+    "leaves PR not deployed yet"
+
+Every one was written for a SHARED DEV INSTANCE, where the deployed build really
+can lag the test. CI is not that, and the claim fails there in one of two ways:
+
+* About the app under test, it is **impossible**. The app IS the head commit, so
+  "not deployed" and "deploy drift" cannot happen, and the same sentence can
+  only mean the feature is missing or broken.
+* About a dependency (decidiq's 46 all say "leaves PR not deployed yet", meaning
+  the pinned `nextcloud-vue`), it is **deterministic**. The lockfile decides it,
+  identically on every run. A test that quietly stands down because the pinned
+  dependency is too old is not waiting for anything: either bump the dependency
+  or drop the test.
+
+Either way the guard is an unconditional escape hatch in the one environment
+where the condition is not a matter of luck. Note the shape of decidiq's worst
+case — `partial registry: 27/29 providers` skips an exact-count assertion, so a
+registry that is 93% correct reads as "not deployed" rather than as a diff.
+
+**V3 — a skip with no reason.** 142 of the 298 carry no description at all. A
+reason is already required by gate-16 and gate-19 for their exclusions; a skip
+is an exclusion decided at run time and the same rule applies. Without one there
+is nothing to review and nothing to expire.
+
+NOT a finding: a skip that names an optional Nextcloud app or external service
+the CI instance genuinely does not have ("No chat backend reachable", "requires
+a TaskProcessing LLM provider"). Those describe a real absence the app does not
+control. They must still carry a reason (V3), but they are allowed to skip.
+
+Modes, following the `app:check-code` precedent in quality.yml: `report` always
+exits 0 and prints the table, `enforce` exits 1 on any violation. Day one is
+report-only per app, because a gate that turns eight apps red at once is a gate
+nobody can turn on.
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import io
+import json
+import os
+import re
+import sys
+import zipfile
+from pathlib import Path
+
+# Reasons that defer to a deploy state CI fully determines — impossible for the
+# app under test, deterministic for a pinned dependency. Each entry was taken
+# from a real skip annotation on a green fleet run, not invented. Matched
+# case-insensitively against the whole reason string.
+DEPLOY_STATE = (
+	"not deployed",
+	"not yet deployed",
+	"deploy drift",
+	"deploy mismatch",
+	"not present in the deployed build",
+	"predates",
+	"not yet wired",
+	"deployed build",
+	"on the shared instance",
+	"in target instance",
+	"on this instance",
+)
+
+# A reason may name a genuinely absent optional dependency even though it also
+# trips a phrase above ("no Talk backend reachable on this instance"). These
+# phrases mark that shape and are checked FIRST, so a real environment gap is
+# never reported as a deploy claim.
+ENVIRONMENT_ABSENCE = (
+	"not reachable",
+	"no chat backend",
+	"unreachable",
+	"credential",
+	"llm provider",
+	"not provisioned",
+	"not installed",
+	"session does not survive",
+)
+
+# Tolerate further attributes between the id and the closing bracket. Playwright
+# writes `<script id="playwrightReportBase64">data:...` today; pinning that exact
+# adjacency would let a future attribute silently turn this gate into a no-op,
+# and a no-op gate is indistinguishable from a clean fleet.
+_BLOB = re.compile(
+	r'id="playwrightReportBase64"[^>]*>\s*data:application/zip;base64,([A-Za-z0-9+/=]+)'
+)
+
+
+def _load_report(report_dir: Path) -> zipfile.ZipFile:
+	"""Locate and open the zip embedded in a Playwright HTML report.
+
+	:param report_dir: Directory holding (or containing) ``index.html``.
+	:return:           The opened in-memory zip archive.
+	:raises SystemExit: When no readable report is found.
+	"""
+	candidates = []
+	if report_dir.is_file():
+		candidates = [report_dir]
+	else:
+		candidates = sorted(report_dir.glob("**/index.html"))
+	for html in candidates:
+		text = html.read_text(encoding="utf-8", errors="replace")
+		match = _BLOB.search(text)
+		if match is None:
+			continue
+		return zipfile.ZipFile(io.BytesIO(base64.b64decode(match.group(1))))
+	sys.stderr.write(
+		f"::error::no Playwright HTML report with an embedded result blob under {report_dir}. "
+		"This gate reads the REPORT, so a missing report is a missing measurement, "
+		"not a pass. Ensure the `html` reporter ran and its directory is the one passed here.\n"
+	)
+	raise SystemExit(2)
+
+
+def _skip_reason(test: dict) -> str:
+	"""Return the skip reason recorded for a test, or the empty string.
+
+	:param test: One test entry from the report.
+	:return:     The reason text, stripped; empty when none was recorded.
+	"""
+	sources = list(test.get("annotations") or [])
+	for result in test.get("results") or []:
+		sources.extend(result.get("annotations") or [])
+	for annotation in sources:
+		if annotation.get("type") != "skip":
+			continue
+		description = (annotation.get("description") or "").strip()
+		if description:
+			return description
+	return ""
+
+
+def _skip_location(test: dict) -> str:
+	"""Return ``file:line`` of the guard that skipped the test, best-effort.
+
+	:param test: One test entry from the report.
+	:return:     A ``file:line`` string, or the test's own location.
+	"""
+	sources = list(test.get("annotations") or [])
+	for result in test.get("results") or []:
+		sources.extend(result.get("annotations") or [])
+	for annotation in sources:
+		if annotation.get("type") != "skip":
+			continue
+		loc = annotation.get("location") or {}
+		if loc.get("file"):
+			return f"{os.path.basename(str(loc['file']))}:{loc.get('line', '?')}"
+	loc = test.get("location") or {}
+	return f"{loc.get('file', '?')}:{loc.get('line', '?')}"
+
+
+def classify(reason: str) -> str:
+	"""Classify a skip reason.
+
+	:param reason: The recorded reason, possibly empty.
+	:return:       One of ``no-reason``, ``deploy-state`` or ``allowed``.
+	"""
+	if reason == "":
+		return "no-reason"
+	low = reason.lower()
+	# Environment absence wins: it describes something the app genuinely does
+	# not control, even when the sentence also mentions the instance.
+	for phrase in ENVIRONMENT_ABSENCE:
+		if phrase in low:
+			return "allowed"
+	for phrase in DEPLOY_STATE:
+		if phrase in low:
+			return "deploy-state"
+	return "allowed"
+
+
+def collect(archive: zipfile.ZipFile) -> dict:
+	"""Read every per-file result entry out of the report archive.
+
+	:param archive: The opened report zip.
+	:return:        Mapping of spec file name to its outcome tallies + skips.
+	"""
+	files: dict[str, dict] = {}
+	for name in archive.namelist():
+		if not name.endswith(".json") or name == "report.json":
+			continue
+		try:
+			payload = json.loads(archive.read(name))
+		except (ValueError, KeyError):
+			continue
+		entries = payload.get("files") or ([payload] if "tests" in payload else [])
+		for entry in entries:
+			file_name = entry.get("fileName") or "(unknown)"
+			bucket = files.setdefault(
+				file_name, {"executed": 0, "skipped": 0, "skips": []}
+			)
+			for test in entry.get("tests") or []:
+				outcome = test.get("outcome") or test.get("status") or "?"
+				if outcome == "skipped":
+					bucket["skipped"] += 1
+					reason = _skip_reason(test)
+					bucket["skips"].append(
+						{
+							"title": test.get("title") or "",
+							"reason": reason,
+							"kind": classify(reason),
+							"where": _skip_location(test),
+						}
+					)
+				else:
+					bucket["executed"] += 1
+	return files
+
+
+def main() -> int:
+	"""Entry point.
+
+	:return: Process exit code.
+	"""
+	parser = argparse.ArgumentParser(description=__doc__)
+	parser.add_argument(
+		"--report",
+		required=True,
+		help="Playwright HTML report directory (or its index.html).",
+	)
+	parser.add_argument(
+		"--mode",
+		choices=("report", "enforce"),
+		default="report",
+		help="report: always exit 0. enforce: exit 1 on any violation.",
+	)
+	parser.add_argument(
+		"--summary",
+		default="",
+		help="Optional path to append a markdown summary to (e.g. $GITHUB_STEP_SUMMARY).",
+	)
+	args = parser.parse_args()
+
+	files = collect(_load_report(Path(args.report)))
+	if not files:
+		sys.stderr.write(
+			"::error::the report parsed but contained no test entries. "
+			"A report with no tests is not a clean run.\n"
+		)
+		return 2
+
+	zero_test = sorted(
+		name
+		for name, data in files.items()
+		if data["executed"] == 0 and data["skipped"] > 0
+	)
+	impossible: list[tuple[str, dict]] = []
+	no_reason: list[tuple[str, dict]] = []
+	allowed = 0
+	for name, data in sorted(files.items()):
+		for skip in data["skips"]:
+			if skip["kind"] == "deploy-state":
+				impossible.append((name, skip))
+			elif skip["kind"] == "no-reason":
+				no_reason.append((name, skip))
+			else:
+				allowed += 1
+
+	total_executed = sum(d["executed"] for d in files.values())
+	total_skipped = sum(d["skipped"] for d in files.values())
+	total = total_executed + total_skipped
+	pct = (100.0 * total_skipped / total) if total else 0.0
+
+	lines: list[str] = []
+	lines.append(
+		f"{total_skipped}/{total} tests skipped ({pct:.1f}%) across {len(files)} spec files"
+	)
+	lines.append("")
+	lines.append(f"  V1 spec files executing ZERO tests : {len(zero_test)}")
+	lines.append(f"  V2 skips deferring to a deploy state CI decides : {len(impossible)}")
+	lines.append(f"  V3 skips with no reason recorded : {len(no_reason)}")
+	lines.append(f"  -- allowed (named a real absence) : {allowed}")
+
+	if zero_test:
+		lines.append("")
+		lines.append("V1 — these spec files ran nothing. gate-19 still accepts them")
+		lines.append("     as the @e2e anchor for an openspec scenario:")
+		for name in zero_test:
+			lines.append(f"       {name} ({files[name]['skipped']} skipped, 0 executed)")
+
+	if impossible:
+		lines.append("")
+		lines.append("V2 — CI decides this state: impossible for the app under test (it IS")
+		lines.append("     the head commit), deterministic for a pinned dependency. Assert it")
+		lines.append("     or drop the test — do not stand down:")
+		for name, skip in impossible[:40]:
+			lines.append(f"       {name} :: {skip['where']}")
+			lines.append(f"         {skip['reason'][:150]}")
+		if len(impossible) > 40:
+			lines.append(f"       ... and {len(impossible) - 40} more")
+
+	if no_reason:
+		lines.append("")
+		lines.append("V3 — a skip is a run-time exclusion; gate-16 and gate-19 both")
+		lines.append("     require exclusions to carry a reason. These carry none:")
+		shown: dict[str, int] = {}
+		for name, _skip in no_reason:
+			shown[name] = shown.get(name, 0) + 1
+		for name, count in sorted(shown.items(), key=lambda kv: -kv[1])[:25]:
+			lines.append(f"       {count:4d}  {name}")
+
+	report_text = "\n".join(lines)
+	print(report_text)
+
+	if args.summary:
+		try:
+			with open(args.summary, "a", encoding="utf-8") as handle:
+				handle.write("\n### E2E skip discipline\n\n```\n")
+				handle.write(report_text)
+				handle.write("\n```\n")
+		except OSError as error:
+			sys.stderr.write(f"::warning::could not append the summary: {error}\n")
+
+	violations = len(zero_test) + len(impossible) + len(no_reason)
+	if violations == 0:
+		print("\nEvery skip names a real absence and every spec file ran something.")
+		return 0
+
+	if args.mode == "enforce":
+		sys.stderr.write(
+			f"::error::{violations} e2e skip-discipline violations. "
+			"A skipped test is not a passing test.\n"
+		)
+		return 1
+
+	sys.stderr.write(
+		f"::warning::{violations} e2e skip-discipline violations (report-only). "
+		"Flip `e2e-skip-blocking: true` for this app once they are worked down.\n"
+	)
+	return 0
+
+
+if __name__ == "__main__":
+	sys.exit(main())
diff --git a/hydra-gates/scripts/lib/test_check_e2e_skips.sh b/hydra-gates/scripts/lib/test_check_e2e_skips.sh
new file mode 100755
index 00000000..9db0ebe7
--- /dev/null
+++ b/hydra-gates/scripts/lib/test_check_e2e_skips.sh
@@ -0,0 +1,209 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: EUPL-1.2
+#
+# Self-test for check_e2e_skips.py — the e2e skip-discipline gate.
+#
+# Discovered and run by tests/run-helper-suites.sh — no workflow edit needed.
+#
+# Every assertion is paired: a NEGATIVE control (a report where every test ran,
+# or skipped for a reason naming a real absence, must produce zero findings) and
+# a POSITIVE control (a report carrying exactly one defect must produce exactly
+# that finding, and must EXIT NON-ZERO under --mode enforce).
+#
+# The pairing matters more here than usual. This gate exists because a skipped
+# test and a passing test are indistinguishable from the outside, and a checker
+# that stays silent on a broken report is the same program as one that stays
+# silent on a clean report. So the enforce-mode exit code is asserted in BOTH
+# directions on every case, never only on the failing one.
+#
+# One case is easy to get backwards and is asserted explicitly: a MISSING or
+# unparseable report must exit non-zero, not 0. A gate that reads an artifact
+# has to treat an absent artifact as an absent measurement. Reporting success
+# because there was nothing to read is precisely the class of lie this gate was
+# written to catch.
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CHECKER="${HERE}/check_e2e_skips.py"
+WORK="$(mktemp -d)"
+trap 'rm -rf "$WORK"' EXIT
+
+pass=0
+fail=0
+
+ok() { echo "  PASS  $1"; pass=$((pass + 1)); }
+no() { echo "  FAIL  $1"; [ -n "${2:-}" ] && printf '        %s\n' "$2"; fail=$((fail + 1)); }
+
+# synth <dir> <json-spec>
+#
+# Build a Playwright HTML report whose embedded result blob contains exactly the
+# tests described by <json-spec>, which is a JSON list of
+#   {"file": "a.spec.ts", "title": "...", "outcome": "expected"|"skipped",
+#    "reason": "..."}
+# The real reporter embeds a zip as a data: URI inside a <script> tag; this
+# reproduces that shape rather than a hand-rolled one, so the parser under test
+# is exercised through the same path it takes in CI.
+synth() {
+    local dir="$1"
+    local spec="$2"
+    mkdir -p "$dir"
+    SYNTH_DIR="$dir" SYNTH_SPEC="$spec" python3 - <<'PY'
+import base64, collections, io, json, os, zipfile
+
+out = os.environ["SYNTH_DIR"]
+tests = json.loads(os.environ["SYNTH_SPEC"])
+
+by_file = collections.OrderedDict()
+for t in tests:
+    by_file.setdefault(t["file"], []).append(t)
+
+buf = io.BytesIO()
+with zipfile.ZipFile(buf, "w") as z:
+    files_rollup = []
+    for i, (name, entries) in enumerate(by_file.items()):
+        payload = {"fileId": f"f{i}", "fileName": name, "tests": []}
+        for j, t in enumerate(entries):
+            test = {
+                "testId": f"f{i}-t{j}",
+                "title": t["title"],
+                "outcome": t["outcome"],
+                "path": ["suite"],
+                "location": {"file": name, "line": 10 + j, "column": 3},
+                "annotations": [],
+                "results": [{"duration": 1, "retry": 0}],
+            }
+            if t["outcome"] == "skipped" and t.get("reason") is not None:
+                test["annotations"].append({
+                    "type": "skip",
+                    "description": t["reason"],
+                    "location": {"file": f"/repo/tests/e2e/{name}", "line": 99, "column": 4},
+                })
+            payload["tests"].append(test)
+        z.writestr(f"{i:04d}deadbeef.json", json.dumps(payload))
+        files_rollup.append(payload)
+    # The roll-up repeats every per-file entry. The checker must ignore it, or
+    # every count doubles — the exact mistake this fixture pins.
+    z.writestr("report.json", json.dumps({
+        "files": files_rollup,
+        "stats": {},
+        "projectNames": ["chromium"],
+    }))
+
+blob = base64.b64encode(buf.getvalue()).decode("ascii")
+html = (
+    "<!doctype html><html><body>"
+    f'<script id="playwrightReportBase64">data:application/zip;base64,{blob}</script>'
+    "</body></html>"
+)
+io.open(os.path.join(out, "index.html"), "w", encoding="utf-8").write(html)
+PY
+}
+
+# expect <label> <dir> <expected-report-exit> <expected-enforce-exit> [grep-for]
+expect() {
+    local label="$1" dir="$2" want_report="$3" want_enforce="$4" needle="${5:-}"
+    local out rc
+
+    out="$(python3 "$CHECKER" --report "$dir" --mode report 2>&1)"; rc=$?
+    if [ "$rc" -ne "$want_report" ]; then
+        no "$label (report mode exit)" "expected ${want_report}, got ${rc}"
+        return
+    fi
+
+    out="$(python3 "$CHECKER" --report "$dir" --mode enforce 2>&1)"; rc=$?
+    if [ "$rc" -ne "$want_enforce" ]; then
+        no "$label (enforce mode exit)" "expected ${want_enforce}, got ${rc}"
+        return
+    fi
+
+    if [ -n "$needle" ] && ! printf '%s' "$out" | grep -qF "$needle"; then
+        no "$label (message)" "expected to find: ${needle}"
+        return
+    fi
+    ok "$label"
+}
+
+echo "check_e2e_skips.py"
+
+# --- NEGATIVE control: everything ran ---------------------------------------
+synth "$WORK/clean" '[
+  {"file":"a.spec.ts","title":"one","outcome":"expected"},
+  {"file":"a.spec.ts","title":"two","outcome":"expected"},
+  {"file":"b.spec.ts","title":"three","outcome":"expected"}
+]'
+expect "a report where every test ran is clean" "$WORK/clean" 0 0 "every spec file ran something"
+
+# The roll-up must not be double-counted. Three tests in, three tests reported.
+count="$(python3 "$CHECKER" --report "$WORK/clean" --mode report 2>/dev/null | head -1)"
+case "$count" in
+    "0/3 tests skipped"*) ok "report.json roll-up is not double-counted" ;;
+    *) no "report.json roll-up is not double-counted" "header was: ${count}" ;;
+esac
+
+# --- NEGATIVE control: a skip naming a real absence -------------------------
+synth "$WORK/absence" '[
+  {"file":"a.spec.ts","title":"one","outcome":"expected"},
+  {"file":"a.spec.ts","title":"two","outcome":"skipped",
+   "reason":"No chat backend reachable on this instance"}
+]'
+expect "a skip naming an absent external service is allowed" "$WORK/absence" 0 0 "allowed (named a real absence) : 1"
+
+# --- POSITIVE control V1: a spec file that ran nothing ----------------------
+synth "$WORK/v1" '[
+  {"file":"a.spec.ts","title":"one","outcome":"expected"},
+  {"file":"dead.spec.ts","title":"never","outcome":"skipped",
+   "reason":"no seeded fixture, tracked in openspec"}
+]'
+expect "a spec file executing zero tests is a finding" "$WORK/v1" 0 1 "dead.spec.ts"
+
+# --- POSITIVE control V2: deferring to a deploy state CI decides ------------
+synth "$WORK/v2" '[
+  {"file":"a.spec.ts","title":"one","outcome":"expected"},
+  {"file":"a.spec.ts","title":"two","outcome":"skipped",
+   "reason":"Members tab not deployed on this instance"}
+]'
+expect "a deploy-state skip is a finding" "$WORK/v2" 0 1 "deploy state CI decides : 1"
+
+synth "$WORK/v2b" '[
+  {"file":"a.spec.ts","title":"one","outcome":"expected"},
+  {"file":"a.spec.ts","title":"two","outcome":"skipped",
+   "reason":"Deploy drift: the deployed app predates minutes-ui-v1"}
+]'
+expect "deploy drift is a finding" "$WORK/v2b" 0 1 "deploy state CI decides : 1"
+
+# --- POSITIVE control V3: no reason at all ----------------------------------
+synth "$WORK/v3" '[
+  {"file":"a.spec.ts","title":"one","outcome":"expected"},
+  {"file":"a.spec.ts","title":"two","outcome":"skipped","reason":null}
+]'
+expect "a skip with no reason is a finding" "$WORK/v3" 0 1 "no reason recorded : 1"
+
+synth "$WORK/v3b" '[
+  {"file":"a.spec.ts","title":"one","outcome":"expected"},
+  {"file":"a.spec.ts","title":"two","outcome":"skipped","reason":"   "}
+]'
+expect "a whitespace-only reason is no reason" "$WORK/v3b" 0 1 "no reason recorded : 1"
+
+# --- precedence: a real absence wins over a deploy-state phrase -------------
+# "not installed" names something the app does not control, even though the same
+# sentence also says "on this instance". Classifying this as a deploy claim would
+# make the gate cry wolf on exactly the skips that are legitimate.
+synth "$WORK/prec" '[
+  {"file":"a.spec.ts","title":"one","outcome":"expected"},
+  {"file":"a.spec.ts","title":"two","outcome":"skipped",
+   "reason":"the Talk app is not installed on this instance"}
+]'
+expect "a real absence outranks a deploy-state phrase" "$WORK/prec" 0 0 "allowed (named a real absence) : 1"
+
+# --- a missing measurement is NOT a pass -----------------------------------
+mkdir -p "$WORK/empty"
+python3 "$CHECKER" --report "$WORK/empty" --mode report >/dev/null 2>&1
+rc=$?
+if [ "$rc" -ne 0 ]; then
+    ok "a missing report fails even in report mode"
+else
+    no "a missing report fails even in report mode" "exit was 0 — an absent artifact read as a pass"
+fi
+
+printf '\n  %d passed, %d failed\n' "$pass" "$fail"
+[ "$fail" -eq 0 ] || exit 1