testguard-cli 0.13.0 → 0.14.0

package/CHANGELOG.md

@@ -7,6 +7,93 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.14.0] - 2026-09-22
+
+Automated weekly release — everything merged since `v0.13.0`.
+
+### Changed
+
+- fix: three defects the arid measurement found, presentational JSX set aside, and the claimspec signal bump (#164)
+- docs: carry the 0.12 and 0.13 results into the brief and the prior-art record (#162)
+- chore(homebrew): sha256 for v0.13.0 (#161)
+
+
+### Added
+
+- **claimspec v1 evidence admits `persistence-payload-unasserted`** to
+  `defenders.signals`, the enum shared with every claimspec consumer. The
+  signal had lived only in the sweep document, so `probe` could not surface
+  why a save-path survivor was missed. Now a `survived` record whose fault
+  sits on the write path carries it for each resolved defender that mocks the
+  persistence layer, with the mocked `specifiers` and the file's assertion
+  `counts` (exact, partial, argument-free). The validator refuses it on any
+  other verdict, on a file that is not a resolved defender, or without its
+  reason — the same rule the sweep document already enforced on its
+  findings, and the sweep now repeats what the record says rather than
+  re-deriving it. Conformance carries a valid example and three invalid
+  cases. No consumer outside this repository validates claimspec evidence
+  today; DocGuard's adoption (docguard#420) is notified rather than broken.
+- `sweep` sets aside a purely presentational JSX element — an icon, or a
+  static wrapper with no expression and no handler — instead of spending a
+  probe run on it, and says so: `selection.presentational` in the document, a
+  line in the report, and the remainder arithmetic now proves
+  proposed = probed + deferred + set aside. Measured on a 14-file UI diff:
+  150 of 510 proposals, 29 of 30 probe slots and 7 of 10 survivors were of
+  this shape — Google's definition of an arid node, in a syntax Google never
+  mutated. Because the ordering learns from survival, those survivors were
+  also teaching it to rank the class higher; set-aside proposals never enter
+  the evidence, so they no longer can. Google's own five arid categories were
+  measured at under 1% of proposals and are not suppressed.
+
+### Fixed
+
+- Python defender discovery lost the last name on an import line that ends in
+  a comment: `from pkg import cli, demo  # noqa: E402` found only `cli`, and
+  `import pkg.demo  # noqa` found nothing. On a real suite where `# noqa` is
+  the idiom of every src-layout test, 12 of 30 probed faults were reported
+  NOCOVER for modules whose tests import them — a gating verdict in the
+  forbidden direction. Comments are now stripped before names are read.
+- File walking descended into `.claude/`, so a nested agent worktree under
+  `.claude/worktrees/` contributed another branch's tests as defenders of this
+  tree — files the scratch worktree cannot even contain, because the directory
+  is gitignored. `.claude` joins the tool-directory skip list, and the claim
+  that promised this now names it.
+- The Python `statement-deleted` producer proposed on lines inside a bracket
+  opened earlier — `help="…")` inside an `add_argument(` — and none of those
+  faults compiled: 81 of 600 proposals on a real CLI (13.5%). The producer now
+  tracks bracket depth across lines (triple-quoted strings included, so a
+  docstring's parentheses cannot leave the rest of the file "inside") and
+  refuses the `pass` shapes there; dict entries and call arguments keep their
+  own producers. Re-measured: 7 of 526 (1.3%).
+
+### Changed
+
+- The self-probe cost budget is 1650 s, from 1440. Six new claims (85 s on
+  the Node 22 PR leg, worst 22 s, all under the 100 s per-claim ceiling) took
+  that leg from 1367 s to 1457 s, over by 17 s. The v0.13.0 release job
+  measured 1113 s from scratch, but the PR leg runs the same claims 25-30%
+  slower and is where the ceiling is checked, so 1650 restores ~13% headroom
+  over the leg that binds. The per-claim ceiling is unchanged.
+- The technical brief carries the 0.12 and 0.13 results it was missing: the
+  whole-surface provability measurement (32 of 37 files that write are defended
+  only by tests that mock the database) replaces the sample-level number in
+  Fig. 7; the ladder's second rung is now a shipped verb with a real finding
+  (a five-line concern found an admin route whose owner/manager check can be
+  forced to `false` with no test failing) rather than a description of intent;
+  and the first rung says its ordering learns from the project's own runs.
+  Re-rendered; still eight sheets from eight pages.
+- `docs-canonical/PRIOR-ART.md` records the arid-node measurement instead of
+  a promise: every proposal from four sweeps over two of the maintainer's
+  repositories was classified by hand against Google's five arid categories,
+  and they account for under 1% of what the producers propose. No suppressor
+  is built for them. The same pass found what IS material — presentational
+  JSX taking 29 of 30 probe slots on a UI diff, and 13.5% of Python proposals
+  that cannot compile — and lists both as open, with numbers.
+- `docs-canonical/PRIOR-ART.md` no longer lists the feedback loop and concerns
+  as unbuilt. The two gaps that remain are restated precisely: the loop learns
+  from verdicts rather than explicit developer clicks, and concerns have no
+  model-backed producer.
+
 ## [0.13.0] - 2026-09-22
 
 Automated weekly release — everything merged since `v0.12.0`.

package/README.md

@@ -127,9 +127,9 @@ raises coverage. TestGuard admits it because it fails when the claim is false.
 | npm | `npm i -D testguard-cli` then `npx testguard probe` |
 | pip | `pip install testguard-cli` then `testguard probe` (needs Node ≥ 20) |
 | Homebrew | `brew tap raccioly/tap && brew install testguard` |
-| GitHub Action | `uses: raccioly/testguard@v0.13.0` — see [`action.yml`](./action.yml) |
+| GitHub Action | `uses: raccioly/testguard@v0.14.0` — see [`action.yml`](./action.yml) |
 | pre-commit | `repo: https://github.com/raccioly/testguard`, hooks `testguard-claims`, `testguard-probe` |
-| GitLab CI | `include: - remote: https://raw.githubusercontent.com/raccioly/testguard/v0.13.0/packaging/gitlab/testguard.gitlab-ci.yml` with `inputs:` — see [`packaging/gitlab/`](./packaging/gitlab/testguard.gitlab-ci.yml) |
+| GitLab CI | `include: - remote: https://raw.githubusercontent.com/raccioly/testguard/v0.14.0/packaging/gitlab/testguard.gitlab-ci.yml` with `inputs:` — see [`packaging/gitlab/`](./packaging/gitlab/testguard.gitlab-ci.yml) |
 
 Projects that set `min-release-age` in `.npmrc` cannot see a version published
 less than that many days ago (`ENOVERSIONS`); install that one with
@@ -234,6 +234,10 @@ npx testguard-cli admit test/x.test.ts --claim X   # is this test green on HEAD
    static signal `mocked-never-asserted` — the cheapest blind-spot signal
    there is, and the exact signature of one escaped bug in the field
    reports. Silence it, visibly, with `// unasserted: <why>` above the mock.
+   Its sibling `persistence-payload-unasserted` is attached to a **survivor
+   on a write path** whose defender mocks the database: the test can prove
+   the call shape and never that the row landed, and the signal names the
+   mocked layer and the file's assertion mix (exact, partial, argument-free).
 
    Runners: **vitest**, **jest**, **Playwright** and **Python** (`--runner
    auto` picks the first of vitest, jest, python that resolves). A JavaScript
@@ -423,8 +427,9 @@ alarming: something was deliberately broken and not one test failed.
 
 ```
 swept 13 of 14 unclaimed changed files against origin/main.
-proposed 510 faults, probed 10 (cap 10), deferred 500.
-  The 500 deferred are not a verdict: raise --cap, or sweep a smaller change.
+proposed 510 faults, probed 10 (cap 10), deferred 350.
+  The 350 deferred are not a verdict: raise --cap, or sweep a smaller change.
+  150 presentational elements (icons, static wrappers) set aside: nobody writes a test for those, and a survivor there would teach the ordering the wrong lesson.
 
 9 findings — a deliberate break that no test noticed:
 
@@ -658,12 +663,12 @@ detected base that does not resolve is a warning for `status` and `brief`
 # GitHub Actions
 - uses: actions/checkout@v4
   with: { fetch-depth: 0 }
-- uses: raccioly/testguard@v0.13.0
+- uses: raccioly/testguard@v0.14.0
   with: { command: gate }
 
 # GitLab CI — the component-shaped template: gate + probe, brief as an artifact and, opted in, as a merge-request note
 include:
-  - remote: 'https://raw.githubusercontent.com/raccioly/testguard/v0.13.0/packaging/gitlab/testguard.gitlab-ci.yml'
+  - remote: 'https://raw.githubusercontent.com/raccioly/testguard/v0.14.0/packaging/gitlab/testguard.gitlab-ci.yml'
     inputs: { dir: backend, post_note: true }   # post_note needs TESTGUARD_GITLAB_TOKEN (api scope); one note, updated in place
 ```
 
@@ -981,7 +986,8 @@ parameter-derived argument swapped for `None`, a key dropped from a payload
 `dict` or an allow-list. Two differences are deliberate. A statement is
 removed by replacing it with `pass`, never by deleting the line, because a
 block whose only statement is gone is an `IndentationError`; and a line that
-leaves a bracket open (`COLOURS = {`) is never removed at all. Both exist
+leaves a bracket open (`COLOURS = {`), or sits inside one opened on an earlier
+line (`help="…"` in an `add_argument(`), is never removed at all. Both exist
 because a fault that cannot compile is a `fault-invalid` verdict — a probe run
 spent saying nothing about the tests. The two JSX shapes (`element-removed`,
 `handler-dropped`) have no Python meaning and are absent rather than faked.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testguard-cli",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Breaks your code on purpose and reports every promise your tests did not notice breaking. Mutation testing bound to the claims a project makes — vitest, jest, Playwright, pytest and unittest.",
   "type": "module",
   "license": "MIT",

package/spec/GATE-SEMANTICS.md

@@ -343,6 +343,14 @@ the suppress-up-to-count semantics are identical.
   tool then records `unasserted-annotated` with the reason — silenced, never
   hidden. A file that mocks the subject is never a discovered defender: a
   mock cannot detect a fault in what it replaced.
+  `persistence-payload-unasserted`: a resolved defender mocks the persistence
+  layer, so it can prove the call shape and never that a row landed; the
+  reason names the layer and the file's assertion mix. It is attached only to
+  a **survived** record whose fault sits on the write path — a field of a
+  persisted payload or the write call itself — because there it says why the
+  survivor was missed, and anywhere else it says nothing. A conforming
+  document never carries it on another verdict, on a file that is not a
+  resolved defender, or without its reason.
 
 ## Claimed source surface
 

package/spec/lib/validate.mjs

@@ -144,6 +144,16 @@ const semantic = {
         if (s.signal === 'target-attribute-patched') {
           if (!s.reason) errors.push({ path: `${p}/defenders/signals`, message: `target-attribute-patched on ${s.file} requires the patched attributes as its reason` });
           if (!r.defenders.resolved.includes(s.file)) errors.push({ path: `${p}/defenders/signals`, message: `${s.file} patches attributes of the subject but is not a resolved defender` });
+        } else if (s.signal === 'persistence-payload-unasserted') {
+          // The same rule the sweep document enforces on its findings: the
+          // signal explains a SURVIVOR on the write path. A record does not
+          // carry the fault's line, so the write-path half is the producer's
+          // to keep (`persistenceSignalsFor`); the verdict half is checked here.
+          // The file mocks the persistence layer, not the subject, so it is a
+          // resolved defender and never a mocking one.
+          if (!s.reason) errors.push({ path: `${p}/defenders/signals`, message: `persistence-payload-unasserted on ${s.file} requires the mocked layer and assertion mix as its reason` });
+          if (r.verdict !== 'survived') errors.push({ path: `${p}/defenders/signals`, message: `persistence-payload-unasserted explains a survivor; on a ${r.verdict} record it explains nothing` });
+          if (!r.defenders.resolved.includes(s.file)) errors.push({ path: `${p}/defenders/signals`, message: `${s.file} mocks the persistence layer but is not a resolved defender` });
         } else if (!(r.defenders.mocking ?? []).includes(s.file)) {
           errors.push({ path: `${p}/defenders/signals`, message: `${s.file} carries a mock signal but is not listed in defenders.mocking` });
         }
@@ -333,7 +343,8 @@ const semantic = {
     const s = doc.selection;
     // A cap that hides its remainder is a coverage claim nobody made, so the
     // arithmetic that proves nothing was dropped is checked, not trusted.
-    if (s.proposed !== s.selected + s.deferred) errors.push({ path: '/selection/proposed', message: `proposed (${s.proposed}) must equal selected (${s.selected}) + deferred (${s.deferred})` });
+    const setAside = s.presentational ?? 0;
+    if (s.proposed !== s.selected + s.deferred + setAside) errors.push({ path: '/selection/proposed', message: `proposed (${s.proposed}) must equal selected (${s.selected}) + deferred (${s.deferred})${setAside ? ` + presentational (${setAside})` : ''}` });
     if (s.selected > s.cap) errors.push({ path: '/selection/selected', message: `selected (${s.selected}) exceeds the cap (${s.cap})` });
     if (doc.scope.swept > doc.scope.targets) errors.push({ path: '/scope/swept', message: `swept (${doc.scope.swept}) cannot exceed targets (${doc.scope.targets})` });
     // The counters that only mean something in one mode must not appear in the

package/spec/schemas/evidence.schema.json

@@ -547,7 +547,7 @@
               }
             },
             "signals": {
-              "description": "Static, annotation-grade signals about the defenders. They never change a verdict. `mocked-never-asserted`: the file mocks the subject and never asserts on anything imported from it. `unasserted-annotated`: the same, but the author annotated the mock with a reason (`// unasserted: <why>`), recorded here \u2014 silenced, never hidden. `target-attribute-patched`: a Python defender that patches individual attributes of the subject (`patch(\"pkg.mod.fn\")`) rather than the module. Unlike a JavaScript module mock it does NOT disqualify the file \u2014 a fault anywhere else in the module is still detectable \u2014 so the file stays in `resolved`; `reason` names the patched attributes, which are where that test is least likely to notice anything.",
+              "description": "Static, annotation-grade signals about the defenders. They never change a verdict. `mocked-never-asserted`: the file mocks the subject and never asserts on anything imported from it. `unasserted-annotated`: the same, but the author annotated the mock with a reason (`// unasserted: <why>`), recorded here \u2014 silenced, never hidden. `target-attribute-patched`: a Python defender that patches individual attributes of the subject (`patch(\"pkg.mod.fn\")`) rather than the module. Unlike a JavaScript module mock it does NOT disqualify the file \u2014 a fault anywhere else in the module is still detectable \u2014 so the file stays in `resolved`; `reason` names the patched attributes, which are where that test is least likely to notice anything. `persistence-payload-unasserted`: a resolved defender that mocks the persistence layer (`vi.mock('@/lib/prisma')`) and so can prove the call shape but never that a row landed; `reason` names the mocked layer and the file's assertion mix (exact, partial, argument-free), `counts` carries the mix as numbers and `specifiers` the mocked module paths. It belongs only to a `survived` record whose fault sits on the write path \u2014 a field of a persisted payload, or the write call itself \u2014 because there it explains why the survivor was missed and anywhere else it explains nothing. Measured on a real application: 12 of 12 survivors on the save path were a dropped payload field, and every one of their defenders asserted with a partial matcher.",
               "type": "array",
               "items": {
                 "type": "object",
@@ -563,13 +563,46 @@
                     "enum": [
                       "mocked-never-asserted",
                       "unasserted-annotated",
-                      "target-attribute-patched"
+                      "target-attribute-patched",
+                      "persistence-payload-unasserted"
                     ]
                   },
                   "reason": {
                     "type": "string",
                     "minLength": 1,
                     "maxLength": 512
+                  },
+                  "specifiers": {
+                    "description": "persistence-payload-unasserted only: the persistence-layer module specifiers the file mocks.",
+                    "type": "array",
+                    "items": {
+                      "type": "string",
+                      "minLength": 1
+                    }
+                  },
+                  "counts": {
+                    "description": "persistence-payload-unasserted only: the file's call-shape assertions by kind. `exact` is the only kind a dropped field can fail.",
+                    "type": "object",
+                    "required": [
+                      "exact",
+                      "partial",
+                      "argless"
+                    ],
+                    "additionalProperties": false,
+                    "properties": {
+                      "exact": {
+                        "type": "integer",
+                        "minimum": 0
+                      },
+                      "partial": {
+                        "type": "integer",
+                        "minimum": 0
+                      },
+                      "argless": {
+                        "type": "integer",
+                        "minimum": 0
+                      }
+                    }
                   }
                 },
                 "additionalProperties": false

package/spec/schemas/sweep.schema.json

@@ -198,6 +198,11 @@
           "type": "integer",
           "minimum": 0,
           "description": "Proposals the concern's fault classes excluded. Reported so a narrow concern cannot look like a quiet one: the producers found these, and this concern is not about them."
+        },
+        "presentational": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Proposals set aside because they remove a purely presentational JSX element — an icon, or a static wrapper with no expression and no handler. Nobody writes a test for those, and a survivor on one would teach the survival-learned ordering to prefer the class. Counted in `proposed` and in `byClass`; never probed, never a finding. Absent when zero."
         }
       }
     },

