R7 Q7: a per-leaf question on a whole-repository review

core/agents/rule-hunter.md

@@ -120,8 +120,9 @@ question the table marks `judgment` reads `R<N> Q<n>: judgment → <findings>
 finding(s)`. When your budget ended before every counted hit was read, the receipt
 says so — `R<N> Q<n>: <judged> of <hits> hit(s) judged → <findings> finding(s)` — and
 the parent renders the review as partial; a receipt that carries the table's number
-over hits you did not read is a false verdict. A question with no receipt was not
-run. Then one tally line per rule you were given, always:
+over hits you did not read is a false verdict. A question its rule leaves unjudged
+on a whole-repository review reads `R<N> Q<n>: <hits> hit(s) → per-leaf, not
+judged`, as the rule spells it. A question with no receipt was not run. Then one tally line per rule you were given, always:
 `R<N>: <M> finding(s)`, or when that rule is clean:
 `R<N>: hunted clean — <K> hits judged, every question receipted over the full scope`.
 When the budget ended the hunt, each rule's tally is instead `R<N>: <M> finding(s) in

core/includes/rules/R7/falsifying-questions.md

@@ -59,6 +59,12 @@ Test files are the ones the repository's test runner picks up (`*{{.TestGlob}}`,
    and boolean conditions, check the table for a row at each boundary value and on
    each side of each condition, and hand-flip any operator whose rows are missing
    (`<` to `<=`, `>` to `>=`, a condition negated), run the leaf's tests, revert.
+   On a whole-repository review this question is not judged: a mutation run or a
+   hand check over every leaf does not fit a hunter's budget. The receipt reads
+   `R7 Q7: <hits> hit(s) → per-leaf, not judged`, R7's tally takes the partial form,
+   and the `not reached:` line names the three leaf directories with the most hits,
+   each as the review that judges it: `R7 Q7: /{{.CmdPrefix}}-review <dir>`. On a
+   scoped review the question is judged in full.
    Violation: any survivor on a leaf type that is not recorded as equivalent — a
    missing table row or dead logic; name the mutant (file, line, operator) and the
    row that would kill it.

core/skills/pre-commit-review/SKILL.md

