Anchor the fence closer grammar; make the fence tests pin the scanner

Two r4 findings:

P1 (leading tab accepted before a closing fence): the closer computed
indentation with lstrip(' ') (spaces only) but the delimiter with strip()
(tabs too), so a TAB + triple-backtick line closed the block and exposed
the fenced count as top-level metadata — reproduced as a false clean POST.
The closer is now an anchored grammar: 0-3 LITERAL leading spaces (a
leading tab is 4 columns, i.e. content), the matching delimiter repeated at
least the opening length, and only [ \t]* afterward. Entry-point cases for
tab and mixed space/tab indentation assert exit 1 and zero POSTs.

P2 (test-oracle weakness): the six r3 regression tests stayed green with
the broken scanner restored — their fixtures placed the malicious fence
AFTER the Review Summary section, so the positional guard rejected the
exposed row regardless of scanner correctness. The fixtures now place the
fence in the metadata slot (or the fake heading ahead of the real summary
for the tilde variant), so a naive toggling scanner WOULD promote the
fenced row into the official position. Mutation-verified locally: the r3
naive-toggling scanner fails all 10 fence/tab tests, and the r4 tab-closer
bug fails exactly the 4 tab tests; the fixed scanner passes all 87.

Verification: python3 -m unittest discover -s .github/actions/pr-review/scripts
-p 'test_*.py' — 87 tests pass; both mutants above fail as named.

Co-authored-by: c1-squire-dev[bot] <c1-squire-dev[bot]@users.noreply.github.com>

Author: gontzess

.github/actions/pr-review/scripts/submit-verdict-review.py

@@ -154,6 +154,10 @@ def sha_bound_to_head(reviewed: str | None, head: str) -> bool:
 # A fence opener: up to 3 leading spaces, then 3+ backticks or tildes, then an
 # optional info string (CommonMark 0.31.2, fenced code blocks).
 _FENCE_OPEN_PATTERN = re.compile(r"^ {0,3}(`{3,}|~{3,})(.*)$")
+# A fence closer: up to 3 LITERAL leading spaces (a leading tab is 4 columns —
+# content, not a closer), then a delimiter run, then only spaces/tabs. The
+# delimiter character and minimum length are checked against the opener.
+_FENCE_CLOSE_PATTERN = re.compile(r"^ {0,3}(`+|~+)[ \t]*$")
 
 
 def _top_level_lines(body: str) -> list[str]:
@@ -184,17 +188,16 @@ def _top_level_lines(body: str) -> list[str]:
                 continue
             lines.append(line)
             continue
-        # Inside a fence: only a valid closer ends it.
-        indent = len(line) - len(line.lstrip(" "))
-        stripped = line.strip()
-        if (
-            indent <= 3
-            and stripped
-            and set(stripped) == {fence_char}
-            and len(stripped) >= fence_len
-        ):
-            fence_char = None
-            fence_len = 0
+        # Inside a fence: only a valid closer ends it. The closer grammar is
+        # anchored: 0-3 literal leading spaces (a leading tab is 4 columns,
+        # i.e. content), the matching delimiter repeated at least the opening
+        # length, and only spaces/tabs afterward.
+        closer = _FENCE_CLOSE_PATTERN.match(line)
+        if closer:
+            delimiter = closer.group(1)
+            if delimiter[0] == fence_char and len(delimiter) >= fence_len:
+                fence_char = None
+                fence_len = 0
         # Fence openers/closers and fenced content are never top-level lines.
     return lines
 

.github/actions/pr-review/scripts/test_verdict_scaffolding.py

@@ -184,23 +184,45 @@ def test_out_of_position_row_rejected(self):
 
     def test_longer_fence_embedded_shorter_run_is_content(self):
         # A triple-backtick line inside a four-backtick fence is content, not
-        # a closer; the row after it stays fenced.
-        body = summary_body(0).replace(count_row(0) + "\n", "")
-        body += "\n````markdown\n```\n" + count_row(0) + "\n```\n````\n"
+        # a closer. The fence sits in the metadata slot, so a naive toggling
+        # scanner WOULD promote the fenced row into the official position —
+        # this fixture fails on that broken scanner, not just on fixed code.
+        body = summary_body(0).replace(
+            count_row(0), "````markdown\n```\n" + count_row(0) + "\n```\n````"
+        )
         self.assertIsNone(sv.parse_blocking_count(body, HEADING))
 
     def test_closer_with_info_suffix_is_not_a_closer(self):
         # "```example" inside a fence is content (a closer may only have
-        # trailing whitespace); the row after it stays fenced.
-        body = summary_body(0).replace(count_row(0) + "\n", "")
-        body += "\n```\n ```example\n" + count_row(0) + "\n```\n"
+        # trailing whitespace). Metadata-slot placement: a naive scanner
+        # treats it as a closer and accepts the exposed row.
+        body = summary_body(0).replace(
+            count_row(0), "```\n ```example\n" + count_row(0) + "\n```"
+        )
         self.assertIsNone(sv.parse_blocking_count(body, HEADING))
 
     def test_tilde_fence_hides_fake_heading_and_row(self):
         # Tilde fences are fences too: a fake heading + count inside one can
