the decoy sweep: 29 gates read, 16 fooled, 10 fixed - and a gate that refuses the next one (R-421)

THE CLASS, now a row: an instrument that matches a LABEL rather than the fact it names. Five
instances - R-410, R-400, R-378, R-419, R-94 - and EVERY ONE was found by accident, by someone
looking at something else. The gates enforce every other rule in this project, including the rule
that findings must be written down rather than left in prose. Nothing had ever checked the gates.

METHOD, and it is the transferable part: for each gate, construct the label WITHOUT the fact - a
directory with the right name and no bake log, a handler case that exists only in a comment, a note
whose prose mentions the marker it lacks - run the gate, record what it says. No verdict was reached
by reading. Reading is how all five hid.

RESULT: 29 distinct scripts (35 registrations; three are shared across three runners). 19 sound, 4
holes left OPEN with rows, 6 that no plausible decoy could be built for and are named UNTESTED rather
than called sound. A gate nobody tried to fool is UNKNOWN.

SCOPE IS A FACT TOO - the largest single cause, and mundane. Eight gates decided what to look at with
os.listdir, one level. Every one was green AND CORRECT today, and every one would have gone blind the
moment anyone added a subdirectory. mojibake and docker-v already used os.walk, caught the identical
planted file, and are the control that proves the cause was the listing and not the decoy.

IN THIS REPO: hub-confirm and manifest-bearer now walk. observations_gate (R-419, CLOSED) requires a
marker at a line start or after a sentence boundary and strips inline code spans - a note SAYING it
carries no marker no longer satisfies the marker test. closed-register now CONVICTS on a row it
cannot parse instead of warning: FOUR rows were in that state, TWO of them written by the session
that closed them the day before, and every one was exempt from the only check that reads that file.
The rows were repaired first and the conviction added second - registering a failing gate refuses
every push.

THE META-GATE: decoy_coverage_gate.py refuses a gate registered without a decoy or a named exemption.
It convicted ITSELF the moment it was registered, which is how it came to have one. Coverage is a
DECLARATION the gate AST-parses, never a grep - searching a test file for a gate's name would be the
very shape this sweep exists to find. The 20 uncovered gates are listed by name (R-426).

NOT FIXED, each with a row and a decoy asserting TODAY's behaviour so the fix must be deliberate:
R-422 reuse-refs (only 7 extensions; a rotted .md citation is invisible), R-423 site (PAGES is a
hardcoded list of 7), R-424 one-register (a defect parked as `idea`), R-425 offbox-rename (fixed
FILES list). R-427: closed_register_gate checks ONE direction - twelve open rows carry a closed
verdict and were NOT moved, because telling finished from partly-finished is a judgement and R-378
is the record of a machine getting it wrong.

FIVE DECOYS WITHDRAWN AS ILLEGITIMATE, mine, named in the audit. A decoy nobody would write proves
nothing, and manufacturing a finding to fill a row is worse than an honest NO.

No product code. No version bump. No image. No golden owed. All four runners green.
Register: OPEN 172 -> 178, CLOSED 160 -> 161.

scripts/observations_gate.py

@@ -76,8 +76,28 @@ ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 # `## 10. Observations — recorded, not acted on`, `### Observations`, `## Observations:` …
 HEADING_RE = re.compile(r"^(#+)\s*(?:\d+[.)]\s*)?observations\b", re.IGNORECASE)
 ITEM_RE = re.compile(r"^\s*(\d+)[.)]\s+(.*)$")
-FILED_RE = re.compile(r"\bFILED:\s*(R-\d+)", re.IGNORECASE)
-NOT_A_FINDING_RE = re.compile(r"\bNOT-A-FINDING:\s*(\S.*)$", re.IGNORECASE | re.MULTILINE)
+# ⚠ THE MARKER IS A MARKER, NOT A MENTION (R-419, fixed 2026-09-01).
+#
+# These were `\bFILED:` and `\bNOT-A-FINDING:` searched over the whole item body, so ANY occurrence
+# counted — including one inside a sentence ABOUT the markers. Measured, and by accident: an
+# observation reading *"it carries no `FILED:` and no `NOT-A-FINDING:` marker"* was reported
+# `OK  1. NOT-A-FINDING` and a real push of mine went green over an unfiled finding. **The gate's
+# whole job is to force an explicit choice, and a sentence disclaiming the choice counted as making
+# it.** That is the substring-for-field class this project has now shipped five times.
+#
+# A marker must now be the START of a line (after optional list/emphasis punctuation), which is
+# where a real marker is written and where a mention inside prose never is. `**FILED: R-417**` at
+# the end of a sentence is the common real shape, so a marker is also accepted after a sentence
+# boundary — but never mid-sentence and never inside backticks.
+_MARK = r"(?:^|(?<=[.!?)]\s)|(?<=[.!?)]\s\s))[\s>*_\-]*"
+FILED_RE = re.compile(_MARK + r"\*{0,2}FILED:\*{0,2}\s*(R-\d+)",
+                      re.IGNORECASE | re.MULTILINE)
+NOT_A_FINDING_RE = re.compile(_MARK + r"\*{0,2}NOT-A-FINDING:\*{0,2}\s*(\S.*)$",
+                              re.IGNORECASE | re.MULTILINE)
+
+# A marker written inside backticks is being TALKED ABOUT, never used. Strip inline code spans
+# before matching — this is what makes the R-419 decoy fail.
+CODE_SPAN_RE = re.compile(r"`[^`]*`")
 
 REGISTERS = [
     os.path.join(ROOT, "documentation", "backlog", "OPEN-ITEMS.md"),
@@ -184,6 +204,7 @@ def main():
     convictions = []
     satisfied = []
     for num, body in items:
+        body = CODE_SPAN_RE.sub("", body)   # R-419: a marker inside backticks is a mention
         filed = FILED_RE.findall(body)
         declared = NOT_A_FINDING_RE.findall(body)
         first_line = body.split("\n")[0].strip()