@ericrisco/rsc 3.0.10 → 3.0.12

package/README.md

@@ -232,6 +232,14 @@ Every turn takes exactly one lane, and your agent names the one it took in a lin
 
 The agent says which lane it took and why, in one line. Ask for the other one and it switches.
 
+**The review only brings you what is real.** In SDD, `review` sends three adversarial reviewers at
+the diff (correctness, security, tests). They often find the same defect in different words, and a
+reviewer hunting for problems can overstate one. So before anything reaches you,
+`rsc review consolidate` merges the duplicates (same place, or the same quoted line), and every
+serious finding left goes to a fresh `finding-verifier` agent whose starting position is that the
+finding is false. It blocks the merge only if the verifier reproduces it or traces it. You get
+"11 reported → 4 unique → 2 confirmed", and the refuted ones are listed with the reason.
+
 **Isolation cleans itself up.** When a lane opens a branch or a worktree, you no longer have to
 remember to retire it: a `post-merge` hook does it the moment the work lands on the trunk, on both
 landing paths — a local merge and the pull after a forge merge. It removes only what is provably
@@ -423,6 +431,7 @@ rsc agent-model opencode openai/gpt-5   # pin the model the generated agents car
 rsc agent-model opencode inherit     # back to the session's model (OpenCode's default)
 rsc agents status                    # installed agents, and which ones you edited
 rsc agents reset developer           # take rsc's version of an agent you edited (yours is backed up first)
+rsc review consolidate c.md s.md t.md  # merge the review lenses' findings; serious ones go to finding-verifier
 rsc backups                          # list project-local snapshots
 rsc restore latest --dry-run         # preview restoring the newest snapshot
 rsc restore <snapshot-id>            # restore a project-local snapshot
@@ -884,7 +893,7 @@ The richer surfaces are intentionally narrower than skill support:
 | Windsurf, Cline, Roo | unsupported | yes | unsupported |
 | Antigravity, Zed, Continue, Amp, Jules, Aider | unsupported | unsupported | unsupported |
 
-`manifest.json` is the generated public inventory: 33 agents (4 base + 29
+`manifest.json` is the generated public inventory: 34 agents (5 base + 29
 selective specialists) and 53 command entries (20 fixed + 33 stack aliases).
 Unsupported means rsc writes nothing for that surface; it does not emulate a
 provider feature with an unverified file.

package/manifest.json

@@ -1,8 +1,8 @@
 {
-  "version": "3.0.10",
+  "version": "3.0.12",
   "counts": {
     "skills": 270,
-    "agents": 33,
+    "agents": 34,
     "commands": 53,
     "fixedCommands": 20
   },
@@ -5715,6 +5715,14 @@
         "fastapi"
       ]
     },