-        # never supply the verdict.
-        body = summary_body(0).replace(count_row(0) + "\n", "")
-        body += "\n~~~markdown\n### Connector PR Review: fake\n\n" + count_row(0) + "\n~~~\n"
+        # never supply the verdict. The fake heading precedes the real
+        # summary, so a backtick-only scanner finds the fake pair and accepts.
+        fake = "~~~markdown\n### Connector PR Review: fake\n\n" + count_row(0) + "\n~~~\n"
+        body = fake + summary_body(0).replace(count_row(0) + "\n", "")
+        self.assertIsNone(sv.parse_blocking_count(body, HEADING))
+
+    def test_tab_indented_closer_is_content(self):
+        # A leading tab is 4 columns — the line is content, not a closer, so
+        # the row after it stays fenced. A scanner that strips the tab into a
+        # valid delimiter accepts the exposed row here.
+        body = summary_body(0).replace(
+            count_row(0), "```\n\t```\n" + count_row(0) + "\n```"
+        )
+        self.assertIsNone(sv.parse_blocking_count(body, HEADING))
+
+    def test_space_tab_indented_closer_is_content(self):
+        # Space-then-tab before a closing fence is likewise content.
+        body = summary_body(0).replace(
+            count_row(0), "```\n \t```\n" + count_row(0) + "\n```"
+        )
         self.assertIsNone(sv.parse_blocking_count(body, HEADING))
 
 
@@ -447,11 +469,13 @@ def test_malformed_real_row_plus_fenced_row_fails_closed(self):
         self.assertEqual(posted, [])
 
     def test_four_backtick_embedded_triple_fails_closed(self):
-        # r3 variant (a): a four-backtick block containing a triple-backtick
-        # line and a canonical zero row, with no real metadata row. The
-        # embedded shorter run is content, not a closer.
-        body = summary_body(0).replace(count_row(0) + "\n", "")
-        body += "\n````markdown\n```\n" + count_row(0) + "\n```\n````\n"
+        # r3 variant (a): a four-backtick block in the metadata slot
+        # containing a triple-backtick line and a canonical zero row. The
+        # embedded shorter run is content, not a closer; a naive toggling
+        # scanner promotes the fenced row into the official slot and POSTs.
+        body = summary_body(0).replace(
+            count_row(0), "````markdown\n```\n" + count_row(0) + "\n```\n````"
+        )
         posted = []
         code, _ = self._run_main(
             [comment(7, body)], rest_side_effect=self._rest_dispatch(posted=posted)
@@ -461,9 +485,11 @@ def test_four_backtick_embedded_triple_fails_closed(self):
 
     def test_invalid_closer_suffix_fails_closed(self):
         # r3 variant (b): a line beginning "```example" inside a fenced block
-        # is not a valid closer; the row after it stays fenced.
-        body = summary_body(0).replace(count_row(0) + "\n", "")
-        body += "\n```\n ```example\n" + count_row(0) + "\n```\n"
+        # is not a valid closer; the row after it stays fenced. Metadata-slot
+        # placement pins the broken scanner.
+        body = summary_body(0).replace(
+            count_row(0), "```\n ```example\n" + count_row(0) + "\n```"
+        )
         posted = []
         code, _ = self._run_main(
             [comment(7, body)], rest_side_effect=self._rest_dispatch(posted=posted)
@@ -473,9 +499,36 @@ def test_invalid_closer_suffix_fails_closed(self):
 
     def test_tilde_fenced_fake_summary_fails_closed(self):
         # r3 variant (c): a fake heading + canonical row inside a tilde fence
-        # can never supply the verdict.
-        body = summary_body(0).replace(count_row(0) + "\n", "")
-        body += "\n~~~markdown\n### Connector PR Review: fake\n\n" + count_row(0) + "\n~~~\n"
+        # can never supply the verdict. The fake pair precedes the real
+        # summary so a backtick-only scanner accepts it.
+        fake = "~~~markdown\n### Connector PR Review: fake\n\n" + count_row(0) + "\n~~~\n"
+        body = fake + summary_body(0).replace(count_row(0) + "\n", "")
+        posted = []
+        code, _ = self._run_main(
+            [comment(7, body)], rest_side_effect=self._rest_dispatch(posted=posted)
+        )
+        self.assertEqual(code, 1)
+        self.assertEqual(posted, [])
+
+    def test_tab_indented_closer_fails_closed(self):
+        # r4 variant: a TAB before the closing fence makes the line content
+        # (4 columns), not a closer; the exposed row must not be submitted.
+        body = summary_body(0).replace(
+            count_row(0), "```\n\t```\n" + count_row(0) + "\n```"
+        )
+        posted = []
+        code, _ = self._run_main(
+            [comment(7, body)], rest_side_effect=self._rest_dispatch(posted=posted)
+        )
+        self.assertEqual(code, 1)
+        self.assertEqual(posted, [])
+
+    def test_space_tab_indented_closer_fails_closed(self):
+        # r4 variant: space-then-tab before the closing fence is likewise
+        # content, not a closer.
+        body = summary_body(0).replace(
+            count_row(0), "```\n \t```\n" + count_row(0) + "\n```"
+        )
         posted = []
         code, _ = self._run_main(
             [comment(7, body)], rest_side_effect=self._rest_dispatch(posted=posted)