package/src/probe/probe.mjs

@@ -16,6 +16,7 @@ import { classifyIndependence } from './independence.mjs';
 import { escalationStart, foldEscalationRun, escalationResult, flakeRate, killersFromRuns, subjectOf, isReusable } from './attribution.mjs';
 import { hashFile, sha256 } from '../util/hash.mjs';
 import { fingerprint } from '../../spec/lib/fingerprint.mjs';
+import { persistenceSignalsFor } from '../supply/persistence.mjs';
 
 
 /** Is `child` the same file as `root`, or under it? Both must already be real paths. */
@@ -485,13 +486,19 @@ async function probeOne({ claim, fault, defenders, discovered, allTests, iso, is
     detail.independence = classifyIndependence({ dir: historyDir, ref: historyRef, targetFile: toRepoPath(fault.file), defenders: (killers.length ? killers : defenders).map(toRepoPath) });
   }
 
+  // Why a survivor on a write path was missed: each defender that mocks the
+  // persistence layer, with its assertion mix. Descriptive, never predictive —
+  // it is attached to a verdict already reached and selects nothing. The sweep
+  // document carried this alone until claimspec v1 admitted it to the evidence.
+  const allSignals = [...signals, ...persistenceSignalsFor({ verdict, fault, defenders, projectDir: iso.projectDir })];
+
   return {
     fingerprint: fingerprint({ claimId: claim.id, subjectId: fault.id, file: fault.file, verdict }),
     claim: { id: claim.id, statement: claim.statement, severity: claim.severity, source: claim.source, producedBy: claim.producedBy },
     subject,
     verdict,
     detail,
-    defenders: { requested: claim.defendedBy ?? [], resolved: defenders, nocover: defenders.length === 0, ...(discovered ? { discovered: true } : {}), ...(byRunner ? { byRunner } : {}), ...(mocking.length ? { mocking } : {}), ...(signals.length ? { signals } : {}) },
+    defenders: { requested: claim.defendedBy ?? [], resolved: defenders, nocover: defenders.length === 0, ...(discovered ? { discovered: true } : {}), ...(byRunner ? { byRunner } : {}), ...(mocking.length ? { mocking } : {}), ...(allSignals.length ? { signals: allSignals } : {}) },
     inputs,
     rank: rank({ severity: claim.severity, sourceKind: claim.source.kind, blast, independence: detail.independence?.class }),
   };

package/src/probe/pyimports.mjs

@@ -49,11 +49,18 @@ export function pyModuleName(projectDir, rel) {
  * `from x import (a, b)` collapsed onto one line so the names are visible.
  */
 function logicalLines(source) {
-  const raw = source.split('\n');
+  // A trailing comment is stripped from every physical line BEFORE anything
+  // is joined or split. An import statement carries no string literal, so a
+  // `#` on one always starts a comment — and `from pkg import cli, demo  # noqa: E402`
+  // is the idiom of every src-layout test that inserts into sys.path before
+  // importing. Measured on a real suite: the comment was kept inside the LAST
+  // name, which then failed the identifier test, so `demo` was never seen and
+  // its tests were reported as no cover. 72 import lines in one suite.
+  const raw = source.split('\n').map((l) => l.replace(/#.*$/, ''));
   const out = [];
   for (let i = 0; i < raw.length; i++) {
     let line = raw[i];
-    if (COMMENT.test(line)) continue;
+    if (!line.trim()) continue;
     while (/\\\s*$/.test(line) && i + 1 < raw.length) line = line.replace(/\\\s*$/, ' ') + raw[++i];
     if (/^\s*from\s/.test(line) && line.includes('(') && !line.includes(')')) {
       // Bounded: a malformed file must not make this loop to the end of a large source.

package/src/scaffold/producers.python.mjs

@@ -60,6 +60,54 @@ function isIncomplete(line) {
   return depth > 0;
 }
 
+/**
+ * The bracket depth at the START of every line, for the whole file.
+ *
+ * `isIncomplete()` answers "does this line leave a bracket open"; this answers
+ * the other half, "does this line sit inside one opened above it". Measured on
+ * a real Python CLI: 77 of 600 proposals were a `statement-deleted` on a
+ * continuation line — `help="...")` inside an `add_argument(` — and none of
+ * them compiled. The tokenizer's exact depth agreed on 74 of the 77 and
+ * flagged no valid proposal: a dict entry or a call argument is inside a
+ * bracket by definition and keeps its own producer.
+ *
+ * Line-oriented, no AST: triple-quoted strings are tracked across lines so a
+ * docstring's parentheses cannot leave the rest of the file "inside" forever,
+ * and single-line strings and comments are skipped. Memoised per `lines`
+ * array because the scaffold calls the producer once per line.
+ */
+const DEPTHS = new WeakMap();
+export function depthBefore(lines) {
+  if (DEPTHS.has(lines)) return DEPTHS.get(lines);
+  const out = new Array(lines.length);
+  let depth = 0;
+  let triple = null;
+  for (let i = 0; i < lines.length; i++) {
+    out[i] = depth;
+    const line = lines[i];
+    for (let j = 0; j < line.length;) {
+      if (triple) {
+        if (line.startsWith(triple, j)) { triple = null; j += 3; } else j += line[j] === '\\' ? 2 : 1;
+        continue;
+      }
+      const ch = line[j];
+      if (ch === '#') break;
+      if (line.startsWith('"""', j) || line.startsWith("'''", j)) { triple = line.slice(j, j + 3); j += 3; continue; }
+      if (ch === '"' || ch === "'") {
+        let k = j + 1;
+        while (k < line.length && line[k] !== ch) k += line[k] === '\\' ? 2 : 1;
+        j = k + 1; // an unterminated string runs to the end of the line
+        continue;
+      }
+      if (ch === '(' || ch === '[' || ch === '{') depth++;
+      else if (ch === ')' || ch === ']' || ch === '}') depth = Math.max(0, depth - 1);
+      j++;
+    }
+  }
+  DEPTHS.set(lines, out);
+  return out;
+}
+
 /** The function a `def` line opens, or null. */
 export function functionHead(line) {
   const m = DEF_LINE.exec(line);
@@ -166,9 +214,13 @@ export function proposalsForLine(lines, i, ctx = {}) {
   if (!line.trim() || COMMENT.test(line) || DEFINITION.test(line)) return out;
   const params = ctx.params ?? new Set();
   const indent = ' '.repeat(indentOf(line) ?? 0);
+  // A line inside a bracket opened above it is an argument or an entry, never
+  // a statement: `pass` there does not parse. The shapes that keep their own
+  // producers on such a line (a dropped field, a swapped argument) are below.
+  const inside = depthBefore(lines)[i] > 0;
 
   const ifm = IF_LINE.exec(line);
-  if (ifm && isGuard(ifm[4], lines, i)) {
+  if (!inside && ifm && isGuard(ifm[4], lines, i)) {
     if (ifm[4]) {
       // `if not allowed: raise …` — the whole guard is this one line.
       out.push({ faultClass: 'statement-deleted', description: `Guard removed: \`${line.trim()}\` no longer runs.`, replace: `${indent}pass` });
@@ -183,7 +235,7 @@ export function proposalsForLine(lines, i, ctx = {}) {
     out.push({ faultClass: 'return-altered', description: `Check always passes: \`return ${rm[2]}\` becomes \`return True\`.`, replace: `${rm[1]}return True` });
   }
 
-  const complete = !isIncomplete(line);
+  const complete = !inside && !isIncomplete(line);
   if (complete && CHECK_CALL.test(line)) {
     out.push({ faultClass: 'call-removed', description: `Check call removed: \`${line.trim()}\` no longer runs.`, replace: `${indent}pass` });
   } else if (complete && MUTATION.test(line)) {

package/src/supply/persistence.mjs

@@ -38,6 +38,7 @@
  */
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { onWritePath } from './select.mjs';
 
 /**
  * Module specifiers that mean "the database". A project-local path counts when
@@ -158,6 +159,25 @@ export function persistenceSignals(projectDir, defenders) {
   return defenders.map((d) => analyzePersistence(projectDir, d)).filter(Boolean);
 }
 
+/**
+ * The persistence signals ONE EVIDENCE RECORD may carry, or none.
+ *
+ * The rule the sweep document already enforces, now applied where the record
+ * is written: the signal explains a SURVIVOR whose fault sits on the write
+ * path, and nothing else. On a kill it explains nothing; off the write path a
+ * loose mock assertion is not evidence of anything; on `nocover` or
+ * `unverifiable` the question was never asked. Reporting it anywhere else is
+ * the non-actionable noise that gets a check switched off.
+ *
+ * `analyze` is injected so the rule is testable without a filesystem; the
+ * probe passes the scratch tree, where the defenders are the project's own.
+ */
+export function persistenceSignalsFor({ verdict, fault, defenders, projectDir }, analyze = persistenceSignals) {
+  if (verdict !== 'survived') return [];
+  if (!onWritePath(fault)) return [];
+  return analyze(projectDir, defenders);
+}
+
 /**
  * One line an agent can act on, in the register `hintFor()` uses.
  *

package/src/supply/select.mjs

@@ -89,6 +89,35 @@ export function onWritePath(fault) {
   return PERSISTENCE_CALL.test(line) || PAYLOAD_KEY.test(line) || PERSISTENCE_CALL.test(fault.description ?? '');
 }
 
+/**
+ * Is this proposal a purely presentational JSX element — the arid class this
+ * tool actually has?
+ *
+ * Google suppresses "arid" nodes nobody would write a test for (logging,
+ * timeouts, flags). Measured here on 2026-09-22, those account for under 1% of
+ * proposals: the producers are shape-targeted and rarely land on a log line.
+ * What IS material is this: on a 14-file UI diff, 150 of 510 proposals were an
+ * `element-removed` on an icon (`<X />`) or a static wrapper (`<div>`, `<p>`
+ * with no expression and no handler). The ranker spent 29 of 30 slots on that
+ * class, 7 of the 10 survivors were of this shape, and because the ordering
+ * learns from survival those survivors then teach it to rank the class higher.
+ *
+ * Line-oriented, like every producer. An icon is a self-closing PascalCase
+ * element whose props are only sizing and styling; a static wrapper is a
+ * layout or text tag whose own line carries no `{expression}` and no
+ * interactive or test-facing attribute. Anything else — a component, an
+ * `<img>`, a `<label>`, an element with a handler or dynamic children — is a
+ * real proposal and stays.
+ */
+const ICON_ELEMENT = /^\s*<[A-Z]\w*(?:\s+(?:size|className|strokeWidth|aria-hidden|color|width|height|fill)(?:=(?:"[^"]*"|\{[^}]*\}))?)*\s*\/>\s*$/;
+const WRAPPER_ELEMENT = /^\s*<(?:div|span|p|h[1-6]|section|header|footer|main|nav|ul|ol|li|small|strong|em|b|i|hr|br)\b/;
+const INTERACTIVE_ATTR = /\b(?:on[A-Z]\w*=|href=|role=|aria-(?!hidden)\w+=|data-testid=|htmlFor=|tabIndex=)/;
+export function presentational(fault) {
+  if (fault.faultClass !== 'element-removed') return false;
+  const line = fault.find ?? '';
+  return ICON_ELEMENT.test(line) || (WRAPPER_ELEMENT.test(line) && !line.includes('{') && !INTERACTIVE_ATTR.test(line));
+}
+
 /** The boost a write-path fault gets. Additive, not multiplicative: it must not be able to overtake a measured 1.0. */
 const WRITE_PATH_BONUS = 0.25;
 
@@ -109,13 +138,17 @@ export const capFor = (fileCount, perFile = 7) => Math.max(perFile, fileCount *
  *
  * `candidates` are `{ claim, fault }` pairs — the claim is carried so the
  * caller can rebuild a claims document from the selection without a second
- * lookup. Returns the selection, everything deferred, and the per-class tally
- * a report needs to explain itself.
+ * lookup. Returns the selection, everything deferred, everything set aside as
+ * presentational, and the per-class tally a report needs to explain itself.
+ * The three lists partition the candidates: nothing is dropped without a name.
  */
 export function selectFaults(candidates, { cap, table } = {}) {
   const limit = Number.isInteger(cap) && cap > 0 ? cap : capFor(new Set(candidates.map((c) => c.fault.file)).size);
-  const ranked = candidates
-    .map((c) => ({ ...c, score: scoreOf(c.fault, { table }), writePath: onWritePath(c.fault) }))
+  const all = candidates.map((c) => ({ ...c, score: scoreOf(c.fault, { table }), writePath: onWritePath(c.fault) }));
+  // Set aside, never silently: a presentational element is not worth a probe
+  // run, and a survivor on one would teach the ordering the wrong lesson.
+  const presentationalList = all.filter((c) => presentational(c.fault));
+  const ranked = all.filter((c) => !presentational(c.fault))
     // Deterministic to the last tie: score, then file, then line, then id.
     // Two runs of the same sweep on the same tree are the same sweep.
     .sort((a, b) =>
@@ -158,11 +191,11 @@ export function selectFaults(candidates, { cap, table } = {}) {
   const taken = new Set(selected);
   const deferred = ranked.filter((r) => !taken.has(r));
   const byClass = {};
-  for (const r of ranked) {
+  for (const r of all) {
     const e = (byClass[r.fault.faultClass] ??= { proposed: 0, selected: 0, writePath: 0 });
     e.proposed += 1;
     if (r.writePath) e.writePath += 1;
   }
   for (const r of selected) byClass[r.fault.faultClass].selected += 1;
-  return { selected, deferred, cap: limit, byClass };
+  return { selected, deferred, presentational: presentationalList, cap: limit, byClass };
 }

package/src/sweep/sweep.mjs

@@ -38,7 +38,7 @@ import { selectFaults, onWritePath, capFor } from '../supply/select.mjs';
 import { learnedProductivity } from '../supply/feedback.mjs';
 import { loadConcerns, concernById, targetsFor, filterByConcern } from '../supply/concerns.mjs';
 import { saveSurface } from '../supply/savepath.mjs';
-import { persistenceSignals, persistenceHint, provabilitySummary } from '../supply/persistence.mjs';
+import { persistenceHint, provabilitySummary } from '../supply/persistence.mjs';
 import { probe } from '../probe/probe.mjs';
 import { discoverDefenders } from '../probe/discover.mjs';
 import { hintFor } from '../brief/brief.mjs';
@@ -109,6 +109,27 @@ export function sortFindings(findings) {
 /** How many findings a sweep is willing to fail on. */
 export const gatingCount = (findings) => findings.filter((f) => GATING.has(f.verdict)).length;
 
+/**
+ * The `selection` block of the document: every proposal accounted for.
+ *
+ * Pure and exported for the same reason as `findingFrom`: the arithmetic that
+ * proves nothing was hidden — proposed = probed + deferred + set aside — is a
+ * rule you can state in one line, and the validator that checks it is not the
+ * engine that has to satisfy it.
+ */
+export function summarizeSelection(selection, { proposed, outOfScope = 0 }) {
+  const presentationalCount = selection.presentational?.length ?? 0;
+  return {
+    proposed,
+    ...(outOfScope ? { outOfScope } : {}),
+    selected: selection.selected.length,
+    deferred: selection.deferred.length,
+    ...(presentationalCount ? { presentational: presentationalCount } : {}),
+    cap: selection.cap,
+    byClass: selection.byClass,
+  };
+}
+
 /** A concern named on the command line that this project does not declare. */
 export class ConcernError extends Error {}
 
@@ -254,7 +275,10 @@ export async function sweep({
   // second scan; `line` and `find` live on the draft, not on the evidence.
   const draftOf = new Map(selection.selected.map(({ claim, fault }) => [`${claim.id}/${fault.id}`, fault]));
 
-  const signalsFor = (r) => persistenceSignals(projectDir, r.defenders?.resolved ?? []);
+  // The probe attaches the persistence signal to the record itself now
+  // (claimspec v1 evidence, `defenders.signals`); the finding repeats what the
+  // record says rather than re-deriving it, so the two can never disagree.
+  const signalsFor = (r) => (r.defenders?.signals ?? []).filter((s) => s.signal === 'persistence-payload-unasserted');
   const counts = {};
   const findings = [];
   for (const r of evidence.records) {
@@ -281,14 +305,7 @@ export async function sweep({
       swept: drafts.length,
       ...(skipped.length ? { skipped } : {}),
     },
-    selection: {
-      proposed: relevant.length,
-      ...(candidates.length !== relevant.length ? { outOfScope: candidates.length - relevant.length } : {}),
-      selected: selection.selected.length,
-      deferred: selection.deferred.length,
-      cap: selection.cap,
-      byClass: selection.byClass,
-    },
+    selection: summarizeSelection(selection, { proposed: relevant.length, outOfScope: candidates.length - relevant.length }),
     counts,
     ordering: { observed: learned.observed, sources: learned.sources },
     // Carried, not written here: the caller owns I/O. Persisting it is what
@@ -342,6 +359,9 @@ export function renderSweep(doc, { limit = 20 } = {}) {
   // A narrow concern must not look like a quiet one: the producers found these,
   // and this concern is not about them.
   if (selection.outOfScope) out.push(`  ${selection.outOfScope} further proposal${selection.outOfScope === 1 ? ' was' : 's were'} outside this concern's fault classes.`);
+  // The arid class this tool has. Set aside and said so: a count nobody prints
+  // is a proposal nobody made.
+  if (selection.presentational) out.push(`  ${selection.presentational} presentational element${selection.presentational === 1 ? '' : 's'} (icons, static wrappers) set aside: nobody writes a test for those, and a survivor there would teach the ordering the wrong lesson.`);
   // An ordering nobody can trace is a number nobody should trust.
   if (doc.ordering) {
     out.push(doc.ordering.observed === 0

package/src/util/glob.mjs

@@ -11,7 +11,11 @@ import { join } from 'node:path';
 // the application — including its writes and its tests — so a surface scan of a
 // real app counted the same code twice and a defender glob could match a
 // compiled chunk. The promise was right and the list was short.
-const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'coverage', '.testguard',
+// `.claude` holds agent tooling and, under `.claude/worktrees/`, whole nested
+// checkouts of OTHER branches. Measured: discovery on a real repository returned
+// another branch's test file as a defender — a file the scratch tree cannot
+// even contain, because the directory is gitignored.
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'coverage', '.testguard', '.claude',
   '.next', '.nuxt', '.svelte-kit', '.output', '.turbo', '.parcel-cache', '.angular', '.astro',
   'build', 'out', '.cache', '.vercel', '.netlify',
   '__pycache__', '.venv', 'venv', 'site-packages', '.tox', '.nox',