+    {
+      "id": "finding-verifier",
+      "description": "Adversarial verifier of review findings: takes ONE consolidated finding and tries to prove it false against the code. Default stance: the finding is false; only a reproduced or traced failure is CONFIRMED. Fresh context, edits nothing.",
+      "role": "refuter",
+      "tier": "balanced",
+      "tools": null,
+      "skills": []
+    },
     {
       "id": "flutter-build-resolver",
       "description": "Flutter build resolver: reproduces a failing build and applies the minimum verified repair. NOT widget review or package modernization.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "3.0.10",
+  "version": "3.0.12",
   "description": "A guided harness builder that turns your goal into a minimal, verified AI-agent setup using strict best practices.",
   "type": "module",
   "bin": {

package/scripts/install-apply.js

@@ -8,7 +8,7 @@ import { targetPaths, writeSkill, wireHook, unwireHook, baseDir, TARGET_IDS } fr
 import { shadowTarget } from '../targets/agents-md-shadow.js';
 import {
   targetHasAgents, reconcileAgents, agentPath, agentNames, writeAgentsDetailed,
-  resolveAgentNames, agentByName, allAgentNames, readDeveloperTier, writeDeveloperTier,
+  resolveAgentNames, withAgentCompanions, agentByName, allAgentNames, readDeveloperTier, writeDeveloperTier,
 } from '../targets/agents.js';
 import { projectOptOuts } from '../targets/opt-outs.js';
 import { readState, writeState } from './lib/state.js';
@@ -114,13 +114,13 @@ export function managedPathsForInstall({ skillIds, agentIds = [], target, home,
   if (targetHasAgents(target)) {
     const state = readState(paths.stateFile);
     const explicit = [...new Set([...(state.explicitAgents || readManifest(cwd)?.agents || []), ...agentIds])];
-    const desired = policy?.agents || resolveAgentNames([...Object.keys(state.skills || {}), ...skillIds], explicit);
+    const desired = withAgentCompanions(policy?.agents || resolveAgentNames([...Object.keys(state.skills || {}), ...skillIds], explicit));
     out.push(...desired.map((n) => agentPath(target, cwd, n)));
   }
   if (targetHasCommands(target)) {
     const state = readState(paths.stateFile);
     const explicit = [...new Set([...(state.explicitAgents || readManifest(cwd)?.agents || []), ...agentIds])];
-    const desiredAgents = policy?.agents || resolveAgentNames([...Object.keys(state.skills || {}), ...skillIds], explicit);
+    const desiredAgents = withAgentCompanions(policy?.agents || resolveAgentNames([...Object.keys(state.skills || {}), ...skillIds], explicit));
     const desiredCommands = resolveCommands({
       target,
       skills: policy ? skillIds : [...new Set([...Object.keys(state.skills || {}), ...skillIds])],
@@ -301,11 +301,11 @@ export async function applyInstall({ skillIds = [], agentIds = [], target, home,
   // naming an agent whose file never landed answers "you have it" for something absent.
   const inheritedExplicit = policy ? (state.explicitAgents || []) : (state.explicitAgents || readManifest(cwd)?.agents || []);
   const explicit = [...new Set([...inheritedExplicit, ...agentIds])].sort();
-  const desiredAgents = policy?.agents
+  const desiredAgents = withAgentCompanions(policy?.agents
     ? [...new Set([...policy.agents, ...explicit])].sort()
     : policy?.baseAgents === false
       ? explicit
-      : resolveAgentNames(Object.keys(state.skills || {}), explicit);
+      : resolveAgentNames(Object.keys(state.skills || {}), explicit));
   const previousAgents = state.agents || [];
   let keptAgents = [];
   if (targetHasAgents(target)) {

package/scripts/lib/review-findings.js

@@ -0,0 +1,175 @@
+// Consolidation of the refuter panel's findings — the deterministic half of `review`.
+//
+// Three fresh-context lenses attack the same diff, so they often report the SAME defect in three
+// different sentences, and the author spends triage time discovering that eleven findings are four.
+// Grouping them is an algorithm, not a judgement (P1), so it lives here and not in the skill's prose.
+// What survives grouping and is serious enough to block goes to `finding-verifier` — that half IS
+// judgement, and stays in the agent.
+//
+// Input: what the lenses emit — fenced ```json findings blocks inside their reports, or plain JSON.
+// Output: unique findings, highest severity first, each with the lenses that reported it and a
+// `verify` flag on the ones the verifier must try to refute before they may block.
+
+export const SEVERITIES = ['blocker', 'should-fix', 'nit', 'question'];
+const ALIASES = {
+  critical: 'blocker', high: 'blocker', blocking: 'blocker',
+  medium: 'should-fix', shouldfix: 'should-fix', 'should_fix': 'should-fix', major: 'should-fix',
+  low: 'nit', info: 'nit', minor: 'nit',
+};
+const rank = (s) => SEVERITIES.indexOf(s);
+export const DEFAULT_WINDOW = 3;
+
+export function normalizeSeverity(raw) {
+  const s = String(raw || '').trim().toLowerCase();
+  if (SEVERITIES.includes(s)) return s;
+  return ALIASES[s] || ALIASES[s.replace(/[-\s]/g, '')] || null;
+}
+
+const text = (v) => (typeof v === 'string' ? v.trim() : '');
+const normFile = (f) => text(f).replace(/\\/g, '/').replace(/^\.\//, '');
+const normEvidence = (e) => text(e).replace(/\s+/g, ' ').toLowerCase();
+
+// Pull every finding out of one source. A source is a lens report (markdown with fenced blocks) or a
+// JSON file. Anything unparseable is reported, never silently dropped: a lost finding is the one
+// failure a consolidation step must not add.
+export function parseFindings(raw, source = 'stdin') {
+  const findings = [];
+  const errors = [];
+  const take = (value, where) => {
+    const list = Array.isArray(value) ? value : (Array.isArray(value?.findings) ? value.findings : [value]);
+    for (const item of list) {
+      if (!item || typeof item !== 'object') { errors.push(`${where}: a finding must be an object`); continue; }
+      findings.push({ ...item, source });
+    }
+  };
+  const blocks = [...String(raw).matchAll(/```json[ \t]+findings[^\n]*\n([\s\S]*?)```/g)];
+  if (blocks.length) {
+    blocks.forEach((m, i) => {
+      try { take(JSON.parse(m[1]), `${source} block ${i + 1}`); }
+      catch (e) { errors.push(`${source} block ${i + 1}: not valid JSON (${e.message})`); }
+    });
+    return { findings, errors };
+  }
+  const trimmed = String(raw).trim();
+  if (!trimmed) return { findings, errors };
+  try { take(JSON.parse(trimmed), source); }
+  catch { errors.push(`${source}: no \`\`\`json findings block and not plain JSON`); }
+  return { findings, errors };
+}
+
+// The pre-report gate, checked instead of trusted: a blocker or should-fix with no location or no
+// concrete failure scenario is a suspicion, and a suspicion is a question. The downgrade is visible.
+export function normalizeFinding(f) {
+  const out = {
+    lens: text(f.lens) || text(f.source) || 'unknown',
+    severity: normalizeSeverity(f.severity),
+    file: normFile(f.file),
+    line: Number.isInteger(Number(f.line)) && Number(f.line) > 0 ? Number(f.line) : null,
+    claim: text(f.claim) || text(f.title) || text(f.summary),
+    failure_scenario: text(f.failure_scenario) || text(f.repro),
+    evidence: text(f.evidence),
+    notes: [],
+  };
+  if (!out.severity) {
+    out.notes.push(`severity "${f.severity ?? ''}" unknown → question`);
+    out.severity = 'question';
+  }
+  if (rank(out.severity) <= rank('should-fix')) {
+    const missing = [];
+    if (!out.file || !out.line) missing.push('file:line');
+    if (!out.failure_scenario) missing.push('failure_scenario');
+    if (missing.length) {
+      out.notes.push(`${out.severity} without ${missing.join(' and ')} → question`);
+      out.severity = 'question';
+    }
+  }
+  return out;
+}
+
+// Two findings are the same defect when they quote the same evidence, or when they point at the same
+// place (same file, lines within the window) AND say the same thing. Place alone is not enough: the
+// first real panel run put two different defects on adjacent lines (a discount applied to one unit,
+// and a missing 0..100 check), and merging them buried the second one where no verifier looked.
+// A missed merge costs one extra verification; a wrong merge hides a defect — so the bar is
+// conservative. "Say the same thing" is word overlap (Jaccard) of claim, or claim + failure scenario.
+const STOP = new Set('the and for with not that this its are was from any only one but has have into than then when which will can its'.split(' '));
+const words = (s) => new Set(String(s || '').toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 2 && !STOP.has(w)));
+function overlap(a, b) {
+  const A = words(a); const B = words(b);
+  let shared = 0;
+  for (const w of A) if (B.has(w)) shared += 1;
+  const union = A.size + B.size - shared;
+  return union ? shared / union : 0;
+}
+export const SAME_CLAIM = 0.2;
+export function similarity(a, b) {
+  return Math.max(overlap(a.claim, b.claim),
+    overlap(`${a.claim} ${a.failure_scenario}`, `${b.claim} ${b.failure_scenario}`));
+}
+function sameDefect(a, b, window) {
+  const ea = normEvidence(a.evidence);
+  if (ea.length >= 12 && ea === normEvidence(b.evidence)) return true;
+  const near = a.file && a.file === b.file && a.line && b.line && Math.abs(a.line - b.line) <= window;
+  return Boolean(near) && similarity(a, b) >= SAME_CLAIM;
+}
+
+export function consolidate(rawFindings, { window = DEFAULT_WINDOW } = {}) {
+  const items = rawFindings.map(normalizeFinding);
+  const parent = items.map((_, i) => i);
+  const find = (i) => (parent[i] === i ? i : (parent[i] = find(parent[i])));
+  for (let i = 0; i < items.length; i += 1) {
+    for (let j = i + 1; j < items.length; j += 1) {
+      if (sameDefect(items[i], items[j], window)) parent[find(j)] = find(i);
+    }
+  }
+  const groups = new Map();
+  items.forEach((it, i) => {
+    const root = find(i);
+    if (!groups.has(root)) groups.set(root, []);
+    groups.get(root).push(it);
+  });
+  const uniq = (xs) => [...new Set(xs.filter(Boolean))];
+  const merged = [...groups.values()].map((members) => {
+    const severity = SEVERITIES[Math.min(...members.map((m) => rank(m.severity)))];
+    const lines = members.map((m) => m.line).filter(Boolean);
+    return {
+      severity,
+      file: uniq(members.map((m) => m.file))[0] || '',
+      lines: lines.length ? [Math.min(...lines), Math.max(...lines)] : [],
+      lenses: uniq(members.map((m) => m.lens)).sort(),
+      claims: uniq(members.map((m) => m.claim)),
+      failure_scenarios: uniq(members.map((m) => m.failure_scenario)),
+      evidence: uniq(members.map((m) => m.evidence)),
+      notes: uniq(members.flatMap((m) => m.notes)),
+      reported: members.length,
+      verify: rank(severity) <= rank('should-fix'),
+    };
+  });
+  merged.sort((a, b) => rank(a.severity) - rank(b.severity)
+    || a.file.localeCompare(b.file) || (a.lines[0] || 0) - (b.lines[0] || 0));
+  merged.forEach((m, i) => { m.id = `F${i + 1}`; });
+  return {
+    reported: items.length,
+    unique: merged.length,
+    toVerify: merged.filter((m) => m.verify).length,
+    findings: merged,
+  };
+}
+
+const where = (f) => (f.file ? `${f.file}${f.lines.length ? `:${f.lines[0]}${f.lines[1] !== f.lines[0] ? `-${f.lines[1]}` : ''}` : ''}` : '(no location)');
+
+export function renderConsolidation(result, errors = []) {
+  const out = [
+    `${result.reported} finding(s) reported → ${result.unique} unique · ${result.toVerify} go to finding-verifier`,
+  ];
+  for (const f of result.findings) {
+    out.push('', `${f.id} [${f.severity}] ${where(f)} — ${f.claims[0] || '(no claim)'}`);
+    out.push(`   lenses: ${f.lenses.join(', ')}${f.reported > 1 ? ` (${f.reported} reports merged)` : ''}`);
+    for (const c of f.claims.slice(1)) out.push(`   also: ${c}`);
+    for (const s of f.failure_scenarios) out.push(`   failure: ${s}`);
+    for (const n of f.notes) out.push(`   note: ${n}`);
+    if (f.verify) out.push('   → verify: dispatch finding-verifier; it blocks only if CONFIRMED');
+  }
+  for (const e of errors) out.push('', `⚠️  ${e}`);
+  return out.join('\n');
+}

package/scripts/rsc.js

@@ -46,7 +46,7 @@ if (['--version', '-v', 'version'].includes(rawArgv[0])) {
   process.exit(0);
 }
 const GENERAL_HELP = [
-  'Use: npx @ericrisco/rsc onboard | reassess | add <id...> | install --profile <p> | consult "<text>" | list | capabilities [--full|gap-log] | audit | registry refresh | doctor | sync | agent-model <target> <model|inherit|status> | agents [status|reset <name|--all>] | memory <on|off|status|save|resume|learn|metrics> | sello <on|off|status|…> | worktrees [reap [path] [--confirm]] | backups | restore <id|latest> | upgrade | repair | uninstall <id...> | purge | help',
+  'Use: npx @ericrisco/rsc onboard | reassess | add <id...> | install --profile <p> | consult "<text>" | list | capabilities [--full|gap-log] | audit | registry refresh | doctor | sync | agent-model <target> <model|inherit|status> | agents [status|reset <name|--all>] | memory <on|off|status|save|resume|learn|metrics> | review consolidate [reports…] | sello <on|off|status|…> | worktrees [reap [path] [--confirm]] | backups | restore <id|latest> | upgrade | repair | uninstall <id...> | purge | help',
   'Any command takes --target <claude|codex|cursor|copilot|gemini|…> (comma-separate for several)',
   '   → without it, rsc uses the assistant already installed here; if two are, it asks instead of guessing.',
 ].join('\n');
@@ -77,7 +77,7 @@ const PURGE_HELP = [
 const GLOBAL_VALUE_FLAGS = new Set([
   '--target', '--technical-level', '--accompaniment', '--project-kind', '--goal', '--goal-base64', '--software-scope', '--workflow', '--accept-plan',
 ]);
-const COMMANDS = new Set(['onboard', 'reassess', 'add', 'install', 'consult', 'catalog', 'audit', 'list', 'doctor', 'memory', 'knowledge-sync', 'git-permissions', 'agent-model', 'agents', 'main', 'isolation', 'sync', 'backups', 'restore', 'upgrade', 'registry', 'worktrees', 'capabilities', 'sello', 'repair', 'uninstall', 'purge']);
+const COMMANDS = new Set(['onboard', 'reassess', 'add', 'install', 'consult', 'catalog', 'audit', 'list', 'doctor', 'memory', 'knowledge-sync', 'git-permissions', 'agent-model', 'agents', 'main', 'isolation', 'sync', 'backups', 'restore', 'upgrade', 'registry', 'worktrees', 'capabilities', 'review', 'sello', 'repair', 'uninstall', 'purge']);
 function positionalTokens(input) {
   const out = [];
   for (let i = 0; i < input.length; i++) {
@@ -1181,6 +1181,37 @@ async function main() {
       say('Use: npx @ericrisco/rsc registry refresh | registry status');
       return;
     }
+    case 'review': {
+      // `review consolidate` — the deterministic half of the refuter panel (P1): the three lenses
+      // often report one defect three ways, so grouping happens here, by location and evidence, and
+      // only the unique serious findings go on to `finding-verifier`, which is judgement.
+      const USE = 'Use: npx @ericrisco/rsc review consolidate [report.md|findings.json ...] [--json] [--window <lines>]\n  Without files it reads stdin. Each lens report carries its findings in ```json findings blocks.';
+      if (argv[1] !== 'consolidate') { say(USE); if (argv[1]) process.exitCode = 1; return; }
+      const { readFileSync } = await import('node:fs');
+      const R = await import('./lib/review-findings.js');
+      const w = flag('window');
+      const window = w === undefined ? R.DEFAULT_WINDOW : Number(w);
+      if (!Number.isInteger(window) || window < 0) { say(`rsc: --window takes a whole number of lines, got '${w}'.\n${USE}`); process.exitCode = 1; return; }
+      const rest = argv.slice(2);
+      const files = rest.filter((a, i) => !a.startsWith('--') && rest[i - 1] !== '--window');
+      const sources = [];
+      try {
+        if (files.length) for (const f of files) sources.push([readFileSync(f, 'utf8'), f]);
+        else if (!process.stdin.isTTY) sources.push([readFileSync(0, 'utf8'), 'stdin']);
+      } catch (e) { say(`rsc: cannot read ${e.path || 'stdin'} (${e.code || e.message}).`); process.exitCode = 1; return; }
+      if (!sources.length) { say(USE); process.exitCode = 1; return; }
+      const all = []; const errors = [];
+      for (const [raw, src] of sources) {
+        const parsed = R.parseFindings(raw, src);
+        all.push(...parsed.findings); errors.push(...parsed.errors);
+      }
+      const result = R.consolidate(all, { window });
+      if (argv.includes('--json')) say(JSON.stringify({ ...result, errors }, null, 2));
+      else say(R.renderConsolidation(result, errors));
+      // An unreadable block is a finding that may have been lost: say it with the exit code too.
+      if (errors.length) process.exitCode = 1;
+      return;
+    }
     case 'worktrees': {
       // The deterministic half of "the cleanup is the default". `ship` and the `worktrees` skill call
       // this instead of judging by eye, which is what turns a rule that was only ever written down

package/skills/code-review/SKILL.md

@@ -93,6 +93,8 @@ Read the surrounding code, trace the *value*, confirm the path is reachable.
 
 If you cannot trace it to a concrete value and a reachable sink, you do not yet have a finding.
 
+When several reviewers looked at the same diff, merge before reporting. Have each one end with a ` ```json findings ` block, run `npx @ericrisco/rsc review consolidate <reports…>`, and send each blocker it marks `verify` to the `finding-verifier` agent. That is the `review` skill's step, and it applies here unchanged.
+
 ## The verdict
 
 End every review with exactly one, plainly — no mushy middle:

package/skills/review/SKILL.md

@@ -128,7 +128,8 @@ gap deliberately with `--accept-partial-lenses` (it is recorded). Every approval
 
 **Lenses by risk tier** — tier 0 never reaches you (the gate passes docs/copy silently);
 tier 1 → run the single most relevant pass from the table above yourself; tier 2 → dispatch
-**three parallel fresh-context subagents** (correctness · security · tests-as-evidence), each told
+**three parallel fresh-context subagents** (`refuter-correctness` · `refuter-security` ·
+`refuter-tests`), each told
 to *refute* readiness, not confirm it. Fresh context is the point: a reviewer who inherits the
 implementer's context inherits its blind spots.
 
@@ -164,6 +165,26 @@ Two extra finding classes the four inputs unlock, neither reachable from a diff:
 - **Mapping, both directions** — an acceptance criterion with no test that can be made to fail, and
   a test pinning behaviour no criterion asked for.
 
+**Consolidate, then verify — before anything reaches the author.** Three lenses on one diff often
+report one defect three ways, and a lens hunting for something can overstate what it found. Two
+steps, in this order:
+
+1. **Group (deterministic).** Each lens ends its report with a ` ```json findings ` block. Save the
+   three reports and run `npx @ericrisco/rsc review consolidate <reports…>`. It merges findings on
+   the same file within 3 lines, or quoting the same evidence; keeps the highest severity and every
+   lens that saw it; and downgrades a blocker or should-fix with no `file:line` or failure scenario to
+   a question. Several lenses on one finding is a reason to look first, never a reason to raise its
+   severity.
+2. **Verify (judgement).** For each finding it marks `verify`, dispatch the **`finding-verifier`**
+   agent with that one finding plus the same four inputs, in parallel. It starts from "this is false"
+   and returns **CONFIRMED** (reproduced or traced, with the proof), **REFUTED** (cites the guard that
+   makes it impossible), or **UNPROVEN** (becomes a question). It never gets the lens's reasoning.
+
+Report the consolidated count honestly ("11 reported → 4 unique → 2 confirmed"), and list what was
+refuted and why: a refuted finding hidden from the author is a review nobody can audit. At tier 1
+(one pass, run by you) there is nothing to group, but a blocker still goes to `finding-verifier`
+before it blocks.
+
 **A finding blocks only if it survives all three filters** — no exceptions, and eagerness to
 find something is not evidence:
 
@@ -171,8 +192,8 @@ find something is not evidence:
    `--note "<finding>"` (they land in `.rsc/sello-findings.md`, surfaced by `doctor`) and
    suggest an issue; they never block this delivery.
 2. **Severity** — only `blocker` blocks. `should-fix`/`nit` → `--note`.
-3. **Evidence** — a `repro` or a concrete failure scenario. A suspicion without one is a
-   `[question]`, and questions don't block.
+3. **Evidence** — `finding-verifier` returned **CONFIRMED** with its proof. REFUTED is dropped (with
+   its reason in the report); UNPROVEN is a `[question]`, and questions don't block.
 
 **Fixing a blocker is budgeted, one attempt.** Before touching anything: estimate the fix and
 declare it — `npx @ericrisco/rsc sello budget --lines <N>`. After the fix:

package/targets/agents.js

@@ -75,7 +75,15 @@ ${REFUTER_FOUR_INPUTS}
 3. Did you inspect the relevant **caller, import, and relevant test**?
 4. Can the severity survive the **existing guards** you verified?
 
-If an answer is no, lower the severity or omit the finding. Every **HIGH or CRITICAL** needs the line and failure mode in the report. **Zero findings with an attack list is valid.**
+If an answer is no, lower the severity or omit the finding. Every **blocker or should-fix** needs the line and failure mode in the report. **Zero findings with an attack list is valid.**
+
+**Report findings in one shape, so the panel can be consolidated** — a fenced ${'`json findings`'} block holding an array (empty when you found nothing):
+
+${'```'}json findings
+[{ "lens": "<your lens>", "severity": "blocker|should-fix|nit|question", "file": "path/from/repo/root", "line": 42, "claim": "one sentence: what is wrong", "failure_scenario": "concrete input + state -> wrong result", "evidence": "the exact changed line, quoted" }]
+${'```'}
+
+${'`rsc review consolidate`'} merges what several lenses reported about the same place and sends each unique blocker or should-fix to ${'`finding-verifier`'}, whose job is to prove it false. A blocker or should-fix with no ${'`file`'}, ${'`line`'} or ${'`failure_scenario`'} is downgraded to a question there, mechanically.
 
 **Common false positives to reject:** an equivalent mutant with no diverging input; a documented dummy value that never reaches a sink; a deliberate boundary already enforced by a caller; generated/vendor code outside the change; style preference presented as correctness; and a theoretical race with no shared state or overlapping lifetime.
 
@@ -133,8 +141,46 @@ ${REFUTER_CONTRACT}
 
 **Check the mapping both ways:** every acceptance criterion needs a falsification procedure that can be made to fail, and every test should trace to something someone asked for.`,
   },
+  // The second half of ECC's orch-review, adapted: after `rsc review consolidate` collapses the panel's
+  // duplicates, every unique blocker/should-fix gets ONE more fresh context whose default is that the
+  // finding is false. A refuter attacks the diff; the verifier attacks the finding. Same asymmetry,
+  // pointed the other way — which is what stops an exaggerated lens from reaching the author as a blocker.
+  {
+    name: 'finding-verifier',
+    desc: 'Adversarial verifier of review findings: takes ONE consolidated finding and tries to prove it false against the code. Default stance: the finding is false; only a reproduced or traced failure is CONFIRMED. Fresh context, edits nothing.',
+    body: `You are the **finding verifier** for this project. ${'`review`'} hands you **one** finding that survived ${'`rsc review consolidate`'} — a blocker or should-fix some refuter lens reported against a diff. Your job is to **prove it false**. Your starting position is that it is false; the finding has to beat you.
+
+**Your inputs:** the finding (location, claim, failure scenario, evidence) plus the same four the lenses had —
+
+${REFUTER_FOUR_INPUTS}
+
+**You do NOT get** the refuter's reasoning or the builder's defence. Judge the claim against the code, not against either story.
+
+**How to try to kill it:**
+1. Read the cited line **and** its callers, guards and tests — the check that makes it impossible often lives two functions up, or in a caller that never passes that input.
+2. Try the failure scenario for real when you can: run the test, execute the command, or write a throwaway check in a temp directory outside the repo. An observed failure outranks any argument.
+3. Ask whether the change **caused** it. A defect that was already there is real but does not block this delivery.
+
+**Verdict — exactly one, with its proof:**
+- **CONFIRMED** — you reproduced it, or traced a reachable path from a concrete input to the wrong result. Quote the output or the path. Only this verdict may block.
+- **REFUTED** — you found what makes it impossible (the guard, the caller, the type, the test). Cite it with file and line.
+- **UNPROVEN** — neither: it becomes a question for the human, and questions never block.
+
+Also state whether the severity holds. A CONFIRMED finding whose blast radius is narrow is a should-fix, not a blocker — say so. You fix nothing and edit no file: your output is the verdict, the proof, and the commands you ran.`,
+  },
 ];
 
+
+// Agents that only make sense next to others, and so travel with them. A project whose accepted plan
+// lists the refuters explicitly (onboarded before 3.0.11) would otherwise get a `review` skill that
+// dispatches `finding-verifier` into a project that does not have it. Same panel the user accepted,
+// one more member — not a new decision, so it is added on sync rather than asked.
+const COMPANIONS = { 'finding-verifier': (names) => names.some((n) => n.startsWith('refuter-')) };
+export function withAgentCompanions(names = []) {
+  const extra = Object.entries(COMPANIONS).filter(([name, needs]) => !names.includes(name) && needs(names)).map(([name]) => name);
+  return extra.length ? [...names, ...extra] : names;
+}
+
 export const BASE_AGENT_NAMES = Object.freeze(AGENTS.map((agent) => agent.name));
 export { stackAgents, stackAgentNames, validateAgentCatalog };
 export const allAgentNames = () => [...BASE_AGENT_NAMES, ...stackAgentNames()];