diff --git a/scripts/README.md b/scripts/README.md
index b4ab767d..567d2dd2 100644
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -2,11 +2,11 @@
 
 Local checks and tooling this repo runs by hand, with the deterministic ones also gating CI. Each one exists because the CI linters pass on the failure it catches: `markdownlint`, `cspell`, `actionlint`, and `editorconfig-checker` all report clean on prose that breaks a documented [`GOVERNANCE.md`][governance] rule. Doc linters stay out of the pre-commit hook, which runs language formatting only so it stays fast.
 
-**Hub-only, not carried.** These are not declared in [`spec/files.json`][files], so the audit does not expect a downstream repo to ship them - the same footing as `spec/audit.py`. Promoting one to fleet-carried is a deliberate act: declare it in the baseline and vendor it, per [`spec/section-model.md`][section-model].
+**Hub-only, not carried.** These are not declared in [`spec/files.json`][files], so the audit does not expect a downstream repo to ship them, the same footing as `spec/audit.py`. Promoting one to fleet-carried is a deliberate act: declare it in the baseline and vendor it, per [`spec/section-model.md`][section-model].
 
 Python only, standard library only, no third-party packages. Every script is read-only and exits non-zero on a finding.
 
-Each script has a `test_<script>.py` beside it, driving its gates against input they must reject, because a gate nobody has watched fail is a gate nobody knows works. Where a case covers a table it reads the live table rather than restating it, and each one asserts a floor on what a healthy run reaches - a check whose scan matches nothing reports zero findings and reads exactly like a pass.
+Each script has a `test_<script>.py` beside it, driving its gates against input they must reject, because a gate nobody has watched fail is a gate nobody knows works. Where a case covers a table it reads the live table rather than restating it, and each one asserts a floor on what a healthy run reaches, since a check whose scan matches nothing reports zero findings and reads exactly like a pass.
 
 ```sh
 python3 scripts/test_prose_lint.py
@@ -48,9 +48,9 @@ The `comment-wrap` rule covers comments in every syntax the fleet's project type
 
 JSON is treated as JSONC, because that is what ships: VS Code tasks, launch, devcontainer and workspace files all carry comments under a plain `.json` name. A marker inside a string literal is not a comment, so each line is scanned with quoted spans blanked first, and Python uses `tokenize` so a trailing comment is seen exactly. A documentation comment (`///`, `/**`, a docstring) is left to CODESTYLE, which permits the paragraphs this rule forbids.
 
-Each syntax also declares how its strings escape: the escape character, the quotes it works inside, and whether it works outside one, all read independently of whether a string embeds its delimiter by doubling it. Neither property implies the other - PowerShell's double-quoted string is escaped by a backtick and doubling at once, while a C# verbatim string is doubling and not escaped. Reading an escape a string does not have consumes its closing quote and blanks the rest of the line, and missing one it does have ends the string early on the escaped quote.
+Each syntax also declares how its strings escape: the escape character, the quotes it works inside, and whether it works outside one, all read independently of whether a string embeds its delimiter by doubling it. Neither property implies the other: PowerShell's double-quoted string is escaped by a backtick and doubling at once, while a C# verbatim string is doubling and not escaped. Reading an escape a string does not have consumes its closing quote and blanks the rest of the line, and missing one it does have ends the string early on the escaped quote.
 
-A string that spans lines carries its state onto the lines it covers, so a marker inside one is data rather than a comment. Each syntax declares the forms it carries: the C# verbatim string, an ordinary quoted string in shell and in PowerShell, a PowerShell here-string, a shell heredoc, and a YAML block scalar. A YAML `run:` scalar is deliberately not one of them, because it holds a script whose `#` lines are exactly the comments this rule governs. A form no syntax declares stays scanned a line at a time, which is where a false positive is still possible: a TOML triple-quoted string is the open case. The reverse direction is guarded too, since a form that carried where the language has none would blank the rest of the file and report nothing - a YAML plain scalar's apostrophe is not a string, so an ordinary quote does not carry there.
+A string that spans lines carries its state onto the lines it covers, so a marker inside one is data rather than a comment. Each syntax declares the forms it carries: the C# verbatim string, an ordinary quoted string in shell and in PowerShell, a PowerShell here-string, a shell heredoc, and a YAML block scalar. A YAML `run:` scalar is deliberately not one of them, because it holds a script whose `#` lines are exactly the comments this rule governs. A form no syntax declares stays scanned a line at a time, which is where a false positive is still possible: a TOML triple-quoted string is the open case. The reverse direction is guarded too, since a form that carried where the language has none would blank the rest of the file and report nothing: a YAML plain scalar's apostrophe is not a string, so an ordinary quote does not carry there.
 
 A comment sentence also has to start with a capital, which `comment-case` checks. A lowercase opening reads as the continuation of the line above it, so the two rules are read together: a wrapped sentence reports as `comment-wrap`, and a lowercase opening that is not a continuation reports as `comment-case`. Where the first word is a tool whose own casing is lowercase, the fix is to restructure rather than to capitalize the name against CODESTYLE's tooling-casing rule.
 