@@ -151,7 +151,9 @@ finding blocks (`rule | file:line | evidence | fix pattern | effort`), one recei
 falsifying question of each rule it was given (`R<N> Q<n>: <hits> hit(s) → <findings>
 finding(s)` with the counts table's number; `R<N> Q<n>: judgment → <findings>
 finding(s)` for a judgment question; `R<N> Q<n>: <judged> of <hits> hit(s) judged →
-<findings> finding(s)` when its budget ended before every hit was read), one tally
+<findings> finding(s)` when its budget ended before every hit was read; `R<N> Q<n>:
+<hits> hit(s) → per-leaf, not judged` for a question its rule leaves to a scoped
+review on a whole-repository one), one tally
 per rule — or, for a rule file that did not read, `R<N>: rule unreadable at <path>`
 in the tally's place — and, when its budget ended the hunt, one `not reached:` line.
 A question with no receipt was not run. Findings, receipts, tallies (or unreadable

go-linter-driven-development/agents/rule-hunter.md

@@ -120,8 +120,9 @@ question the table marks `judgment` reads `R<N> Q<n>: judgment → <findings>
 finding(s)`. When your budget ended before every counted hit was read, the receipt
 says so — `R<N> Q<n>: <judged> of <hits> hit(s) judged → <findings> finding(s)` — and
 the parent renders the review as partial; a receipt that carries the table's number
-over hits you did not read is a false verdict. A question with no receipt was not
-run. Then one tally line per rule you were given, always:
+over hits you did not read is a false verdict. A question its rule leaves unjudged
+on a whole-repository review reads `R<N> Q<n>: <hits> hit(s) → per-leaf, not
+judged`, as the rule spells it. A question with no receipt was not run. Then one tally line per rule you were given, always:
 `R<N>: <M> finding(s)`, or when that rule is clean:
 `R<N>: hunted clean — <K> hits judged, every question receipted over the full scope`.
 When the budget ended the hunt, each rule's tally is instead `R<N>: <M> finding(s) in

go-linter-driven-development/rules/R7-test-placement.md

@@ -211,7 +211,7 @@ Answer each with evidence (`file:line`, command output) — never a bare verdict
    Violation: any hit — replace with channels/wait groups.
 
 7. **Does a mutant survive a leaf type's tests?**
-   Detect-grep: `(<=?|>=?) *('.'|-?[0-9]+|[a-zA-Z_.]*[Ll]en\b)|\b[Ll]en\([^)]*\) *(<=?|>=?|==|!=)`
+   Detect-grep: `(<=?|>=?) *('.'|-?[0-9]+|[a-zA-Z_.]*[Ll]en\b)|\b[Ll]en\([^)]*\) *(<=?|>=?|==|!=)` exclude-path=(^|/)cmd/,(^|/)main\.go$,(^|/)handlers/
    Detection: for each new or changed leaf package,
    `gremlins unleash ./path/to/leaf | grep -E '^\s*LIVED'`; skip orchestrators, the
    top rung and any package that does I/O. `gremlins` not on `PATH`: propose the
@@ -221,6 +221,12 @@ Answer each with evidence (`file:line`, command output) — never a bare verdict
    leaf's comparisons and boolean conditions, check the table for a row at each
    boundary value and on each side of each condition, and name the row that is
    missing.
+   On a whole-repository review this question is not judged: a mutation run or a
+   hand check over every leaf does not fit a hunter's budget. The receipt reads
+   `R7 Q7: <hits> hit(s) → per-leaf, not judged`, R7's tally takes the partial form,
+   and the `not reached:` line names the three leaf directories with the most hits,
+   each as the review that judges it: `R7 Q7: /go-ldd-review <dir>`. On a
+   scoped review the question is judged in full.
    Violation: any `LIVED` line on a leaf package that is not recorded as an
    equivalent mutant — a missing table row or dead logic; name the mutant (file,
    line, mutation) and the row that would kill it.

go-linter-driven-development/skills/pre-commit-review/SKILL.md

@@ -153,7 +153,9 @@ finding blocks (`rule | file:line | evidence | fix pattern | effort`), one recei
 falsifying question of each rule it was given (`R<N> Q<n>: <hits> hit(s) → <findings>
 finding(s)` with the counts table's number; `R<N> Q<n>: judgment → <findings>
 finding(s)` for a judgment question; `R<N> Q<n>: <judged> of <hits> hit(s) judged →
-<findings> finding(s)` when its budget ended before every hit was read), one tally
+<findings> finding(s)` when its budget ended before every hit was read; `R<N> Q<n>:
+<hits> hit(s) → per-leaf, not judged` for a question its rule leaves to a scoped
+review on a whole-repository one), one tally
 per rule — or, for a rule file that did not read, `R<N>: rule unreadable at <path>`
 in the tally's place — and, when its budget ended the hunt, one `not reached:` line.
 A question with no receipt was not run. Findings, receipts, tallies (or unreadable

lang/go/rules/R7/falsifying-questions.md

@@ -39,7 +39,7 @@
    Violation: any hit — replace with channels/wait groups.
 
 7. **Does a mutant survive a leaf type's tests?**
-   Detect-grep: `(<=?|>=?) *('.'|-?[0-9]+|[a-zA-Z_.]*[Ll]en\b)|\b[Ll]en\([^)]*\) *(<=?|>=?|==|!=)`
+   Detect-grep: `(<=?|>=?) *('.'|-?[0-9]+|[a-zA-Z_.]*[Ll]en\b)|\b[Ll]en\([^)]*\) *(<=?|>=?|==|!=)` exclude-path=(^|/)cmd/,(^|/)main\.go$,(^|/)handlers/
    Detection: for each new or changed leaf package,
    `gremlins unleash ./path/to/leaf | grep -E '^\s*LIVED'`; skip orchestrators, the
    top rung and any package that does I/O. `gremlins` not on `PATH`: propose the
@@ -49,6 +49,12 @@
    leaf's comparisons and boolean conditions, check the table for a row at each
    boundary value and on each side of each condition, and name the row that is
    missing.
+   On a whole-repository review this question is not judged: a mutation run or a
+   hand check over every leaf does not fit a hunter's budget. The receipt reads
+   `R7 Q7: <hits> hit(s) → per-leaf, not judged`, R7's tally takes the partial form,
+   and the `not reached:` line names the three leaf directories with the most hits,
+   each as the review that judges it: `R7 Q7: /{{.CmdPrefix}}-review <dir>`. On a
+   scoped review the question is judged in full.
    Violation: any `LIVED` line on a leaf package that is not recorded as an
    equivalent mutant — a missing table row or dead logic; name the mutant (file,
    line, mutation) and the row that would kill it.

lang/python/rules/R7/falsifying-questions.md

@@ -48,15 +48,27 @@
    yields the loop once is scheduling, not synchronization, and stays.
 
 7. **Does a mutant survive a leaf type's tests?**
-   Detect-grep: `(<=?|>=?) *('.'|-?[0-9]+|[a-zA-Z_.]*len\b)|\blen\([^)]*\) *(<=?|>=?|==|!=)`
+   Detect-grep: `(<=?|>=?) *('.'|-?[0-9]+|[a-zA-Z_.]*len\b)|\blen\([^)]*\) *(<=?|>=?|==|!=)` exclude-path=(^|/)handlers/,(^|/)__main__\.py$,(^|/)main\.py$,(^|/)cli\.py$
    Detection: for each new or changed leaf package, with `paths_to_mutate` under
    `[tool.mutmut]` naming that package only, `mutmut run` then `mutmut results`;
    skip orchestrators, the top rung and any module that does I/O. `mutmut` not
    installed: propose the install the mechanics bullet describes before hunting; no
    survivors from a run that did not execute is not a pass. In a read-only review,
    where no tests may run, take the hand check instead: list the leaf's comparisons
    and boolean conditions, check the parametrize table for a row at each boundary
-   value and on each side of each condition, and name the row that is missing.
+   value and on each side of each condition, and name the row that is missing. Open
+   the leaf's test file for this, also when the file is outside the review's scope.
+   Then read each error assertion of each leaf in scope, once per leaf file and not
+   only where a hit row points. An assertion that matches only a word all the
+   leaf's errors share (`match="tenant"`) cannot tell one error path from another, so
+   a removed check or a changed message survives.
+   On a whole-repository review this question is not judged: a mutation run or a
+   hand check over every leaf does not fit a hunter's budget. The receipt reads
+   `R7 Q7: <hits> hit(s) → per-leaf, not judged`, R7's tally takes the partial form,
+   and the `not reached:` line names the three leaf directories with the most hits,
+   each as the review that judges it: `R7 Q7: /{{.CmdPrefix}}-review <dir>`. On a
+   scoped review the question is judged in full.
    Violation: any surviving mutant on a leaf module that is not recorded as
-   equivalent — a missing parametrize row or dead logic; name the mutant (`mutmut
+   equivalent — a missing parametrize row, an assertion on part of the message, or
+   dead logic; name the mutant (`mutmut
    show <id>`) and the row that would kill it.

lang/ts-react/rules/R7/falsifying-questions.md

@@ -56,7 +56,7 @@
    synchronization, and stays.
 
 7. **Does a mutant survive a leaf type's tests?**
-   Detect-grep: `(<=?|>=?) *('.'|-?[0-9]+|[a-zA-Z_.]*\.length\b)|\.length *(<=?|>=?|===|!==)`
+   Detect-grep: `(<=?|>=?) *('.'|-?[0-9]+|[a-zA-Z_.]*\.length\b)|\.length *(<=?|>=?|===|!==)` exclude-path=\.tsx$,(^|/)components/,(^|/)hooks/,(^|/)context/
    Detection: for each new or changed leaf module, `npx stryker run` with a
    `stryker.config.mjs` whose `mutate` lists that module only (`.ts` leaves —
    parsers, reducers, a pure hook's helpers — never `.tsx` components, whose mutants
@@ -70,7 +70,18 @@
    run that did not execute is not a pass. In a read-only review, where no tests
    may run, take the hand check instead: list the leaf's comparisons and boolean
    conditions, check the `it.each` table for a row at each boundary value and on
-   each side of each condition, and name the row that is missing.
+   each side of each condition, and name the row that is missing. Open the leaf's
+   test file for this, also when the file is outside the review's scope. Then read
+   each error assertion. An assertion that matches only a word all the leaf's errors
+   share (`toThrow('tenant')`) cannot tell one error path from another, so a removed
+   check or a changed message survives.
+   On a whole-repository review this question is not judged: a mutation run or a
+   hand check over every leaf does not fit a hunter's budget. The receipt reads
+   `R7 Q7: <hits> hit(s) → per-leaf, not judged`, R7's tally takes the partial form,
+   and the `not reached:` line names the three leaf directories with the most hits,
+   each as the review that judges it: `R7 Q7: /{{.CmdPrefix}}-review <dir>`. On a
+   scoped review the question is judged in full.
    Violation: any surviving mutant on a leaf module that is not recorded as
-   equivalent — a missing `it.each` row or dead logic; name the mutant (file, line,
+   equivalent — a missing `it.each` row, an assertion on part of the message, or dead
+   logic; name the mutant (file, line,
    replacement from the `Survived` line) and the row that would kill it.

linter-driven-development/agents/rule-hunter.md

@@ -120,8 +120,9 @@ question the table marks `judgment` reads `R<N> Q<n>: judgment → <findings>
 finding(s)`. When your budget ended before every counted hit was read, the receipt
 says so — `R<N> Q<n>: <judged> of <hits> hit(s) judged → <findings> finding(s)` — and
 the parent renders the review as partial; a receipt that carries the table's number
-over hits you did not read is a false verdict. A question with no receipt was not
-run. Then one tally line per rule you were given, always:
+over hits you did not read is a false verdict. A question its rule leaves unjudged
+on a whole-repository review reads `R<N> Q<n>: <hits> hit(s) → per-leaf, not
+judged`, as the rule spells it. A question with no receipt was not run. Then one tally line per rule you were given, always:
 `R<N>: <M> finding(s)`, or when that rule is clean:
 `R<N>: hunted clean — <K> hits judged, every question receipted over the full scope`.
 When the budget ended the hunt, each rule's tally is instead `R<N>: <M> finding(s) in

linter-driven-development/rules/R7-test-placement.md

@@ -209,6 +209,12 @@ Test files are the ones the repository's test runner picks up (`*<test-file suff
    and boolean conditions, check the table for a row at each boundary value and on
    each side of each condition, and hand-flip any operator whose rows are missing
    (`<` to `<=`, `>` to `>=`, a condition negated), run the leaf's tests, revert.
+   On a whole-repository review this question is not judged: a mutation run or a
+   hand check over every leaf does not fit a hunter's budget. The receipt reads
+   `R7 Q7: <hits> hit(s) → per-leaf, not judged`, R7's tally takes the partial form,
+   and the `not reached:` line names the three leaf directories with the most hits,
+   each as the review that judges it: `R7 Q7: /ldd-review <dir>`. On a
+   scoped review the question is judged in full.
    Violation: any survivor on a leaf type that is not recorded as equivalent — a
    missing table row or dead logic; name the mutant (file, line, operator) and the
    row that would kill it.

linter-driven-development/skills/pre-commit-review/SKILL.md

@@ -155,7 +155,9 @@ finding blocks (`rule | file:line | evidence | fix pattern | effort`), one recei
 falsifying question of each rule it was given (`R<N> Q<n>: <hits> hit(s) → <findings>
 finding(s)` with the counts table's number; `R<N> Q<n>: judgment → <findings>
 finding(s)` for a judgment question; `R<N> Q<n>: <judged> of <hits> hit(s) judged →
-<findings> finding(s)` when its budget ended before every hit was read), one tally
+<findings> finding(s)` when its budget ended before every hit was read; `R<N> Q<n>:
+<hits> hit(s) → per-leaf, not judged` for a question its rule leaves to a scoped
+review on a whole-repository one), one tally
 per rule — or, for a rule file that did not read, `R<N>: rule unreadable at <path>`
 in the tally's place — and, when its budget ended the hunt, one `not reached:` line.
 A question with no receipt was not run. Findings, receipts, tallies (or unreadable

python-linter-driven-development/agents/rule-hunter.md

@@ -120,8 +120,9 @@ question the table marks `judgment` reads `R<N> Q<n>: judgment → <findings>
 finding(s)`. When your budget ended before every counted hit was read, the receipt
 says so — `R<N> Q<n>: <judged> of <hits> hit(s) judged → <findings> finding(s)` — and
 the parent renders the review as partial; a receipt that carries the table's number
-over hits you did not read is a false verdict. A question with no receipt was not
-run. Then one tally line per rule you were given, always:
+over hits you did not read is a false verdict. A question its rule leaves unjudged
+on a whole-repository review reads `R<N> Q<n>: <hits> hit(s) → per-leaf, not
+judged`, as the rule spells it. A question with no receipt was not run. Then one tally line per rule you were given, always:
 `R<N>: <M> finding(s)`, or when that rule is clean:
 `R<N>: hunted clean — <K> hits judged, every question receipted over the full scope`.
 When the budget ended the hunt, each rule's tally is instead `R<N>: <M> finding(s) in

python-linter-driven-development/rules/R7-test-placement.md

@@ -234,15 +234,27 @@ Answer each with evidence (`file:line`, command output) — never a bare verdict
    yields the loop once is scheduling, not synchronization, and stays.
 
 7. **Does a mutant survive a leaf type's tests?**
-   Detect-grep: `(<=?|>=?) *('.'|-?[0-9]+|[a-zA-Z_.]*len\b)|\blen\([^)]*\) *(<=?|>=?|==|!=)`
+   Detect-grep: `(<=?|>=?) *('.'|-?[0-9]+|[a-zA-Z_.]*len\b)|\blen\([^)]*\) *(<=?|>=?|==|!=)` exclude-path=(^|/)handlers/,(^|/)__main__\.py$,(^|/)main\.py$,(^|/)cli\.py$
    Detection: for each new or changed leaf package, with `paths_to_mutate` under
    `[tool.mutmut]` naming that package only, `mutmut run` then `mutmut results`;
    skip orchestrators, the top rung and any module that does I/O. `mutmut` not
    installed: propose the install the mechanics bullet describes before hunting; no
    survivors from a run that did not execute is not a pass. In a read-only review,
    where no tests may run, take the hand check instead: list the leaf's comparisons
    and boolean conditions, check the parametrize table for a row at each boundary
-   value and on each side of each condition, and name the row that is missing.
+   value and on each side of each condition, and name the row that is missing. Open
+   the leaf's test file for this, also when the file is outside the review's scope.
+   Then read each error assertion of each leaf in scope, once per leaf file and not
+   only where a hit row points. An assertion that matches only a word all the
+   leaf's errors share (`match="tenant"`) cannot tell one error path from another, so
+   a removed check or a changed message survives.
+   On a whole-repository review this question is not judged: a mutation run or a
+   hand check over every leaf does not fit a hunter's budget. The receipt reads
+   `R7 Q7: <hits> hit(s) → per-leaf, not judged`, R7's tally takes the partial form,
+   and the `not reached:` line names the three leaf directories with the most hits,
+   each as the review that judges it: `R7 Q7: /py-ldd-review <dir>`. On a
+   scoped review the question is judged in full.
    Violation: any surviving mutant on a leaf module that is not recorded as
-   equivalent — a missing parametrize row or dead logic; name the mutant (`mutmut
+   equivalent — a missing parametrize row, an assertion on part of the message, or
+   dead logic; name the mutant (`mutmut
    show <id>`) and the row that would kill it.

python-linter-driven-development/skills/pre-commit-review/SKILL.md

@@ -157,7 +157,9 @@ finding blocks (`rule | file:line | evidence | fix pattern | effort`), one recei
 falsifying question of each rule it was given (`R<N> Q<n>: <hits> hit(s) → <findings>
 finding(s)` with the counts table's number; `R<N> Q<n>: judgment → <findings>
 finding(s)` for a judgment question; `R<N> Q<n>: <judged> of <hits> hit(s) judged →
-<findings> finding(s)` when its budget ended before every hit was read), one tally
+<findings> finding(s)` when its budget ended before every hit was read; `R<N> Q<n>:
+<hits> hit(s) → per-leaf, not judged` for a question its rule leaves to a scoped
+review on a whole-repository one), one tally
 per rule — or, for a rule file that did not read, `R<N>: rule unreadable at <path>`
 in the tally's place — and, when its budget ended the hunt, one `not reached:` line.
 A question with no receipt was not run. Findings, receipts, tallies (or unreadable