fix(review): ban unexecuted mutation claims in coverage briefs (#9923)

* fix(review): ban unexecuted mutation claims in coverage briefs

Reader agents (Agent 5 and the test-matrix) described their
reading-based mutation analysis in execution-grade language, so
test-coverage findings could claim "mutant verified N/N green" while
their own gap notice admitted the suite could not run in the review
environment. Add witness discipline to both briefs: an unrung mutation
must be phrased as a reasoned hypothesis, never an executed result, and
a claim whose weight depends on an unperformed run carries
`witness: not run — <why>`.

* fix(review): align mutation-witness discipline across briefs (#9923)

Name both banned execution-grade phrasings in the test-matrix bullet
(Agent 5 already banned both), switch the nonstandard 'unrung' to the
codebase's established 'unrun' vocabulary, and pin the banned-phrase
list plus the false-capability guard for both briefs in the lockstep
test so a one-sided edit to either copy fails the suite.

* test(review): pin the hypothesis clause in the test-matrix lockstep

The lockstep test pinned the witness tag and both banned phrasings for
the test-matrix brief, but not its hypothesis-phrasing clause, while
Agent 5's block pins its half — deleting only that clause from the
test-matrix bullet shipped green. Pin the clause so both halves of the
discipline stay graded identically.

---------

Co-authored-by: qwen-code-dev-bot <qwen-code-dev@service.alibaba.com>

Author: wenshao

packages/cli/src/commands/review/agent-prompt.test.ts

@@ -2960,12 +2960,37 @@ describe('buildRoleBrief — every agent, not just the territory ones', () => {
     expect(p).toContain('A vacuous test is a **Suggestion**');
     expect(p).toContain('report **that behaviour** as the Critical');
     expect(p).not.toContain('is a **Critical**: a green-no-matter-what');
+    // The brief's mutation analysis is reading-based — executed verdicts
+    // belong to Agent 7's efficacy probe — so its mutation claims must be
+    // phrased as hypotheses or carry an explicit not-run witness, never the
+    // execution-grade "verified N/N green" (issue #9901). The rule anchors on
+    // ownership, not on a capability claim: the review-agent tool table is
+    // role-neutral and includes the shell, so "you have no runner" would be
+    // false and must never come back.
+    expect(p).toContain('An unrun mutation is a hypothesis');
+    expect(p).toContain('ships N/N green');
+    expect(p).toContain('verified N/N green');
+    expect(p).toContain('witness: not run —');
+    expect(p).toContain('Executed mutation verdicts belong to Agent 7');
+    expect(p).not.toContain('you have no runner');
     // The test-matrix agent applies Agent 5's rules to the behaviour/test pairing
     // it owns, so its severity must move in lockstep — a revert of just this bullet
     // would let the two agents grade the same inert test differently on one PR.
     expect(buildRoleBrief(PLAN, 'test-matrix')).toContain(
       'a **Suggestion** on its own, Critical only when',
     );
+    // And the witness discipline must move in lockstep too — test-matrix is the
+    // same reading-based mutation analysis, so it carries the same bar on
+    // execution-grade phrasing.
+    expect(buildRoleBrief(PLAN, 'test-matrix')).toContain('witness: not run —');
+    expect(buildRoleBrief(PLAN, 'test-matrix')).toContain('ships N/N green');
+    expect(buildRoleBrief(PLAN, 'test-matrix')).toContain('verified N/N green');
+    expect(buildRoleBrief(PLAN, 'test-matrix')).toContain(
+      'phrase an unrun mutation as a reasoned hypothesis',
+    );
+    expect(buildRoleBrief(PLAN, 'test-matrix')).not.toContain(
+      'you have no runner',
+    );
   });
 
   it('gives the verifier the probe capability — run a claim, self-check the probe, tag [probe]', () => {

packages/cli/src/commands/review/lib/agent-briefs.ts

@@ -492,7 +492,9 @@ Not your dimension: whether the code already exists elsewhere (3a) or whether th
 
 A vacuous test is a **Suggestion** — an ineffective guard is a gap, not a defect in the code, and grading it Critical merely for being the sole guard is the severity inflation the shared ladder is built to avoid (Agent 7's efficacy probe reports the very same inert test as a Suggestion, and Step 4 keeps the higher of the two). Escalate only the way this dimension always does: if the vacuous test lets a **specific incorrect behaviour** ship, report **that behaviour** as the Critical with the test as your evidence — naming the bug is the work, naming the gap is not; and a test that asserts the **opposite** of the intended behaviour, or was **weakened/disabled in this diff**, is already Critical under the existing rule.
 
-Before you call a test vacuous, rule out the **equivalent mutant** — a mutation that leaves observable behaviour unchanged is not a coverage gap, because *nothing* could discriminate it. If the branch you would flip is unreachable given an invariant the code already holds, or two paths are provably identical for every input the code can actually reach, the test is not weak; the mutation is unobservable by construction. Name the mutation you tried and the input that makes it observable — a surviving mutation is a finding only when a real input tells the mutant apart from the original.`,
+Before you call a test vacuous, rule out the **equivalent mutant** — a mutation that leaves observable behaviour unchanged is not a coverage gap, because *nothing* could discriminate it. If the branch you would flip is unreachable given an invariant the code already holds, or two paths are provably identical for every input the code can actually reach, the test is not weak; the mutation is unobservable by construction. Name the mutation you considered and the input that makes it observable — a surviving mutation is a finding only when a real input tells the mutant apart from the original.
+
+**An unrun mutation is a hypothesis — never write it as an executed result.** Executed mutation verdicts belong to Agent 7's efficacy probe; your analysis is reading-based. A mutation you only reasoned about reads "would likely survive, because <the assertion moves with the code>" — never "the mutation ships N/N green" or "mutant verified N/N green", which assert a run you did not do and a maintainer reads as observed. When a finding's weight depends on a run you did not do, carry \`witness: not run — <why>\` in the body, exactly as the verifier does for an unreachable claim.`,
   },
 
   '6a': {
@@ -593,7 +595,7 @@ Use \`Source: [build]\` or \`Source: [test]\`, never \`[review]\`.`,
 - **Map each behavioural change in the production code to the test that exercises it**, wherever that test lives.
 - **Flag behaviour/test pairs split across territories** — the change in one place, its only test weakened or deleted in another. That pairing is invisible to both of the agents who own those halves, which is the entire reason you exist.
 - Otherwise apply Agent 5's rules: name the specific untested scenario, never "coverage is low". A missing test is a **Suggestion**. **A test weakened, disabled, or deleted _in this diff_ so that new behaviour passes is Critical** — as is a test that asserts the opposite of the intended behaviour, because it will bless the very regression it was written to catch.
-- **Mutation-test the pairing, do not just confirm it exists:** for the test you paired to a change, name the mutation that should turn it red; a test that stays green under that mutation — both sides of its assertion move together (\`expect(undefined).toBe(undefined)\`), or it reads only the first of the sites the change spans — is **vacuous** — a **Suggestion** on its own, Critical only when it asserts the opposite of the intended behaviour, was weakened in this diff, or lets a **specific incorrect behaviour** ship (report that behaviour, not the gap).`,
+- **Mutation-test the pairing, do not just confirm it exists:** for the test you paired to a change, name the mutation that should turn it red; a test that stays green under that mutation — both sides of its assertion move together (\`expect(undefined).toBe(undefined)\`), or it reads only the first of the sites the change spans — is **vacuous** — a **Suggestion** on its own, Critical only when it asserts the opposite of the intended behaviour, was weakened in this diff, or lets a **specific incorrect behaviour** ship (report that behaviour, not the gap). Like Agent 5, your mutant analysis is reading-based: phrase an unrun mutation as a reasoned hypothesis ("would likely stay green because …"), never as an executed result ("the mutation ships N/N green" or "mutant verified N/N green"), and carry \`witness: not run — <why>\` when the claim needs a run you did not do.`,
   },
 
   'invariant-a': {