@@ -60,8 +60,8 @@ A comment sentence also has to start with a capital, which `comment-case` checks
 
 Two deterministic checks:
 
-- `sha-pin` - every workflow `uses:` is a 40-hex commit SHA, with the one documented `dotnet/nbgv@master` exception allowed.
-- `eol` - every path pinned LF in [`.gitattributes`][gitattributes] has the matching [`.editorconfig`][editorconfig] override the line-ending rule requires, with EditorConfig brace syntax expanded. One direction only: an `.editorconfig` LF glob with no git pin is legitimate, since `.editorconfig` governs what the editor writes where git enforces a class it must not guess at.
+- `sha-pin`: every workflow `uses:` is a 40-hex commit SHA, with the one documented `dotnet/nbgv@master` exception allowed.
+- `eol`: every path pinned LF in [`.gitattributes`][gitattributes] has the matching [`.editorconfig`][editorconfig] override the line-ending rule requires, with EditorConfig brace syntax expanded. One direction only: an `.editorconfig` LF glob with no git pin is legitimate, since `.editorconfig` governs what the editor writes where git enforces a class it must not guess at.
 
 ```sh
 python3 scripts/repo_gate.py
@@ -81,6 +81,10 @@ python3 scripts/pr_review.py wait 452 --timeout 2700
 
 `wait` exits `30` when the review is still pending at the timeout, which is pending rather than failed. Its failure mode is a wrong answer rather than a crash, so the cases feed crafted GraphQL payloads: a review attributed to the wrong login, a review counted against a stale head, a maintainer's own thread read as a finding, and a wait that returns success while nothing landed. One case reads the reviewer login out of the runbook rather than restating it, since GraphQL drops the `[bot]` suffix REST carries, and another asserts no mutation has crept into a read-only script.
 
+The digest also reports the **suppressed findings** a review body collapses into a `<details>` block. Those reach no review thread, so a loop that polls threads alone reports a clean pass while they stand, and the [merge gate][governance] counts them as outstanding findings either way. `suppressed=N` counts findings rather than blocks, reading the `(N)` the heading carries, since one body holds one block per round and counting blocks reports two findings as one. It covers the reviews on the current head only, so a finding answered before a push does not re-open after it. Each block prints whole where a thread body truncates, because a thread can be re-read at its id and a suppressed finding cannot, and it prints under a marker naming what closing it takes: no thread exists to reply on or resolve, so the answer goes in the PR conversation.
+
+The match is on the block's heading rather than anywhere in the body, and on the runbook's alternation rather than on one phrasing, since the wording has already appeared two ways. A case asserts the script's pattern is the one the runbook publishes rather than a copy of it that can drift. Reading the whole body was the first implementation and its own review caught it: a review whose overview prose discusses suppressed findings carries none, and reporting that as a finding trains the reader to skim the field. A heading outside any `<details>` wrapper is still read, because reporting zero when the markup moves is the same false clean one level up, and that fallback takes a count so ordinary prose does not become one.
+
 <!-- Internal -->
 
 [copilot-instructions]: ../.github/copilot-instructions.md
diff --git a/scripts/pr_review.py b/scripts/pr_review.py
index 71c2d08e..ec0ed133 100644
--- a/scripts/pr_review.py
+++ b/scripts/pr_review.py
@@ -8,7 +8,7 @@
 Discipline" for the rule this implements.
 
 Subcommands
-  status   One digest line plus any unresolved threads. Read-only.
+  status   One digest line, any unresolved threads, and any suppressed findings. Read-only.
   wait     Poll until Copilot's review lands on the current head, then print the digest.
            The loop runs in-process, so a 45-minute wait costs one agent turn, not 90.
            Exit 0 = review present, 30 = still pending at timeout (pending is not failure).
@@ -19,10 +19,20 @@
 .github/copilot-instructions.md for the mutation runbook.
 """
 from __future__ import annotations
-import argparse, json, subprocess, sys, time
+import argparse, json, re, subprocess, sys, time
 
 REVIEWER = 'copilot-pull-request-reviewer'
 
+# A review body can carry a collapsed block of findings withheld from the inline threads.
+# Those appear nowhere in `reviewThreads`, so polling threads alone reports a clean pass while
+# they stand. The alternation is the runbook's, because the heading wording has changed once
+# already, and matching one phrasing alone reports zero on a review that has them.
+SUPPRESSED = re.compile(r'Suppressed comments|low confidence', re.IGNORECASE)
+DETAILS = re.compile(r'<details>(.*?)</details>', re.DOTALL | re.IGNORECASE)
+SUMMARY = re.compile(r'<summary>(.*?)</summary>', re.DOTALL | re.IGNORECASE)
+TAGS = re.compile(r'</?(?:details|summary)>', re.IGNORECASE)
+COUNT = re.compile(r'\((\d+)\)')
+
 # Liveness query: two scalars only, no comment bodies.
 # A liveness check does not need the finding text, and re-fetching bodies was 76% of polls.
 Q_LIVE = """
@@ -38,7 +48,7 @@
 query($o:String!,$r:String!,$n:Int!){
   repository(owner:$o,name:$r){ pullRequest(number:$n){
     headRefOid mergeable mergeStateStatus
-    reviews(last:20){ nodes{ author{login} state commit{oid} submittedAt } }
+    reviews(last:20){ nodes{ author{login} state commit{oid} submittedAt body } }
     reviewThreads(first:100){ nodes{ id isResolved
       comments(first:1){ nodes{ author{login} path line body } } }}
   }}}
@@ -66,6 +76,37 @@ def live_state(owner: str, repo: str, num: int) -> tuple[str, bool]:
     return head, done
 
 
+def heading_of(block: str) -> str:
+    """The block's `<summary>`, or its opening where the wrapper carries none."""
+    m = SUMMARY.search(block)
+    return m.group(1) if m else block[:200]
+
+
+def suppressed_blocks(body: str) -> list[str]:
+    """Return the review body's low-confidence sections, matched on their heading.
+
+    The heading carries the match rather than the body text, since a review whose prose discusses
+    suppressed findings is not itself carrying any. The fallback covers the day the `<details>`
+    wrapper moves, and takes a heading with a count so ordinary prose is not read as one.
+    """
+    if not body:
+        return []
+    blocks = [b for b in DETAILS.findall(body) if SUPPRESSED.search(heading_of(b))]
+    if blocks:
+        return blocks
+    outside = DETAILS.sub('', body).splitlines()
+    for i, line in enumerate(outside):
+        if SUPPRESSED.search(line) and COUNT.search(line):
+            return ['\n'.join(outside[i:])]
+    return []
+
+
+def finding_count(block: str) -> int:
+    """The heading's `(N)`, floored at one, since a block reported as zero reads as a clean pass."""
+    m = COUNT.search(heading_of(block))
+    return max(int(m.group(1)), 1) if m else 1
+
+
 def digest(owner: str, repo: str, num: int, seen: set[str] | None = None) -> tuple[str, int]:
     pr = gql(Q_FULL, owner, repo, num)
     head = pr['headRefOid']
@@ -78,10 +119,14 @@ def digest(owner: str, repo: str, num: int, seen: set[str] | None = None) -> tup
                   and ((t.get('comments') or {}).get('nodes') or [{}])[0]
                   .get('author', {}).get('login') == REVIEWER]
 
+    # Scoped to the head, so a finding answered in an earlier round does not re-open.
+    blocks = [b for n in on_head for b in suppressed_blocks(n.get('body') or '')]
+
     lines = [
         f'pr={num} head={head[:8]} rounds={len(revs)} '
         f'review_on_head={"yes" if on_head else "NO"} '
         f'threads={len(threads)} unresolved={len(unresolved)} '
+        f'suppressed={sum(finding_count(b) for b in blocks)} '
         f'merge={pr.get("mergeStateStatus")}'
     ]
     new = 0
@@ -97,6 +142,12 @@ def digest(owner: str, repo: str, num: int, seen: set[str] | None = None) -> tup
             new += 1
         body = ' '.join((c.get('body') or '').split())
         lines.append(f'  {mark}{tid} {c.get("path")}:{c.get("line")} {body[:160]}')
+    for b in blocks:
+        # Printed whole where a thread body is truncated: a thread can be re-read at its id,
+        # while a suppressed finding has no thread, so this digest is the only place it appears.
+        lines.append('  SUPPRESSED: no thread to resolve, answer it in the PR conversation')
+        # Indentation is kept, since a block carries fenced code a flattened line would garble.
+        lines += [f'    {ln.rstrip()}' for ln in TAGS.sub('', b).splitlines() if ln.strip()]
     if seen is not None:
         lines[0] += f' new={new}'
     return '\n'.join(lines), len(unresolved)
diff --git a/scripts/test_pr_review.py b/scripts/test_pr_review.py
index 0159cf40..79f4e79d 100644
--- a/scripts/test_pr_review.py
+++ b/scripts/test_pr_review.py
@@ -22,8 +22,15 @@
 OLD = 'b' * 40
 
 
-def review(login: str = pr_review.REVIEWER, oid: str = HEAD) -> dict:
-    return {'author': {'login': login}, 'state': 'COMMENTED', 'commit': {'oid': oid}}
+def review(login: str = pr_review.REVIEWER, oid: str = HEAD, body: str = '') -> dict:
+    return {'author': {'login': login}, 'state': 'COMMENTED', 'commit': {'oid': oid},
+            'body': body}
+
+
+def collapsed(heading: str = 'Comments suppressed due to low confidence (1)',
+              finding: str = 'a.py:12 The retry count is off by one.') -> str:
+    return (f'Reviewed 3 of 3 changed files.\n\n<details>\n<summary>{heading}</summary>\n\n'
+            f'{finding}\n\n</details>\n')
 
 
 def thread(tid: str, resolved: bool = False, login: str = pr_review.REVIEWER,
@@ -124,6 +131,81 @@ def test_a_body_is_flattened_and_bounded(self) -> None:
         self.assertLessEqual(len(body.split('a.py:1 ')[1]), 160)
 
 
+class TestSuppressed(GqlCase):
+    """The findings collapsed in a review body, which reach no thread and so no thread poll."""
+
+    def test_either_documented_heading_counts_and_a_clean_body_does_not(self) -> None:
+        """One phrasing alone reports zero on a review that has them, the false clean once more."""
+        for label, body, want in (
+            ('the current heading', collapsed(), 1),
+            ('the earlier heading', collapsed(heading='Suppressed comments (2)'), 2),
+            ('a heading with no count', collapsed(heading='Suppressed comments'), 1),
+            ('a clean pass', 'Reviewed 3 of 3 changed files and generated no comments.', 0),
+            ('no body at all', '', 0),
+        ):
+            with self.subTest(case=label):
+                self.answer(payload([review(body=body)]))
+                out, _ = pr_review.digest('o', 'r', 7)
+                self.assertIn(f'suppressed={want}', out)
+
+    def test_a_block_on_a_stale_round_is_not_reported_again(self) -> None:
+        """Scoped to the head, so a finding answered before a push does not re-open after it."""
+        self.answer(payload([review(oid=OLD, body=collapsed()), review()]))
+        out, _ = pr_review.digest('o', 'r', 7)
+        self.assertIn('suppressed=0', out)
+        self.assertNotIn('SUPPRESSED', out)
+
+    def test_the_finding_prints_whole_under_a_marker_naming_the_answer(self) -> None:
+        """A thread can be re-read at its id and truncates for that reason, and this cannot."""
+        finding = 'a.py:12 ' + ('the same clause repeated. ' * 20).strip()
+        self.answer(payload([review(body=collapsed(finding=finding))]))
+        out, _ = pr_review.digest('o', 'r', 7)
+        self.assertIn('SUPPRESSED: no thread to resolve, answer it in the PR conversation', out)
+        self.assertIn(finding, out)
+        # The `<details>` wrapper is markup around the finding, not part of it.
+        self.assertNotIn('<summary>', out)
+        self.assertNotIn('<details>', out)
+
+    def test_a_body_naming_the_block_outside_a_details_wrapper_still_reports(self) -> None:
+        """Reporting zero because the markup moved is the failure the whole case guards."""
+        self.answer(payload([review(body='Suppressed comments (1)\n\na.py:12 Off by one.')]))
+        out, _ = pr_review.digest('o', 'r', 7)
+        self.assertIn('suppressed=1', out)
+        self.assertIn('a.py:12 Off by one.', out)
+
+    def test_the_per_file_summary_block_beside_it_is_not_a_finding(self) -> None:
+        """Every real body collapses a file table too, and reporting that is noise, not a finding."""
+        body = ('<details>\n<summary>Show a summary per file</summary>\n\n'
+                '| File | Description |\n\n</details>\n' + collapsed())
+        self.answer(payload([review(body=body)]))
+        out, _ = pr_review.digest('o', 'r', 7)
+        self.assertIn('suppressed=1', out)
+        self.assertNotIn('Show a summary per file', out)
+        self.assertIn('The retry count is off by one.', out)
+
+    def test_the_count_is_findings_rather_than_blocks(self) -> None:
+        """A body holds one block per round, so counting blocks reports two findings as one."""
+        self.answer(payload([review(body=collapsed(heading='Suppressed comments (3)')),
+                             review(body=collapsed(heading='Suppressed comments (2)'))]))
+        out, _ = pr_review.digest('o', 'r', 7)
+        self.assertIn('suppressed=5', out)
+
+    def test_prose_that_merely_discusses_the_phrase_is_not_a_block(self) -> None:
+        """This PR's own review body was the false positive, discussing the phrase and carrying none."""
+        body = ('## Pull request overview\n\nThis PR reports the suppressed and low confidence '
+                'findings that reach no thread (and are therefore invisible to a thread poll).\n\n'
+                '<details>\n<summary>Show a summary per file</summary>\n\n| File |\n\n</details>\n')
+        self.answer(payload([review(body=body)]))
+        out, _ = pr_review.digest('o', 'r', 7)
+        self.assertIn('suppressed=0', out)
+        self.assertNotIn('SUPPRESSED', out)
+
+    def test_a_human_review_carrying_the_phrase_is_not_a_copilot_finding(self) -> None:
+        self.answer(payload([review(login='ptr727', body=collapsed()), review()]))
+        out, _ = pr_review.digest('o', 'r', 7)
+        self.assertIn('suppressed=0', out)
+
+
 class TestGqlTransport(unittest.TestCase):
     def test_a_failed_call_raises_rather_than_returning_an_empty_reading(self) -> None:
         """Returning nothing on failure would read as a PR with no reviews and no threads."""
@@ -191,6 +273,11 @@ def test_the_reviewer_login_matches_the_runbook_graphql_form(self) -> None:
         self.assertIn(f'`{pr_review.REVIEWER}`, with **no `[bot]` suffix**', text)
         self.assertFalse(pr_review.REVIEWER.endswith('[bot]'))
 
+    def test_the_suppressed_pattern_is_the_runbook_alternation(self) -> None:
+        """The heading wording has changed once, so the pattern tracks the runbook, not a memory."""
+        text = RUNBOOK.read_text(encoding='utf-8')
+        self.assertIn(f'test("{pr_review.SUPPRESSED.pattern}")', text)
+
     def test_no_mutation_reaches_this_script(self) -> None:
         """Mutations stay as explicit `gh` calls so the write-guard hook and review still see them."""
         source = (REPO / 'scripts' / 'pr_review.py').read_text(encoding='utf-8')
@@ -214,7 +301,7 @@ class TestHarness(unittest.TestCase):
     def test_this_module_collects_a_plausible_number_of_cases(self) -> None:
         """A module whose cases fail to load still reports OK, which is a pass proving nothing."""
         loaded = unittest.defaultTestLoader.loadTestsFromModule(sys.modules[__name__])
-        self.assertGreaterEqual(loaded.countTestCases(), 15)
+        self.assertGreaterEqual(loaded.countTestCases(), 20)
 
 
 if __name__ == '__main__':