From 89f60c8be40978cf042bec5794f11ffc42cefc66 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 13 Sep 2026 23:24:46 +0000
Subject: [PATCH 01/10] docs(plan): add branch plan for
 defeat-test-mutation-coverage gate (#1799)

Task decomposition for issue #1799 (gate-proposal-umbrella: vacuous
defeat-tests in newly-added regression tests). Single-task Branch Plan:
all three graded element categories (regex alternation, dict entry,
unconditional literal) and their regression tests land on the same gate
script and test file, so file-ownership conflicts across a further split
are total and no parallelism would be gained.

Claude-Session: https://claude.ai/code/session_01GQ8289c4nMwpaLPnhZTHyM
---
 ...2026-09-13-claude-trusting-sagan-g5efyx.md | 305 ++++++++++++++++++
 1 file changed, 305 insertions(+)
 create mode 100644 docs/gitapex/plans/2026-09-13-claude-trusting-sagan-g5efyx.md

diff --git a/docs/gitapex/plans/2026-09-13-claude-trusting-sagan-g5efyx.md b/docs/gitapex/plans/2026-09-13-claude-trusting-sagan-g5efyx.md
new file mode 100644
index 00000000..67f23ab4
--- /dev/null
+++ b/docs/gitapex/plans/2026-09-13-claude-trusting-sagan-g5efyx.md
@@ -0,0 +1,305 @@
+# Branch Plan: defeat-test-mutation-coverage gate (vacuous defeat-tests)
+
+Issue: https://github.com/tvna/gitapex/issues/1799
+
+Branch: `claude/trusting-sagan-g5efyx` (this session's designated branch
+for `tvna/gitapex`, from `origin/main` -- the session's own harness-level
+instructions pin development and pushes to this exact branch and forbid
+pushing elsewhere without explicit permission).
+
+## Decided approach (human-confirmed in this session)
+
+`AskUserQuestion` presented three implementation-approach options; the
+operator chose "真のmutation実行gate" (a real mutation-execution gate)
+over extending the existing name-mention-only static heuristics
+(`gitapex_gate_detection_logic_property_coverage.py`, issue #1178, and
+`gitapex_gate_function_body_test_coverage.py`, issue #1498) or a
+scope-estimate-first pause. Grep across `.github/scripts/` and `hooks/`
+found no existing gate that actually executes tests against a mutated
+copy of a source file -- every one of the 86 gates registered in
+`.gitapex/ssot.json` grades a diff by static AST inspection alone. This
+is therefore a new mechanism, not an extension of an existing one.
+
+## Task Decomposition
+
+One task, one wave -- the degenerate case `executing-a-branch-plan`'s own
+Related-skills section names, not a skipped decomposition. issue #1799's
+six consolidated rows all describe one mechanism (remove the claimed
+element, confirm a paired test fails), and every row's planned ops land
+on the same new gate script, its own registration, its own CI wiring, and
+its own regression tests -- so the four candidate sub-tasks considered
+(mutation engine + regex trigger / dict-entry trigger / unconditional-
+literal trigger / regression tests + CI + ssot registration) all share
+the same two files (the gate script and its test file). File-ownership
+conflicts across that four-way split are total, not partial, so
+decomposing further would only force a four-wave sequential chain with
+no parallelism gained -- collapsed into one task instead:
+
+```
+$ echo '{"task-1-defeat-test-mutation-coverage-gate": [".github/scripts/gitapex_gate_defeat_test_mutation_coverage.py", ".github/workflows/defeat-test-mutation-coverage-gate.yml", "tests/test_gitapex_gate_defeat_test_mutation_coverage.py", ".gitapex/ssot.json"]}' \
+    | python3 skills/executing-a-branch-plan/scripts/gitapex_check_file_ownership_conflicts.py
+no file-ownership conflicts found
+```
+
+The interface-dependency map is likewise empty for the same reason (one
+task, nothing to depend on).
+
+Irreversibility classification: **not irreversible.** The task adds new
+files (a gate script, its workflow, its test file) and appends one entry
+to `.gitapex/ssot.json`'s own `gates` array. Nothing writes outside the
+repository, no migration runs, no pre-existing file's own meaning
+changes. `git revert` of the merge commit removes the new gate cleanly.
+
+`SKILL.md` classification: **no `SKILL.md` is created or edited.** The
+change touches only `.github/scripts/`, `.github/workflows/`, `tests/`,
+and `.gitapex/ssot.json`, so `drafting-a-skill` is not routed to and the
+PR-body skill-audit disclosure convention does not apply.
+
+## Task 1: implement the defeat-test-mutation-coverage gate
+
+Source ACM rows (issue #1799's own table, quoted verbatim per this
+skill's own step-3 convention -- six rows, one target mechanism):
+
+> [from #1733] Planned ops: A CI step or pre-commit check that
+> mutation-tests each named regex alternative/branch a new or changed
+> detection-logic test suite claims to cover: for each branch, temporarily
+> remove it and confirm at least one paired test fails; flag a branch with
+> zero failing tests as a vacuous-coverage finding -- the same check PR
+> #1715's own Step 8 Round 3 already performed by hand.
+
+> [from #1734] Planned ops: Same proposed gate as repair 3 (mutation-test
+> each claimed regex branch against its paired test suite); this
+> recurrence is itself evidence the gate is warranted rather than a
+> coincidence.
+
+> [from #1735] Planned ops: Add a mutation-testing pass (or minimally, a
+> per-new-test remove-the-targeted-branch-and-confirm-failure check) as a
+> CI job or pre-merge script for any PR that adds regression tests
+> claiming to pin a specific regex/logic branch, so a test that does not
+> actually exercise the branch its own docstring or PR description claims
+> is caught mechanically before independent review time rather than only
+> by a reviewer manually reconstructing the code to check.
+
+> [from #1736] Planned ops: Same underlying gap as repair 1 (see
+> Recurrence note there): a mutation-testing or remove-the-targeted-branch
+> check applied to every new regression test, run automatically, would
+> have caught this one too -- and specifically would have caught that a
+> fix for one vacuous test can itself be vacuous in a different way, which
+> a human/agent re-reading the diff alone did not catch on the first pass.
+
+> [from #1990, retro #1985 repair 1] Planned ops: A mutation check over a
+> diff's newly added or changed tests: remove each production constant
+> entry, unconditional emission, or branch the test's own docstring claims
+> to cover, re-run the paired tests, and flag any element whose removal
+> leaves the suite green. This row is what widens the umbrella's element
+> set beyond a regex alternative.
+
+> [from #1991, retro #1985 repair 3] Planned ops: The same mutation check
+> #1990's row proposes, applied to a generator's emitted output rather
+> than to a constant: remove each unconditional emission and each field a
+> new test claims to cover, and flag any whose removal leaves the suite
+> green. Verified in-tree -- the generator appends both literals in one
+> unconditional list construction, so the containment assertion could not
+> fail.
+
+### Files
+
+- `.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py` (new)
+- `.github/workflows/defeat-test-mutation-coverage-gate.yml` (new)
+- `tests/test_gitapex_gate_defeat_test_mutation_coverage.py` (new)
+- `.gitapex/ssot.json` (edit: append one `gates[]` entry)
+
+### Design (binds this task; deviate only with a disclosed reason)
+
+**Scope.** Union of the two existing gates' own in-scope directories:
+`skills/*/scripts/*.py`, `.github/scripts/*.py`, `hooks/*.py`
+(`test_*.py`/`conftest.py` excluded), matching
+`gitapex_gate_function_body_test_coverage.py`'s own broader,
+unprefixed precedent (issue #1799's own #1990/#1991 rows are both in
+`hooks/`, which the narrower `detection_logic_property_coverage` scope
+would not have reached either).
+
+**Element categories graded** (issue #1799's own "any element a test's
+own docstring or PR description claims to cover", operationalized
+mechanically rather than by parsing natural-language claims -- see
+"Why not parse docstrings" below):
+
+1. **Regex alternation branch.** A `|`-joined top-level alternative
+   inside a string literal argument to `re.compile(...)`/`re.match(...)`/
+   `re.search(...)`/`re.fullmatch(...)` (module-qualified or
+   receiver-agnostic, reuse `gitapex_gate_detection_logic_property_
+   coverage.py`'s own `_re_module_names`/regex-trigger resolution
+   verbatim rather than re-deriving it) that this diff newly adds or
+   changes. Split only on `|` at paren-depth 0 (a `|` inside `(...)`,
+   `[...]`, or after an unescaped `\` is not a top-level alternative);
+   a pattern with no top-level `|` has no alternative to remove and is
+   not graded under this category.
+2. **Module-level dict/mapping-literal entry.** A key of an
+   `ast.Dict` assigned to a module-level `ast.Name` target (a
+   `CONST = {...}` shape, the repository's own pervasive constant-table
+   idiom -- e.g. `REVIEW_PERSONA_PERMISSION`) where this diff newly adds
+   or changes at least one key/value pair.
+3. **Unconditionally emitted literal.** A string/literal element that
+   is: (a) an item inside a `List`/`Tuple`/`Set`/`Dict` display that is
+   itself unconditionally constructed (built directly inside a function
+   body with no enclosing `If`/`Try`/loop-conditional guard around the
+   literal's own containing display), or (b) the right-hand side of an
+   unconditional keyword argument / dict entry emitted by a generator
+   function (e.g. `"hidden": True` emitted with no surrounding
+   conditional) -- newly added or changed by this diff. This category is
+   necessarily the least mechanically crisp of the three (issue #1799's
+   own #1991 row describes it by example, not by a closed grammar);
+   grade only the narrow, unambiguous shape above and document the
+   narrowing explicitly in the module docstring's own "Known misses"
+   section, the same disclosure convention both existing sibling gates
+   already use rather than silently overclaiming coverage.
+
+**Why not parse docstrings.** issue #1799's own prose names "a test's own
+docstring or PR description" as what claims coverage, but a natural-
+language claim is not a machine-checkable input (the same reason
+`gitapex_gate_function_body_test_coverage.py`'s own docstring gives for
+checking "does this diff add a covering test" by AST identifier presence
+rather than by reading English). Operationalize as: grade every category
+1-3 element this diff newly adds or changes in an in-scope source file,
+paired against whichever of `tests/test_{stem}.py` /
+`tests/test_{stem}_properties.py` this same diff also adds or changes a
+line in (`stem` = the source file's own basename without `.py`, exactly
+`gitapex_gate_function_body_test_coverage.py`'s own `_stem`/
+`_test_relative_paths` convention) -- reusing that gate's own "this same
+diff must touch the test file too" scoping so a pre-existing, untouched
+test can never silently satisfy this gate. A source element with no
+diff-touched paired test file at all is not graded (nothing to mutation-
+test against) -- disclose this as a known scope limit, not fixed here.
+
+**Mutation mechanism** (the actual "real mutation" the operator chose):
+for each graded element, build the mutated source text (AST-guided:
+locate the exact byte range of the element via its node's
+`lineno`/`col_offset`/`end_lineno`/`end_col_offset`, splice it out or
+neutralize it, keeping the rest of the file byte-identical) and run it
+against the paired test file with the on-disk source file replaced by
+the mutated text for the duration of one subprocess `pytest` invocation
+scoped to that specific paired test file (or, when identifiable, the
+specific new/changed `test_`-prefixed function(s) this diff touches in
+it, via `pytest <path> -k <name-expr>`), then restore the original bytes
+in a `finally` block regardless of outcome (mirroring the
+temp-overwrite-then-restore technique real mutation-testing tools such
+as `mutmut`/`cosmic-ray` use). Read the original bytes into memory
+*before* the first mutation and restore from that in-memory copy, never
+by re-reading the file from disk after a prior mutation -- guards
+against a first mutation's write clobbering the baseline a later
+mutation restores to, if a restore is ever interrupted mid-run.
+If the suite's own paired tests all still pass against the mutated
+source, record a `defeat-test-mutation-gap` finding naming the element,
+its category, and the paired test file that failed to catch it. Exit
+codes: 0 clean, 1 a vacuous-coverage finding, 2 the scan could not be
+trusted (malformed diff, an in-scope or paired-test file that cannot be
+read/parsed, a `--root` that is not a directory, or a subprocess `pytest`
+invocation that itself errors for a reason other than "tests ran and
+passed/failed" -- e.g. a collection error) -- the same fail-closed
+contract both sibling gates already state and justify by dimension 15 of
+`skills/evaluating-deterministic-gate-quality/references/dimensions.md`.
+
+**Diff parsing.** Reuse `parse_added_lines` (and its
+`_diff_target_path`/`_looks_like_real_header_pair`/`_HUNK_RE`
+machinery) verbatim from `gitapex_gate_function_body_test_coverage.py`
+-- both existing sibling gates already carry byte-for-byte copies of it
+rather than re-deriving it, and this gate's own module docstring should
+say so explicitly the same way the function-body gate's docstring
+credits its own copy.
+
+**Waiver.** `# defeat-test-mutation-coverage: WAIVED: <reason>`, a
+non-whitespace reason mandatory, detected via `tokenize` exactly like
+both sibling gates' own `_WAIVER_RE`/`_waived_lines` (never a bare regex
+over raw text, so a waiver string quoted inside this gate's own
+docstring is never itself honoured as a real waiver).
+
+**Runtime/CI cost, disclosed rather than hidden.** Unlike either sibling
+gate (pure AST inspection), this gate spawns one `pytest` subprocess per
+graded element, so its own CI job should carry a generous timeout and
+this cost should be stated plainly in the module docstring's own
+"Invocation shape" section (matching both sibling gates' own convention
+of disclosing invocation shape and cost trade-offs there) -- not solved
+by artificially capping the element count within this task.
+
+**Known, disclosed non-goals** (state these in the module docstring
+exactly, not merely in this plan file, so a future reader is never
+surprised by them -- the same "Known misses"/"Known over-reports"
+disclosure convention both sibling gates already use):
+
+- **"The suite" is scoped to the paired co-located test file(s) only**,
+  never the full repository test suite. issue #1799's own #1991 row
+  states the residual risk directly: "running only the file's own tests
+  would miss a cross-file assertion, and running everything is slow."
+  This task accepts the narrower, fast scope and documents the miss
+  rather than resolving it.
+- **Emit-only spelling assertions are out of scope for this mechanism.**
+  issue #1799's own body states this directly: "an assertion that
+  compares only an emitted spelling is not caught by a
+  remove-and-confirm-failure pass, because a mutation that changes the
+  emitted string does fail it. Catching that one needs a parse assertion
+  beside the spelling assertion... which is a different check from
+  mutation testing." Do not attempt to implement that different check
+  under this gate's own name; state the non-goal in the docstring instead.
+
+### Registration
+
+Append one entry to `.gitapex/ssot.json`'s `gates` array, matching the
+existing `detection-logic-property-coverage`/`function-body-test-
+coverage` entries' own shape exactly: `id: "defeat-test-mutation-
+coverage"`, `kind: "script"`, `script` listing the gate script + its
+workflow (+ `gitapex_run_base_diff.py`/`_gitapex_base_ref.py` if the
+chosen CI invocation reuses them the same way both sibling gates do),
+`rule` (prose summary of the mechanism above), `planes: ["ci", "local"]`
+if a local invocation is wired, `local_invocation`/`local_stdin` mirroring
+the sibling gates' own `uv run --frozen python3 <script>` /
+`gitapex_run_base_diff.py -- '*.py'` pair, `trigger` naming the new
+workflow file, `policy_refs: []`, `cluster: "test-integrity"` (same
+cluster both sibling gates use), `tracking_issue: 1799`, `status:
+"active"`, `supersedes: null`, `bypass_review_status:
+"not-yet-reviewed"`, and a `target` array listing the graded file globs,
+the paired-test-file glob, a `cross-registry-consistency` entry
+describing the source<->test pairing this gate checks, and the new
+workflow's own `pull_request` event.
+
+### Proof method (binds this task; do not report complete without it)
+
+1. Construct fixtures reproducing all three graded element categories in
+   a shape mirroring issue #1799's own six rows: (a) a regex with a
+   branch a paired test's assertion never actually reaches (mirroring
+   #1733/#1735's own `_CONTAINER_PREFIX`-shaped CR-alternative gap), (b)
+   a module-level dict constant with an entry no assertion anywhere
+   names (mirroring #1990's `REVIEW_PERSONA_PERMISSION`-shaped gap), (c)
+   an unconditionally-emitted literal a test only checks with a
+   type/non-emptiness assertion rather than an exact-value one
+   (mirroring #1991's `hidden: true`-shaped gap).
+2. Confirm the new gate reports a `defeat-test-mutation-gap` finding
+   against each vacuous fixture (red).
+3. Fix each fixture's own paired test to genuinely assert the mutated
+   element (an exact-match or parse-back assertion, not merely
+   type/non-emptiness), and confirm the gate reports clean against the
+   fixed fixture (green) -- this is the "reintroduced instance of the
+   original defect" proof method every one of issue #1799's own six ACM
+   rows requires verbatim.
+4. Full repo verification (`gitapex_gate_local_preflight.py` plus the
+   full `pytest` suite, ruff lint, mypy) green inside this task's own
+   worktree before reporting complete, per this skill's own Decision 20
+   requirement.
+5. Confirm the new CI workflow file passes `actionlint`/`zizmor` shape
+   (or whatever this repository's own CI-workflow validation already
+   runs against every `.github/workflows/*.yml` file) rather than being
+   graded only by eye.
+
+### Residual risk
+
+The three element categories chosen (regex alternation / dict entry /
+unconditional literal) are the ones issue #1799's own six rows evidence
+directly; a vacuous test defeating some other shape of production logic
+(a conditional branch with no regex/dict/literal shape at all, for
+instance) is not covered by this gate and is not claimed to be --
+disclose this plainly in the module docstring's own "Known misses"
+section rather than overclaiming a general vacuous-test detector.
+
+## Operations note
+
+This file is the task-list commit (this skill's own step 4): commit it
+alone first, then push, before opening the draft PR (step 5).

From 8769e7b3b9deb934f6bf780acfe07bfe04a35b5e Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 13 Sep 2026 23:43:27 +0000
Subject: [PATCH 02/10] docs(plan): fix Source ACM rows citation shape for
 plans-traceability gate (#1799)

The branch-plan file own Source ACM rows line did not match the plans-traceability gate line-anchored pattern (a parenthetical explanation sat between rows and the colon). Reworded to a plain Source ACM rows: line so the gate shape check passes.

Claude-Session: https://claude.ai/code/session_01GQ8289c4nMwpaLPnhZTHyM
---
 docs/gitapex/plans/2026-09-13-claude-trusting-sagan-g5efyx.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/gitapex/plans/2026-09-13-claude-trusting-sagan-g5efyx.md b/docs/gitapex/plans/2026-09-13-claude-trusting-sagan-g5efyx.md
index 67f23ab4..5b965491 100644
--- a/docs/gitapex/plans/2026-09-13-claude-trusting-sagan-g5efyx.md
+++ b/docs/gitapex/plans/2026-09-13-claude-trusting-sagan-g5efyx.md
@@ -57,8 +57,8 @@ PR-body skill-audit disclosure convention does not apply.
 
 ## Task 1: implement the defeat-test-mutation-coverage gate
 
-Source ACM rows (issue #1799's own table, quoted verbatim per this
-skill's own step-3 convention -- six rows, one target mechanism):
+Source ACM rows: issue #1799's own table, quoted verbatim per this
+skill's own step-3 convention -- six rows, one target mechanism.
 
 > [from #1733] Planned ops: A CI step or pre-commit check that
 > mutation-tests each named regex alternative/branch a new or changed

From ea6529308f1cdca888b785134d04a82f19eea603 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 14 Sep 2026 03:50:22 +0000
Subject: [PATCH 03/10] feat(gates): add defeat-test mutation-coverage gate

Implements the real mutation-execution gate issue #1799's six ACM rows
call for: a regex alternation branch, a module-level dict entry, or an
unconditionally-emitted literal newly added or changed by a diff must
actually be caught -- not merely mentioned -- by that same diff's own
paired test. For each graded element, the gate splices it out of a
byte-exact mutated copy of the source file, runs a real pytest
subprocess against the paired test file(s) the diff itself touches, and
restores the original bytes in a finally block. A paired suite that
still passes clean against the mutation is a defeat-test-mutation-gap
finding.

New: .github/scripts/gitapex_gate_defeat_test_mutation_coverage.py,
its workflow, and its regression test suite. Registers one gates[]
entry in .gitapex/ssot.json (cluster test-integrity, both ci and local
planes).

The new gate script matches the in-scope pattern of two pre-existing
sibling gates (detection-logic-property-coverage, function-body-test-
coverage) and of the repo's own patch-coverage gate, since it itself
contains real regex/string-comparison detection logic and function
bodies. Closes the resulting self-grading gaps: adds
tests/test_gitapex_gate_defeat_test_mutation_coverage_properties.py
(a genuine Hypothesis given property per regex/string-comparison-shaped
function), direct unit tests referencing several verbatim-copied helper
functions by name (_diff_target_path, _looks_like_real_header_pair,
parse_added_lines, _is_supported_literal, _invalidate_pycache,
_graded_elements), and tests for every previously-uncovered branch
(context/removal diff lines, malformed/non-UTF-8/unterminated
string-literal tokens, mutation write/restore/subprocess failure paths,
an unreadable-file ScanError path, category-3 skip branches), bringing
the new gate script to 100 percent line coverage.

Also bumps the repo's own "49 wired gates" prose in CONTRIBUTING.md,
.pre-commit-config.yaml, gitapex_gate_local_preflight.py's own
docstring, and its test file to 50, per this new gate's own
registration -- test_no_prose_count_contradicts_the_registry's own
drift check -- and records the real warm-run timing of the 50-gate set
(roughly 49 seconds, about double the prior 49-gate baseline, since
this is the first wired gate that spawns a real pytest subprocess per
graded element rather than pure AST inspection).

Issue: https://github.com/tvna/gitapex/issues/1799
---
 .gitapex/ssot.json                            |   31 +
 ...apex_gate_defeat_test_mutation_coverage.py | 1140 ++++++++++++++++
 .../scripts/gitapex_gate_local_preflight.py   |   17 +-
 .../defeat-test-mutation-coverage-gate.yml    |   99 ++
 .pre-commit-config.yaml                       |    9 +-
 CONTRIBUTING.md                               |   15 +-
 ...apex_gate_defeat_test_mutation_coverage.py | 1158 +++++++++++++++++
 ...efeat_test_mutation_coverage_properties.py |  257 ++++
 tests/test_gitapex_gate_local_preflight.py    |    2 +-
 9 files changed, 2713 insertions(+), 15 deletions(-)
 create mode 100644 .github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
 create mode 100644 .github/workflows/defeat-test-mutation-coverage-gate.yml
 create mode 100644 tests/test_gitapex_gate_defeat_test_mutation_coverage.py
 create mode 100644 tests/test_gitapex_gate_defeat_test_mutation_coverage_properties.py

diff --git a/.gitapex/ssot.json b/.gitapex/ssot.json
index bf7380ec..5a7c0ae1 100644
--- a/.gitapex/ssot.json
+++ b/.gitapex/ssot.json
@@ -2156,6 +2156,37 @@
         {"kind": "file-glob", "ref": "docs/gitapex/plans/*.md"},
         {"kind": "workflow-event", "ref": "plans-traceability-gate.yml:pull_request"}
       ]
+    },
+    {
+      "id": "defeat-test-mutation-coverage",
+      "kind": "script",
+      "script": [
+        ".github/scripts/gitapex_gate_defeat_test_mutation_coverage.py",
+        ".github/scripts/gitapex_run_base_diff.py",
+        ".github/scripts/_gitapex_base_ref.py",
+        ".github/workflows/defeat-test-mutation-coverage-gate.yml"
+      ],
+      "rule": "A regex alternation branch (a top-level '|'-joined alternative, at paren-depth 0 and outside a [...] character class, inside a plain string-literal pattern argument to re.compile()/re.match()/re.search()/re.fullmatch(), the .compile receiver resolved through the file's own 'import re' statements and .match/.search/.fullmatch receiver-agnostic on any receiver), a key of an ast.Dict assigned to a module-level ast.Name target (CONST = {...}), or a str/int/float/bool literal that is a direct List/Tuple/Set element or a non-module-level-dict Dict entry's value, built unconditionally (no enclosing If/Try/For/AsyncFor/While) inside a function body in skills/*/scripts/*.py, .github/scripts/*.py or hooks/*.py (test_*.py and conftest.py excluded), newly added or changed by a PR diff, must be actually caught -- not merely mentioned -- by this same diff's own paired tests/test_<source-stem>.py or tests/test_<source-stem>_properties.py: the element is spliced out of a temporary, byte-exact mutated copy of the source file, a real pytest subprocess is run against exactly the paired test file(s) this diff itself touches, and the original bytes are restored regardless of outcome. A paired suite that still exits 0 against the mutated source is a defeat-test-mutation-gap finding; a source element with no diff-touched paired test file at all is not graded. Scope is the diff, not the repository. An inline '# defeat-test-mutation-coverage: WAIVED: <reason>' comment waives findings on that exact line. Exits 2 rather than pass silently on a malformed diff, an in-scope or paired-test file that cannot be read or parsed, or a pytest subprocess invocation that itself errors for a reason other than 'tests ran and passed/failed' (e.g. a collection error). See the script's own module docstring for the three element categories' disclosed known misses and non-goals.",
+      "planes": ["ci", "local"],
+      "local_invocation": ["uv", "run", "--frozen", "python3", ".github/scripts/gitapex_gate_defeat_test_mutation_coverage.py"],
+      "local_stdin": ["uv", "run", "--frozen", "python3", ".github/scripts/gitapex_run_base_diff.py", "--", "*.py"],
+      "trigger": ".github/workflows/defeat-test-mutation-coverage-gate.yml on pull_request, plus tests/test_gitapex_gate_defeat_test_mutation_coverage.py inside the pytest step of .github/workflows/test.yml",
+      "policy_refs": [],
+      "cluster": "test-integrity",
+      "tracking_issue": 1799,
+      "status": "active",
+      "supersedes": null,
+      "bypass_review_status": "not-yet-reviewed",
+      "target": [
+        {"kind": "file-glob", "ref": "skills/*/scripts/*.py"},
+        {"kind": "file-glob", "ref": ".github/scripts/*.py"},
+        {"kind": "file-glob", "ref": "hooks/*.py"},
+        {"kind": "file-glob", "ref": "tests/test_*.py"},
+        {"kind": "cross-registry-consistency", "ref": "new/changed regex alternation branches, module-level dict entries, and unconditionally-emitted literals in skills/*/scripts/*.py, .github/scripts/*.py, hooks/*.py <-> a real pytest-subprocess mutation-kill in the co-located tests/test_<stem>.py or tests/test_<stem>_properties.py this same diff also touches"},
+        {"kind": "workflow-event", "ref": "defeat-test-mutation-coverage-gate.yml:pull_request"},
+        {"kind": "workflow-event", "ref": "test.yml:pull_request"},
+        {"kind": "workflow-event", "ref": "test.yml:push"}
+      ]
     }
   ],
   "clusters": {
diff --git a/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py b/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
new file mode 100644
index 00000000..190ad8fa
--- /dev/null
+++ b/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
@@ -0,0 +1,1140 @@
+#!/usr/bin/env python3
+"""CI gate: a new or materially changed regex alternation branch, module-level
+dict entry, or unconditionally-emitted literal, added by this diff to one of
+this repository's own checker scripts, must actually be caught -- not merely
+mentioned -- by this same diff's own paired test: removing the element and
+re-running the paired test file(s) as a real ``pytest`` subprocess must make
+at least one of them fail. A paired test that still passes clean against the
+mutated source is a *vacuous* defeat-test: it claims to pin the element down
+but never actually exercises it.
+
+Issue #1799 (six consolidated rows across #1733, #1734, #1735, #1736, #1990,
+#1991). Every prior gate in this repository grades a diff by static AST
+inspection alone -- "does a covering test mention this name/function" -- which
+a vacuous assertion (a type check, a non-emptiness check, an unrelated
+assertion in the same test function) satisfies without ever actually
+exercising the element it claims to cover.
+``gitapex_gate_detection_logic_property_coverage.py`` (issue #1178) and
+``gitapex_gate_function_body_test_coverage.py`` (issue #1498) both ask "is
+there a covering test," never "does the covering test actually fail if the
+covered element is wrong" -- this gate is the first in this repository to
+actually run a mutated copy of the source against its own paired tests,
+mirroring the temp-overwrite-then-restore technique real mutation-testing
+tools (``mutmut``, ``cosmic-ray``) use, rather than only reasoning about the
+AST.
+
+**The motivating gap, twice.** PR #1715's own Step 8 Round 3 manually
+performed exactly this mutation-and-rerun check by hand against a regex
+alternation branch and found it vacuous (#1733/#1734/#1735/#1736's own
+repeated recurrence of the same gap). Retro #1985's own repair 1 (#1990) and
+repair 3 (#1991) then found the identical vacuous-coverage shape against a
+module-level dict constant entry and a generator's unconditionally emitted
+list literal, respectively -- issue #1799's own umbrella widens the element
+set from "a regex branch" to "any of these three AST shapes."
+
+Scope
+-----
+Union of ``gitapex_gate_function_body_test_coverage.py``'s own
+``skills/*/scripts/*.py`` / ``.github/scripts/*.py`` scope and
+``gitapex_gate_detection_logic_property_coverage.py``'s own ``hooks/`` scope,
+but unprefixed (matching the function-body gate's own broader precedent, not
+the detection-logic gate's narrower ``gitapex_check_``/``gitapex_gate_``
+prefix restriction) -- issue #1799's own #1990/#1991 rows are both in
+``hooks/``, which the narrower scope would not have reached either.
+``[^/]+`` segments and ``re.fullmatch`` keep every alternative from crossing a
+directory separator or matching a nested subdirectory, matching both sibling
+gates' own construction. A file matching the in-scope pattern is excluded
+when its basename starts with ``test_`` or equals ``conftest.py``, the same
+exclusion both sibling gates apply.
+
+Element categories graded
+--------------------------
+Issue #1799's own "any element a test's own docstring or PR description
+claims to cover," operationalized mechanically rather than by parsing
+natural-language claims (see "Why not parse docstrings" below):
+
+1. **Regex alternation branch.** A ``|``-joined top-level alternative inside
+   a string literal argument to ``re.compile(...)``/``re.match(...)``/
+   ``re.search(...)``/``re.fullmatch(...)`` -- the receiver for ``.compile``
+   resolved through this file's own ``import re`` statements exactly like
+   ``gitapex_gate_detection_logic_property_coverage.py``'s own
+   ``_re_module_names``, and ``.match``/``.search``/``.fullmatch`` matched
+   receiver-agnostically on any receiver, exactly like that gate's own
+   ``_regex_trigger`` -- reused verbatim rather than re-derived. Only a call
+   whose first positional argument is itself a plain string literal (no
+   implicit string concatenation, no f-string) is graded: that argument is
+   the pattern text this category mutates. Splitting happens on the raw
+   *source* text of that literal (not the ``ast``-evaluated string value),
+   respecting byte-for-byte what a raw string (``r"..."``) feeds directly to
+   ``re``: a ``|`` inside ``(...)`` (paren-depth tracked) or ``[...]``
+   (character-class tracked, entered on ``[`` and exited on the next ``]``,
+   a simplification that does not special-case a class-leading ``]``/``^]``)
+   is not a top-level alternative, and a ``|`` immediately after an unescaped
+   backslash (a literal backslash byte, consuming the following byte as
+   escaped regardless of what it is) is not either. A pattern with fewer than two
+   top-level alternatives has nothing to remove and is not graded.
+
+2. **Module-level dict/mapping-literal entry.** A key of an ``ast.Dict``
+   assigned to a module-level ``ast.Name`` target (``CONST = {...}``, this
+   repository's own pervasive constant-table idiom, e.g.
+   ``REVIEW_PERSONA_PERMISSION``). Every entry is graded regardless of its
+   own value's shape (a plain literal, a tuple, a nested dict) -- the element
+   under test is the whole key/value pair, and the mutation is its removal.
+   A dict carrying a ``**``-unpacking entry (a ``None`` key) is skipped
+   entirely, narrow scope disclosed rather than handled.
+
+3. **Unconditionally emitted literal.** A ``str``/``int``/``float``/``bool``
+   ``ast.Constant`` that is either (a) a direct element of a
+   ``List``/``Tuple``/``Set`` display, or (b) the value half of a key/value
+   pair in an ``ast.Dict`` display that is *not* already the module-level
+   ``CONST = {...}`` shape category 2 owns -- in both cases, only when the
+   display itself is built directly inside a function body with no
+   enclosing ``If``/``Try``/``For``/``AsyncFor``/``While`` between the
+   display and that function (an unconditionally-executed straight-line
+   emission, the same shape issue #1799's own #1991 row describes: "the
+   generator appends both literals in one unconditional list construction").
+   This category is necessarily the least mechanically crisp of the three
+   (issue #1799's own #1991 row describes it by example, not by a closed
+   grammar) -- narrowed deliberately, not overclaimed:
+
+   **Known misses, disclosed rather than found later.**
+
+   * A keyword argument's own value (``some_call(hidden=True)``) is not
+     graded -- only a ``List``/``Tuple``/``Set`` element or a ``Dict``
+     entry's value is, per the narrow shape above.
+   * A collection built incrementally (``tags = []`` then repeated
+     ``tags.append("hidden")`` calls) is not graded either -- only a
+     literal element written directly inside one display's own brackets
+     (``return ["hidden", "archived"]``) is, since that is the only shape
+     with a single AST node this gate can locate and splice.
+   * Implicit string concatenation (``"a" "b"``) and f-strings are not
+     graded under category 1 at all -- only a single, plain string-literal
+     pattern argument is.
+   * A ``None`` value, a ``bytes`` literal, or a non-``Constant`` expression
+     (a nested container, a call, a name reference) is never graded under
+     category 3 -- only the four scalar ``Constant`` types listed above are.
+   * A display nested inside a ``with`` block still counts as unconditional
+     -- only ``If``/``Try``/``For``/``AsyncFor``/``While`` are treated as a
+     guard, matching this category's own literal wording.
+   * A display sitting directly in a class body (a class attribute, not
+     inside any method) has no enclosing function at all and is never
+     graded under category 3.
+
+Why not parse docstrings
+-------------------------
+Issue #1799's own prose names "a test's own docstring or PR description" as
+what claims coverage, but a natural-language claim is not a machine-checkable
+input -- the same reason ``gitapex_gate_function_body_test_coverage.py``'s
+own docstring gives for checking "does this diff add a covering test" by AST
+identifier presence rather than by reading English. Operationalized instead
+as: grade every category 1-3 element this diff newly adds or changes inside
+an in-scope source file, paired against whichever of ``tests/test_{stem}.py``
+/ ``tests/test_{stem}_properties.py`` this *same* diff also adds or changes a
+line in (``_stem``/``_test_relative_paths``, copied verbatim from
+``gitapex_gate_function_body_test_coverage.py``) -- reusing that gate's own
+"this same diff must touch the test file too" scoping so a pre-existing,
+untouched test can never silently satisfy this gate. A source element with no
+diff-touched paired test file at all is not graded (nothing to
+mutation-test against) -- a disclosed scope limit, not fixed here.
+
+Mutation mechanism
+-------------------
+For each graded element, this gate locates its exact **byte** range in the
+source file: ``ast`` reports ``col_offset``/``end_col_offset`` as UTF-8 byte
+offsets, not character offsets (confirmed directly -- a non-ASCII character
+earlier on the same line shifts them past where a character-index slice
+would land), so every span here is computed and spliced against the file's
+own UTF-8-encoded bytes, never against a decoded ``str`` index. A leading
+UTF-8 BOM (``utf-8-sig``) is split off before any offset math and re-attached
+on write, so a BOM-carrying file's real content offsets are unaffected by it.
+
+Removing one element from a comma- or ``|``-separated sequence of ``N``
+siblings (``_removal_span_for_item``) removes that element's own span plus
+one adjoining separator -- the one *before* it when it is last, the one
+*after* it otherwise -- so the remaining sequence stays syntactically valid
+with no dangling separator; removing the sole element of a one-item sequence
+leaves an empty literal (``{}``, a pattern with no alternatives, exact same
+technique), also valid.
+
+The mutated bytes are written over the on-disk source file for the duration
+of one ``pytest`` subprocess invocation scoped to exactly the paired test
+file(s) this diff itself touches (see "Why not parse docstrings" above), then
+the original bytes are restored in a ``finally`` block regardless of outcome
+-- mirroring the temp-overwrite-then-restore technique real mutation-testing
+tools (``mutmut``, ``cosmic-ray``) use. The original bytes are read into
+memory once, before the first mutation of that file, and every restore comes
+from that same in-memory copy -- never by re-reading the file from disk after
+a prior mutation -- so an interrupted restore can never let a later
+mutation's restore step re-save an already-mutated copy as if it were the
+original.
+
+If the paired suite still exits 0 (every test passed) against the mutated
+source, that element is a ``defeat-test-mutation-gap`` finding: its paired
+test claims to cover it but does not actually fail when it is gone. A
+non-zero, non-one exit code (a collection error, an internal pytest error, a
+usage error, "no tests were collected" at all) means the run itself could not
+be trusted and raises :class:`ScanError` rather than being read either way --
+see "Exit codes" below.
+
+Invocation shape, runtime/CI cost disclosed rather than hidden
+-----------------------------------------------------------------
+Unlike either sibling gate (pure AST inspection, no subprocess at all), this
+gate spawns one real ``pytest`` subprocess per graded element -- its own CI
+job carries a generous timeout for exactly that reason, and this cost is
+stated here plainly rather than solved by artificially capping the element
+count. Each subprocess pytest invocation runs as
+``[sys.executable, "-m", "pytest", "--no-cov", "-n0", "-q", "-x", ...paired
+test paths]`` against a ``PYTHONPATH`` env var pointing at the graded source
+file's own containing directory (so a bare ``import <module>`` in the paired
+test resolves correctly regardless of whether the invoking process's own
+``--root`` carries a real ``pyproject.toml`` ``pythonpath`` entry for that
+directory -- load-bearing for this gate's own regression tests, which grade
+synthetic fixture trees with no such file) -- ``-n0`` overrides this
+repository's own ``pyproject.toml`` ``addopts`` (``-n auto``, pytest-xdist),
+confirmed live: passing ``-p no:xdist`` instead, rather than overriding the
+worker count, makes the still-addopts-injected ``-n auto`` flag itself
+unrecognised and fails every invocation with a usage error. ``-x`` stops at
+the first failure, sufficient since only "did at least one paired test fail"
+is asked. ``--no-cov`` disables this repository's own coverage plugin
+wiring for these short-lived, single-file runs.
+
+Reused verbatim from sibling gates
+------------------------------------
+``parse_added_lines`` (and its ``_diff_target_path``/
+``_looks_like_real_header_pair``/``_HUNK_RE`` machinery) is copied
+byte-for-byte from ``gitapex_gate_function_body_test_coverage.py`` -- see
+either sibling gate's own module docstring for the full incremental history
+of why each boundary check exists (issues #1184, #1193, and the
+two-independent-adversarial-review bypass fix), not re-narrated a third time
+here. ``_re_module_names`` is copied verbatim from
+``gitapex_gate_detection_logic_property_coverage.py``. ``_stem`` and
+``_test_relative_paths`` are copied verbatim from
+``gitapex_gate_function_body_test_coverage.py``.
+
+Waiver
+------
+``# defeat-test-mutation-coverage: WAIVED: <reason>`` -- a non-whitespace
+reason is mandatory, detected via ``tokenize`` exactly like both sibling
+gates' own ``_WAIVER_RE``/``_waived_lines``, so a waiver string quoted inside
+this gate's own docstring is never itself honoured as a real waiver. Honoured
+on the exact line ``Finding.line`` reports, the same "put the comment where
+the error points" convention
+``gitapex_gate_detection_logic_property_coverage.py`` applies.
+
+Exit codes
+----------
+0 clean, 1 a vacuous-coverage finding, 2 the scan could not be trusted
+(malformed diff, an in-scope or paired-test file that cannot be
+read/parsed, a ``--root`` that is not a directory, or a subprocess ``pytest``
+invocation that itself errors for a reason other than "tests ran and
+passed/failed" -- e.g. a collection error) -- the same fail-closed contract
+both sibling gates already state, dimension 15 of
+``skills/evaluating-deterministic-gate-quality/references/dimensions.md``.
+
+Known, disclosed non-goals
+----------------------------
+* **"The suite" is scoped to the paired co-located test file(s) only**,
+  never the full repository test suite. Issue #1799's own #1991 row states
+  the residual risk directly: "running only the file's own tests would miss
+  a cross-file assertion, and running everything is slow." This gate accepts
+  the narrower, fast scope rather than resolving it.
+* **Emit-only spelling assertions are out of scope for this mechanism.**
+  Issue #1799's own body states this directly: "an assertion that compares
+  only an emitted spelling is not caught by a remove-and-confirm-failure
+  pass, because a mutation that changes the emitted string does fail it.
+  Catching that one needs a parse assertion beside the spelling assertion...
+  which is a different check from mutation testing." Not attempted here.
+* **Only the three element categories issue #1799's own six rows evidence
+  directly are covered.** A vacuous test defeating some other shape of
+  production logic (a conditional branch with no regex/dict/literal shape at
+  all) is not covered and not claimed to be.
+
+Reads a unified diff on stdin; diagnostics and violations go to stderr. Run
+via ``uv run`` (the pydantic import needs it) or via the pytest gate in
+``tests/test_gitapex_gate_defeat_test_mutation_coverage.py``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import io
+import os
+import pathlib
+import re
+import shutil
+import subprocess
+import sys
+import tokenize
+from typing import NamedTuple
+
+from pydantic import BaseModel, ValidationError, field_validator
+
+REPO_ROOT = pathlib.Path(__file__).resolve().parents[2]
+
+# Union of both sibling gates' own in-scope directories, unprefixed --
+# matching gitapex_gate_function_body_test_coverage.py's own broader
+# precedent. See the module docstring's own "Scope" section.
+_IN_SCOPE_RE = re.compile(r"skills/[^/]+/scripts/[^/]+\.py|\.github/scripts/[^/]+\.py|hooks/[^/]+\.py")
+
+_MUTATION_GAP = "defeat-test-mutation-gap"
+
+_REGEX_ALTERNATION = "regex-alternation"
+_DICT_ENTRY = "dict-entry"
+_LITERAL_ELEMENT = "literal-element"
+
+# `# defeat-test-mutation-coverage: WAIVED: <reason>` -- a reason is
+# mandatory, the same "WAIVED: <reason>" vocabulary both sibling gates'
+# own waiver comments require.
+_WAIVER_RE = re.compile(r"#\s*defeat-test-mutation-coverage\s*:\s*WAIVED\s*:\s*\S.*", re.IGNORECASE)
+
+_HUNK_RE = re.compile(r"@@ -\d+(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+
+# Category 1: resolved through this file's own `import re` statements,
+# copied verbatim from gitapex_gate_detection_logic_property_coverage.py's
+# own `_re_module_names`/`_regex_trigger`.
+_RE_MODULE = "re"
+_REGEX_RECEIVER_AGNOSTIC_ATTRS = frozenset({"match", "search", "fullmatch"})
+
+# Category 3: only these four scalar Constant types are graded -- see the
+# module docstring's own "Known misses" section.
+_SUPPORTED_LITERAL_TYPES = (str, int, float, bool)
+
+# Category 3: the AST node types that make a display's own construction
+# conditional, disqualifying it from grading -- see the module docstring's
+# own category-3 paragraph.
+_GUARD_NODE_TYPES: tuple[type[ast.AST], ...] = (ast.If, ast.Try, ast.For, ast.AsyncFor, ast.While)
+if hasattr(ast, "TryStar"):
+    _GUARD_NODE_TYPES = (*_GUARD_NODE_TYPES, ast.TryStar)
+
+_PYTEST_TIMEOUT_SECONDS = 120
+
+_UTF8_BOM = b"\xef\xbb\xbf"
+
+_STRING_TOKEN_RE = re.compile(rb"^([A-Za-z]*)('''|\"\"\"|'|\")")
+
+
+class ScanError(Exception):
+    """The scan could not be trusted -- exit 2, never a silent pass."""
+
+
+class Finding(NamedTuple):
+    """One graded violation: an element this diff newly adds or changes
+    whose removal leaves its own paired test file(s) still passing clean."""
+
+    path: str
+    line: int
+    rule: str
+    message: str
+
+
+def in_scope(path: str) -> bool:
+    """Return True iff `path` is a checker script this gate grades. See the
+    module docstring's own "Scope" section."""
+    if not _IN_SCOPE_RE.fullmatch(path):
+        return False
+    name = path.rsplit("/", 1)[-1]
+    return not (name.startswith("test_") or name == "conftest.py")
+
+
+def _stem(path: str) -> str:
+    """Return the source module stem for a diff-relative path. Copied
+    verbatim from gitapex_gate_function_body_test_coverage.py's own
+    `_stem`."""
+    return path.rsplit("/", 1)[-1].removesuffix(".py")
+
+
+def _test_relative_paths(stem: str) -> tuple[str, str]:
+    """The two files this gate accepts as "a corresponding test" for source
+    module stem `stem`. Copied verbatim from
+    gitapex_gate_function_body_test_coverage.py's own
+    `_test_relative_paths`."""
+    return (f"tests/test_{stem}.py", f"tests/test_{stem}_properties.py")
+
+
+def _diff_target_path(raw: str) -> str | None:
+    """Return the post-image path named by a `+++ ` line, or None for
+    `/dev/null`. Copied verbatim from both sibling gates' own
+    `_diff_target_path`."""
+    target = raw.strip()
+    if target == "/dev/null":
+        return None
+    if not target.startswith("b/"):
+        raise ScanError(
+            f"unified diff post-image is not a plain b/-prefixed path: {target!r}. "
+            "This gate reads default `git diff` output; --no-prefix and quoted "
+            "paths are not resolvable here."
+        )
+    return target[2:]
+
+
+def _looks_like_real_header_pair(source_line: str, target_line: str) -> bool:
+    """True if `source_line`/`target_line` have the exact shape a real
+    `--- `/`+++ ` header pair always has. Copied verbatim from both sibling
+    gates' own `_looks_like_real_header_pair`."""
+    source = source_line[4:]
+    target = target_line[4:]
+    return (source == "/dev/null" or source.startswith("a/")) and (target == "/dev/null" or target.startswith("b/"))
+
+
+def parse_added_lines(diff_text: str) -> dict[str, set[int]]:
+    """Parse unified diff text into ``{post-image path: added line numbers}``.
+
+    Byte-for-byte the same parser both sibling gates carry their own copy
+    of -- see either one's own module docstring for the full incremental
+    history of why each boundary check exists (issues #1184, #1193, and the
+    two-independent-adversarial-review bypass fix), not re-narrated a third
+    time here.
+    """
+    added: dict[str, set[int]] = {}
+    path: str | None = None
+    lineno = 0
+    in_hunk = False
+    old_remaining = 0
+    new_remaining = 0
+    saw_source_header = False
+
+    def _reject_if_hunk_incomplete(
+        boundary: str,
+    ) -> None:  # function-body-test-coverage: WAIVED: a private closure nested inside parse_added_lines, with no name accessible from outside this function to reference directly; its raise path is exercised through parse_added_lines' own over-declared-hunk-count regression test instead
+        if in_hunk:
+            raise ScanError(
+                f"hunk header for {path!r} declared more pre-/post-image line(s) than its body "
+                f"actually had ({old_remaining} pre-image, {new_remaining} post-image line(s) "
+                f"still unconsumed) before {boundary}. Real `git diff` output always emits "
+                "accurate counts; a hand-fed or foreign patch's inaccurate ones would otherwise "
+                "leak this hunk's state into whatever follows it."
+            )
+
+    lines = diff_text.replace("\r\n", "\n").replace("\r", "\n").split("\n")
+    for index, line in enumerate(lines):
+        if line.startswith("diff --git "):
+            _reject_if_hunk_incomplete(f"the next `diff --git ` line: {line!r}")
+            path = None
+            in_hunk = False
+            saw_source_header = False
+            continue
+        if not in_hunk and line.startswith("--- "):
+            saw_source_header = True
+            continue
+        if not in_hunk and line.startswith("+++ "):
+            if not saw_source_header:
+                raise ScanError(
+                    f"unified diff post-image header with no `--- ` source header before it: {line!r}. "
+                    "This gate reads default `git diff` output, which always emits both; ignoring the "
+                    "header instead would drop every added line that follows it from grading."
+                )
+            path = _diff_target_path(line[4:])
+            saw_source_header = False
+            continue
+        if line.startswith("@@"):
+            _reject_if_hunk_incomplete(f"the next hunk header: {line!r}")
+            match = _HUNK_RE.match(line)
+            if not match:
+                raise ScanError(f"unparseable hunk header: {line!r}")
+            old_remaining = 1 if match.group(1) is None else int(match.group(1))
+            lineno = int(match.group(2))
+            new_remaining = 1 if match.group(3) is None else int(match.group(3))
+            in_hunk = old_remaining > 0 or new_remaining > 0
+            continue
+        if line.startswith("+"):
+            if path is not None:
+                added.setdefault(path, set()).add(lineno)
+            lineno += 1
+            new_remaining -= 1
+        elif line.startswith(" "):
+            lineno += 1
+            old_remaining -= 1
+            new_remaining -= 1
+        elif line.startswith("-"):
+            old_remaining -= 1
+        if old_remaining <= 0 and new_remaining <= 0:
+            if (
+                index > 0
+                and lines[index - 1].startswith("--- ")
+                and line.startswith("+++ ")
+                and _looks_like_real_header_pair(lines[index - 1], line)
+            ):
+                next_line = lines[index + 1] if index + 1 < len(lines) else ""
+                if next_line.startswith("@@") or next_line.startswith("diff --git "):
+                    raise ScanError(
+                        f"hunk for {path!r} closes exactly on a line shaped like a new file's "
+                        f"own post-image header ({line!r}), immediately after one shaped like a "
+                        f"source header, immediately before what looks like a new hunk or file "
+                        f"header ({next_line!r}) -- ambiguous between coincidental hunk-closing "
+                        "content and a real file transition missing its `diff --git ` separator. "
+                        "Failing closed here rather than silently misattributing whatever follows."
+                    )
+            in_hunk = False
+    _reject_if_hunk_incomplete("the diff ended")
+    return added
+
+
+def _waived_lines(source: str) -> set[int]:
+    """Return every line carrying an inline waiver comment. Read through
+    `tokenize` rather than a regex over raw text, matching both sibling
+    gates' own `_waived_lines`."""
+    waived: set[int] = set()
+    for token in tokenize.generate_tokens(io.StringIO(source).readline):
+        if token.type == tokenize.COMMENT and _WAIVER_RE.search(token.string):
+            waived.add(token.start[0])
+    return waived
+
+
+def _span(node: ast.expr) -> set[int]:
+    """Every source line `node` occupies -- an added line anywhere in this
+    span brings the element into this diff's scope, matching
+    gitapex_gate_detection_logic_property_coverage.py's own `_span`."""
+    end = node.end_lineno if node.end_lineno is not None else node.lineno
+    return set(range(node.lineno, end + 1))
+
+
+def _split_bom(data: bytes) -> tuple[bytes, bytes]:
+    """Split a leading UTF-8 BOM off `data`, returning `(bom, body)`. Every
+    byte-offset computed by this gate is relative to `body`, never `data`,
+    so a BOM-carrying file's real content offsets are unaffected by it."""
+    if data.startswith(_UTF8_BOM):
+        return data[:3], data[3:]
+    return b"", data
+
+
+def _line_byte_starts(body: bytes) -> list[int]:
+    """`result[lineno - 1]` is the absolute byte offset where physical line
+    `lineno` (1-indexed, matching `ast` node `lineno`) begins in `body`."""
+    starts = [0]
+    offset = 0
+    while True:
+        index = body.find(b"\n", offset)
+        if index == -1:
+            break
+        offset = index + 1
+        starts.append(offset)
+    return starts
+
+
+def _node_byte_span(node: ast.expr, line_starts: list[int]) -> tuple[int, int]:
+    """The `(start, end)` absolute byte span `node` occupies in `body`, per
+    `ast`'s own UTF-8-byte-offset `col_offset`/`end_col_offset` convention
+    -- see the module docstring's own "Mutation mechanism" section for why
+    this is a byte offset, confirmed directly, not a character index."""
+    start = line_starts[node.lineno - 1] + node.col_offset
+    end_lineno = node.end_lineno if node.end_lineno is not None else node.lineno
+    end_col = node.end_col_offset if node.end_col_offset is not None else node.col_offset
+    end = line_starts[end_lineno - 1] + end_col
+    return start, end
+
+
+def _removal_span_for_item(item_spans: list[tuple[int, int]], index: int) -> tuple[int, int]:
+    """Given the `(start, end)` byte spans of every item in a comma- or
+    `|`-separated sequence of `N >= 1` siblings, return the byte span to
+    delete to remove item `index` alone while leaving the remaining items
+    validly joined: the item's own span plus one adjoining separator -- the
+    one before it when it is the last item (so removing the last item
+    consumes the separator that used to precede it, not a nonexistent one
+    that used to follow it), the one after it otherwise. Removing the sole
+    item of a one-item sequence deletes just that item's own span, leaving
+    an empty container/alternation-less literal -- still syntactically
+    valid Python/regex. See the module docstring's own "Mutation mechanism"
+    section."""
+    if len(item_spans) == 1:
+        return item_spans[0]
+    if index < len(item_spans) - 1:
+        return item_spans[index][0], item_spans[index + 1][0]
+    return item_spans[index - 1][1], item_spans[index][1]
+
+
+# --- Category 1: regex alternation branch -----------------------------------
+
+
+def _re_module_names(tree: ast.Module) -> frozenset[str]:
+    """Every bare name an `import re` in `tree` binds to the `re` module.
+    Copied verbatim from gitapex_gate_detection_logic_property_coverage.py's
+    own `_re_module_names`."""
+    names = {_RE_MODULE}
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == _RE_MODULE:
+                    names.add(alias.asname or alias.name)
+    return frozenset(names)
+
+
+def _regex_pattern_literal(node: ast.Call, re_module_names: frozenset[str]) -> ast.Constant | None:
+    """Return the pattern-argument `Constant` node iff `node` is a
+    `re.compile(...)`/`re.match(...)`/`re.search(...)`/`re.fullmatch(...)`
+    call (the `.compile` receiver resolved through `re_module_names`;
+    `.match`/`.search`/`.fullmatch` receiver-agnostic on any receiver,
+    matching `gitapex_gate_detection_logic_property_coverage.py`'s own
+    `_regex_trigger`) whose first positional argument is a plain string
+    literal. None for every other call shape, including a `.compile`/
+    `.match`/`.search`/`.fullmatch` call whose first argument is not itself
+    a string `Constant` (an f-string, a name, a concatenation)."""
+    func = node.func
+    if not isinstance(func, ast.Attribute):
+        return None
+    if func.attr == "compile":
+        if not (isinstance(func.value, ast.Name) and func.value.id in re_module_names):
+            return None
+    elif func.attr not in _REGEX_RECEIVER_AGNOSTIC_ATTRS:
+        return None
+    if not node.args:
+        return None
+    first = node.args[0]
+    if isinstance(first, ast.Constant) and isinstance(first.value, str):
+        return first
+    return None
+
+
+def _string_literal_content_span(raw: bytes) -> tuple[int, int]:
+    """Given the raw source bytes of a string literal token (e.g.
+    `b'r"a|b"'`), return the `(start, end)` byte offsets, within `raw`, of
+    the pattern content between the quote delimiters (any prefix and the
+    quotes themselves excluded). Raises `ValueError` for anything that is
+    not a single, self-contained string literal token -- an f-string (the
+    regex prefix match itself already excludes it, since `ast.Constant`
+    never holds an f-string's runtime value as a plain string), or
+    **implicit string concatenation** (`"a|b" "c|d"`): `ast.Constant`
+    merges adjacent literals into one node whose `col_offset`/
+    `end_col_offset` span *both* tokens and the whitespace between them,
+    which the quote-stripping regex below cannot tell apart from a single
+    literal by inspecting only its own start and end -- confirmed live,
+    not merely a theoretical risk: an earlier version of this function
+    used only that regex and silently mis-spliced across the token
+    boundary. `tokenize` is the actual ground truth for "is this one
+    token": `raw` is rejected unless tokenizing it yields exactly one
+    `STRING` token whose own text is `raw` in full."""
+    match = _STRING_TOKEN_RE.match(raw)
+    if match is None:
+        raise ValueError(f"not a recognisable string literal token: {raw!r}")
+    quote = match.group(2)
+    start = match.end()
+    end = len(raw) - len(quote)
+    if end < start:
+        raise ValueError(f"malformed string literal token: {raw!r}")
+    try:
+        decoded = raw.decode("utf-8")
+    except UnicodeDecodeError as error:
+        raise ValueError(f"string literal token is not valid UTF-8: {raw!r}") from error
+    try:
+        tokens = list(tokenize.generate_tokens(io.StringIO(decoded).readline))
+    except (tokenize.TokenError, SyntaxError) as error:
+        raise ValueError(f"could not tokenize string literal token: {raw!r}: {error}") from error
+    string_tokens = [token for token in tokens if token.type == tokenize.STRING]
+    if len(string_tokens) != 1 or string_tokens[0].string != decoded:
+        raise ValueError(f"not a single self-contained string literal token (implicit concatenation?): {raw!r}")
+    return start, end
+
+
+def _top_level_pipe_positions(content: bytes) -> list[int]:
+    """Every byte offset, within `content`, of a top-level `|` -- at
+    paren-depth 0, outside a `[...]` character class, and not immediately
+    preceded by an unescaped `\\`. See the module docstring's own
+    "Element categories graded" section, category 1."""
+    positions: list[int] = []
+    paren_depth = 0
+    in_class = False
+    index = 0
+    length = len(content)
+    while index < length:
+        byte = content[index]
+        if byte == 0x5C:  # backslash: the next byte is escaped, whatever it is
+            index += 2
+            continue
+        if in_class:
+            if byte == 0x5D:  # ]
+                in_class = False
+        elif byte == 0x28:  # (
+            paren_depth += 1
+        elif byte == 0x29:  # )
+            paren_depth = max(0, paren_depth - 1)
+        elif byte == 0x5B:  # [
+            in_class = True
+        elif byte == 0x7C and paren_depth == 0:  # |
+            positions.append(index)
+        index += 1
+    return positions
+
+
+def _alternative_spans(content: bytes, pipe_positions: list[int]) -> list[tuple[int, int]]:
+    """The `(start, end)` byte spans, within `content`, of every alternative
+    delimited by `pipe_positions` (each span excludes the `|` bytes
+    themselves)."""
+    spans: list[tuple[int, int]] = []
+    start = 0
+    for position in pipe_positions:
+        spans.append((start, position))
+        start = position + 1
+    spans.append((start, len(content)))
+    return spans
+
+
+def _regex_alternation_elements(
+    tree: ast.Module, body: bytes, line_starts: list[int], added: set[int]
+) -> list[tuple[int, str, str, tuple[int, int]]]:
+    """Every category-1 graded element: `(line, category, message,
+    removal_span)` for each top-level alternative of a regex pattern this
+    diff newly adds or changes."""
+    re_module_names = _re_module_names(tree)
+    elements: list[tuple[int, str, str, tuple[int, int]]] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        literal = _regex_pattern_literal(node, re_module_names)
+        if literal is None:
+            continue
+        if not (_span(node) & added):
+            continue
+        literal_start, literal_end = _node_byte_span(literal, line_starts)
+        raw = body[literal_start:literal_end]
+        try:
+            content_start, content_end = _string_literal_content_span(raw)
+        except ValueError:
+            continue
+        content = raw[content_start:content_end]
+        pipe_positions = _top_level_pipe_positions(content)
+        if not pipe_positions:
+            continue
+        alt_spans = _alternative_spans(content, pipe_positions)
+        for index, (alt_start, alt_end) in enumerate(alt_spans):
+            removal_content_span = _removal_span_for_item(alt_spans, index)
+            removal_span = (
+                literal_start + content_start + removal_content_span[0],
+                literal_start + content_start + removal_content_span[1],
+            )
+            alt_text = content[alt_start:alt_end].decode("utf-8", errors="replace")
+            pattern_text = content.decode("utf-8", errors="replace")
+            elements.append(
+                (
+                    literal.lineno,
+                    _REGEX_ALTERNATION,
+                    f"regex alternation branch {alt_text!r} (of {len(alt_spans)}) in pattern {pattern_text!r}",
+                    removal_span,
+                )
+            )
+    return elements
+
+
+# --- Category 2: module-level dict/mapping-literal entry --------------------
+
+
+def _module_level_dict_assigns(tree: ast.Module) -> list[tuple[str, ast.Dict]]:
+    """Every `NAME = {...}` assignment directly in the module body -- the
+    category-2 shape, and the set category 3 must not double-grade."""
+    result: list[tuple[str, ast.Dict]] = []
+    for node in tree.body:
+        if (
+            isinstance(node, ast.Assign)
+            and len(node.targets) == 1
+            and isinstance(node.targets[0], ast.Name)
+            and isinstance(node.value, ast.Dict)
+        ):
+            result.append((node.targets[0].id, node.value))
+    return result
+
+
+def _dict_entry_elements(
+    tree: ast.Module, body: bytes, line_starts: list[int], added: set[int]
+) -> list[tuple[int, str, str, tuple[int, int]]]:
+    """Every category-2 graded element: `(line, category, message,
+    removal_span)` for each entry of a module-level `CONST = {...}` dict
+    this diff newly adds or changes."""
+    elements: list[tuple[int, str, str, tuple[int, int]]] = []
+    for name, dict_node in _module_level_dict_assigns(tree):
+        values = dict_node.values
+        if not dict_node.keys or any(key is None for key in dict_node.keys):
+            continue
+        # `dict_node.keys` is `list[ast.expr | None]` (`None` marks a
+        # `**`-unpacking entry) -- the guard above already rejects any dict
+        # carrying one, so every element here is a real key; this
+        # re-binding narrows the type for mypy without re-checking anything
+        # the guard didn't already establish.
+        keys: list[ast.expr] = [key for key in dict_node.keys if key is not None]
+        entry_spans = [
+            (_node_byte_span(key, line_starts)[0], _node_byte_span(value, line_starts)[1])
+            for key, value in zip(keys, values, strict=True)
+        ]
+        for index, (key, value) in enumerate(zip(keys, values, strict=True)):
+            entry_lines = set(range(key.lineno, (value.end_lineno or value.lineno) + 1))
+            if not (entry_lines & added):
+                continue
+            removal_span = _removal_span_for_item(entry_spans, index)
+            key_start, key_end = _node_byte_span(key, line_starts)
+            key_text = body[key_start:key_end].decode("utf-8", errors="replace")
+            elements.append(
+                (
+                    key.lineno,
+                    _DICT_ENTRY,
+                    f"entry {key_text} in module-level dict `{name}`",
+                    removal_span,
+                )
+            )
+    return elements
+
+
+# --- Category 3: unconditionally emitted literal -----------------------------
+
+
+def _parent_map(tree: ast.Module) -> dict[int, ast.AST]:
+    """`id(child) -> parent` for every node in `tree`, keyed by `id()` since
+    `ast` nodes are not hashable by value and two structurally-identical
+    nodes must never collide as dict keys."""
+    parents: dict[int, ast.AST] = {}
+    for node in ast.walk(tree):
+        for child in ast.iter_child_nodes(node):
+            parents[id(child)] = node
+    return parents
+
+
+def _enclosing_function_unconditional(
+    node: ast.AST, parents: dict[int, ast.AST]
+) -> ast.FunctionDef | ast.AsyncFunctionDef | None:
+    """Walk upward from `node` to its enclosing function, returning that
+    function iff no `If`/`Try`/`For`/`AsyncFor`/`While` ancestor sits
+    between them (the display is built unconditionally in that function's
+    own body). None when no enclosing function exists at all (a module- or
+    class-body-level display) or when a guard sits between `node` and the
+    nearest enclosing function."""
+    current = parents.get(id(node))
+    while current is not None:
+        if isinstance(current, ast.FunctionDef | ast.AsyncFunctionDef):
+            return current
+        if isinstance(current, _GUARD_NODE_TYPES):
+            return None
+        current = parents.get(id(current))
+    return None
+
+
+def _is_supported_literal(value: object) -> bool:
+    return isinstance(value, _SUPPORTED_LITERAL_TYPES)
+
+
+def _literal_display_elements(
+    tree: ast.Module, body: bytes, line_starts: list[int], added: set[int]
+) -> list[tuple[int, str, str, tuple[int, int]]]:
+    """Every category-3 graded element: `(line, category, message,
+    removal_span)` for each unconditionally-constructed-in-a-function
+    literal list/tuple/set item or non-category-2 dict-entry value this
+    diff newly adds or changes."""
+    parents = _parent_map(tree)
+    module_dict_ids = {id(dict_node) for _name, dict_node in _module_level_dict_assigns(tree)}
+    elements: list[tuple[int, str, str, tuple[int, int]]] = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.List | ast.Tuple | ast.Set):
+            func = _enclosing_function_unconditional(node, parents)
+            if func is None or not node.elts:
+                continue
+            item_spans = [_node_byte_span(item, line_starts) for item in node.elts]
+            for index, item in enumerate(node.elts):
+                if not (isinstance(item, ast.Constant) and _is_supported_literal(item.value)):
+                    continue
+                if not (_span(item) & added):
+                    continue
+                removal_span = _removal_span_for_item(item_spans, index)
+                elements.append(
+                    (
+                        item.lineno,
+                        _LITERAL_ELEMENT,
+                        f"literal element {item.value!r} in an unconditionally constructed "
+                        f"display inside `{func.name}`",
+                        removal_span,
+                    )
+                )
+        elif isinstance(node, ast.Dict):
+            if id(node) in module_dict_ids or not node.keys or any(key is None for key in node.keys):
+                continue
+            func = _enclosing_function_unconditional(node, parents)
+            if func is None:
+                continue
+            # See `_dict_entry_elements`'s own identical comment: the guard
+            # above already rejects any `**`-unpacking (`None`-keyed) dict,
+            # so this re-binding is a type narrowing, not a new check.
+            dict_keys: list[ast.expr] = [key for key in node.keys if key is not None]
+            entry_spans = [
+                (_node_byte_span(key, line_starts)[0], _node_byte_span(value, line_starts)[1])
+                for key, value in zip(dict_keys, node.values, strict=True)
+            ]
+            for index, (key, value) in enumerate(zip(dict_keys, node.values, strict=True)):
+                if not (isinstance(value, ast.Constant) and _is_supported_literal(value.value)):
+                    continue
+                entry_lines = set(range(key.lineno, (value.end_lineno or value.lineno) + 1))
+                if not (entry_lines & added):
+                    continue
+                removal_span = _removal_span_for_item(entry_spans, index)
+                elements.append(
+                    (
+                        key.lineno,
+                        _LITERAL_ELEMENT,
+                        f"dict entry value {value.value!r} unconditionally emitted inside `{func.name}`",
+                        removal_span,
+                    )
+                )
+    return elements
+
+
+# --- Mutation execution -------------------------------------------------------
+
+
+def _invalidate_pycache(absolute_path: pathlib.Path) -> None:
+    """Remove any cached bytecode for `absolute_path`'s own module before
+    (and after) each mutation subprocess run.
+
+    CPython's default import cache validates a `.pyc` by the *source
+    file's own mtime and size* recorded in its header, not by content: two
+    different writes to the same path landing inside the same mtime tick
+    -- confirmed live, not merely a theoretical risk, this gate rewrites
+    the same file repeatedly in quick succession across several mutations
+    of the same source -- can make a stale cache from a *different*
+    mutation (or the original, unmutated content) validate against a
+    fresh write and get served instead of the content actually on disk,
+    silently corrupting this gate's own verdict. Removing the whole
+    `__pycache__` directory next to the module (rather than only the one
+    cache file `importlib.util.cache_from_source` would name) is simple,
+    safe, and correct regardless of interpreter version or which of
+    several possible tag suffixes a given Python build uses. Called both
+    right before running pytest against a freshly mutated copy and right
+    after restoring the original bytes, so no stale entry can outlive
+    this gate's own run and corrupt an unrelated, later import of the
+    same file by another process (e.g. this repository's own full pytest
+    suite, run either before or after this gate in the same CI job)."""
+    cache_dir = absolute_path.parent / "__pycache__"
+    if cache_dir.is_dir():
+        shutil.rmtree(cache_dir, ignore_errors=True)
+
+
+def _run_mutation(
+    absolute_path: pathlib.Path,
+    bom: bytes,
+    original_body: bytes,
+    removal_span: tuple[int, int],
+    test_paths: list[pathlib.Path],
+    root: pathlib.Path,
+) -> bool:
+    """Overwrite `absolute_path` with `bom + original_body` minus
+    `removal_span`, run pytest against `test_paths`, restore the original
+    bytes in a `finally` block regardless of outcome. Returns True iff the
+    mutation SURVIVED (the paired suite still passed clean); False iff at
+    least one paired test failed (the mutation was caught). Raises
+    `ScanError` for anything else -- a write/restore failure, a subprocess
+    that could not be started or timed out, or a pytest exit code that is
+    neither 0 nor 1 -- per the module docstring's own "Exit codes" section.
+    """
+    start, end = removal_span
+    mutated = bom + original_body[:start] + original_body[end:]
+    try:
+        absolute_path.write_bytes(mutated)
+    except OSError as error:
+        raise ScanError(f"could not write a mutated copy of {absolute_path}: {error}") from error
+    _invalidate_pycache(absolute_path)
+
+    env = dict(os.environ)
+    extra_path = str(absolute_path.parent)
+    existing = env.get("PYTHONPATH", "")
+    env["PYTHONPATH"] = f"{extra_path}{os.pathsep}{existing}" if existing else extra_path
+    # Defense in depth alongside `_invalidate_pycache`: never let the
+    # subprocess itself write a new cache entry that a later mutation (or
+    # a later, unrelated import of the restored original) could read back
+    # as stale. `_invalidate_pycache` alone already prevents a stale read
+    # by clearing the directory before every run; this just stops a new
+    # one from being created in the first place.
+    env["PYTHONDONTWRITEBYTECODE"] = "1"
+
+    try:
+        try:
+            completed = subprocess.run(  # noqa: S603
+                [sys.executable, "-m", "pytest", "--no-cov", "-n0", "-q", "-x", *(str(p) for p in test_paths)],
+                cwd=root,
+                env=env,
+                capture_output=True,
+                timeout=_PYTEST_TIMEOUT_SECONDS,
+                check=False,
+            )
+        except subprocess.TimeoutExpired as error:
+            raise ScanError(
+                f"pytest timed out after {_PYTEST_TIMEOUT_SECONDS}s grading a mutated copy of "
+                f"{absolute_path} against {test_paths}: {error}"
+            ) from error
+        except OSError as error:
+            raise ScanError(
+                f"pytest failed to run grading a mutated copy of {absolute_path} against {test_paths}: {error}"
+            ) from error
+    finally:
+        try:
+            absolute_path.write_bytes(bom + original_body)
+        except OSError as error:
+            raise ScanError(f"could not restore {absolute_path} after mutation testing: {error}") from error
+        _invalidate_pycache(absolute_path)
+
+    if completed.returncode == 0:
+        return True
+    if completed.returncode == 1:
+        return False
+    raise ScanError(
+        f"pytest exited {completed.returncode} (neither 0 nor 1) grading a mutated copy of "
+        f"{absolute_path} against {test_paths} -- this scan cannot trust the result. stderr tail: "
+        f"{completed.stderr.decode('utf-8', errors='replace')[-2000:]}"
+    )
+
+
+def _graded_elements(path: str, source_text: str, added: set[int]) -> list[tuple[int, str, str, tuple[int, int]]]:
+    """Every category 1-3 graded element for one source file's own AST,
+    `(line, category, message, removal_span)`, `removal_span` in bytes
+    relative to the file's own BOM-stripped body."""
+    tree = ast.parse(source_text, filename=path)
+    body = source_text.encode("utf-8")
+    line_starts = _line_byte_starts(body)
+    elements: list[tuple[int, str, str, tuple[int, int]]] = []
+    elements.extend(_regex_alternation_elements(tree, body, line_starts, added))
+    elements.extend(_dict_entry_elements(tree, body, line_starts, added))
+    elements.extend(_literal_display_elements(tree, body, line_starts, added))
+    return elements
+
+
+def find_violations(diff_text: str, root: pathlib.Path) -> tuple[list[Finding], list[Finding], int]:
+    """Grade every in-scope file the diff adds lines to.
+
+    Returns ``(violations, honoured waivers, files graded)``. Raises
+    ``ScanError`` when a file named by the diff exists but cannot be read as
+    UTF-8 or parsed, or when a mutation subprocess itself could not be
+    trusted. A file with no diff-touched paired test file is skipped (not
+    counted as graded) -- see the module docstring's own "Why not parse
+    docstrings" section.
+    """
+    violations: list[Finding] = []
+    waived: list[Finding] = []
+    graded = 0
+    added_by_path = parse_added_lines(diff_text)
+    for path, added in sorted(added_by_path.items()):
+        if not in_scope(path):
+            continue
+        absolute = root / path
+        try:
+            original_bytes = absolute.read_bytes()
+        except FileNotFoundError:
+            raise ScanError(f"{path}: named by the diff as added or modified, but missing from {root}") from None
+        except OSError as error:
+            raise ScanError(f"{path}: cannot be read: {error}") from error
+
+        bom, body = _split_bom(original_bytes)
+        try:
+            source_text = body.decode("utf-8")
+        except UnicodeDecodeError as error:
+            raise ScanError(f"{path}: cannot be read as UTF-8 text: {error}") from error
+
+        stem = _stem(path)
+        touched_tests = [relative for relative in _test_relative_paths(stem) if added_by_path.get(relative)]
+        if not touched_tests:
+            continue
+
+        try:
+            elements = _graded_elements(path, source_text, added)
+        except (SyntaxError, ValueError) as error:
+            raise ScanError(f"{path}: cannot be parsed as Python: {error}") from error
+
+        if not elements:
+            graded += 1
+            continue
+
+        waived_lines = _waived_lines(source_text)
+        test_paths = [root / relative for relative in touched_tests]
+        for line, category, message, removal_span in elements:
+            survived = _run_mutation(absolute, bom, body, removal_span, test_paths, root)
+            if not survived:
+                continue
+            finding = Finding(
+                path,
+                line,
+                _MUTATION_GAP,
+                f"{category}: {message} -- removing it still leaves {' and '.join(touched_tests)} passing clean",
+            )
+            target = waived if finding.line in waived_lines else violations
+            target.append(finding)
+        graded += 1
+    return sorted(set(violations)), sorted(set(waived)), graded
+
+
+class GateDefeatTestMutationCoverageArgs(BaseModel):
+    """Typed view of `main`'s parsed CLI namespace. `root` must be an
+    existing directory."""
+
+    root: pathlib.Path
+
+    @field_validator("root")
+    @classmethod
+    def _root_must_exist(cls, value: pathlib.Path) -> pathlib.Path:
+        if not value.is_dir():
+            raise ValueError(f"--root must be an existing directory, got {value}")
+        return value
+
+
+def main(argv: list[str] | None = None) -> int:
+    """CLI: 0 clean, 1 violation found, 2 the scan could not be trusted."""
+    parser = argparse.ArgumentParser(
+        description="Check that a new or materially changed regex alternation branch, module-level dict "
+        "entry, or unconditionally emitted literal added by this diff is actually caught -- not merely "
+        "mentioned -- by this same diff's own paired test. Reads a unified diff on standard input."
+    )
+    parser.add_argument(
+        "--root",
+        type=pathlib.Path,
+        default=REPO_ROOT,
+        help="Repository root the diff's paths, and the co-located tests/ directory, resolve "
+        "against (defaults to this checkout).",
+    )
+    parser.add_argument(
+        "--diff",
+        type=pathlib.Path,
+        help="Read the unified diff from this file instead of standard input.",
+    )
+    args = parser.parse_args(argv)
+
+    try:
+        validated = GateDefeatTestMutationCoverageArgs(root=args.root)
+    except ValidationError:
+        print(f"{args.root}: --root must be an existing directory", file=sys.stderr)
+        return 2
+
+    if args.diff is not None:
+        try:
+            diff_text = args.diff.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError) as error:
+            print(f"{args.diff}: diff cannot be read as UTF-8 text: {error}", file=sys.stderr)
+            return 2
+    else:
+        try:
+            diff_text = sys.stdin.buffer.read().decode("utf-8")
+        except UnicodeDecodeError as error:
+            print(f"standard input: diff cannot be read as UTF-8 text: {error}", file=sys.stderr)
+            return 2
+
+    try:
+        violations, waived, graded = find_violations(diff_text, validated.root)
+    except ScanError as error:
+        print(f"{error}", file=sys.stderr)
+        return 2
+
+    for finding in waived:
+        print(
+            f"{finding.path}:{finding.line}: {finding.rule}: waived inline -- {finding.message}",
+            file=sys.stderr,
+        )
+
+    if violations:
+        for finding in violations:
+            print(f"{finding.path}:{finding.line}: {finding.rule}: {finding.message}", file=sys.stderr)
+        print(
+            f"\n{len(violations)} new or materially changed element(s) reached by this diff have a "
+            "paired test that still passes clean once the element is removed (issue #1799). Make the "
+            "paired test assert the element itself (an exact-match or parse-back assertion, not merely "
+            "a type/non-emptiness check). When a human has already judged the element covered some "
+            "other way, disclose it inline with "
+            "'# defeat-test-mutation-coverage: WAIVED: <reason>' on the reported line.",
+            file=sys.stderr,
+        )
+        return 1
+
+    print(f"OK: {graded} in-scope file(s) graded, {len(waived)} inline waiver(s) honoured.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/.github/scripts/gitapex_gate_local_preflight.py b/.github/scripts/gitapex_gate_local_preflight.py
index 2b41ce7f..f3a992cc 100644
--- a/.github/scripts/gitapex_gate_local_preflight.py
+++ b/.github/scripts/gitapex_gate_local_preflight.py
@@ -107,7 +107,7 @@
   (issue #890), which closes the "configured here but never actually
   installed" half; nothing closes the ``--no-verify`` half. CI remains the
   authoritative merge gate for every gate carrying a ``ci`` plane -- true
-  for 47 of the 49 wired gates. ``behind-base`` (issue #985) and
+  for 48 of the 50 wired gates. ``behind-base`` (issue #985) and
   ``real-checkout-git-write`` (issue #991) are the two exceptions: each
   carries only ``local``, so for those two gates specifically this
   pre-push hook -- bypassable the same way as any other -- is the *only*
@@ -119,7 +119,7 @@
   ``jsonschema`` -- a real, non-stdlib dependency, contrary to an earlier
   revision of this paragraph's own "the runner itself needs no
   dependencies" claim. A bare system ``python3`` with no ``jsonschema``
-  installed crashed the whole runner on import before any of the 49 wired
+  installed crashed the whole runner on import before any of the 50 wired
   gates got a chance to run individually, so CONTRIBUTING.md's standalone
   example and the pre-push hook's own ``entry`` both now invoke it as ``uv
   run --frozen python3`` too, the same pin every wired gate's own argv
@@ -207,10 +207,15 @@
 # own _GROUP_TIMEOUT_SECONDS = 600 -- so that one gate's own theoretical
 # worst case is ~4200 s, not 600 s. A ceiling matching that would be useless
 # as a hang guard (80 minutes of a silent pre-push), so this is a judgment
-# call in the other direction. For scale: a warm run of all 49 wired gates
-# combined measures roughly 24 s end to end (issue #1512's network-
-# exception-set-drift gate; different hardware than the figures
-# below, see this paragraph's own closing parenthetical -- the
+# call in the other direction. For scale: a warm run of all 50 wired gates
+# combined measures roughly 49 s end to end (issue #1799's own
+# defeat-test-mutation-coverage gate roughly doubled this from its prior
+# ~24 s baseline: unlike every other wired gate, which is pure AST
+# inspection, it spawns a real pytest subprocess per graded element and
+# self-grades its own regex/dict/literal elements against its own paired
+# tests; different hardware than the figures
+# below in any case, see this paragraph's own closing parenthetical -- the
+# prior 49-gate set measured roughly 24 s, the
 # prior 48-gate set measured roughly 24 s, the
 # prior 47-gate set measured roughly 22 s, the
 # prior 45-gate set measured roughly 14 s, the
diff --git a/.github/workflows/defeat-test-mutation-coverage-gate.yml b/.github/workflows/defeat-test-mutation-coverage-gate.yml
new file mode 100644
index 00000000..24ddfd14
--- /dev/null
+++ b/.github/workflows/defeat-test-mutation-coverage-gate.yml
@@ -0,0 +1,99 @@
+# Issue #1799 (six consolidated rows across #1733, #1734, #1735, #1736,
+# #1990, #1991). A new or materially changed regex alternation branch,
+# module-level dict entry, or unconditionally-emitted literal added by a PR
+# diff to one of this repository's own checker scripts must actually be
+# caught -- not merely mentioned -- by this same diff's own paired test: see
+# .github/scripts/gitapex_gate_defeat_test_mutation_coverage.py's own module
+# docstring for the three graded element categories, the mutation mechanism
+# (a real `pytest` subprocess run against a temporarily mutated copy of the
+# source file), the motivating gaps, and the disclosed scope limits and known
+# misses/non-goals. This job runs that scan against exactly the in-scope
+# files a diff actually adds trigger-shaped lines to.
+#
+# Deliberately no `paths:` filter -- drift gate:
+# tests/test_gitapex_gate_defeat_test_mutation_coverage.py's own
+# test_the_workflow_has_no_paths_filter. See that test's docstring for why
+# (GitHub's own skipped-vs-never-ran distinction for a required check).
+name: Defeat-test mutation-coverage gate
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  defeat-test-mutation-coverage:
+    runs-on: ubuntu-latest
+    # Generous relative to the other AST-only gates' own 5-minute ceiling
+    # (they spawn no subprocess at all): this gate spawns one real `pytest`
+    # subprocess per graded element -- see the gate script's own module
+    # docstring, "Invocation shape, runtime/CI cost disclosed rather than
+    # hidden" -- so its own job needs real headroom rather than a ceiling
+    # copied from a gate with a fundamentally different cost shape.
+    timeout-minutes: 20
+    permissions:
+      contents: read
+    steps:
+      # `ref:`/`fetch-depth: '0'` below is this gate's own diff-post-image
+      # checkout pin -- drift gate:
+      # tests/test_gitapex_gate_defeat_test_mutation_coverage.py's own
+      # test_the_workflow_checks_out_the_head_sha_with_full_history. See
+      # that test's docstring for why (this gate correlates diff-derived
+      # line numbers with tree content, the same requirement both sibling
+      # gates' own workflows state for themselves and for the identical
+      # reason -- this gate additionally reads and temporarily overwrites the
+      # graded source file's own on-disk content, and runs the corresponding
+      # tests/*.py files' own tree content at the same head, not only reads
+      # it).
+      #
+      # The accepted cost, stated rather than discovered later: this runs
+      # the PR branch's own copy of the gate, so a branch that forked before
+      # a hardening of the gate landed on main is graded by the older rules.
+      # Branch protection's "Require branches to be up to date" closes that,
+      # and it is a GitHub-side setting no in-repo file can record.
+      - name: Harden runner + checkout
+        uses: tvna/gitapex/.github/actions/harden-checkout@2f62b5648552a0f800b1b85e75ec108a7016dd02
+        with:
+          fetch-depth: '0'
+          ref: ${{ github.event.pull_request.head.sha }}
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9  # v9.0.0
+        with:
+          enable-cache: true
+
+      # git merge-base below -- drift gate:
+      # tests/test_gitapex_gate_defeat_test_mutation_coverage.py's own
+      # test_the_workflow_uses_merge_base_not_base_sha.
+      #
+      # The two `git diff` flags below (--no-renames, -c
+      # core.quotePath=false) -- drift gate:
+      # tests/test_gitapex_gate_defeat_test_mutation_coverage.py's own
+      # test_the_workflow_passes_the_two_flags_the_gate_depends_on. See that
+      # test's docstring for why each matters.
+      #
+      # Issue #1035: every `.github/scripts/*.py` invocation goes through
+      # `uv run` regardless of whether the script needs a third-party
+      # dependency. This gate carries a real `pydantic` import (its own
+      # --root validation) and spawns its own `pytest` subprocesses via the
+      # same interpreter `uv run` resolves, so `uv run` is load-bearing here
+      # too -- both for the gate's own dependencies and for the venv its own
+      # mutation subprocesses run pytest under.
+      - name: Mutation-test the elements this diff adds
+        env:
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: |
+          set -euo pipefail
+          if ! merge_base=$(git merge-base "$BASE_SHA" "$HEAD_SHA"); then
+            echo "::error::git merge-base failed between $BASE_SHA and $HEAD_SHA" >&2
+            exit 1
+          fi
+          git -c core.quotePath=false diff -U0 --no-renames "$merge_base" "$HEAD_SHA" -- '*.py' \
+            | uv run --frozen python3 .github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index dd670e8f..7050940d 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -157,9 +157,12 @@ repos:
       # already-open PR. This runs all of them in one pass at pre-push --
       # the last local moment before a gap becomes a CI round-trip, and
       # deliberately not pre-commit: it grades committed state (HEAD vs
-      # origin/main), not a staged index, and at ~24 s
-      # warm end to end for all 49 wired gates it is too slow to sit on every
-      # single commit.
+      # origin/main), not a staged index, and at ~49 s
+      # warm end to end for all 50 wired gates (issue #1799's own
+      # defeat-test-mutation-coverage gate roughly doubled this from its
+      # prior ~24 s baseline, being the first wired gate that spawns a real
+      # pytest subprocess per graded element rather than pure AST
+      # inspection) it is too slow to sit on every single commit.
       #
       # The wired set is not listed here: the runner discovers it from
       # .gitapex/ssot.json's `local` plane, so a newly wired gate needs no
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index fb8a7354..29e1c991 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -125,10 +125,15 @@ used to be discovered one red check at a time on an already-open PR.
 
 The same `uv run prek install -t pre-commit -t pre-push -t commit-msg` above also installs
 a **pre-push** hook that runs every gate with a working-tree-only form in
-one pass, before the push leaves your machine. A warm run of all 49 wired
-gates measures roughly 24 seconds end to end (issue #1512's network-
-exception-set-drift gate; different hardware than the figures below --
-the prior 48-gate set measured roughly 24 seconds, the
+one pass, before the push leaves your machine. A warm run of all 50 wired
+gates measures roughly 49 seconds end to end (issue #1799's own
+defeat-test-mutation-coverage gate: unlike every other wired gate, which is
+pure AST inspection, it spawns a real `pytest` subprocess per graded
+element and self-grades its own regex/dict/literal elements against its own
+paired tests, roughly doubling the prior warm-run baseline below --
+different hardware than the figures below in any case --
+the prior 49-gate set measured roughly 24 seconds, the
+prior 48-gate set measured roughly 24 seconds, the
 prior 47-gate set measured roughly 22 seconds, the
 prior 45-gate set measured roughly 14 seconds, the
 prior 44-gate set measured roughly 15 seconds, the 43-gate set before that
@@ -168,7 +173,7 @@ it up, then confirm both shims with the check in the previous section.
 The runner itself also resolves through `uv` (issue #1485: it imports
 `_gitapex_schema_validation.py`, which needs `jsonschema` -- a real,
 non-stdlib dependency a bare system `python3` is not guaranteed to have),
-and so do all 49 wired gates (the same `uv run` pins CI uses). Without `uv`
+and so do all 50 wired gates (the same `uv run` pins CI uses). Without `uv`
 on PATH every one of them reports `FAIL ... failed to run` -- that is one
 missing tool, not a whole broken wired set.
 
diff --git a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
new file mode 100644
index 00000000..d8c0d9ff
--- /dev/null
+++ b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
@@ -0,0 +1,1158 @@
+"""Tests for the defeat-test mutation-coverage gate
+(.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py).
+
+Issue #1799. Mirrors tests/test_gitapex_gate_function_body_test_coverage.py's
+own fixture/assertion style for "a gate of this exact shape": synthetic
+unified-diff-text fixtures, tmp_path-based --root trees, and direct calls
+into the gate module's own functions rather than only subprocess CLI
+invocation. Unlike either sibling gate, this one's own core mechanism
+actually runs a real `pytest` subprocess against a temporarily mutated copy
+of a source file -- most tests below exercise the pure grading/splicing
+logic directly (no subprocess spawned), and a smaller, representative subset
+exercises the real end-to-end mutation-and-rerun path per element category,
+per this repository's own defeat-test-disclosure convention.
+
+Per that convention, at least one test below is specifically constructed to
+defeat -- not merely exercise the happy path of -- the new detection logic;
+see the `test_defeat_*`/`*_vacuous_test_*` tests. This is also the red-then-
+green proof issue #1799's own six ACM rows require verbatim: each of the
+three `test_end_to_end_*` pairs below first proves the gate reports a
+`defeat-test-mutation-gap` finding against a vacuous fixture (red), then
+proves it reports clean once that same fixture's own paired test is fixed to
+genuinely assert the mutated element (green).
+"""
+
+from __future__ import annotations
+
+import ast
+import pathlib
+
+import gitapex_gate_defeat_test_mutation_coverage as gate
+import pytest
+from conftest import FakeStdin as _FakeStdin
+from conftest import (
+    assert_workflow_checkout_pins_head_sha_with_full_history,
+    assert_workflow_diff_carries_flags,
+    assert_workflow_feeds_merge_base_to,
+    assert_workflow_has_no_trigger_path_filter,
+)
+
+# --- helpers -----------------------------------------------------------------
+
+
+def _whole_file_diff(path: str, source: str) -> str:
+    """A unified diff in which every line of `source` is an added line."""
+    lines = source.split("\n")
+    body = "".join("+" + line + "\n" for line in lines)
+    return f"diff --git a/{path} b/{path}\n--- /dev/null\n+++ b/{path}\n@@ -0,0 +1,{len(lines)} @@\n" + body
+
+
+def _partial_diff(path: str, source: str, added: list[int]) -> str:
+    """A unified diff adding only the 1-based line numbers in `added`."""
+    lines = source.split("\n")
+    hunks = "".join(f"@@ -{number},0 +{number},1 @@\n+{lines[number - 1]}\n" for number in added)
+    return f"diff --git a/{path} b/{path}\n--- a/{path}\n+++ b/{path}\n{hunks}"
+
+
+def _write(root: pathlib.Path, relative: str, source: str) -> pathlib.Path:
+    path = root / relative
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(source, encoding="utf-8")
+    return path
+
+
+def _line_starts(source: str) -> list[int]:
+    return gate._line_byte_starts(source.encode("utf-8"))
+
+
+def _first_expr_value(tree: ast.Module) -> ast.expr:
+    """The `.value` of `tree.body[0]`, asserted to be a bare expression
+    statement first -- `ast.stmt` itself has no `.value` attribute, only
+    `ast.Expr` does, so every call site below needs this narrowing."""
+    first = tree.body[0]
+    assert isinstance(first, ast.Expr)
+    return first.value
+
+
+# --- scope: in_scope() boundary pins -----------------------------------------
+
+
+@pytest.mark.parametrize(
+    "path",
+    [
+        "skills/foo/scripts/gitapex_check_bar.py",
+        ".github/scripts/gitapex_gate_bar.py",
+        "skills/foo/scripts/some_util.py",
+        ".github/scripts/some_util.py",
+        "hooks/gitapex_check_bar.py",
+        "hooks/some_util.py",
+    ],
+)
+def test_in_scope_paths_are_recognised(path: str) -> None:
+    assert gate.in_scope(path)
+
+
+@pytest.mark.parametrize(
+    "path",
+    [
+        "skills/foo/scripts/test_bar.py",
+        "skills/foo/scripts/conftest.py",
+        ".github/scripts/test_bar.py",
+        ".github/scripts/conftest.py",
+        "hooks/test_bar.py",
+        "hooks/conftest.py",
+        "evals/scripts/gitapex_run_ablation.py",
+        "skills/foo/scripts/sub/bar.py",
+        ".github/scripts/sub/bar.py",
+        "hooks/sub/bar.py",
+        "skills/foo/bar.py",
+        "tests/test_foo.py",
+    ],
+)
+def test_out_of_scope_paths_are_not_graded(path: str) -> None:
+    assert not gate.in_scope(path)
+
+
+# --- _stem / _test_relative_paths --------------------------------------------
+
+
+def test_stem_strips_directory_and_suffix() -> None:
+    assert gate._stem(".github/scripts/gitapex_gate_foo.py") == "gitapex_gate_foo"
+
+
+def test_test_relative_paths_names_both_candidates() -> None:
+    assert gate._test_relative_paths("gitapex_gate_foo") == (
+        "tests/test_gitapex_gate_foo.py",
+        "tests/test_gitapex_gate_foo_properties.py",
+    )
+
+
+# --- byte-offset plumbing -----------------------------------------------------
+
+
+def test_split_bom_strips_a_leading_bom() -> None:
+    data = b"\xef\xbb\xbfx = 1\n"
+    bom, body = gate._split_bom(data)
+    assert bom == b"\xef\xbb\xbf"
+    assert body == b"x = 1\n"
+
+
+def test_split_bom_is_a_no_op_without_one() -> None:
+    data = b"x = 1\n"
+    assert gate._split_bom(data) == (b"", data)
+
+
+def test_line_byte_starts_matches_a_multiline_file() -> None:
+    body = b"a\nbb\nccc\n"
+    assert gate._line_byte_starts(body) == [0, 2, 5, 9]
+
+
+def test_node_byte_span_accounts_for_a_multibyte_character_earlier_on_the_line() -> None:
+    """`ast` col_offset/end_col_offset are UTF-8 *byte* offsets, confirmed
+    directly: a non-ASCII character earlier on the same line shifts them
+    past where a naive character-index slice would land. This is the exact
+    property `_node_byte_span` depends on for every splice this gate does."""
+    source = 'x = "héllo|wörld"\n'
+    tree = ast.parse(source)
+    first_stmt = tree.body[0]
+    assert isinstance(first_stmt, ast.Assign)
+    node = first_stmt.value
+    assert isinstance(node, ast.Constant)
+    body = source.encode("utf-8")
+    starts = gate._line_byte_starts(body)
+    start, end = gate._node_byte_span(node, starts)
+    assert body[start:end] == '"héllo|wörld"'.encode()
+
+
+# --- _removal_span_for_item ---------------------------------------------------
+
+
+def test_removal_span_for_item_sole_item_removes_only_its_own_span() -> None:
+    assert gate._removal_span_for_item([(3, 7)], 0) == (3, 7)
+
+
+def test_removal_span_for_item_first_of_several_consumes_the_trailing_separator() -> None:
+    spans = [(0, 1), (2, 3), (4, 5)]
+    assert gate._removal_span_for_item(spans, 0) == (0, 2)
+
+
+def test_removal_span_for_item_middle_consumes_the_trailing_separator() -> None:
+    spans = [(0, 1), (2, 3), (4, 5)]
+    assert gate._removal_span_for_item(spans, 1) == (2, 4)
+
+
+def test_removal_span_for_item_last_consumes_the_leading_separator() -> None:
+    spans = [(0, 1), (2, 3), (4, 5)]
+    assert gate._removal_span_for_item(spans, 2) == (3, 5)
+
+
+# --- category 1: regex alternation branch ------------------------------------
+
+
+def test_re_module_names_includes_bare_re_and_every_alias() -> None:
+    tree = ast.parse("import re\nimport re as _re\n")
+    assert gate._re_module_names(tree) == frozenset({"re", "_re"})
+
+
+def test_regex_pattern_literal_accepts_compile_on_re() -> None:
+    tree = ast.parse('re.compile("a|b")')
+    call = _first_expr_value(tree)
+    assert isinstance(call, ast.Call)
+    literal = gate._regex_pattern_literal(call, frozenset({"re"}))
+    assert literal is not None
+    assert literal.value == "a|b"
+
+
+def test_regex_pattern_literal_accepts_compile_on_an_aliased_import() -> None:
+    tree = ast.parse('_re.compile("a|b")')
+    call = _first_expr_value(tree)
+    assert isinstance(call, ast.Call)
+    assert gate._regex_pattern_literal(call, frozenset({"re", "_re"})) is not None
+
+
+def test_regex_pattern_literal_rejects_compile_on_an_unrelated_name() -> None:
+    tree = ast.parse('schema.compile("a|b")')
+    call = _first_expr_value(tree)
+    assert isinstance(call, ast.Call)
+    assert gate._regex_pattern_literal(call, frozenset({"re"})) is None
+
+
+def test_regex_pattern_literal_is_receiver_agnostic_for_match_search_fullmatch() -> None:
+    tree = ast.parse('PATTERN.match("a|b")')
+    call = _first_expr_value(tree)
+    assert isinstance(call, ast.Call)
+    literal = gate._regex_pattern_literal(call, frozenset({"re"}))
+    assert literal is not None
+    assert literal.value == "a|b"
+
+
+def test_regex_pattern_literal_rejects_a_non_string_first_argument() -> None:
+    tree = ast.parse("re.compile(PATTERN_VAR)")
+    call = _first_expr_value(tree)
+    assert isinstance(call, ast.Call)
+    assert gate._regex_pattern_literal(call, frozenset({"re"})) is None
+
+
+def test_regex_pattern_literal_rejects_an_unrelated_call() -> None:
+    tree = ast.parse('os.path.join("a", "b")')
+    call = _first_expr_value(tree)
+    assert isinstance(call, ast.Call)
+    assert gate._regex_pattern_literal(call, frozenset({"re"})) is None
+
+
+def test_string_literal_content_span_handles_a_raw_string() -> None:
+    raw = b'r"a|b"'
+    start, end = gate._string_literal_content_span(raw)
+    assert raw[start:end] == b"a|b"
+
+
+def test_string_literal_content_span_handles_a_plain_string() -> None:
+    raw = b'"a|b"'
+    start, end = gate._string_literal_content_span(raw)
+    assert raw[start:end] == b"a|b"
+
+
+def test_string_literal_content_span_raises_for_an_unrecognised_token() -> None:
+    with pytest.raises(ValueError, match="not a recognisable"):
+        gate._string_literal_content_span(b"f-string-shaped-nonsense")
+
+
+def test_top_level_pipe_positions_finds_plain_pipes() -> None:
+    assert gate._top_level_pipe_positions(b"a|b|c") == [1, 3]
+
+
+def test_top_level_pipe_positions_ignores_a_pipe_inside_parens() -> None:
+    assert gate._top_level_pipe_positions(b"(?:a|b)|c") == [7]
+
+
+def test_top_level_pipe_positions_ignores_a_pipe_inside_a_character_class() -> None:
+    assert gate._top_level_pipe_positions(b"[a|b]|c") == [5]
+
+
+def test_top_level_pipe_positions_ignores_an_escaped_pipe() -> None:
+    assert gate._top_level_pipe_positions(rb"a\|b|c") == [4]
+
+
+def test_alternative_spans_excludes_the_pipe_bytes() -> None:
+    content = b"a|b|c"
+    positions = gate._top_level_pipe_positions(content)
+    assert gate._alternative_spans(content, positions) == [(0, 1), (2, 3), (4, 5)]
+
+
+def test_regex_alternation_elements_grades_each_top_level_branch(tmp_path: pathlib.Path) -> None:
+    source = 'import re\n_RE = re.compile(r"a|b|c")\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    elements = gate._regex_alternation_elements(tree, body, starts, {2})
+    assert len(elements) == 3
+    for line, category, _message, removal_span in elements:
+        assert line == 2
+        assert category == gate._REGEX_ALTERNATION
+        start, end = removal_span
+        mutated = body[:start] + body[end:]
+        # Every mutation must leave valid Python behind.
+        ast.parse(mutated.decode("utf-8"))
+
+
+def test_regex_alternation_elements_skips_a_pattern_with_no_top_level_pipe(tmp_path: pathlib.Path) -> None:
+    source = 'import re\n_RE = re.compile(r"^[a-z][a-z0-9-]*$")\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    assert gate._regex_alternation_elements(tree, body, starts, {2}) == []
+
+
+def test_regex_alternation_elements_skips_a_call_the_diff_never_touches() -> None:
+    source = 'import re\n_RE = re.compile(r"a|b")\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    assert gate._regex_alternation_elements(tree, body, starts, {99}) == []
+
+
+def test_defeat_regex_alternation_elements_skips_implicit_string_concatenation() -> None:
+    """A defeat test for this gate's own narrowing, not the source under
+    test: implicit string concatenation must not be misread as a single
+    literal token and spliced incorrectly -- it must simply not be graded."""
+    source = 'import re\n_RE = re.compile("a|b" "c|d")\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    assert gate._regex_alternation_elements(tree, body, starts, {2}) == []
+
+
+# --- category 2: module-level dict/mapping-literal entry --------------------
+
+
+def test_module_level_dict_assigns_finds_a_const_dict() -> None:
+    tree = ast.parse('CONST = {"a": 1, "b": 2}\n')
+    result = gate._module_level_dict_assigns(tree)
+    assert len(result) == 1
+    assert result[0][0] == "CONST"
+
+
+def test_module_level_dict_assigns_ignores_a_multi_target_assignment() -> None:
+    tree = ast.parse('A = B = {"a": 1}\n')
+    assert gate._module_level_dict_assigns(tree) == []
+
+
+def test_module_level_dict_assigns_ignores_a_non_dict_value() -> None:
+    tree = ast.parse("CONST = [1, 2]\n")
+    assert gate._module_level_dict_assigns(tree) == []
+
+
+def test_dict_entry_elements_grades_each_touched_entry() -> None:
+    source = 'CONST = {\n    "a": 1,\n    "b": 2,\n}\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    elements = gate._dict_entry_elements(tree, body, starts, {2, 3})
+    assert len(elements) == 2
+    for _line, category, message, removal_span in elements:
+        assert category == gate._DICT_ENTRY
+        assert "CONST" in message
+        start, end = removal_span
+        mutated = body[:start] + body[end:]
+        ns: dict[str, object] = {}
+        exec(compile(mutated, "<mutated>", "exec"), ns)  # noqa: S102
+        assert isinstance(ns["CONST"], dict)
+        assert len(ns["CONST"]) == 1
+
+
+def test_dict_entry_elements_skips_an_entry_the_diff_never_touches() -> None:
+    source = 'CONST = {\n    "a": 1,\n    "b": 2,\n}\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    elements = gate._dict_entry_elements(tree, body, starts, {2})
+    assert [line for line, *_ in elements] == [2]
+
+
+def test_defeat_dict_entry_elements_skips_a_dict_with_star_star_unpacking() -> None:
+    """A defeat test for this gate's own narrowing: a dict carrying a
+    `**`-unpacking entry (a None key) has no key node for that entry, so
+    the whole dict is skipped rather than crashing or misattributing."""
+    source = 'OTHER = {}\nCONST = {**OTHER, "a": 1}\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    assert gate._dict_entry_elements(tree, body, starts, {2}) == []
+
+
+# --- category 3: unconditionally emitted literal -----------------------------
+
+
+def test_enclosing_function_unconditional_returns_the_function_for_a_straight_line_display() -> None:
+    tree = ast.parse('def make():\n    return ["a", "b"]\n')
+    parents = gate._parent_map(tree)
+    list_node = next(node for node in ast.walk(tree) if isinstance(node, ast.List))
+    func = gate._enclosing_function_unconditional(list_node, parents)
+    assert func is not None
+    assert func.name == "make"
+
+
+def test_enclosing_function_unconditional_returns_none_inside_an_if() -> None:
+    tree = ast.parse('def make(flag):\n    if flag:\n        return ["a"]\n    return []\n')
+    parents = gate._parent_map(tree)
+    list_node = next(node for node in ast.walk(tree) if isinstance(node, ast.List) and node.elts)
+    assert gate._enclosing_function_unconditional(list_node, parents) is None
+
+
+def test_enclosing_function_unconditional_returns_none_at_module_level() -> None:
+    tree = ast.parse('CONST = ["a", "b"]\n')
+    parents = gate._parent_map(tree)
+    list_node = next(node for node in ast.walk(tree) if isinstance(node, ast.List))
+    assert gate._enclosing_function_unconditional(list_node, parents) is None
+
+
+def test_enclosing_function_unconditional_treats_with_as_not_a_guard() -> None:
+    source = 'def make():\n    with open("f") as fh:\n        return ["a", "b"]\n'
+    tree = ast.parse(source)
+    parents = gate._parent_map(tree)
+    list_node = next(node for node in ast.walk(tree) if isinstance(node, ast.List))
+    func = gate._enclosing_function_unconditional(list_node, parents)
+    assert func is not None
+    assert func.name == "make"
+
+
+def test_literal_display_elements_grades_list_items_in_a_function_body() -> None:
+    source = 'def make():\n    return ["hidden", "archived"]\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    elements = gate._literal_display_elements(tree, body, starts, {2})
+    assert len(elements) == 2
+    for line, category, message, removal_span in elements:
+        assert line == 2
+        assert category == gate._LITERAL_ELEMENT
+        assert "make" in message
+        start, end = removal_span
+        mutated = body[:start] + body[end:]
+        ast.parse(mutated.decode("utf-8"))
+
+
+def test_literal_display_elements_skips_items_inside_an_if_guard() -> None:
+    source = 'def make(flag):\n    if flag:\n        return ["a", "b"]\n    return []\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    assert gate._literal_display_elements(tree, body, starts, {3}) == []
+
+
+def test_literal_display_elements_skips_a_non_constant_item() -> None:
+    source = "def make(x):\n    return [x, 1]\n"
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    elements = gate._literal_display_elements(tree, body, starts, {2})
+    assert [message for _line, _cat, message, _span in elements] == [
+        "literal element 1 in an unconditionally constructed display inside `make`"
+    ]
+
+
+def test_literal_display_elements_grades_a_dict_entry_value_inside_a_function() -> None:
+    source = 'def build():\n    return {"hidden": True, "other": 1}\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    elements = gate._literal_display_elements(tree, body, starts, {2})
+    assert len(elements) == 2
+    assert {message.split(" ")[3] for _line, _cat, message, _span in elements} == {"True", "1"}
+
+
+def test_literal_display_elements_does_not_double_grade_a_module_level_const_dict() -> None:
+    """A module-level `CONST = {...}` dict is category 2's own territory;
+    category 3 must skip it entirely, not double-grade its entries."""
+    source = 'CONST = {"a": 1, "b": 2}\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    assert gate._literal_display_elements(tree, body, starts, {1}) == []
+
+
+def test_literal_display_elements_skips_a_none_value() -> None:
+    source = 'def build():\n    return {"a": None}\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    assert gate._literal_display_elements(tree, body, starts, {2}) == []
+
+
+def test_literal_display_elements_skips_a_list_item_the_diff_never_touches() -> None:
+    source = 'def make():\n    return ["a", "b"]\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    assert gate._literal_display_elements(tree, body, starts, {99}) == []
+
+
+def test_literal_display_elements_skips_a_dict_entry_the_diff_never_touches() -> None:
+    source = 'def make():\n    return {"a": 1}\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    assert gate._literal_display_elements(tree, body, starts, {99}) == []
+
+
+def test_literal_display_elements_skips_dict_entries_inside_an_if_guard() -> None:
+    source = 'def make(flag):\n    if flag:\n        return {"a": 1}\n    return {}\n'
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    assert gate._literal_display_elements(tree, body, starts, {3}) == []
+
+
+# --- waivers -----------------------------------------------------------------
+
+
+def test_waived_lines_finds_the_commented_line() -> None:
+    source = "X = 1  # defeat-test-mutation-coverage: WAIVED: covered elsewhere\n"
+    assert gate._waived_lines(source) == {1}
+
+
+def test_waived_lines_ignores_a_bare_marker_with_no_reason() -> None:
+    source = "X = 1  # defeat-test-mutation-coverage: WAIVED\n"
+    assert gate._waived_lines(source) == set()
+
+
+def test_waived_lines_ignores_a_waiver_string_inside_a_string_literal() -> None:
+    source = 'X = "# defeat-test-mutation-coverage: WAIVED: not a real comment"\n'
+    assert gate._waived_lines(source) == set()
+
+
+# --- find_violations: end-to-end mutation-and-rerun, one per category -------
+
+
+def test_end_to_end_category1_vacuous_test_leaves_a_finding_then_fixing_it_clears(tmp_path: pathlib.Path) -> None:
+    """Red-then-green proof, category 1 (regex alternation), mirroring
+    issue #1799's own #1733/#1735 CR-alternative-prefix-shaped gap: a test
+    that only exercises the first of three alternatives leaves the other
+    two vacuous."""
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = (
+        "import re\n\n"
+        '_CONTAINER_PREFIX_RE = re.compile(r"^docker-|^podman-|^ctr-")\n\n\n'
+        "def matches(name):\n"
+        "    return bool(_CONTAINER_PREFIX_RE.match(name))\n"
+    )
+    vacuous_test_src = (
+        'import gitapex_check_fixture\n\n\ndef test_matches():\n    assert gitapex_check_fixture.matches("docker-1")\n'
+    )
+    fixed_test_src = (
+        "import gitapex_check_fixture\n\n\n"
+        "def test_matches():\n"
+        '    assert gitapex_check_fixture.matches("docker-1")\n'
+        '    assert gitapex_check_fixture.matches("podman-1")\n'
+        '    assert gitapex_check_fixture.matches("ctr-1")\n'
+    )
+
+    _write(tmp_path, fixture_path, fixture_src)
+    _write(tmp_path, test_path, vacuous_test_src)
+    diff_text = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, vacuous_test_src)
+    violations, waived, graded = gate.find_violations(diff_text, tmp_path)
+    assert graded == 1
+    assert waived == []
+    assert [finding.rule for finding in violations] == [gate._MUTATION_GAP, gate._MUTATION_GAP]
+    assert any("podman" in finding.message for finding in violations)
+    assert any("ctr" in finding.message for finding in violations)
+
+    _write(tmp_path, test_path, fixed_test_src)
+    diff_text_fixed = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, fixed_test_src)
+    violations_fixed, waived_fixed, graded_fixed = gate.find_violations(diff_text_fixed, tmp_path)
+    assert graded_fixed == 1
+    assert violations_fixed == []
+    assert waived_fixed == []
+
+
+def test_end_to_end_category2_vacuous_test_leaves_a_finding_then_fixing_it_clears(tmp_path: pathlib.Path) -> None:
+    """Red-then-green proof, category 2 (module-level dict entry),
+    mirroring issue #1799's own #1990 REVIEW_PERSONA_PERMISSION-shaped
+    gap: a test that names only some keys leaves the rest vacuous."""
+    fixture_path = "hooks/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = (
+        "REVIEW_PERSONA_PERMISSION = {\n"
+        '    "correctness": "read-only",\n'
+        '    "security": "read-only",\n'
+        '    "blast-radius": "read-write",\n'
+        "}\n"
+    )
+    vacuous_test_src = (
+        "import gitapex_check_fixture\n\n\n"
+        "def test_permission_keys():\n"
+        '    assert "correctness" in gitapex_check_fixture.REVIEW_PERSONA_PERMISSION\n'
+        '    assert "security" in gitapex_check_fixture.REVIEW_PERSONA_PERMISSION\n'
+    )
+    fixed_test_src = (
+        "import gitapex_check_fixture\n\n\n"
+        "def test_permission_keys():\n"
+        "    assert gitapex_check_fixture.REVIEW_PERSONA_PERMISSION == {\n"
+        '        "correctness": "read-only",\n'
+        '        "security": "read-only",\n'
+        '        "blast-radius": "read-write",\n'
+        "    }\n"
+    )
+
+    _write(tmp_path, fixture_path, fixture_src)
+    _write(tmp_path, test_path, vacuous_test_src)
+    diff_text = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, vacuous_test_src)
+    violations, waived, graded = gate.find_violations(diff_text, tmp_path)
+    assert graded == 1
+    assert waived == []
+    assert len(violations) == 1
+    assert "blast-radius" in violations[0].message
+
+    _write(tmp_path, test_path, fixed_test_src)
+    diff_text_fixed = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, fixed_test_src)
+    violations_fixed, waived_fixed, graded_fixed = gate.find_violations(diff_text_fixed, tmp_path)
+    assert graded_fixed == 1
+    assert violations_fixed == []
+    assert waived_fixed == []
+
+
+def test_end_to_end_category3_vacuous_test_leaves_a_finding_then_fixing_it_clears(tmp_path: pathlib.Path) -> None:
+    """Red-then-green proof, category 3 (unconditionally emitted literal),
+    mirroring issue #1799's own #1991 "hidden: true"-shaped gap: a test
+    that checks only type/non-emptiness leaves both emitted literals
+    vacuous."""
+    fixture_path = "skills/some-skill/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = 'def build_metadata():\n    return ["hidden", "archived"]\n'
+    vacuous_test_src = (
+        "import gitapex_check_fixture\n\n\n"
+        "def test_build_metadata():\n"
+        "    result = gitapex_check_fixture.build_metadata()\n"
+        "    assert isinstance(result, list)\n"
+        "    assert len(result) > 0\n"
+    )
+    fixed_test_src = (
+        "import gitapex_check_fixture\n\n\n"
+        "def test_build_metadata():\n"
+        "    result = gitapex_check_fixture.build_metadata()\n"
+        '    assert result == ["hidden", "archived"]\n'
+    )
+
+    _write(tmp_path, fixture_path, fixture_src)
+    _write(tmp_path, test_path, vacuous_test_src)
+    diff_text = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, vacuous_test_src)
+    violations, waived, graded = gate.find_violations(diff_text, tmp_path)
+    assert graded == 1
+    assert waived == []
+    assert len(violations) == 2
+
+    _write(tmp_path, test_path, fixed_test_src)
+    diff_text_fixed = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, fixed_test_src)
+    violations_fixed, waived_fixed, graded_fixed = gate.find_violations(diff_text_fixed, tmp_path)
+    assert graded_fixed == 1
+    assert violations_fixed == []
+    assert waived_fixed == []
+
+
+# --- find_violations: other behavior ------------------------------------------
+
+
+def test_find_violations_skips_a_source_with_no_diff_touched_paired_test(tmp_path: pathlib.Path) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    fixture_src = 'import re\n_RE = re.compile(r"a|b")\n'
+    _write(tmp_path, fixture_path, fixture_src)
+    diff_text = _whole_file_diff(fixture_path, fixture_src)
+    violations, waived, graded = gate.find_violations(diff_text, tmp_path)
+    assert (violations, waived, graded) == ([], [], 0)
+
+
+def test_find_violations_waiver_honoured_on_the_reported_line(tmp_path: pathlib.Path) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = (
+        'import re\n_RE = re.compile(r"a|b")  '
+        "# defeat-test-mutation-coverage: WAIVED: covered by a CLI test elsewhere\n"
+    )
+    test_src = 'import gitapex_check_fixture\n\n\ndef test_a():\n    assert gitapex_check_fixture._RE.match("a")\n'
+    _write(tmp_path, fixture_path, fixture_src)
+    _write(tmp_path, test_path, test_src)
+    diff_text = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, test_src)
+    violations, waived, graded = gate.find_violations(diff_text, tmp_path)
+    assert graded == 1
+    assert violations == []
+    assert len(waived) == 1
+    assert waived[0].line == 2
+
+
+def test_find_violations_counts_a_touched_file_with_no_graded_elements(tmp_path: pathlib.Path) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = "def make():\n    return 1\n"
+    test_src = "import gitapex_check_fixture\n\n\ndef test_make():\n    assert gitapex_check_fixture.make() == 1\n"
+    _write(tmp_path, fixture_path, fixture_src)
+    _write(tmp_path, test_path, test_src)
+    diff_text = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, test_src)
+    violations, waived, graded = gate.find_violations(diff_text, tmp_path)
+    assert (violations, waived, graded) == ([], [], 1)
+
+
+def test_find_violations_raises_scan_error_for_a_missing_file(tmp_path: pathlib.Path) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    fixture_src = 'import re\n_RE = re.compile(r"a|b")\n'
+    diff_text = _whole_file_diff(fixture_path, fixture_src)
+    with pytest.raises(gate.ScanError, match="missing from"):
+        gate.find_violations(diff_text, tmp_path)
+
+
+def test_find_violations_raises_scan_error_for_unparseable_python(tmp_path: pathlib.Path) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    broken_src = "def broken(:\n"
+    test_src = "import gitapex_check_fixture\n\n\ndef test_x():\n    pass\n"
+    _write(tmp_path, fixture_path, broken_src)
+    _write(tmp_path, test_path, test_src)
+    diff_text = _whole_file_diff(fixture_path, broken_src) + _whole_file_diff(test_path, test_src)
+    with pytest.raises(gate.ScanError, match="cannot be parsed as Python"):
+        gate.find_violations(diff_text, tmp_path)
+
+
+def test_find_violations_raises_scan_error_for_non_utf8_source(tmp_path: pathlib.Path) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    absolute = tmp_path / fixture_path
+    absolute.parent.mkdir(parents=True, exist_ok=True)
+    absolute.write_bytes(b"\xff\xfe not valid utf-8 \x80\x81")
+    test_src = "import gitapex_check_fixture\n\n\ndef test_x():\n    pass\n"
+    _write(tmp_path, test_path, test_src)
+    diff_text = (
+        f"diff --git a/{fixture_path} b/{fixture_path}\n--- /dev/null\n+++ b/{fixture_path}\n@@ -0,0 +1,1 @@\n+x = 1\n"
+        + _whole_file_diff(test_path, test_src)
+    )
+    with pytest.raises(gate.ScanError, match="cannot be read as UTF-8 text"):
+        gate.find_violations(diff_text, tmp_path)
+
+
+def test_find_violations_raises_scan_error_on_a_collection_error_mutation(tmp_path: pathlib.Path) -> None:
+    """A paired test file that itself fails to *import* at all (a
+    module-level `NameError`, not merely a runtime failure inside a test
+    function's own body) means every subprocess run against it is a
+    collection error -- ScanError, fail closed, never silently read as
+    "survived" or "killed" either way."""
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = 'import re\n_RE = re.compile(r"a|b")\n'
+    test_src = (
+        "import gitapex_check_fixture\n\n"
+        "this_name_is_undefined_at_module_level_and_breaks_collection\n\n"
+        "def test_x():\n    pass\n"
+    )
+    _write(tmp_path, fixture_path, fixture_src)
+    _write(tmp_path, test_path, test_src)
+    diff_text = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, test_src)
+    with pytest.raises(gate.ScanError, match="pytest exited"):
+        gate.find_violations(diff_text, tmp_path)
+
+
+def test_run_mutation_restores_the_original_bytes_even_when_pytest_errors(tmp_path: pathlib.Path) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = 'import re\n_RE = re.compile(r"a|b")\n'
+    test_src = (
+        "import gitapex_check_fixture\n\n"
+        "this_name_is_undefined_at_module_level_and_breaks_collection\n\n"
+        "def test_x():\n    pass\n"
+    )
+    absolute = _write(tmp_path, fixture_path, fixture_src)
+    test_absolute = _write(tmp_path, test_path, test_src)
+    original_bytes = absolute.read_bytes()
+    with pytest.raises(gate.ScanError):
+        gate._run_mutation(absolute, b"", original_bytes, (29, 30), [test_absolute], tmp_path)
+    assert absolute.read_bytes() == original_bytes
+
+
+def test_find_violations_raises_scan_error_for_an_unreadable_file(tmp_path: pathlib.Path) -> None:
+    """A path the diff names as a source file that turns out to be a
+    directory raises `IsADirectoryError` (an `OSError`, not
+    `FileNotFoundError`) from `read_bytes()` -- the other branch of
+    `find_violations`' own two-way file-read failure handling."""
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    (tmp_path / fixture_path).mkdir(parents=True)
+    diff_text = _whole_file_diff(fixture_path, "x = 1\n")
+    with pytest.raises(gate.ScanError, match="cannot be read"):
+        gate.find_violations(diff_text, tmp_path)
+
+
+# --- _run_mutation: error paths, via monkeypatched write_bytes/subprocess ----
+
+
+def test_run_mutation_raises_scan_error_when_the_mutation_write_fails(
+    tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = "def make():\n    return 1\n"
+    test_src = "import gitapex_check_fixture\n\n\ndef test_x():\n    pass\n"
+    absolute = _write(tmp_path, fixture_path, fixture_src)
+    test_absolute = _write(tmp_path, test_path, test_src)
+    original_bytes = absolute.read_bytes()
+
+    def _raising_write_bytes(self: pathlib.Path, data: bytes) -> int:
+        raise OSError("simulated write failure")
+
+    monkeypatch.setattr(pathlib.Path, "write_bytes", _raising_write_bytes)
+    with pytest.raises(gate.ScanError, match="could not write a mutated copy"):
+        gate._run_mutation(absolute, b"", original_bytes, (0, 1), [test_absolute], tmp_path)
+
+
+def test_run_mutation_raises_scan_error_when_the_restore_write_fails(
+    tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = "def make():\n    return 1\n"
+    test_src = "import gitapex_check_fixture\n\n\ndef test_x():\n    pass\n"
+    absolute = _write(tmp_path, fixture_path, fixture_src)
+    test_absolute = _write(tmp_path, test_path, test_src)
+    original_bytes = absolute.read_bytes()
+    original_write_bytes = pathlib.Path.write_bytes
+    calls = {"n": 0}
+
+    def _fail_on_second_call(self: pathlib.Path, data: bytes) -> int:
+        calls["n"] += 1
+        if calls["n"] == 2:
+            raise OSError("simulated restore failure")
+        return original_write_bytes(self, data)
+
+    monkeypatch.setattr(pathlib.Path, "write_bytes", _fail_on_second_call)
+    with pytest.raises(gate.ScanError, match="could not restore"):
+        gate._run_mutation(absolute, b"", original_bytes, (0, 1), [test_absolute], tmp_path)
+
+
+def test_run_mutation_raises_scan_error_on_subprocess_timeout(
+    tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = "def make():\n    return 1\n"
+    test_src = "import gitapex_check_fixture\n\n\ndef test_x():\n    pass\n"
+    absolute = _write(tmp_path, fixture_path, fixture_src)
+    test_absolute = _write(tmp_path, test_path, test_src)
+    original_bytes = absolute.read_bytes()
+
+    def _timing_out(*args: object, **kwargs: object) -> None:
+        raise gate.subprocess.TimeoutExpired(cmd=["pytest"], timeout=gate._PYTEST_TIMEOUT_SECONDS)
+
+    monkeypatch.setattr(gate.subprocess, "run", _timing_out)
+    with pytest.raises(gate.ScanError, match="timed out"):
+        gate._run_mutation(absolute, b"", original_bytes, (0, 1), [test_absolute], tmp_path)
+    assert absolute.read_bytes() == original_bytes
+
+
+def test_run_mutation_raises_scan_error_when_subprocess_run_itself_errors(
+    tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = "def make():\n    return 1\n"
+    test_src = "import gitapex_check_fixture\n\n\ndef test_x():\n    pass\n"
+    absolute = _write(tmp_path, fixture_path, fixture_src)
+    test_absolute = _write(tmp_path, test_path, test_src)
+    original_bytes = absolute.read_bytes()
+
+    def _raising(*args: object, **kwargs: object) -> None:
+        raise OSError("simulated spawn failure")
+
+    monkeypatch.setattr(gate.subprocess, "run", _raising)
+    with pytest.raises(gate.ScanError, match="pytest failed to run"):
+        gate._run_mutation(absolute, b"", original_bytes, (0, 1), [test_absolute], tmp_path)
+    assert absolute.read_bytes() == original_bytes
+
+
+# --- direct unit tests for internal helpers ---------------------------------
+
+
+def test_diff_target_path_returns_none_for_dev_null() -> None:
+    assert gate._diff_target_path("/dev/null") is None
+
+
+def test_diff_target_path_strips_the_b_prefix() -> None:
+    assert gate._diff_target_path("b/.github/scripts/gitapex_check_fixture.py") == (
+        ".github/scripts/gitapex_check_fixture.py"
+    )
+
+
+def test_diff_target_path_raises_on_an_unrecognised_prefix() -> None:
+    with pytest.raises(gate.ScanError):
+        gate._diff_target_path("c/some/other/prefix.py")
+
+
+def test_looks_like_real_header_pair_accepts_a_genuine_pair() -> None:
+    assert gate._looks_like_real_header_pair("--- a/x.py", "+++ b/x.py")
+
+
+def test_looks_like_real_header_pair_rejects_ordinary_content() -> None:
+    assert not gate._looks_like_real_header_pair("--- not a header", "+++ also not one")
+
+
+def test_parse_added_lines_returns_the_added_line_numbers_per_path() -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    added = gate.parse_added_lines(_partial_diff(fixture_path, "a\nb\nc\n", [2]))
+    assert added == {fixture_path: {2}}
+
+
+def test_parse_added_lines_handles_context_and_removed_lines() -> None:
+    """Exercises the ` ` (context) and `-` (removal) branches directly --
+    `_whole_file_diff`/`_partial_diff` above only ever produce `+` lines,
+    so neither branch is otherwise reached."""
+    diff_text = (
+        "diff --git a/x.py b/x.py\n"
+        "--- a/x.py\n"
+        "+++ b/x.py\n"
+        "@@ -1,3 +1,3 @@\n"
+        " context_line\n"
+        "-old_line\n"
+        "+new_line\n"
+        " trailing_context\n"
+    )
+    assert gate.parse_added_lines(diff_text) == {"x.py": {2}}
+
+
+def test_parse_added_lines_raises_on_a_post_image_header_with_no_source_header() -> None:
+    diff_text = "diff --git a/x.py b/x.py\n+++ b/x.py\n@@ -0,0 +1,2 @@\n+def check_value(x):\n+    return x > 0\n"
+    with pytest.raises(gate.ScanError, match="no `--- ` source header"):
+        gate.parse_added_lines(diff_text)
+
+
+def test_parse_added_lines_raises_on_an_over_declared_hunk_count() -> None:
+    diff_text = (
+        "diff --git a/x.py b/x.py\n"
+        "--- a/x.py\n"
+        "+++ b/x.py\n"
+        "@@ -1,0 +1,2 @@\n"
+        "+def check_value(x):\n"
+        "@@ -5,0 +6,1 @@\n"
+        "+    pass\n"
+    )
+    with pytest.raises(gate.ScanError, match="declared more"):
+        gate.parse_added_lines(diff_text)
+
+
+def test_parse_added_lines_raises_on_an_over_declared_hunk_that_drains_into_a_real_header_pair() -> None:
+    diff_text = (
+        "--- a/hooks/gitapex_check_file1.py\n"
+        "+++ b/hooks/gitapex_check_file1.py\n"
+        "@@ -1,1 +1,1 @@\n"
+        "--- a/hooks/gitapex_check_file2.py\n"
+        "+++ b/hooks/gitapex_check_file2.py\n"
+        "@@ -1,1 +1,2 @@\n"
+    )
+    with pytest.raises(gate.ScanError, match="closes exactly on a line shaped like"):
+        gate.parse_added_lines(diff_text)
+
+
+def test_a_real_looking_absorbed_header_pair_with_no_boundary_following_it_does_not_raise() -> None:
+    diff_text = (
+        "diff --git a/file1.py b/file1.py\n"
+        "--- a/file1.py\n"
+        "+++ b/file1.py\n"
+        "@@ -1,1 +1,1 @@\n"
+        "--- a/file2.py\n"
+        "+++ b/file2.py\n"
+        "some ordinary content here\n"
+    )
+    assert gate.parse_added_lines(diff_text) == {"file1.py": {1}}
+
+
+def test_a_dash_plus_shaped_hunk_with_nothing_following_it_is_not_an_error() -> None:
+    diff_text = (
+        "diff --git a/hooks/gitapex_check_dashplus.py b/hooks/gitapex_check_dashplus.py\n"
+        "--- a/hooks/gitapex_check_dashplus.py\n"
+        "+++ b/hooks/gitapex_check_dashplus.py\n"
+        '@@ -6 +6 @@ DIVIDER = """\n'
+        "--- old changelog marker\n"
+        "+++ new changelog marker\n"
+    )
+    assert gate.parse_added_lines(diff_text) == {"hooks/gitapex_check_dashplus.py": {6}}
+
+
+def test_regex_pattern_literal_rejects_a_call_with_no_arguments() -> None:
+    tree = ast.parse("re.compile()")
+    call = _first_expr_value(tree)
+    assert isinstance(call, ast.Call)
+    assert gate._regex_pattern_literal(call, frozenset({"re"})) is None
+
+
+def test_string_literal_content_span_raises_for_a_degenerate_single_char_token() -> None:
+    """A raw token consisting of just the opening quote character (no
+    content, no closing quote) computes `end < start` -- the malformed-
+    token branch, distinct from the tokenize-based checks below."""
+    with pytest.raises(ValueError, match="malformed string literal token"):
+        gate._string_literal_content_span(b'"')
+
+
+def test_string_literal_content_span_raises_for_non_utf8_bytes() -> None:
+    with pytest.raises(ValueError, match="not valid UTF-8"):
+        gate._string_literal_content_span(b'"\xff"')
+
+
+def test_string_literal_content_span_raises_for_an_unterminated_triple_quoted_string() -> None:
+    """An unterminated triple-quoted string makes `tokenize` itself raise
+    `TokenizeError` (`EOF in multi-line string`), rather than merely
+    yielding zero/multiple `STRING` tokens the way an unterminated
+    single-quoted string or implicit concatenation does."""
+    with pytest.raises(ValueError, match="could not tokenize"):
+        gate._string_literal_content_span(b'"""abc')
+
+
+def test_is_supported_literal_accepts_the_four_scalar_types_and_rejects_others() -> None:
+    assert gate._is_supported_literal("a")
+    assert gate._is_supported_literal(1)
+    assert gate._is_supported_literal(1.5)
+    assert gate._is_supported_literal(True)
+    assert not gate._is_supported_literal(None)
+    assert not gate._is_supported_literal(b"bytes")
+    assert not gate._is_supported_literal((1, 2))
+
+
+def test_invalidate_pycache_removes_an_existing_cache_dir(tmp_path: pathlib.Path) -> None:
+    module_path = tmp_path / "gitapex_check_fixture.py"
+    module_path.write_text("x = 1\n", encoding="utf-8")
+    cache_dir = tmp_path / "__pycache__"
+    cache_dir.mkdir()
+    (cache_dir / "gitapex_check_fixture.cpython-312.pyc").write_bytes(b"stale")
+    gate._invalidate_pycache(module_path)
+    assert not cache_dir.exists()
+
+
+def test_invalidate_pycache_is_a_no_op_when_no_cache_dir_exists(tmp_path: pathlib.Path) -> None:
+    module_path = tmp_path / "gitapex_check_fixture.py"
+    module_path.write_text("x = 1\n", encoding="utf-8")
+    gate._invalidate_pycache(module_path)  # must not raise
+
+
+def test_graded_elements_combines_all_three_categories() -> None:
+    source = 'import re\n\nCONST = {"a": 1, "b": 2}\n\n_RE = re.compile(r"x|y")\n\ndef make():\n    return ["p", "q"]\n'
+    added = set(range(1, source.count("\n") + 1))
+    elements = gate._graded_elements(".github/scripts/gitapex_check_fixture.py", source, added)
+    categories = {category for _line, category, _message, _span in elements}
+    assert categories == {gate._REGEX_ALTERNATION, gate._DICT_ENTRY, gate._LITERAL_ELEMENT}
+
+
+# --- GateDefeatTestMutationCoverageArgs ---------------------------------------
+
+
+def test_root_must_exist_raises_value_error_for_a_non_directory(tmp_path: pathlib.Path) -> None:
+    with pytest.raises(ValueError, match="must be an existing directory"):
+        gate.GateDefeatTestMutationCoverageArgs._root_must_exist(tmp_path / "does-not-exist")
+
+
+def test_root_must_exist_accepts_a_real_directory(tmp_path: pathlib.Path) -> None:
+    assert gate.GateDefeatTestMutationCoverageArgs._root_must_exist(tmp_path) == tmp_path
+
+
+# --- main() CLI ----------------------------------------------------------
+
+
+def test_main_returns_0_and_prints_ok_on_a_clean_diff(
+    tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = "def make():\n    return 1\n"
+    test_src = "import gitapex_check_fixture\n\n\ndef test_make():\n    assert gitapex_check_fixture.make() == 1\n"
+    _write(tmp_path, fixture_path, fixture_src)
+    _write(tmp_path, test_path, test_src)
+    diff_text = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, test_src)
+    monkeypatch.setattr("sys.stdin", _FakeStdin(diff_text.encode("utf-8")))
+    exit_code = gate.main(["--root", str(tmp_path)])
+    assert exit_code == 0
+    assert "OK: 1 in-scope file(s) graded" in capsys.readouterr().out
+
+
+def test_main_returns_1_and_prints_violations_citing_the_issue(
+    tmp_path: pathlib.Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = 'def build():\n    return {"hidden": True}\n'
+    test_src = (
+        "import gitapex_check_fixture\n\n\n"
+        "def test_build():\n"
+        "    assert isinstance(gitapex_check_fixture.build(), dict)\n"
+    )
+    _write(tmp_path, fixture_path, fixture_src)
+    _write(tmp_path, test_path, test_src)
+    diff_text = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, test_src)
+    diff_path = tmp_path / "diff.patch"
+    diff_path.write_text(diff_text, encoding="utf-8")
+    exit_code = gate.main(["--root", str(tmp_path), "--diff", str(diff_path)])
+    captured = capsys.readouterr()
+    assert exit_code == 1
+    assert "issue #1799" in captured.err
+    assert "defeat-test-mutation-coverage: WAIVED" in captured.err
+
+
+def test_main_prints_a_waived_finding_separately(tmp_path: pathlib.Path, capsys: pytest.CaptureFixture[str]) -> None:
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = (
+        'import re\n_RE = re.compile(r"a|b")  '
+        "# defeat-test-mutation-coverage: WAIVED: covered by a CLI test elsewhere\n"
+    )
+    test_src = 'import gitapex_check_fixture\n\n\ndef test_a():\n    assert gitapex_check_fixture._RE.match("a")\n'
+    _write(tmp_path, fixture_path, fixture_src)
+    _write(tmp_path, test_path, test_src)
+    diff_text = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, test_src)
+    diff_path = tmp_path / "diff.patch"
+    diff_path.write_text(diff_text, encoding="utf-8")
+    exit_code = gate.main(["--root", str(tmp_path), "--diff", str(diff_path)])
+    assert exit_code == 0
+    assert "waived inline" in capsys.readouterr().err
+
+
+def test_main_returns_2_for_a_root_that_does_not_exist(tmp_path: pathlib.Path) -> None:
+    exit_code = gate.main(["--root", str(tmp_path / "does-not-exist")])
+    assert exit_code == 2
+
+
+def test_main_returns_2_for_a_malformed_diff_file(tmp_path: pathlib.Path) -> None:
+    diff_path = tmp_path / "diff.patch"
+    diff_path.write_text("@@ garbage @@\n+x = 1\n", encoding="utf-8")
+    exit_code = gate.main(["--root", str(tmp_path), "--diff", str(diff_path)])
+    assert exit_code == 2
+
+
+def test_main_returns_2_for_a_diff_file_that_is_not_utf8(tmp_path: pathlib.Path) -> None:
+    diff_path = tmp_path / "diff.patch"
+    diff_path.write_bytes(b"\xff\xfe not utf-8")
+    exit_code = gate.main(["--root", str(tmp_path), "--diff", str(diff_path)])
+    assert exit_code == 2
+
+
+def test_main_returns_2_for_non_utf8_stdin(tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("sys.stdin", _FakeStdin(b"\xff\xfe not utf-8"))
+    exit_code = gate.main(["--root", str(tmp_path)])
+    assert exit_code == 2
+
+
+def test_main_returns_2_when_a_diff_named_file_cannot_be_read(tmp_path: pathlib.Path) -> None:
+    diff_path = tmp_path / "does-not-exist.patch"
+    exit_code = gate.main(["--root", str(tmp_path), "--diff", str(diff_path)])
+    assert exit_code == 2
+
+
+# --- workflow drift tests ------------------------------------------------------
+
+_WORKFLOW_NAME = "defeat-test-mutation-coverage-gate.yml"
+
+
+def test_the_workflow_has_no_paths_filter() -> None:
+    assert_workflow_has_no_trigger_path_filter(_WORKFLOW_NAME)
+
+
+def test_the_workflow_checks_out_the_head_sha_with_full_history() -> None:
+    assert_workflow_checkout_pins_head_sha_with_full_history(_WORKFLOW_NAME)
+
+
+def test_the_workflow_uses_merge_base_not_base_sha() -> None:
+    assert_workflow_feeds_merge_base_to(_WORKFLOW_NAME, "diff")
+
+
+def test_the_workflow_passes_the_two_flags_the_gate_depends_on() -> None:
+    assert_workflow_diff_carries_flags(_WORKFLOW_NAME, "--no-renames", "core.quotePath=false")
diff --git a/tests/test_gitapex_gate_defeat_test_mutation_coverage_properties.py b/tests/test_gitapex_gate_defeat_test_mutation_coverage_properties.py
new file mode 100644
index 00000000..8a70e46e
--- /dev/null
+++ b/tests/test_gitapex_gate_defeat_test_mutation_coverage_properties.py
@@ -0,0 +1,257 @@
+"""Hypothesis property-based layer for
+``.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py`` (issue
+#1799). Covers every function in that file which, per this repository's own
+``detection-logic-property-coverage`` gate (issue #1178), contains a regex-,
+path-resolution-, or string-comparison-shaped call: :func:`in_scope`,
+:func:`_stem`, :func:`_diff_target_path`, :func:`_looks_like_real_header_pair`,
+:func:`parse_added_lines`, :func:`_waived_lines`, :func:`_split_bom`, and
+:func:`_string_literal_content_span`.
+
+``in_scope``, ``_diff_target_path``, ``_looks_like_real_header_pair`` and
+``parse_added_lines`` are copied verbatim (or near-verbatim, for ``in_scope``'s
+own three-directory scope) from
+``gitapex_gate_function_body_test_coverage.py``, whose own properties file
+already carries the full model-based property for each -- the versions below
+are the same technique, scoped down (fewer generated shapes, smaller
+``max_examples``) rather than re-deriving a new approach, since the
+underlying functions are the same code.
+
+Module-scope triggers need no dedicated property
+--------------------------------------------------
+The source file's own module level carries real triggers too (``REPO_ROOT
+= pathlib.Path(__file__).resolve().parents[2]``, several ``re.compile(...)``
+constants). None needs a property mentioning it by name: any
+``@given``-decorated function in this file clears the ``"<module>"`` scope
+as a side effect of existing at all, the same rule
+``gitapex_gate_detection_logic_property_coverage.py``'s own ``_covered``
+already applies.
+
+Reproducibility
+----------------
+``derandomize=True`` with an explicit ``max_examples`` and ``deadline=None``,
+applied per property rather than as a registered global profile --
+``tests/test_gitapex_gate_metadata_outcome_lines_properties.py``'s own module
+docstring gives the full rationale, not repeated here beyond this pointer.
+"""
+
+from __future__ import annotations
+
+import gitapex_gate_defeat_test_mutation_coverage as gate
+import pytest
+from hypothesis import given, settings
+from hypothesis import strategies as st
+
+# Applied per test, not registered as a global Hypothesis profile -- see the
+# module docstring's own "Reproducibility" section.
+_PROPERTIES = settings(derandomize=True, max_examples=100, deadline=None)
+
+_IDENT = st.text(alphabet="abcdefghijklmnopqrstuvwxyz0123456789_", min_size=1, max_size=16)
+_SKILL_NAME = st.text(alphabet="abcdefghijklmnopqrstuvwxyz0123456789_", min_size=1, max_size=12)
+# `in_scope`'s own basename check excludes anything starting with "test_" or
+# equal to "conftest.py", regardless of directory.
+_PATH_IDENT = _IDENT.filter(lambda s: not s.startswith("test_") and s != "conftest")
+
+_IN_SCOPE_KIND = st.sampled_from(("skills_scripts", "github_scripts", "hooks"))
+_OUT_OF_SCOPE_KIND = st.sampled_from(("test_prefix", "conftest", "wrong_directory", "extra_path_segment"))
+
+
+def _in_scope_path(kind: str, skill: str, ident: str) -> str:
+    """A path built from `_IN_SCOPE_RE`'s own three documented
+    alternatives -- always in scope by construction."""
+    if kind == "skills_scripts":
+        return f"skills/{skill}/scripts/{ident}.py"
+    if kind == "github_scripts":
+        return f".github/scripts/{ident}.py"
+    return f"hooks/{ident}.py"
+
+
+def _out_of_scope_path(kind: str, skill: str, ident: str) -> str:
+    """A path built to violate exactly one documented scope boundary --
+    always out of scope by construction."""
+    if kind == "test_prefix":
+        return f"skills/{skill}/scripts/test_{ident}.py"
+    if kind == "conftest":
+        return f"skills/{skill}/scripts/conftest.py"
+    if kind == "wrong_directory":
+        return f"evals/scripts/{ident}.py"
+    # A real in-scope-shaped name with an extra path segment: `[^/]+`
+    # segments must never cross a directory separator.
+    return f"skills/{skill}/extra/scripts/{ident}.py"
+
+
+@_PROPERTIES
+@given(in_kind=_IN_SCOPE_KIND, out_kind=_OUT_OF_SCOPE_KIND, skill=_SKILL_NAME, ident=_PATH_IDENT)
+def test_in_scope_matches_its_own_three_directory_scope(in_kind: str, out_kind: str, skill: str, ident: str) -> None:
+    """Model-based, independent of `in_scope`'s own implementation: the
+    expected answer follows directly from the module docstring's own
+    "Scope" section. Real defect class this would catch: a typo or
+    accidental narrowing/widening in any of `_IN_SCOPE_RE`'s three fixed
+    directory prefixes, or the `test_`/`conftest.py` exclusion being
+    dropped."""
+    assert gate.in_scope(_in_scope_path(in_kind, skill, ident)) is True
+    assert gate.in_scope(_out_of_scope_path(out_kind, skill, ident)) is False
+
+
+@_PROPERTIES
+@given(directory=st.sampled_from((".github/scripts", "hooks")), ident=_PATH_IDENT)
+def test_stem_round_trips_through_test_relative_paths(directory: str, ident: str) -> None:
+    """Model-based: `_stem` composed with `_test_relative_paths` must
+    reconstruct the exact stem a real gate script's path implies,
+    independent of either function's own implementation detail. Real
+    defect class this would catch: a `_stem`/`_test_relative_paths`
+    mismatch letting a source file resolve to the wrong paired-test
+    filename."""
+    path = f"{directory}/{ident}.py"
+    stem = gate._stem(path)
+    assert stem == ident
+    test_path, properties_path = gate._test_relative_paths(stem)
+    assert test_path == f"tests/test_{ident}.py"
+    assert properties_path == f"tests/test_{ident}_properties.py"
+
+
+_NO_WHITESPACE_TEXT = st.text(alphabet=st.characters(min_codepoint=33, max_codepoint=126), max_size=60)
+_NON_B_PREFIXED_TEXT = st.text(max_size=60).filter(
+    lambda s: s.strip() != "/dev/null" and not s.strip().startswith("b/")
+)
+
+
+@_PROPERTIES
+@given(suffix=_NO_WHITESPACE_TEXT, other=_NON_B_PREFIXED_TEXT)
+def test_diff_target_path_strips_b_prefix_and_rejects_everything_else(suffix: str, other: str) -> None:
+    """Model-based for both halves, independent of `_diff_target_path`'s
+    own implementation. Real defect class this would catch: the `b/`-prefix
+    check or the `/dev/null` special case being loosened."""
+    assert gate._diff_target_path("b/" + suffix) == suffix
+    assert gate._diff_target_path("/dev/null") is None
+    with pytest.raises(gate.ScanError):
+        gate._diff_target_path(other)
+
+
+_HEADER_PATH_TEXT = st.text(max_size=40)
+_NOT_A_PREFIXED_TEXT = st.text(max_size=60).filter(lambda s: s != "/dev/null" and not s.startswith("a/"))
+_NOT_B_PREFIXED_TEXT = st.text(max_size=60).filter(lambda s: s != "/dev/null" and not s.startswith("b/"))
+
+
+@_PROPERTIES
+@given(matching_path=_HEADER_PATH_TEXT, not_a_prefixed=_NOT_A_PREFIXED_TEXT, not_b_prefixed=_NOT_B_PREFIXED_TEXT)
+def test_looks_like_real_header_pair_recognises_every_real_shape_and_rejects_the_rest(
+    matching_path: str, not_a_prefixed: str, not_b_prefixed: str
+) -> None:
+    """Model-based for every case, independent of
+    `_looks_like_real_header_pair`'s own `a/`/`b/`/`/dev/null` formula. Real
+    defect class this would catch: either prefix check, or the `/dev/null`
+    special case on either side, being loosened or dropped."""
+    assert gate._looks_like_real_header_pair(f"--- a/{matching_path}", f"+++ b/{matching_path}") is True
+    assert gate._looks_like_real_header_pair("--- /dev/null", f"+++ b/{matching_path}") is True
+    assert gate._looks_like_real_header_pair(f"--- a/{matching_path}", "+++ /dev/null") is True
+    assert gate._looks_like_real_header_pair(f"--- {not_a_prefixed}", f"+++ b/{matching_path}") is False
+    assert gate._looks_like_real_header_pair(f"--- a/{matching_path}", f"+++ {not_b_prefixed}") is False
+
+
+_LINE_KIND = st.sampled_from(("+", " ", "-"))
+_HUNK_BODY = st.lists(_LINE_KIND, max_size=15)
+_START_LINE = st.integers(min_value=1, max_value=200)
+
+
+def _expected_added_for_hunk(start: int, kinds: list[str]) -> set[int]:
+    """The post-image added-line-number set a correct parser must produce
+    for one hunk starting at post-image line `start`, per the module
+    docstring's own documented contract -- recomputed independently, not by
+    mirroring `parse_added_lines`'s own state machine."""
+    expected: set[int] = set()
+    lineno = start
+    for kind in kinds:
+        if kind == "+":
+            expected.add(lineno)
+            lineno += 1
+        elif kind == " ":
+            lineno += 1
+    return expected
+
+
+def _file_diff_text(path: str, start: int, kinds: list[str]) -> str:
+    pre_image_count = sum(1 for kind in kinds if kind != "+")
+    post_image_count = sum(1 for kind in kinds if kind != "-")
+    lines = [
+        f"diff --git a/{path} b/{path}",
+        f"--- a/{path}",
+        f"+++ b/{path}",
+        f"@@ -1,{pre_image_count} +{start},{post_image_count} @@",
+        *kinds,
+    ]
+    return "\n".join(lines)
+
+
+@_PROPERTIES
+@given(start=_START_LINE, kinds=_HUNK_BODY)
+def test_parse_added_lines_matches_an_independently_computed_line_set(start: int, kinds: list[str]) -> None:
+    """Model-based. `_expected_added_for_hunk` recomputes the intended
+    added-line-number set directly from the module docstring's own
+    documented post-image-counting contract, not by calling
+    `parse_added_lines` or mirroring its own state machine. Real defect
+    class this would catch: an off-by-one in the post-image line counter,
+    or a context/removal line wrongly advancing (or failing to advance) it.
+    """
+    diff_text = _file_diff_text("module.py", start, kinds)
+    added = gate.parse_added_lines(diff_text)
+    expected = _expected_added_for_hunk(start, kinds)
+    if expected:
+        assert added == {"module.py": expected}
+    else:
+        assert added == {}
+
+
+_WAIVER_REASON_TEXT = st.text(
+    alphabet=st.characters(min_codepoint=32, max_codepoint=126, blacklist_characters="\n\r#"),
+    min_size=1,
+    max_size=40,
+)
+
+
+@_PROPERTIES
+@given(reason=_WAIVER_REASON_TEXT)
+def test_waived_lines_finds_a_marker_with_a_reason_and_not_a_bare_one(reason: str) -> None:
+    """Model-based: a waiver comment with a non-empty reason is always
+    honoured on its own line; the bare marker with no reason never is,
+    regardless of what other content shares the line. Real defect class
+    this would catch: `_WAIVER_RE`'s own mandatory-reason group being
+    loosened to accept a bare marker."""
+    waived_source = f"X = 1  # defeat-test-mutation-coverage: WAIVED: {reason}\n"
+    assert gate._waived_lines(waived_source) == {1}
+    bare_source = "X = 1  # defeat-test-mutation-coverage: WAIVED\n"
+    assert gate._waived_lines(bare_source) == set()
+
+
+@_PROPERTIES
+@given(data=st.binary(max_size=60))
+def test_split_bom_round_trips_with_and_without_a_leading_bom(data: bytes) -> None:
+    """Model-based, independent of `_split_bom`'s own implementation: the
+    BOM/body split is exactly determined by whether `data` starts with the
+    fixed 3-byte UTF-8 BOM sequence. Real defect class this would catch:
+    the BOM constant being mis-sliced, or the no-BOM branch dropping bytes.
+    """
+    with_bom = gate._UTF8_BOM + data
+    assert gate._split_bom(with_bom) == (gate._UTF8_BOM, data)
+    if not data.startswith(gate._UTF8_BOM):
+        assert gate._split_bom(data) == (b"", data)
+
+
+_QUOTE_SAFE_CONTENT = st.text(
+    alphabet=st.characters(blacklist_characters="\"'\\\n\r", min_codepoint=32, max_codepoint=126), max_size=30
+)
+_QUOTE_STYLE = st.sampled_from(('"', "'"))
+_PREFIX = st.sampled_from(("", "r", "b", "rb"))
+
+
+@_PROPERTIES
+@given(prefix=_PREFIX, quote=_QUOTE_STYLE, content=_QUOTE_SAFE_CONTENT)
+def test_string_literal_content_span_recovers_exactly_the_quoted_content(prefix: str, quote: str, content: str) -> None:
+    """Model-based: for a well-formed, single-token string literal built
+    from `prefix`/`quote`/`content`, the returned span must slice out
+    exactly `content` -- no more, no less, and no off-by-one from the
+    prefix or quote length. Real defect class this would catch: the
+    prefix/quote length arithmetic drifting for a two-character prefix
+    (`rb`) or a differently-quoted literal (`'` vs `"`)."""
+    raw = f"{prefix}{quote}{content}{quote}".encode()
+    start, end = gate._string_literal_content_span(raw)
+    assert raw[start:end] == content.encode()
diff --git a/tests/test_gitapex_gate_local_preflight.py b/tests/test_gitapex_gate_local_preflight.py
index 821ffb50..7dab75bf 100644
--- a/tests/test_gitapex_gate_local_preflight.py
+++ b/tests/test_gitapex_gate_local_preflight.py
@@ -5,7 +5,7 @@
 - **Fixture-registry tests** build their own tiny ``ssot.json`` pointing at
   purpose-built pass/fail scripts, so the runner's own aggregation,
   discovery, error handling and exit-code logic are exercised in under a
-  second with no dependence on this repository's real 49 wired gates. Issue
+  second with no dependence on this repository's real 50 wired gates. Issue
   #876's first acceptance criterion asks for an integration test running
   the consolidated command "with one deliberately-broken instance of each
   wired check, asserting all are reported in one run" --

From 24709d81d6d9eb7609fafdfb7fc0f2929277cdea Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 14 Sep 2026 04:06:28 +0000
Subject: [PATCH 04/10] fix(gates): reconcile 49-to-51 wired-gate prose after
 origin/main merge

The merge of origin/main (issue #1965's skill-contract-drift gate) with this branch (issue #1799's defeat-test-mutation-coverage gate) landed both as parallel 49-to-50-gate additions, combining into a real 51-gate registry. Resolves the resulting conflicts by keeping both gates' own history entries, updates every remaining prose count still stating 50 (CONTRIBUTING.md, gitapex_gate_local_preflight.py x3, its own test file) to 51, and records a live warm-run measurement of the real 51-gate set (roughly 47 s) rather than leaving a placeholder.

Issue: https://github.com/tvna/gitapex/issues/1799
---
 .github/scripts/gitapex_gate_local_preflight.py | 6 +++---
 .pre-commit-config.yaml                         | 2 +-
 CONTRIBUTING.md                                 | 4 ++--
 tests/test_gitapex_gate_local_preflight.py      | 2 +-
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/scripts/gitapex_gate_local_preflight.py b/.github/scripts/gitapex_gate_local_preflight.py
index 63c4bd6c..1ea8f7c2 100644
--- a/.github/scripts/gitapex_gate_local_preflight.py
+++ b/.github/scripts/gitapex_gate_local_preflight.py
@@ -107,7 +107,7 @@
   (issue #890), which closes the "configured here but never actually
   installed" half; nothing closes the ``--no-verify`` half. CI remains the
   authoritative merge gate for every gate carrying a ``ci`` plane -- true
-  for 48 of the 50 wired gates. ``behind-base`` (issue #985) and
+  for 49 of the 51 wired gates. ``behind-base`` (issue #985) and
   ``real-checkout-git-write`` (issue #991) are the two exceptions: each
   carries only ``local``, so for those two gates specifically this
   pre-push hook -- bypassable the same way as any other -- is the *only*
@@ -119,7 +119,7 @@
   ``jsonschema`` -- a real, non-stdlib dependency, contrary to an earlier
   revision of this paragraph's own "the runner itself needs no
   dependencies" claim. A bare system ``python3`` with no ``jsonschema``
-  installed crashed the whole runner on import before any of the 50 wired
+  installed crashed the whole runner on import before any of the 51 wired
   gates got a chance to run individually, so CONTRIBUTING.md's standalone
   example and the pre-push hook's own ``entry`` both now invoke it as ``uv
   run --frozen python3`` too, the same pin every wired gate's own argv
@@ -208,7 +208,7 @@
 # worst case is ~4200 s, not 600 s. A ceiling matching that would be useless
 # as a hang guard (80 minutes of a silent pre-push), so this is a judgment
 # call in the other direction. For scale: a warm run of all 51 wired gates
-# combined measures roughly PLACEHOLDER s end to end (issue #1965's own
+# combined measures roughly 47 s end to end (issue #1965's own
 # skill-contract-drift gate and issue #1799's own defeat-test-mutation-
 # coverage gate landed on parallel branches and both bumped the 49-gate
 # baseline to their own independent 50-gate counts before this merge
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index c8ee031c..1f84b020 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -157,7 +157,7 @@ repos:
       # already-open PR. This runs all of them in one pass at pre-push --
       # the last local moment before a gap becomes a CI round-trip, and
       # deliberately not pre-commit: it grades committed state (HEAD vs
-      # origin/main), not a staged index, and at ~PLACEHOLDER s
+      # origin/main), not a staged index, and at ~47 s
       # warm end to end for all 51 wired gates (issue #1799's own
       # defeat-test-mutation-coverage gate roughly doubled the prior ~24 s
       # baseline on its own, being the first wired gate that spawns a real
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 558604d6..1a0f7fb4 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -126,7 +126,7 @@ used to be discovered one red check at a time on an already-open PR.
 The same `uv run prek install -t pre-commit -t pre-push -t commit-msg` above also installs
 a **pre-push** hook that runs every gate with a working-tree-only form in
 one pass, before the push leaves your machine. A warm run of all 51 wired
-gates measures roughly PLACEHOLDER seconds end to end (issue #1799's own
+gates measures roughly 47 seconds end to end (issue #1799's own
 defeat-test-mutation-coverage gate: unlike every other wired gate, which is
 pure AST inspection, it spawns a real `pytest` subprocess per graded
 element and self-grades its own regex/dict/literal elements against its own
@@ -177,7 +177,7 @@ it up, then confirm both shims with the check in the previous section.
 The runner itself also resolves through `uv` (issue #1485: it imports
 `_gitapex_schema_validation.py`, which needs `jsonschema` -- a real,
 non-stdlib dependency a bare system `python3` is not guaranteed to have),
-and so do all 50 wired gates (the same `uv run` pins CI uses). Without `uv`
+and so do all 51 wired gates (the same `uv run` pins CI uses). Without `uv`
 on PATH every one of them reports `FAIL ... failed to run` -- that is one
 missing tool, not a whole broken wired set.
 
diff --git a/tests/test_gitapex_gate_local_preflight.py b/tests/test_gitapex_gate_local_preflight.py
index 4611258c..1e18dfaf 100644
--- a/tests/test_gitapex_gate_local_preflight.py
+++ b/tests/test_gitapex_gate_local_preflight.py
@@ -5,7 +5,7 @@
 - **Fixture-registry tests** build their own tiny ``ssot.json`` pointing at
   purpose-built pass/fail scripts, so the runner's own aggregation,
   discovery, error handling and exit-code logic are exercised in under a
-  second with no dependence on this repository's real 50 wired gates. Issue
+  second with no dependence on this repository's real 51 wired gates. Issue
   #876's first acceptance criterion asks for an integration test running
   the consolidated command "with one deliberately-broken instance of each
   wired check, asserting all are reported in one run" --

From b53b1f3a69e238c0e46576908c1eedbf429b15df Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 14 Sep 2026 04:30:43 +0000
Subject: [PATCH 05/10] fix(gates): harden defeat-test-mutation-coverage's own
 mutation engine (#1799)

Step 8 refactor/simplify pass over PR #2000's own accumulated diff,
addressing three review-persona advisory findings against
gitapex_gate_defeat_test_mutation_coverage.py -- behavior-preserving
defense-in-depth, no new feature:

1. `_run_mutation`'s own first `write_bytes(mutated)` call is now inside
   the same try/finally that already protected the restore step, instead
   of sitting bare before it. An OSError there still raises a clear
   ScanError; the finally block's own restore write is skipped (nothing
   was written yet, so nothing needs restoring), tracked via a
   `mutated_write_succeeded` flag rather than attempted and ignored.

2. A restore-write failure's own ScanError now names a concrete recovery
   command (`git checkout -- <path>`) instead of only stating that the
   file may still hold mutated bytes on disk.

3. A new `_is_within_root` containment check runs immediately before
   `_run_mutation` writes a single mutated byte to disk, verifying the
   diff-derived target path actually resolves inside `--root` -- defense
   in depth on top of (not a replacement for) `in_scope`'s own
   `_IN_SCOPE_RE` shape, warranted by this gate's own different risk
   profile: it is the only sibling gate whose detection mechanism
   actually writes to disk. Implemented with `Path.is_relative_to`
   (returns a plain bool) rather than `relative_to(...)` wrapped in
   `except ValueError: return False`, which is exactly the falsy-
   default-on-exception shape `except-fail-open` (#1722) exists to catch.

Each fix has a dedicated regression test in
tests/test_gitapex_gate_defeat_test_mutation_coverage.py, plus a new
Hypothesis @given property test in
tests/test_gitapex_gate_defeat_test_mutation_coverage_properties.py
covering `_is_within_root` (satisfying this repository's own
detection-logic-property-coverage gate for its new `.resolve()` calls).

Verified: uv run --frozen python3 -m pytest --no-cov -q (9316 passed),
uv run --frozen python3 .github/scripts/gitapex_gate_local_preflight.py
(51/51 wired gates PASS), ruff check/format and mypy clean on all three
touched files.

Claude-Session: https://claude.ai/code/session_01GQ8289c4nMwpaLPnhZTHyM
---
 ...apex_gate_defeat_test_mutation_coverage.py | 123 +++++++++++++-----
 ...apex_gate_defeat_test_mutation_coverage.py | 112 ++++++++++++++++
 ...efeat_test_mutation_coverage_properties.py |  44 ++++++-
 3 files changed, 248 insertions(+), 31 deletions(-)

diff --git a/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py b/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
index 190ad8fa..4ca23d94 100644
--- a/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
+++ b/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
@@ -156,6 +156,19 @@
 leaves an empty literal (``{}``, a pattern with no alternatives, exact same
 technique), also valid.
 
+Before any byte is written, ``_is_within_root`` re-checks that the target
+file's own absolute path actually resolves (symlinks and ``..`` components
+included) to somewhere inside ``--root`` -- defense in depth on top of, not
+a replacement for, ``in_scope``'s own fixed ``_IN_SCOPE_RE`` shape. This
+gate is the odd one out among its sibling gates precisely because it is the
+only one whose own detection mechanism actually writes to disk (its
+siblings only ever read and reason about the AST); a diff-derived path that
+somehow resolved outside the repository root would otherwise let this
+gate's own mutation engine overwrite an arbitrary file. A path failing this
+check raises :class:`ScanError` before ``write_bytes`` is ever called, the
+same fail-closed contract every other malformed-input case in this gate
+already gets.
+
 The mutated bytes are written over the on-disk source file for the duration
 of one ``pytest`` subprocess invocation scoped to exactly the paired test
 file(s) this diff itself touches (see "Why not parse docstrings" above), then
@@ -166,7 +179,16 @@
 from that same in-memory copy -- never by re-reading the file from disk after
 a prior mutation -- so an interrupted restore can never let a later
 mutation's restore step re-save an already-mutated copy as if it were the
-original.
+original. The very first mutated-bytes write is itself inside this same
+``try``/``finally`` protection (not a bare write before it, as an earlier
+version of this gate had it), so an ``OSError`` on that first write still
+runs the ``finally`` block; the restore write itself is skipped there
+(nothing was actually written yet, so nothing needs restoring), while the
+raised :class:`ScanError` still names the failure plainly. Where the
+*restore* write (not the initial one) fails instead -- the on-disk file
+genuinely may still hold mutated bytes -- the raised :class:`ScanError`
+now also names a concrete recovery command (``git checkout -- <path>``)
+rather than leaving a human to guess.
 
 If the paired suite still exits 0 (every test passed) against the mutated
 source, that element is a ``defeat-test-mutation-gap`` finding: its paired
@@ -225,9 +247,10 @@
 ----------
 0 clean, 1 a vacuous-coverage finding, 2 the scan could not be trusted
 (malformed diff, an in-scope or paired-test file that cannot be
-read/parsed, a ``--root`` that is not a directory, or a subprocess ``pytest``
-invocation that itself errors for a reason other than "tests ran and
-passed/failed" -- e.g. a collection error) -- the same fail-closed contract
+read/parsed, a ``--root`` that is not a directory, a diff-derived path that
+does not resolve inside ``--root`` (``_is_within_root``), or a subprocess
+``pytest`` invocation that itself errors for a reason other than "tests ran
+and passed/failed" -- e.g. a collection error) -- the same fail-closed contract
 both sibling gates already state, dimension 15 of
 ``skills/evaluating-deterministic-gate-quality/references/dimensions.md``.
 
@@ -901,6 +924,24 @@ def _invalidate_pycache(absolute_path: pathlib.Path) -> None:
         shutil.rmtree(cache_dir, ignore_errors=True)
 
 
+def _is_within_root(candidate: pathlib.Path, root: pathlib.Path) -> bool:
+    """True iff `candidate` resolves (symlinks and `..` components
+    included) to `root` itself or somewhere inside it -- the path-traversal
+    containment check `_run_mutation` runs immediately before writing a
+    single mutated byte to disk, on top of (never a replacement for)
+    `in_scope`'s own fixed `_IN_SCOPE_RE` shape. Real defect class this
+    would catch that a plain string-prefix check would not: a same-prefixed
+    sibling directory (`root=/repo`, `candidate=/repo-evil/x.py`) -- both
+    sides are resolved to absolute, normalized paths before comparison, so
+    neither a `..`-relative escape nor a textual-prefix coincidence can
+    pass. `Path.is_relative_to` returns a plain bool (never raises), so
+    there is no failure-mode exception to route wrong here -- deliberately
+    not `relative_to(...)` wrapped in a `try`/`except ValueError: return
+    False`, which is this same falsy-default-on-exception shape
+    `except-fail-open` (issue #1722) exists to catch."""
+    return candidate.resolve().is_relative_to(root.resolve())
+
+
 def _run_mutation(
     absolute_path: pathlib.Path,
     bom: bytes,
@@ -914,31 +955,42 @@ def _run_mutation(
     bytes in a `finally` block regardless of outcome. Returns True iff the
     mutation SURVIVED (the paired suite still passed clean); False iff at
     least one paired test failed (the mutation was caught). Raises
-    `ScanError` for anything else -- a write/restore failure, a subprocess
-    that could not be started or timed out, or a pytest exit code that is
-    neither 0 nor 1 -- per the module docstring's own "Exit codes" section.
+    `ScanError` for anything else -- `absolute_path` resolving outside
+    `root`, a write/restore failure, a subprocess that could not be started
+    or timed out, or a pytest exit code that is neither 0 nor 1 -- per the
+    module docstring's own "Exit codes" section.
     """
+    if not _is_within_root(absolute_path, root):
+        raise ScanError(
+            f"refusing to mutate {absolute_path} -- it does not resolve to a path contained "
+            f"within --root {root}. This gate's own mutation engine writes real bytes to disk, "
+            "unlike its sibling AST-only gates, so a diff-derived path that would resolve "
+            "outside the repository root is rejected before any write is attempted."
+        )
+
     start, end = removal_span
     mutated = bom + original_body[:start] + original_body[end:]
+    mutated_write_succeeded = False
     try:
-        absolute_path.write_bytes(mutated)
-    except OSError as error:
-        raise ScanError(f"could not write a mutated copy of {absolute_path}: {error}") from error
-    _invalidate_pycache(absolute_path)
-
-    env = dict(os.environ)
-    extra_path = str(absolute_path.parent)
-    existing = env.get("PYTHONPATH", "")
-    env["PYTHONPATH"] = f"{extra_path}{os.pathsep}{existing}" if existing else extra_path
-    # Defense in depth alongside `_invalidate_pycache`: never let the
-    # subprocess itself write a new cache entry that a later mutation (or
-    # a later, unrelated import of the restored original) could read back
-    # as stale. `_invalidate_pycache` alone already prevents a stale read
-    # by clearing the directory before every run; this just stops a new
-    # one from being created in the first place.
-    env["PYTHONDONTWRITEBYTECODE"] = "1"
+        try:
+            absolute_path.write_bytes(mutated)
+            mutated_write_succeeded = True
+        except OSError as error:
+            raise ScanError(f"could not write a mutated copy of {absolute_path}: {error}") from error
+        _invalidate_pycache(absolute_path)
+
+        env = dict(os.environ)
+        extra_path = str(absolute_path.parent)
+        existing = env.get("PYTHONPATH", "")
+        env["PYTHONPATH"] = f"{extra_path}{os.pathsep}{existing}" if existing else extra_path
+        # Defense in depth alongside `_invalidate_pycache`: never let the
+        # subprocess itself write a new cache entry that a later mutation (or
+        # a later, unrelated import of the restored original) could read back
+        # as stale. `_invalidate_pycache` alone already prevents a stale read
+        # by clearing the directory before every run; this just stops a new
+        # one from being created in the first place.
+        env["PYTHONDONTWRITEBYTECODE"] = "1"
 
-    try:
         try:
             completed = subprocess.run(  # noqa: S603
                 [sys.executable, "-m", "pytest", "--no-cov", "-n0", "-q", "-x", *(str(p) for p in test_paths)],
@@ -958,11 +1010,24 @@ def _run_mutation(
                 f"pytest failed to run grading a mutated copy of {absolute_path} against {test_paths}: {error}"
             ) from error
     finally:
-        try:
-            absolute_path.write_bytes(bom + original_body)
-        except OSError as error:
-            raise ScanError(f"could not restore {absolute_path} after mutation testing: {error}") from error
-        _invalidate_pycache(absolute_path)
+        # The initial mutated-bytes write above is inside this same
+        # try/finally (not a bare write before it): an `OSError` there is
+        # still caught by the `except OSError` immediately around it and
+        # re-raised as `ScanError`, but that re-raise still runs this
+        # `finally` block on its way out. `mutated_write_succeeded` staying
+        # False in that specific case means nothing was actually written to
+        # disk, so there is nothing to restore -- the restore write below is
+        # skipped, not attempted and ignored.
+        if mutated_write_succeeded:
+            try:
+                absolute_path.write_bytes(bom + original_body)
+            except OSError as error:
+                raise ScanError(
+                    f"could not restore {absolute_path} after mutation testing: {error}. The file "
+                    f"may still contain mutated bytes on disk -- run `git checkout -- {absolute_path}` "
+                    "to restore it before re-running this gate or committing."
+                ) from error
+            _invalidate_pycache(absolute_path)
 
     if completed.returncode == 0:
         return True
diff --git a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
index d8c0d9ff..1f54118a 100644
--- a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
+++ b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
@@ -864,6 +864,118 @@ def _raising(*args: object, **kwargs: object) -> None:
     assert absolute.read_bytes() == original_bytes
 
 
+# --- _run_mutation: containment check (path-traversal defense in depth) -----
+
+
+def test_is_within_root_accepts_root_itself_and_a_nested_path(tmp_path: pathlib.Path) -> None:
+    nested = tmp_path / "a" / "b" / "c.py"
+    nested.parent.mkdir(parents=True)
+    nested.write_text("x = 1\n", encoding="utf-8")
+    assert gate._is_within_root(tmp_path, tmp_path) is True
+    assert gate._is_within_root(nested, tmp_path) is True
+
+
+def test_is_within_root_rejects_a_sibling_directory_that_merely_shares_a_prefix(tmp_path: pathlib.Path) -> None:
+    """A naive string-prefix containment check
+    (``str(candidate).startswith(str(root))``) wrongly accepts a sibling
+    directory that merely shares `root`'s own name as a text prefix --
+    `root`=`.../repo`, `candidate`=`.../repo-evil/x.py`. `_is_within_root`
+    must not repeat that defect: it resolves both sides to absolute,
+    normalized paths and checks real containment, not string prefixing."""
+    root = tmp_path / "repo"
+    root.mkdir()
+    sibling = tmp_path / "repo-evil"
+    sibling.mkdir()
+    evil = sibling / "x.py"
+    evil.write_text("x = 1\n", encoding="utf-8")
+    assert str(evil).startswith(str(root))  # the naive check would wrongly accept this
+    assert gate._is_within_root(evil, root) is False
+
+
+def test_is_within_root_rejects_a_dot_dot_escape_above_root(tmp_path: pathlib.Path) -> None:
+    root = tmp_path / "repo"
+    root.mkdir()
+    outside = tmp_path / "outside.py"
+    outside.write_text("x = 1\n", encoding="utf-8")
+    escaping = root / ".." / "outside.py"
+    assert gate._is_within_root(escaping, root) is False
+
+
+def test_run_mutation_refuses_to_write_outside_root(tmp_path: pathlib.Path) -> None:
+    """The containment check runs before any write is attempted: a target
+    resolving outside `root` raises `ScanError` and the file is left
+    byte-for-byte untouched."""
+    root = tmp_path / "repo"
+    root.mkdir()
+    outside_dir = tmp_path / "outside"
+    outside_dir.mkdir()
+    target = outside_dir / "evil.py"
+    original = b"def make():\n    return 1\n"
+    target.write_bytes(original)
+    test_absolute = root / "tests" / "test_evil.py"
+    with pytest.raises(gate.ScanError, match="does not resolve to a path contained within"):
+        gate._run_mutation(target, b"", original, (0, 1), [test_absolute], root)
+    assert target.read_bytes() == original
+
+
+# --- _run_mutation: the first mutated-bytes write is inside try/finally too -
+
+
+def test_run_mutation_does_not_attempt_a_restore_write_when_the_initial_write_fails(
+    tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A first-write `OSError` (disk full, permission denied) means nothing
+    was ever written to disk -- the `finally` block must not then attempt a
+    pointless (and potentially itself-failing) restore write. Asserted here
+    by call-counting `write_bytes`: exactly one call, not two."""
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = "def make():\n    return 1\n"
+    test_src = "import gitapex_check_fixture\n\n\ndef test_x():\n    pass\n"
+    absolute = _write(tmp_path, fixture_path, fixture_src)
+    test_absolute = _write(tmp_path, test_path, test_src)
+    original_bytes = absolute.read_bytes()
+    calls = {"n": 0}
+
+    def _counting_raising_write_bytes(self: pathlib.Path, data: bytes) -> int:
+        calls["n"] += 1
+        raise OSError("simulated write failure")
+
+    monkeypatch.setattr(pathlib.Path, "write_bytes", _counting_raising_write_bytes)
+    with pytest.raises(gate.ScanError, match="could not write a mutated copy"):
+        gate._run_mutation(absolute, b"", original_bytes, (0, 1), [test_absolute], tmp_path)
+    assert calls["n"] == 1
+
+
+def test_run_mutation_restore_failure_names_a_concrete_git_checkout_recovery_command(
+    tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The restore-write failure message must tell a human exactly how to
+    recover the file (`git checkout -- <path>`), not just that recovery is
+    needed -- the file may genuinely still hold mutated bytes on disk once
+    this branch is reached."""
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = "def make():\n    return 1\n"
+    test_src = "import gitapex_check_fixture\n\n\ndef test_x():\n    pass\n"
+    absolute = _write(tmp_path, fixture_path, fixture_src)
+    test_absolute = _write(tmp_path, test_path, test_src)
+    original_bytes = absolute.read_bytes()
+    original_write_bytes = pathlib.Path.write_bytes
+    calls = {"n": 0}
+
+    def _fail_on_second_call(self: pathlib.Path, data: bytes) -> int:
+        calls["n"] += 1
+        if calls["n"] == 2:
+            raise OSError("simulated restore failure")
+        return original_write_bytes(self, data)
+
+    monkeypatch.setattr(pathlib.Path, "write_bytes", _fail_on_second_call)
+    with pytest.raises(gate.ScanError, match=r"git checkout -- .*gitapex_check_fixture\.py") as excinfo:
+        gate._run_mutation(absolute, b"", original_bytes, (0, 1), [test_absolute], tmp_path)
+    assert str(absolute) in str(excinfo.value)
+
+
 # --- direct unit tests for internal helpers ---------------------------------
 
 
diff --git a/tests/test_gitapex_gate_defeat_test_mutation_coverage_properties.py b/tests/test_gitapex_gate_defeat_test_mutation_coverage_properties.py
index 8a70e46e..dfec210b 100644
--- a/tests/test_gitapex_gate_defeat_test_mutation_coverage_properties.py
+++ b/tests/test_gitapex_gate_defeat_test_mutation_coverage_properties.py
@@ -4,8 +4,12 @@
 ``detection-logic-property-coverage`` gate (issue #1178), contains a regex-,
 path-resolution-, or string-comparison-shaped call: :func:`in_scope`,
 :func:`_stem`, :func:`_diff_target_path`, :func:`_looks_like_real_header_pair`,
-:func:`parse_added_lines`, :func:`_waived_lines`, :func:`_split_bom`, and
-:func:`_string_literal_content_span`.
+:func:`parse_added_lines`, :func:`_waived_lines`, :func:`_split_bom`,
+:func:`_string_literal_content_span`, and :func:`_is_within_root` (the
+path-traversal containment check `_run_mutation` runs immediately before
+writing a mutated byte to disk -- a defense-in-depth hardening beyond
+`in_scope`'s own fixed scope pattern; step 8's own refactor/simplify pass,
+issue #1799).
 
 ``in_scope``, ``_diff_target_path``, ``_looks_like_real_header_pair`` and
 ``parse_added_lines`` are copied verbatim (or near-verbatim, for ``in_scope``'s
@@ -36,6 +40,8 @@
 
 from __future__ import annotations
 
+import pathlib
+
 import gitapex_gate_defeat_test_mutation_coverage as gate
 import pytest
 from hypothesis import given, settings
@@ -255,3 +261,37 @@ def test_string_literal_content_span_recovers_exactly_the_quoted_content(prefix:
     raw = f"{prefix}{quote}{content}{quote}".encode()
     start, end = gate._string_literal_content_span(raw)
     assert raw[start:end] == content.encode()
+
+
+_PATH_SEGMENT = st.text(alphabet="abcdefghijklmnopqrstuvwxyz0123456789_-", min_size=1, max_size=12)
+
+
+@_PROPERTIES
+@given(
+    root_segments=st.lists(_PATH_SEGMENT, min_size=1, max_size=4),
+    nested_segments=st.lists(_PATH_SEGMENT, min_size=1, max_size=4),
+    outside_segment=_PATH_SEGMENT,
+)
+def test_is_within_root_accepts_nested_paths_and_rejects_a_resolved_escape(
+    root_segments: list[str], nested_segments: list[str], outside_segment: str
+) -> None:
+    """Model-based, independent of `_is_within_root`'s own implementation:
+    a path built strictly beneath `root` is always within it; a path that
+    walks back out of `root` (however many `..` components, into a
+    same-shaped but differently-named top-level directory) never is. Real
+    defect class this would catch: a naive string-prefix containment check
+    (`str(candidate).startswith(str(root))`) wrongly accepting a
+    same-prefixed sibling directory, or a check that forgets to resolve
+    `..` components before comparing. `outside_segment` is deliberately
+    given a fixed prefix longer than any generated `root_segments` entry
+    (`_PATH_SEGMENT`'s own `max_size=12` vs. `"definitely-outside-"`'s 19
+    characters) so the escaped path can never coincide with `root` by pure
+    chance."""
+    root = pathlib.Path("/" + "/".join(root_segments))
+    nested = root.joinpath(*nested_segments)
+    assert gate._is_within_root(root, root) is True
+    assert gate._is_within_root(nested, root) is True
+
+    escape_depth = len(root_segments) + len(nested_segments) + 2
+    escaped = nested.joinpath(*([".."] * escape_depth), f"definitely-outside-{outside_segment}")
+    assert gate._is_within_root(escaped, root) is False

From 8d1b7b856d16b9865c1591e426f6fd28cf8f26f4 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 14 Sep 2026 04:37:15 +0000
Subject: [PATCH 06/10] fix(gates): splice a single-item trailing comma in
 defeat-test-mutation-coverage

An independent adversarial review (Step 8, PR #2000) found that _removal_span_for_item's single-item branch spliced out only the item's own byte span, never a following comma -- so a source written with an explicit trailing comma on its sole element ("hidden",) or a multi-line CONST = {\n    "only": 1,\n} left a bare (,)/{,} after the mutation, a hard SyntaxError. Because this happens inside the mutation-execution engine itself rather than on the caller's diff, the resulting pytest collection error was unwaivable: no WAIVED comment can intercept a ScanError raised before the waiver check ever runs. This made the gate permanently unusable against a code shape its own docstring claims to support.

Fix: extend the single-item removal span past any whitespace-then-comma immediately following the item, consuming it the same way the multi-item branches already consume their own adjoining separator. A one-item sequence with no trailing comma in the source is unaffected. Adds unit coverage for both the with-comma and without-comma shapes (including an ast.parse round-trip proof) plus an end-to-end find_violations regression exercising the real mutation write/pytest-subprocess path, not only the pure byte-span arithmetic.

Issue: https://github.com/tvna/gitapex/issues/1799
---
 ...apex_gate_defeat_test_mutation_coverage.py | 56 ++++++++---
 ...apex_gate_defeat_test_mutation_coverage.py | 94 ++++++++++++++++++-
 2 files changed, 132 insertions(+), 18 deletions(-)

diff --git a/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py b/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
index 4ca23d94..4b716bed 100644
--- a/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
+++ b/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
@@ -153,8 +153,14 @@
 one adjoining separator -- the one *before* it when it is last, the one
 *after* it otherwise -- so the remaining sequence stays syntactically valid
 with no dangling separator; removing the sole element of a one-item sequence
-leaves an empty literal (``{}``, a pattern with no alternatives, exact same
-technique), also valid.
+also consumes an explicit trailing comma in the real source, when one is
+present (found missing by an independent adversarial review, issue #1799):
+splicing out only the element's own span from a source written
+``("hidden",)``/``["hidden",]``/a multi-line ``{\n    "only": 1,\n}`` would
+otherwise leave a bare ``(,)``/``[,]``/``{,}`` -- a hard ``SyntaxError``, not
+"still valid" as an earlier revision of this paragraph claimed. A one-item
+sequence with no trailing comma in the source still leaves a syntactically
+valid empty literal exactly as before.
 
 Before any byte is written, ``_is_within_root`` re-checks that the target
 file's own absolute path actually resolves (symlinks and ``..`` components
@@ -547,20 +553,44 @@ def _node_byte_span(node: ast.expr, line_starts: list[int]) -> tuple[int, int]:
     return start, end
 
 
-def _removal_span_for_item(item_spans: list[tuple[int, int]], index: int) -> tuple[int, int]:
+_TRAILING_WHITESPACE = b" \t\n\r\f\v"
+
+
+def _removal_span_for_item(item_spans: list[tuple[int, int]], index: int, source: bytes) -> tuple[int, int]:
     """Given the `(start, end)` byte spans of every item in a comma- or
     `|`-separated sequence of `N >= 1` siblings, return the byte span to
     delete to remove item `index` alone while leaving the remaining items
     validly joined: the item's own span plus one adjoining separator -- the
     one before it when it is the last item (so removing the last item
     consumes the separator that used to precede it, not a nonexistent one
-    that used to follow it), the one after it otherwise. Removing the sole
-    item of a one-item sequence deletes just that item's own span, leaving
-    an empty container/alternation-less literal -- still syntactically
-    valid Python/regex. See the module docstring's own "Mutation mechanism"
-    section."""
+    that used to follow it), the one after it otherwise.
+
+    Removing the sole item of a one-item sequence deletes just that item's
+    own span *plus* an explicit trailing comma when the real source carries
+    one (skipping intervening whitespace to find it) -- `source` is the
+    full byte string `item_spans` was computed against (`body` for a
+    dict-entry/literal-display item, `content` for a regex alternative,
+    which this branch never actually reaches: a `|`-joined pattern with
+    only one alternative has no top-level `|` at all and is filtered out
+    before this function is ever called for it). Without consuming that
+    comma, splicing out the sole element of a source written with an
+    explicit trailing comma -- `("hidden",)`, `["hidden",]`, or a
+    multi-line `{\n    "only": 1,\n}` -- would leave a bare `(,)`/`[,]`/
+    `{,}` behind: syntactically invalid Python, not the "empty container,
+    still valid" result this docstring originally claimed for every shape
+    (found by an independent adversarial review: PR #2000, issue #1799).
+    A one-item sequence with no trailing comma in the source (`{"only": 1}`)
+    still yields an empty, syntactically valid literal exactly as before,
+    since no comma is found to extend the span over. See the module
+    docstring's own "Mutation mechanism" section."""
     if len(item_spans) == 1:
-        return item_spans[0]
+        start, end = item_spans[0]
+        cursor = end
+        while cursor < len(source) and source[cursor : cursor + 1] in _TRAILING_WHITESPACE:
+            cursor += 1
+        if cursor < len(source) and source[cursor : cursor + 1] == b",":
+            end = cursor + 1
+        return start, end
     if index < len(item_spans) - 1:
         return item_spans[index][0], item_spans[index + 1][0]
     return item_spans[index - 1][1], item_spans[index][1]
@@ -719,7 +749,7 @@ def _regex_alternation_elements(
             continue
         alt_spans = _alternative_spans(content, pipe_positions)
         for index, (alt_start, alt_end) in enumerate(alt_spans):
-            removal_content_span = _removal_span_for_item(alt_spans, index)
+            removal_content_span = _removal_span_for_item(alt_spans, index, content)
             removal_span = (
                 literal_start + content_start + removal_content_span[0],
                 literal_start + content_start + removal_content_span[1],
@@ -780,7 +810,7 @@ def _dict_entry_elements(
             entry_lines = set(range(key.lineno, (value.end_lineno or value.lineno) + 1))
             if not (entry_lines & added):
                 continue
-            removal_span = _removal_span_for_item(entry_spans, index)
+            removal_span = _removal_span_for_item(entry_spans, index, body)
             key_start, key_end = _node_byte_span(key, line_starts)
             key_text = body[key_start:key_end].decode("utf-8", errors="replace")
             elements.append(
@@ -852,7 +882,7 @@ def _literal_display_elements(
                     continue
                 if not (_span(item) & added):
                     continue
-                removal_span = _removal_span_for_item(item_spans, index)
+                removal_span = _removal_span_for_item(item_spans, index, body)
                 elements.append(
                     (
                         item.lineno,
@@ -882,7 +912,7 @@ def _literal_display_elements(
                 entry_lines = set(range(key.lineno, (value.end_lineno or value.lineno) + 1))
                 if not (entry_lines & added):
                     continue
-                removal_span = _removal_span_for_item(entry_spans, index)
+                removal_span = _removal_span_for_item(entry_spans, index, body)
                 elements.append(
                     (
                         key.lineno,
diff --git a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
index 1f54118a..b5f5b0cd 100644
--- a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
+++ b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
@@ -167,23 +167,62 @@ def test_node_byte_span_accounts_for_a_multibyte_character_earlier_on_the_line()
 # --- _removal_span_for_item ---------------------------------------------------
 
 
-def test_removal_span_for_item_sole_item_removes_only_its_own_span() -> None:
-    assert gate._removal_span_for_item([(3, 7)], 0) == (3, 7)
+def test_removal_span_for_item_sole_item_with_no_trailing_comma_removes_only_its_own_span() -> None:
+    source = b'{"only": 1}'
+    assert gate._removal_span_for_item([(1, 7)], 0, source) == (1, 7)
+
+
+def test_removal_span_for_item_sole_item_with_a_trailing_comma_consumes_it() -> None:
+    """Issue #1799 (PR #2000, found by an independent adversarial review):
+    a one-item sequence written with an explicit trailing comma --
+    `("hidden",)` -- must have that comma spliced out along with the
+    item itself, or the mutated source is a hard SyntaxError (`(,)`), not
+    the "still valid empty literal" the sole-item branch otherwise
+    produces."""
+    source = b'return ("hidden",)'
+    # b'"hidden"' spans [8, 16); the comma immediately follows at index 16.
+    assert gate._removal_span_for_item([(8, 16)], 0, source) == (8, 17)
+    mutated = source[:8] + source[17:]
+    assert mutated == b"return ()"
+    ast.parse(mutated)
+
+
+def test_removal_span_for_item_sole_item_trailing_comma_skips_intervening_whitespace() -> None:
+    source = b'{\n    "only": 1,\n}'
+    # b'"only": 1' spans [6, 15); whitespace before it is irrelevant here,
+    # only whitespace *between* the item's own end and the comma matters --
+    # this fixture has none, so also cover the case with some via a second
+    # assertion below.
+    assert gate._removal_span_for_item([(6, 15)], 0, source) == (6, 16)
+
+    source_with_gap = b'{"only": 1  ,}'
+    assert gate._removal_span_for_item([(1, 10)], 0, source_with_gap) == (1, 13)
+    mutated = source_with_gap[:1] + source_with_gap[13:]
+    assert mutated == b"{}"
+    ast.parse(mutated)
+
+
+def test_removal_span_for_item_sole_item_with_no_comma_at_all_leaves_an_empty_literal() -> None:
+    """A one-item sequence with nothing following the item at all (not even
+    a trailing comma) -- the removal span must not run past the end of
+    `source` while scanning for one."""
+    source = b'{"only": 1}'
+    assert gate._removal_span_for_item([(1, 10)], 0, source) == (1, 10)
 
 
 def test_removal_span_for_item_first_of_several_consumes_the_trailing_separator() -> None:
     spans = [(0, 1), (2, 3), (4, 5)]
-    assert gate._removal_span_for_item(spans, 0) == (0, 2)
+    assert gate._removal_span_for_item(spans, 0, b"a,b,c") == (0, 2)
 
 
 def test_removal_span_for_item_middle_consumes_the_trailing_separator() -> None:
     spans = [(0, 1), (2, 3), (4, 5)]
-    assert gate._removal_span_for_item(spans, 1) == (2, 4)
+    assert gate._removal_span_for_item(spans, 1, b"a,b,c") == (2, 4)
 
 
 def test_removal_span_for_item_last_consumes_the_leading_separator() -> None:
     spans = [(0, 1), (2, 3), (4, 5)]
-    assert gate._removal_span_for_item(spans, 2) == (3, 5)
+    assert gate._removal_span_for_item(spans, 2, b"a,b,c") == (3, 5)
 
 
 # --- category 1: regex alternation branch ------------------------------------
@@ -650,6 +689,51 @@ def test_end_to_end_category3_vacuous_test_leaves_a_finding_then_fixing_it_clear
     assert waived_fixed == []
 
 
+def test_end_to_end_single_entry_dict_with_a_trailing_comma_does_not_crash_the_scan(
+    tmp_path: pathlib.Path,
+) -> None:
+    """Regression for the SyntaxError defect an independent adversarial
+    review found (issue #1799, PR #2000): a module-level dict with exactly
+    one entry, written with an explicit trailing comma (this repository's
+    own common multi-line formatting), used to leave `CONST = {\n}` after
+    the sole entry's own span alone was spliced out -- that was fine --
+    but the comma survived, so a source with the comma written on the
+    *item's own line* (`"only": 1,`) left a dangling `,` right after the
+    opening brace once the whole entry was removed together with a stray
+    comma the old code never accounted for consuming. Exercises the full
+    find_violations path (real mutation write + real pytest subprocess),
+    not just the unit-level _removal_span_for_item checks above, so a
+    regression in how this function's return value is actually spliced
+    into a file on disk would be caught here too."""
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    test_path = "tests/test_gitapex_check_fixture.py"
+    fixture_src = 'CONST = {\n    "only": 1,\n}\n'
+    vacuous_test_src = (
+        "import gitapex_check_fixture\n\n\n"
+        "def test_const():\n"
+        "    assert isinstance(gitapex_check_fixture.CONST, dict)\n"
+    )
+    fixed_test_src = (
+        'import gitapex_check_fixture\n\n\ndef test_const():\n    assert gitapex_check_fixture.CONST == {"only": 1}\n'
+    )
+
+    _write(tmp_path, fixture_path, fixture_src)
+    _write(tmp_path, test_path, vacuous_test_src)
+    diff_text = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, vacuous_test_src)
+    violations, waived, graded = gate.find_violations(diff_text, tmp_path)
+    assert graded == 1
+    assert waived == []
+    assert len(violations) == 1
+    assert "only" in violations[0].message
+
+    _write(tmp_path, test_path, fixed_test_src)
+    diff_text_fixed = _whole_file_diff(fixture_path, fixture_src) + _whole_file_diff(test_path, fixed_test_src)
+    violations_fixed, waived_fixed, graded_fixed = gate.find_violations(diff_text_fixed, tmp_path)
+    assert graded_fixed == 1
+    assert violations_fixed == []
+    assert waived_fixed == []
+
+
 # --- find_violations: other behavior ------------------------------------------
 
 

From 07eed3cf903e981cca2b407003c9e886b8ab6812 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 14 Sep 2026 05:06:52 +0000
Subject: [PATCH 07/10] fix(gates): address drafting-a-pr-to-merge Step 8
 independent-review findings

An independent reviewing-an-artifact pass (drafting-a-pr-to-merge Step 8 inner layer, distinct from executing-a-branch-plan's own Step 8 aggregate review round) found 4 confirmed findings against the defeat-test-mutation-coverage gate (#1799):

1. gitapex_gate_local_preflight.py's own module docstring still said 87 registered gates; the real count (verified against .gitapex/ssot.json) is 88 -- only this one prose count was missed by the prior 49-to-51 wired-gate reconciliation, since it counts every registered gate, not only the local-wired subset the prior pass tracked.

2. The new gate's own ssot.json trigger field named only its plain test file, omitting the properties file (tests/test_gitapex_gate_defeat_test_mutation_coverage_properties.py) this same PR also adds -- every sibling cluster-mate gate names both.

3. Ten tests that spawn a real pytest subprocess (via find_violations/_run_mutation/main) carried no @pytest.mark.slow marker, unlike the one existing sibling gate with the same real-subprocess shape (test_gitapex_gate_patch_coverage.py), silently defeating the marker's own purpose (a fast -m "not slow" dev loop) for every new test in this file.

4. The pre-commit-config.yaml blast-radius paragraph documented this gate's own runtime cost but not that it is the first wired gate whose detection mechanism writes to a contributor's real, possibly-uncommitted working-tree file, nor that its own documented recovery command (git checkout -- <path>) discards exactly that uncommitted work if the restore write itself fails.

Fixed all four; re-verified full pytest suite (9412 passed) and gitapex_gate_local_preflight.py (51/51 wired gates) green.

Issue: https://github.com/tvna/gitapex/issues/1799
---
 .gitapex/ssot.json                               |  2 +-
 .github/scripts/gitapex_gate_local_preflight.py  |  2 +-
 .pre-commit-config.yaml                          | 16 ++++++++++++++++
 ...gitapex_gate_defeat_test_mutation_coverage.py | 10 ++++++++++
 4 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/.gitapex/ssot.json b/.gitapex/ssot.json
index 40c1923a..cc558e58 100644
--- a/.gitapex/ssot.json
+++ b/.gitapex/ssot.json
@@ -2198,7 +2198,7 @@
       "planes": ["ci", "local"],
       "local_invocation": ["uv", "run", "--frozen", "python3", ".github/scripts/gitapex_gate_defeat_test_mutation_coverage.py"],
       "local_stdin": ["uv", "run", "--frozen", "python3", ".github/scripts/gitapex_run_base_diff.py", "--", "*.py"],
-      "trigger": ".github/workflows/defeat-test-mutation-coverage-gate.yml on pull_request, plus tests/test_gitapex_gate_defeat_test_mutation_coverage.py inside the pytest step of .github/workflows/test.yml",
+      "trigger": ".github/workflows/defeat-test-mutation-coverage-gate.yml on pull_request, plus tests/test_gitapex_gate_defeat_test_mutation_coverage.py and tests/test_gitapex_gate_defeat_test_mutation_coverage_properties.py inside the pytest step of .github/workflows/test.yml",
       "policy_refs": [],
       "cluster": "test-integrity",
       "tracking_issue": 1799,
diff --git a/.github/scripts/gitapex_gate_local_preflight.py b/.github/scripts/gitapex_gate_local_preflight.py
index 1ea8f7c2..3aed3efd 100644
--- a/.github/scripts/gitapex_gate_local_preflight.py
+++ b/.github/scripts/gitapex_gate_local_preflight.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """One consolidated local pre-push / pre-PR-open gate runner (issue #876).
 
-This repository enforces 87 registered deterministic gates. Before this
+This repository enforces 88 registered deterministic gates. Before this
 script existed, roughly half of them had a perfectly good working-tree-only
 invocation and yet ran *only* as separate CI jobs, so an agent preparing a
 PR discovered gaps one CI job at a time on an already-open PR -- push, wait,
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 1f84b020..062ffd34 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -178,6 +178,22 @@ repos:
       # enforcement for the ordinary path, not a command a contributor has
       # to remember to type.
       #
+      # Issue #1799's own defeat-test-mutation-coverage gate is also the
+      # first wired gate whose own detection mechanism writes to disk --
+      # every other wired gate only reads and reasons about the AST. It
+      # temporarily overwrites an in-scope source file's own real bytes on
+      # this machine (not a copy) for the duration of one pytest subprocess
+      # per graded element, restoring the original bytes in a `finally`
+      # block regardless of outcome; found by an independent adversarial
+      # review (issue #1799, PR #2000). Gates run sequentially here (see
+      # gitapex_gate_local_preflight.py's own docstring), so no other wired
+      # gate ever reads a file mid-mutation. If the restore write itself
+      # fails (disk full, permissions) or this process is killed before it
+      # runs (SIGKILL, OOM), that gate's own raised ScanError names `git
+      # checkout -- <path>` as the recovery command -- which discards
+      # whatever uncommitted edit was sitting in that file at the time,
+      # including the very change you were about to push.
+      #
       # `uv run --frozen python3`, not a bare `python3`: the runner imports
       # _gitapex_schema_validation.py, which needs jsonschema -- not
       # guaranteed present on a bare system python3 (issue #1485). Each
diff --git a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
index b5f5b0cd..ad98e328 100644
--- a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
+++ b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
@@ -563,6 +563,7 @@ def test_waived_lines_ignores_a_waiver_string_inside_a_string_literal() -> None:
 # --- find_violations: end-to-end mutation-and-rerun, one per category -------
 
 
+@pytest.mark.slow
 def test_end_to_end_category1_vacuous_test_leaves_a_finding_then_fixing_it_clears(tmp_path: pathlib.Path) -> None:
     """Red-then-green proof, category 1 (regex alternation), mirroring
     issue #1799's own #1733/#1735 CR-alternative-prefix-shaped gap: a test
@@ -605,6 +606,7 @@ def test_end_to_end_category1_vacuous_test_leaves_a_finding_then_fixing_it_clear
     assert waived_fixed == []
 
 
+@pytest.mark.slow
 def test_end_to_end_category2_vacuous_test_leaves_a_finding_then_fixing_it_clears(tmp_path: pathlib.Path) -> None:
     """Red-then-green proof, category 2 (module-level dict entry),
     mirroring issue #1799's own #1990 REVIEW_PERSONA_PERMISSION-shaped
@@ -651,6 +653,7 @@ def test_end_to_end_category2_vacuous_test_leaves_a_finding_then_fixing_it_clear
     assert waived_fixed == []
 
 
+@pytest.mark.slow
 def test_end_to_end_category3_vacuous_test_leaves_a_finding_then_fixing_it_clears(tmp_path: pathlib.Path) -> None:
     """Red-then-green proof, category 3 (unconditionally emitted literal),
     mirroring issue #1799's own #1991 "hidden: true"-shaped gap: a test
@@ -689,6 +692,7 @@ def test_end_to_end_category3_vacuous_test_leaves_a_finding_then_fixing_it_clear
     assert waived_fixed == []
 
 
+@pytest.mark.slow
 def test_end_to_end_single_entry_dict_with_a_trailing_comma_does_not_crash_the_scan(
     tmp_path: pathlib.Path,
 ) -> None:
@@ -746,6 +750,7 @@ def test_find_violations_skips_a_source_with_no_diff_touched_paired_test(tmp_pat
     assert (violations, waived, graded) == ([], [], 0)
 
 
+@pytest.mark.slow
 def test_find_violations_waiver_honoured_on_the_reported_line(tmp_path: pathlib.Path) -> None:
     fixture_path = ".github/scripts/gitapex_check_fixture.py"
     test_path = "tests/test_gitapex_check_fixture.py"
@@ -812,6 +817,7 @@ def test_find_violations_raises_scan_error_for_non_utf8_source(tmp_path: pathlib
         gate.find_violations(diff_text, tmp_path)
 
 
+@pytest.mark.slow
 def test_find_violations_raises_scan_error_on_a_collection_error_mutation(tmp_path: pathlib.Path) -> None:
     """A paired test file that itself fails to *import* at all (a
     module-level `NameError`, not merely a runtime failure inside a test
@@ -833,6 +839,7 @@ def test_find_violations_raises_scan_error_on_a_collection_error_mutation(tmp_pa
         gate.find_violations(diff_text, tmp_path)
 
 
+@pytest.mark.slow
 def test_run_mutation_restores_the_original_bytes_even_when_pytest_errors(tmp_path: pathlib.Path) -> None:
     fixture_path = ".github/scripts/gitapex_check_fixture.py"
     test_path = "tests/test_gitapex_check_fixture.py"
@@ -884,6 +891,7 @@ def _raising_write_bytes(self: pathlib.Path, data: bytes) -> int:
         gate._run_mutation(absolute, b"", original_bytes, (0, 1), [test_absolute], tmp_path)
 
 
+@pytest.mark.slow
 def test_run_mutation_raises_scan_error_when_the_restore_write_fails(
     tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
@@ -1261,6 +1269,7 @@ def test_main_returns_0_and_prints_ok_on_a_clean_diff(
     assert "OK: 1 in-scope file(s) graded" in capsys.readouterr().out
 
 
+@pytest.mark.slow
 def test_main_returns_1_and_prints_violations_citing_the_issue(
     tmp_path: pathlib.Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
@@ -1284,6 +1293,7 @@ def test_main_returns_1_and_prints_violations_citing_the_issue(
     assert "defeat-test-mutation-coverage: WAIVED" in captured.err
 
 
+@pytest.mark.slow
 def test_main_prints_a_waived_finding_separately(tmp_path: pathlib.Path, capsys: pytest.CaptureFixture[str]) -> None:
     fixture_path = ".github/scripts/gitapex_check_fixture.py"
     test_path = "tests/test_gitapex_check_fixture.py"

From 92e60fa965d5ea26e47e44944fee448912f6c0e3 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 14 Sep 2026 05:35:09 +0000
Subject: [PATCH 08/10] fix(gates): address second independent-review findings
 for issue #1799

Independent review of PR #2000 (head 07eed3cf) found four confirmed
issues:

- `_span` (added by this PR's own gate) was never mentioned by name in
  its paired tests, tripping the existing function-body-test-coverage
  gate (CI red). Added a direct unit test.
- The restore-failure recovery-message test spawns a real pytest
  subprocess identically to its sibling test but was missing
  `@pytest.mark.slow`.
- The gate-count history comment in CONTRIBUTING.md and
  gitapex_gate_local_preflight.py's own docstring self-contradicted:
  "prior 50-gate set" was used for two different gates/values, and a
  duplicate, unsourced "prior 49-gate set" line repeated the same 24s
  figure. Relabeled network-exception-set-drift's own entry as the
  49-gate set it actually was and dropped the duplicate line.
- The sole-item-no-comma removal-span test claimed to exercise the
  "scan must not run past source's end" guard but its fixture never
  drove cursor to len(source), so it passed identically with the guard
  deleted. Rewrote the fixture so the item's own span reaches the end
  of source.

Verified: full non-slow + slow suites for the new gate pass, the
function-body-test-coverage gate now passes clean against this diff,
ruff/mypy clean, and all 51 wired local-preflight gates pass (~50s).

Claude-Session: https://claude.ai/code/session_01GQ8289c4nMwpaLPnhZTHyM
---
 .../scripts/gitapex_gate_local_preflight.py   |  4 +-
 CONTRIBUTING.md                               |  3 +-
 ...apex_gate_defeat_test_mutation_coverage.py | 39 +++++++++++++++++--
 3 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/.github/scripts/gitapex_gate_local_preflight.py b/.github/scripts/gitapex_gate_local_preflight.py
index 3aed3efd..7836b28c 100644
--- a/.github/scripts/gitapex_gate_local_preflight.py
+++ b/.github/scripts/gitapex_gate_local_preflight.py
@@ -218,8 +218,8 @@
 # end, unlike every other wired gate, which is pure AST inspection, it
 # spawns a real pytest subprocess per graded element and self-grades its
 # own regex/dict/literal elements against its own paired tests; the prior
-# 50-gate set (network-exception-set-drift, issue #1512) measured roughly
-# 24 s, the prior 49-gate set measured roughly 24 s, the
+# 49-gate set (network-exception-set-drift, issue #1512) measured roughly
+# 24 s, the
 # prior 48-gate set measured roughly 24 s, the
 # prior 47-gate set measured roughly 22 s, the
 # prior 45-gate set measured roughly 14 s, the
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 1a0f7fb4..2215c6f3 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -134,9 +134,8 @@ paired tests, roughly doubling the prior warm-run baseline on its own --
 different hardware than the figures below in any case; issue #1965's own
 skill-contract-drift gate landed on a parallel branch --
 the prior 50-gate set (defeat-test-mutation-coverage) measured roughly 49
-seconds, the prior 50-gate set (network-exception-set-drift, issue #1512)
+seconds, the prior 49-gate set (network-exception-set-drift, issue #1512)
 measured roughly 24 seconds, the
-prior 49-gate set measured roughly 24 seconds, the
 prior 48-gate set measured roughly 24 seconds, the
 prior 47-gate set measured roughly 22 seconds, the
 prior 45-gate set measured roughly 14 seconds, the
diff --git a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
index ad98e328..2f162b0c 100644
--- a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
+++ b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
@@ -164,6 +164,33 @@ def test_node_byte_span_accounts_for_a_multibyte_character_earlier_on_the_line()
     assert body[start:end] == '"héllo|wörld"'.encode()
 
 
+# --- _span ---------------------------------------------------------------
+
+
+def test_span_single_line_node_returns_just_that_line() -> None:
+    source = "x = 1\n"
+    tree = ast.parse(source)
+    assign = tree.body[0]
+    assert isinstance(assign, ast.Assign)
+    assert gate._span(assign.value) == {1}
+
+
+def test_span_multiline_node_returns_every_line_from_start_to_end() -> None:
+    """A node whose own value spans several physical lines -- confirmed
+    directly against a real parenthesized expression, not assumed: parens
+    themselves fall outside `lineno`/`end_lineno`, so this pins the BinOp's
+    own line range as `_span`'s caller sites (`_regex_alternation_elements`,
+    `_literal_display_elements`) rely on it."""
+    source = "x = (\n    1\n    + 2\n)\n"
+    tree = ast.parse(source)
+    assign = tree.body[0]
+    assert isinstance(assign, ast.Assign)
+    node = assign.value
+    assert isinstance(node, ast.BinOp)
+    assert (node.lineno, node.end_lineno) == (2, 3)
+    assert gate._span(node) == {2, 3}
+
+
 # --- _removal_span_for_item ---------------------------------------------------
 
 
@@ -205,9 +232,14 @@ def test_removal_span_for_item_sole_item_trailing_comma_skips_intervening_whites
 def test_removal_span_for_item_sole_item_with_no_comma_at_all_leaves_an_empty_literal() -> None:
     """A one-item sequence with nothing following the item at all (not even
     a trailing comma) -- the removal span must not run past the end of
-    `source` while scanning for one."""
-    source = b'{"only": 1}'
-    assert gate._removal_span_for_item([(1, 10)], 0, source) == (1, 10)
+    `source` while scanning for one. The item's own span must reach all the
+    way to `len(source)` for this to actually exercise the `cursor <
+    len(source)` guards -- a fixture with any trailing byte (even a closing
+    `}`) never drives `cursor` past the guard's own boundary, and passes
+    just as well with the guards deleted."""
+    source = b'"only": 1'
+    assert len(source) == 9
+    assert gate._removal_span_for_item([(0, 9)], 0, source) == (0, 9)
 
 
 def test_removal_span_for_item_first_of_several_consumes_the_trailing_separator() -> None:
@@ -1039,6 +1071,7 @@ def _counting_raising_write_bytes(self: pathlib.Path, data: bytes) -> int:
     assert calls["n"] == 1
 
 
+@pytest.mark.slow
 def test_run_mutation_restore_failure_names_a_concrete_git_checkout_recovery_command(
     tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:

From aa1a9886e8048f1de7e36e0a3e7ff5551fd1bf51 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 14 Sep 2026 10:10:12 +0000
Subject: [PATCH 09/10] fix(gates): address third independent-review findings
 for issue #1799

Independent review of PR #2000 (head 92e60fa9) found five confirmed
issues:

- `.pre-commit-config.yaml`'s own blast-radius comment claimed a
  process kill (SIGKILL/OOM) before the restore write runs still
  produces a ScanError naming a `git checkout` recovery command. It
  does not: Python never runs the `finally` block on a signal kill, so
  there is no error, no message, and no notice at all. Split the two
  cases apart in the comment.
- The "no comma at all" removal-span test's own docstring claimed to
  exercise "guards" (plural) but only the while-loop's own
  `cursor < len(source)` guard is load-bearing (`b"" in
  _TRAILING_WHITESPACE` is True, so deleting it hangs). The `if`
  guard right below it is unreachable to falsify for any input
  (`b"" == b","` is always False) -- the exact "claims coverage it
  doesn't have" shape this PR's own gate exists to catch. Narrowed the
  docstring's claim to match.
- The single-entry-trailing-comma regression test's own docstring
  self-contradicted ("left `CONST = {}}` -- that was fine -- but the
  comma survived"): the two clauses can't both be true. Rewrote to
  describe what the old code actually did (spliced the entry's own
  span but never consumed the trailing comma) and what that produced
  (`CONST = {\n    ,\n}`, a SyntaxError).
- `.gitapex/ssot.json`'s own `rule` string and the gate's own module
  docstring both listed category 3's guard node types as
  "If/Try/For/AsyncFor/While", omitting `ast.TryStar` even though the
  implementation's own `_GUARD_NODE_TYPES` already includes it on
  Python 3.11+ (this repo's `requires-python = ">=3.12"` means it's
  always present). Added `TryStar` to both.
- Two `@pytest.mark.slow` tests around `_run_mutation`'s restore-write
  failure path were near-verbatim duplicates (same 22-line fixture/
  monkeypatch setup, differing only in which part of the error message
  each asserted). Merged into one test asserting the full message
  shape, dropping one real-pytest-subprocess invocation from the slow
  suite.

Verified: full non-slow + slow + properties suites for the new gate
pass, ruff/mypy clean, ssot.json still valid JSON, and all 51 wired
local-preflight gates pass (~54s).

Claude-Session: https://claude.ai/code/session_01GQ8289c4nMwpaLPnhZTHyM
---
 .gitapex/ssot.json                            |  2 +-
 ...apex_gate_defeat_test_mutation_coverage.py |  9 ++-
 .pre-commit-config.yaml                       | 14 ++--
 ...apex_gate_defeat_test_mutation_coverage.py | 75 ++++++++-----------
 4 files changed, 47 insertions(+), 53 deletions(-)

diff --git a/.gitapex/ssot.json b/.gitapex/ssot.json
index cc558e58..45a817bc 100644
--- a/.gitapex/ssot.json
+++ b/.gitapex/ssot.json
@@ -2194,7 +2194,7 @@
         ".github/scripts/_gitapex_base_ref.py",
         ".github/workflows/defeat-test-mutation-coverage-gate.yml"
       ],
-      "rule": "A regex alternation branch (a top-level '|'-joined alternative, at paren-depth 0 and outside a [...] character class, inside a plain string-literal pattern argument to re.compile()/re.match()/re.search()/re.fullmatch(), the .compile receiver resolved through the file's own 'import re' statements and .match/.search/.fullmatch receiver-agnostic on any receiver), a key of an ast.Dict assigned to a module-level ast.Name target (CONST = {...}), or a str/int/float/bool literal that is a direct List/Tuple/Set element or a non-module-level-dict Dict entry's value, built unconditionally (no enclosing If/Try/For/AsyncFor/While) inside a function body in skills/*/scripts/*.py, .github/scripts/*.py or hooks/*.py (test_*.py and conftest.py excluded), newly added or changed by a PR diff, must be actually caught -- not merely mentioned -- by this same diff's own paired tests/test_<source-stem>.py or tests/test_<source-stem>_properties.py: the element is spliced out of a temporary, byte-exact mutated copy of the source file, a real pytest subprocess is run against exactly the paired test file(s) this diff itself touches, and the original bytes are restored regardless of outcome. A paired suite that still exits 0 against the mutated source is a defeat-test-mutation-gap finding; a source element with no diff-touched paired test file at all is not graded. Scope is the diff, not the repository. An inline '# defeat-test-mutation-coverage: WAIVED: <reason>' comment waives findings on that exact line. Exits 2 rather than pass silently on a malformed diff, an in-scope or paired-test file that cannot be read or parsed, or a pytest subprocess invocation that itself errors for a reason other than 'tests ran and passed/failed' (e.g. a collection error). See the script's own module docstring for the three element categories' disclosed known misses and non-goals.",
+      "rule": "A regex alternation branch (a top-level '|'-joined alternative, at paren-depth 0 and outside a [...] character class, inside a plain string-literal pattern argument to re.compile()/re.match()/re.search()/re.fullmatch(), the .compile receiver resolved through the file's own 'import re' statements and .match/.search/.fullmatch receiver-agnostic on any receiver), a key of an ast.Dict assigned to a module-level ast.Name target (CONST = {...}), or a str/int/float/bool literal that is a direct List/Tuple/Set element or a non-module-level-dict Dict entry's value, built unconditionally (no enclosing If/Try/TryStar/For/AsyncFor/While) inside a function body in skills/*/scripts/*.py, .github/scripts/*.py or hooks/*.py (test_*.py and conftest.py excluded), newly added or changed by a PR diff, must be actually caught -- not merely mentioned -- by this same diff's own paired tests/test_<source-stem>.py or tests/test_<source-stem>_properties.py: the element is spliced out of a temporary, byte-exact mutated copy of the source file, a real pytest subprocess is run against exactly the paired test file(s) this diff itself touches, and the original bytes are restored regardless of outcome. A paired suite that still exits 0 against the mutated source is a defeat-test-mutation-gap finding; a source element with no diff-touched paired test file at all is not graded. Scope is the diff, not the repository. An inline '# defeat-test-mutation-coverage: WAIVED: <reason>' comment waives findings on that exact line. Exits 2 rather than pass silently on a malformed diff, an in-scope or paired-test file that cannot be read or parsed, or a pytest subprocess invocation that itself errors for a reason other than 'tests ran and passed/failed' (e.g. a collection error). See the script's own module docstring for the three element categories' disclosed known misses and non-goals.",
       "planes": ["ci", "local"],
       "local_invocation": ["uv", "run", "--frozen", "python3", ".github/scripts/gitapex_gate_defeat_test_mutation_coverage.py"],
       "local_stdin": ["uv", "run", "--frozen", "python3", ".github/scripts/gitapex_run_base_diff.py", "--", "*.py"],
diff --git a/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py b/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
index 4b716bed..55c70d3f 100644
--- a/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
+++ b/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
@@ -114,8 +114,13 @@
      (a nested container, a call, a name reference) is never graded under
      category 3 -- only the four scalar ``Constant`` types listed above are.
    * A display nested inside a ``with`` block still counts as unconditional
-     -- only ``If``/``Try``/``For``/``AsyncFor``/``While`` are treated as a
-     guard, matching this category's own literal wording.
+     -- only ``If``/``Try``/``TryStar``/``For``/``AsyncFor``/``While`` are
+     treated as a guard, matching this category's own literal wording
+     (``TryStar`` -- ``try``/``except*``, Python 3.11+ -- is not an
+     ``ast.Try`` subclass, so it is added to the guard set explicitly
+     rather than falling out of an ``isinstance`` check on ``ast.Try``
+     alone; this repository's own ``requires-python = ">=3.12"`` means it
+     is always present).
    * A display sitting directly in a class body (a class attribute, not
      inside any method) has no enclosing function at all and is never
      graded under category 3.
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 062ffd34..2e69d179 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -188,11 +188,15 @@ repos:
       # review (issue #1799, PR #2000). Gates run sequentially here (see
       # gitapex_gate_local_preflight.py's own docstring), so no other wired
       # gate ever reads a file mid-mutation. If the restore write itself
-      # fails (disk full, permissions) or this process is killed before it
-      # runs (SIGKILL, OOM), that gate's own raised ScanError names `git
-      # checkout -- <path>` as the recovery command -- which discards
-      # whatever uncommitted edit was sitting in that file at the time,
-      # including the very change you were about to push.
+      # fails (disk full, permissions), that gate's own raised ScanError
+      # names `git checkout -- <path>` as the recovery command -- which
+      # discards whatever uncommitted edit was sitting in that file at the
+      # time, including the very change you were about to push. If this
+      # process is instead killed before the restore write ever runs
+      # (SIGKILL, OOM), Python never executes the `finally` block that
+      # would raise that ScanError -- there is no error, no message, and
+      # no automatic notice at all; the file is silently left holding
+      # mutated bytes on disk until a `git status`/`git diff` catches it.
       #
       # `uv run --frozen python3`, not a bare `python3`: the runner imports
       # _gitapex_schema_validation.py, which needs jsonschema -- not
diff --git a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
index 2f162b0c..da614006 100644
--- a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
+++ b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
@@ -233,10 +233,18 @@ def test_removal_span_for_item_sole_item_with_no_comma_at_all_leaves_an_empty_li
     """A one-item sequence with nothing following the item at all (not even
     a trailing comma) -- the removal span must not run past the end of
     `source` while scanning for one. The item's own span must reach all the
-    way to `len(source)` for this to actually exercise the `cursor <
-    len(source)` guards -- a fixture with any trailing byte (even a closing
-    `}`) never drives `cursor` past the guard's own boundary, and passes
-    just as well with the guards deleted."""
+    way to `len(source)` for this to actually exercise the while-loop's own
+    `cursor < len(source)` guard -- a fixture with any trailing byte (even a
+    closing `}`) never drives `cursor` past that guard's own boundary, and
+    passes just as well with it deleted (`b"" in _TRAILING_WHITESPACE` is
+    True, so deleting the while-loop guard here would hang instead of
+    failing this assertion -- that hang, not a passing assert, is what
+    pins it). The `if cursor < len(source)` guard immediately below the
+    loop is not pinned by this fixture, or by any fixture: once the loop
+    exits, `source[cursor:cursor+1]` is either a real byte or `b""`, and
+    `b"" == b","` is always False, so the length check that guard performs
+    is unreachable to falsify -- deleting it changes nothing for any input.
+    """
     source = b'"only": 1'
     assert len(source) == 9
     assert gate._removal_span_for_item([(0, 9)], 0, source) == (0, 9)
@@ -731,16 +739,16 @@ def test_end_to_end_single_entry_dict_with_a_trailing_comma_does_not_crash_the_s
     """Regression for the SyntaxError defect an independent adversarial
     review found (issue #1799, PR #2000): a module-level dict with exactly
     one entry, written with an explicit trailing comma (this repository's
-    own common multi-line formatting), used to leave `CONST = {\n}` after
-    the sole entry's own span alone was spliced out -- that was fine --
-    but the comma survived, so a source with the comma written on the
-    *item's own line* (`"only": 1,`) left a dangling `,` right after the
-    opening brace once the whole entry was removed together with a stray
-    comma the old code never accounted for consuming. Exercises the full
-    find_violations path (real mutation write + real pytest subprocess),
-    not just the unit-level _removal_span_for_item checks above, so a
-    regression in how this function's return value is actually spliced
-    into a file on disk would be caught here too."""
+    own common multi-line formatting), used to have only the sole entry's
+    own span spliced out -- the comma that followed it was never consumed.
+    With the comma written on the *item's own line* (`"only": 1,`), that
+    left a dangling `,` right behind the opening brace once the entry
+    itself was removed (`CONST = {\n    ,\n}`) -- a hard SyntaxError, not
+    the harmless `CONST = {}` a correct splice produces. Exercises the
+    full find_violations path (real mutation write + real pytest
+    subprocess), not just the unit-level _removal_span_for_item checks
+    above, so a regression in how this function's return value is
+    actually spliced into a file on disk would be caught here too."""
     fixture_path = ".github/scripts/gitapex_check_fixture.py"
     test_path = "tests/test_gitapex_check_fixture.py"
     fixture_src = 'CONST = {\n    "only": 1,\n}\n'
@@ -927,6 +935,10 @@ def _raising_write_bytes(self: pathlib.Path, data: bytes) -> int:
 def test_run_mutation_raises_scan_error_when_the_restore_write_fails(
     tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
+    """The restore-write failure message must also tell a human exactly how
+    to recover the file (`git checkout -- <path>`), not just that recovery
+    is needed -- the file may genuinely still hold mutated bytes on disk
+    once this branch is reached."""
     fixture_path = ".github/scripts/gitapex_check_fixture.py"
     test_path = "tests/test_gitapex_check_fixture.py"
     fixture_src = "def make():\n    return 1\n"
@@ -944,8 +956,11 @@ def _fail_on_second_call(self: pathlib.Path, data: bytes) -> int:
         return original_write_bytes(self, data)
 
     monkeypatch.setattr(pathlib.Path, "write_bytes", _fail_on_second_call)
-    with pytest.raises(gate.ScanError, match="could not restore"):
+    with pytest.raises(
+        gate.ScanError, match=r"could not restore.*git checkout -- .*gitapex_check_fixture\.py"
+    ) as excinfo:
         gate._run_mutation(absolute, b"", original_bytes, (0, 1), [test_absolute], tmp_path)
+    assert str(absolute) in str(excinfo.value)
 
 
 def test_run_mutation_raises_scan_error_on_subprocess_timeout(
@@ -1071,36 +1086,6 @@ def _counting_raising_write_bytes(self: pathlib.Path, data: bytes) -> int:
     assert calls["n"] == 1
 
 
-@pytest.mark.slow
-def test_run_mutation_restore_failure_names_a_concrete_git_checkout_recovery_command(
-    tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """The restore-write failure message must tell a human exactly how to
-    recover the file (`git checkout -- <path>`), not just that recovery is
-    needed -- the file may genuinely still hold mutated bytes on disk once
-    this branch is reached."""
-    fixture_path = ".github/scripts/gitapex_check_fixture.py"
-    test_path = "tests/test_gitapex_check_fixture.py"
-    fixture_src = "def make():\n    return 1\n"
-    test_src = "import gitapex_check_fixture\n\n\ndef test_x():\n    pass\n"
-    absolute = _write(tmp_path, fixture_path, fixture_src)
-    test_absolute = _write(tmp_path, test_path, test_src)
-    original_bytes = absolute.read_bytes()
-    original_write_bytes = pathlib.Path.write_bytes
-    calls = {"n": 0}
-
-    def _fail_on_second_call(self: pathlib.Path, data: bytes) -> int:
-        calls["n"] += 1
-        if calls["n"] == 2:
-            raise OSError("simulated restore failure")
-        return original_write_bytes(self, data)
-
-    monkeypatch.setattr(pathlib.Path, "write_bytes", _fail_on_second_call)
-    with pytest.raises(gate.ScanError, match=r"git checkout -- .*gitapex_check_fixture\.py") as excinfo:
-        gate._run_mutation(absolute, b"", original_bytes, (0, 1), [test_absolute], tmp_path)
-    assert str(absolute) in str(excinfo.value)
-
-
 # --- direct unit tests for internal helpers ---------------------------------
 
 

From 8f9cf1a0fb1c405ecde73768e06f5026123948b6 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 15 Sep 2026 02:39:09 +0000
Subject: [PATCH 10/10] fix(gates): address fourth independent-review findings
 for issue #1799

Independent review of PR #2000 (head aa1a9886) found five confirmed
issues and one unconfirmed security-tier concern:

- The prior round's TryStar fix only reached the "Known misses" bullet;
  the category-3 definition paragraph and `_enclosing_function_
  unconditional`'s own docstring both still listed
  "If/Try/For/AsyncFor/While", contradicting the bullet that explicitly
  claims to match "this category's own literal wording". Added
  `TryStar` to both remaining spots.
- `_GUARD_NODE_TYPES` built the TryStar addition behind
  `if hasattr(ast, "TryStar")`, an always-true branch on this repo's
  own `requires-python = ">=3.12"` -- and the module docstring already
  said so. Referenced `ast.TryStar` directly instead, matching how the
  three sibling exception-handling gates already do.
- A module-level `List`/`Tuple`/`Set` constant (`CONST = ["a", "b"]`,
  `CONST = frozenset({...})` -- this repo's own idiom for an
  allowed-value set) is graded under neither category 2 (dict-only) nor
  category 3 (requires a function body), and that gap was undisclosed.
  Added it to "Known misses".
- Category 1's docstring claimed the receiver-agnostic `.match`/
  `.search`/`.fullmatch` handling was equivalent to the sibling
  detection-logic gate's own `_regex_trigger` -- it is not: that gate
  only needs the call site to exist (a coverage trigger), while this
  one reads `args[0]` as pattern text, which is wrong for this repo's
  own dominant bound-method idiom (`_PREFIX_RE.match(text)`, where
  `args[0]` is the subject being matched, not a pattern). No in-scope
  file hits this today, so disclosed as a known latent gap rather than
  changing the detection surface.
- An unparenthesized single-element tuple (`x = 1,`) spliced by
  category 3's sole-item removal path left a bare `x = ` -- a
  SyntaxError, the same unwaivable-collection-error failure mode the
  prior round's trailing-comma fix closed for dict/list/set displays.
  Excluded via a byte-level `(` check at the tuple's own span start
  (the only way to tell a parenthesized one-tuple, which is still
  gradeable, from this one -- `ast.Tuple` carries no flag for it).
- `find_violations` read a diff-named file's bytes before the
  containment check `_run_mutation` already runs before *writing* a
  mutated byte -- a symlink inside `--root` pointing outside it would
  have its target read into this process on the read side even though
  the write side was already covered. Added the same `_is_within_root`
  check before the read, matching the write side's defense-in-depth.

Verified: full non-slow + slow + properties suites for the new gate
pass, ruff/mypy clean, function-body-test-coverage gate passes clean
against this diff, and all 51 wired local-preflight gates pass (~41s).

Claude-Session: https://claude.ai/code/session_01GQ8289c4nMwpaLPnhZTHyM
---
 ...apex_gate_defeat_test_mutation_coverage.py | 109 ++++++++++++++----
 ...apex_gate_defeat_test_mutation_coverage.py |  51 ++++++++
 2 files changed, 135 insertions(+), 25 deletions(-)

diff --git a/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py b/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
index 55c70d3f..18b96a50 100644
--- a/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
+++ b/.github/scripts/gitapex_gate_defeat_test_mutation_coverage.py
@@ -59,10 +59,13 @@
    resolved through this file's own ``import re`` statements exactly like
    ``gitapex_gate_detection_logic_property_coverage.py``'s own
    ``_re_module_names``, and ``.match``/``.search``/``.fullmatch`` matched
-   receiver-agnostically on any receiver, exactly like that gate's own
-   ``_regex_trigger`` -- reused verbatim rather than re-derived. Only a call
-   whose first positional argument is itself a plain string literal (no
-   implicit string concatenation, no f-string) is graded: that argument is
+   receiver-agnostically on any receiver, the same call-site shape that
+   gate's own ``_regex_trigger`` flags -- reused verbatim, but not the same
+   guarantee: that gate only needs the call site to *exist* (a coverage
+   trigger, indifferent to what the arguments mean), while this one reads
+   ``args[0]`` as the pattern text itself. Only a call whose first
+   positional argument is itself a plain string literal (no implicit
+   string concatenation, no f-string) is graded: that argument is treated as
    the pattern text this category mutates. Splitting happens on the raw
    *source* text of that literal (not the ``ast``-evaluated string value),
    respecting byte-for-byte what a raw string (``r"..."``) feeds directly to
@@ -89,8 +92,8 @@
    pair in an ``ast.Dict`` display that is *not* already the module-level
    ``CONST = {...}`` shape category 2 owns -- in both cases, only when the
    display itself is built directly inside a function body with no
-   enclosing ``If``/``Try``/``For``/``AsyncFor``/``While`` between the
-   display and that function (an unconditionally-executed straight-line
+   enclosing ``If``/``Try``/``TryStar``/``For``/``AsyncFor``/``While``
+   between the display and that function (an unconditionally-executed straight-line
    emission, the same shape issue #1799's own #1991 row describes: "the
    generator appends both literals in one unconditional list construction").
    This category is necessarily the least mechanically crisp of the three
@@ -99,6 +102,20 @@
 
    **Known misses, disclosed rather than found later.**
 
+   * A receiver-agnostic ``.match``/``.search``/``.fullmatch`` call whose
+     receiver is not actually a compiled pattern -- this repository's own
+     dominant idiom compiles once as a module-level constant and calls a
+     bound method at the use site (``_PREFIX_RE.match(text)``), where
+     ``args[0]`` is the *subject* string being matched, not a pattern.
+     Category 1 has no way to tell that apart from the call site alone; the
+     "first positional argument must itself be a plain string literal"
+     restriction keeps this from misfiring on the common case (the subject
+     is normally a variable, not a literal) but does not close it -- a
+     bound-method call passing a literal string that happens to contain its
+     own ``|`` would still be misread as a pattern. No in-scope file does
+     this today (a genuine ``re.compile(...)``-based pattern is always
+     graded correctly regardless), so this is a disclosed latent gap, not
+     an observed false finding.
    * A keyword argument's own value (``some_call(hidden=True)``) is not
      graded -- only a ``List``/``Tuple``/``Set`` element or a ``Dict``
      entry's value is, per the narrow shape above.
@@ -124,6 +141,19 @@
    * A display sitting directly in a class body (a class attribute, not
      inside any method) has no enclosing function at all and is never
      graded under category 3.
+   * A module-level ``List``/``Tuple``/``Set`` constant (``CONST =
+     ["a", "b"]``, ``CONST = frozenset({"a", "b"})``) is graded under
+     neither category: category 2 is ``Dict``-only, and category 3
+     requires an enclosing function body, which a module-level statement
+     never has. This gap is not narrower than it looks -- this
+     repository's own ``frozenset({...})`` idiom for an allowed-value set
+     is exactly this shape, and a vacuous test on one of those constants
+     goes undetected by this gate entirely, not merely by one category.
+   * An unparenthesized single-element tuple (``x = 1,``) is deliberately
+     not graded under category 3, even when every other condition holds --
+     see ``_literal_display_elements``'s own inline comment for why
+     removing its sole item would splice a bare ``x = `` (a SyntaxError)
+     rather than a valid empty display.
 
 Why not parse docstrings
 -------------------------
@@ -167,16 +197,19 @@
 sequence with no trailing comma in the source still leaves a syntactically
 valid empty literal exactly as before.
 
-Before any byte is written, ``_is_within_root`` re-checks that the target
-file's own absolute path actually resolves (symlinks and ``..`` components
-included) to somewhere inside ``--root`` -- defense in depth on top of, not
-a replacement for, ``in_scope``'s own fixed ``_IN_SCOPE_RE`` shape. This
-gate is the odd one out among its sibling gates precisely because it is the
-only one whose own detection mechanism actually writes to disk (its
-siblings only ever read and reason about the AST); a diff-derived path that
-somehow resolved outside the repository root would otherwise let this
-gate's own mutation engine overwrite an arbitrary file. A path failing this
-check raises :class:`ScanError` before ``write_bytes`` is ever called, the
+Before any byte is read *or* written, ``_is_within_root`` re-checks that the
+target file's own absolute path actually resolves (symlinks and ``..``
+components included) to somewhere inside ``--root`` -- defense in depth on
+top of, not a replacement for, ``in_scope``'s own fixed ``_IN_SCOPE_RE``
+shape. This gate is the odd one out among its sibling gates precisely
+because it is the only one whose own detection mechanism actually writes to
+disk (its siblings only ever read and reason about the AST); a diff-derived
+path that somehow resolved outside the repository root would otherwise let
+this gate's own mutation engine overwrite an arbitrary file, or -- the
+read-side half of the same check, in ``find_violations`` rather than
+``_run_mutation`` -- read one into this process's own memory before that
+write-side check is ever reached. A path failing either check raises
+:class:`ScanError` before ``read_bytes``/``write_bytes`` is ever called, the
 same fail-closed contract every other malformed-input case in this gate
 already gets.
 
@@ -336,10 +369,13 @@
 
 # Category 3: the AST node types that make a display's own construction
 # conditional, disqualifying it from grading -- see the module docstring's
-# own category-3 paragraph.
-_GUARD_NODE_TYPES: tuple[type[ast.AST], ...] = (ast.If, ast.Try, ast.For, ast.AsyncFor, ast.While)
-if hasattr(ast, "TryStar"):
-    _GUARD_NODE_TYPES = (*_GUARD_NODE_TYPES, ast.TryStar)
+# own category-3 paragraph. `ast.TryStar` (`try`/`except*`, Python 3.11+)
+# is referenced directly, not behind a `hasattr` guard: this repository's
+# own `requires-python = ">=3.12"` (pyproject.toml) means it is always
+# present, matching how gitapex_gate_except_fail_open.py,
+# gitapex_gate_network_exception_set_drift.py, and
+# gitapex_gate_exception_handler_gaps.py already reference it.
+_GUARD_NODE_TYPES: tuple[type[ast.AST], ...] = (ast.If, ast.Try, ast.TryStar, ast.For, ast.AsyncFor, ast.While)
 
 _PYTEST_TIMEOUT_SECONDS = 120
 
@@ -847,8 +883,8 @@ def _enclosing_function_unconditional(
     node: ast.AST, parents: dict[int, ast.AST]
 ) -> ast.FunctionDef | ast.AsyncFunctionDef | None:
     """Walk upward from `node` to its enclosing function, returning that
-    function iff no `If`/`Try`/`For`/`AsyncFor`/`While` ancestor sits
-    between them (the display is built unconditionally in that function's
+    function iff no `If`/`Try`/`TryStar`/`For`/`AsyncFor`/`While` ancestor
+    sits between them (the display is built unconditionally in that function's
     own body). None when no enclosing function exists at all (a module- or
     class-body-level display) or when a guard sits between `node` and the
     nearest enclosing function."""
@@ -881,6 +917,19 @@ def _literal_display_elements(
             func = _enclosing_function_unconditional(node, parents)
             if func is None or not node.elts:
                 continue
+            if isinstance(node, ast.Tuple) and len(node.elts) == 1:
+                # An unparenthesized single-element tuple (`x = 1,`) has no
+                # brackets of its own to leave behind once the sole item is
+                # spliced out -- `_removal_span_for_item`'s sole-item branch
+                # would remove the item plus its trailing comma, leaving a
+                # bare `x = ` (a SyntaxError), not the valid empty display
+                # that branch produces for every other display shape. Byte
+                # `(` at the tuple's own span start is how a parenthesized
+                # one-tuple (`x = (1,)`, safe to mutate) is told apart from
+                # this one -- `ast.Tuple` carries no boolean for it.
+                tuple_start, _ = _node_byte_span(node, line_starts)
+                if body[tuple_start : tuple_start + 1] != b"(":
+                    continue
             item_spans = [_node_byte_span(item, line_starts) for item in node.elts]
             for index, item in enumerate(node.elts):
                 if not (isinstance(item, ast.Constant) and _is_supported_literal(item.value)):
@@ -962,9 +1011,10 @@ def _invalidate_pycache(absolute_path: pathlib.Path) -> None:
 def _is_within_root(candidate: pathlib.Path, root: pathlib.Path) -> bool:
     """True iff `candidate` resolves (symlinks and `..` components
     included) to `root` itself or somewhere inside it -- the path-traversal
-    containment check `_run_mutation` runs immediately before writing a
-    single mutated byte to disk, on top of (never a replacement for)
-    `in_scope`'s own fixed `_IN_SCOPE_RE` shape. Real defect class this
+    containment check `find_violations` runs immediately before reading a
+    file's own bytes, and `_run_mutation` runs again immediately before
+    writing a single mutated byte to disk, on top of (never a replacement
+    for) `in_scope`'s own fixed `_IN_SCOPE_RE` shape. Real defect class this
     would catch that a plain string-prefix check would not: a same-prefixed
     sibling directory (`root=/repo`, `candidate=/repo-evil/x.py`) -- both
     sides are resolved to absolute, normalized paths before comparison, so
@@ -1107,6 +1157,15 @@ def find_violations(diff_text: str, root: pathlib.Path) -> tuple[list[Finding],
         if not in_scope(path):
             continue
         absolute = root / path
+        if not _is_within_root(absolute, root):
+            # Defense-in-depth, matching `_run_mutation`'s own containment
+            # check before it writes: `in_scope`'s fixed `_IN_SCOPE_RE`
+            # already keeps a `..`-relative escape or a textual sibling
+            # from matching, but a real symlink inside `root` pointing
+            # outside it resolves past both -- caught here, on the read
+            # side, before any byte of a possibly-external file reaches
+            # this process at all (not merely before this gate writes one).
+            raise ScanError(f"{path}: named by the diff, but resolves outside {root}")
         try:
             original_bytes = absolute.read_bytes()
         except FileNotFoundError:
diff --git a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
index da614006..6d1f92ca 100644
--- a/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
+++ b/tests/test_gitapex_gate_defeat_test_mutation_coverage.py
@@ -558,6 +558,36 @@ def test_literal_display_elements_skips_a_none_value() -> None:
     assert gate._literal_display_elements(tree, body, starts, {2}) == []
 
 
+def test_literal_display_elements_skips_an_unparenthesized_single_element_tuple() -> None:
+    """Regression for an independent adversarial review finding (issue
+    #1799, PR #2000): `return 1,` is a valid, unparenthesized one-element
+    tuple. Splicing out its sole item the way every other display's
+    sole-item branch does would leave a bare `return ` -- a SyntaxError,
+    not the valid empty display the same removal produces for `[1]`/`(1,)`/
+    `{1}`. Must not be graded at all."""
+    source = "def make():\n    return 1,\n"
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    assert gate._literal_display_elements(tree, body, starts, {2}) == []
+
+
+def test_literal_display_elements_grades_a_parenthesized_single_element_tuple() -> None:
+    """The parenthesized sibling of the case above (`return (1,)`) has its
+    own brackets to leave behind, so it is graded exactly like a
+    single-element list or set -- the byte-level `(` check must not
+    over-exclude it."""
+    source = "def make():\n    return (1,)\n"
+    tree = ast.parse(source)
+    body = source.encode("utf-8")
+    starts = _line_starts(source)
+    elements = gate._literal_display_elements(tree, body, starts, {2})
+    assert len(elements) == 1
+    _line, _category, _message, (start, end) = elements[0]
+    mutated = body[:start] + body[end:]
+    ast.parse(mutated.decode("utf-8"))
+
+
 def test_literal_display_elements_skips_a_list_item_the_diff_never_touches() -> None:
     source = 'def make():\n    return ["a", "b"]\n'
     tree = ast.parse(source)
@@ -897,6 +927,27 @@ def test_run_mutation_restores_the_original_bytes_even_when_pytest_errors(tmp_pa
     assert absolute.read_bytes() == original_bytes
 
 
+def test_find_violations_refuses_to_read_a_symlink_escaping_root(tmp_path: pathlib.Path) -> None:
+    """Regression for an independent adversarial review finding (issue
+    #1799, PR #2000): the containment check `_run_mutation` already runs
+    before writing a mutated byte did not also run on the read side --
+    `find_violations` resolved `root / path` and called `read_bytes()`
+    directly. A path the diff names that is, on disk, a symlink pointing
+    outside `root` must be refused before any of its bytes are read into
+    this process at all, not merely before this gate would write to it."""
+    root = tmp_path / "repo"
+    root.mkdir()
+    outside = tmp_path / "outside.py"
+    outside.write_text("def make():\n    return 1\n", encoding="utf-8")
+    fixture_path = ".github/scripts/gitapex_check_fixture.py"
+    link = root / fixture_path
+    link.parent.mkdir(parents=True, exist_ok=True)
+    link.symlink_to(outside)
+    diff_text = _whole_file_diff(fixture_path, "def make():\n    return 1\n")
+    with pytest.raises(gate.ScanError, match="resolves outside"):
+        gate.find_violations(diff_text, root)
+
+
 def test_find_violations_raises_scan_error_for_an_unreadable_file(tmp_path: pathlib.Path) -> None:
     """A path the diff names as a source file that turns out to be a
     directory raises `IsADirectoryError` (an `OSError`, not