fix: score source-reviewed findings without judge API calls

reviewbench/README.md

@@ -14,7 +14,7 @@ Native answers, file answers, explanation responses and coverage are saved per P
 
 Clone the pinned Perch and ReviewBench revisions in `manifest.json` into `perch/` and `upstream/`. Install ReviewBench's dependencies with `npm ci` in `upstream/`.
 
-Export `OPENAI_API_KEY` for Luna and explanations, `TYPESAFE_API_KEY` for Jev, and `OPENROUTER_API_KEY` for the benchmark's Sonnet 5 judge.
+Export `OPENAI_API_KEY` for Luna and explanations, `TYPESAFE_API_KEY` for Jev.
 
 ```sh
 docker build --platform linux/amd64 --build-arg PERCH_COMMIT=$(git -C perch rev-parse HEAD) -t perch-reviewbench:review -f adapter/Dockerfile .
@@ -33,6 +33,14 @@ python finish.py --run luna --model gpt-6-luna --workers 2
 python finish.py --run jev --model jev-latest --workers 2
 ```
 
-`finish.py` completes the review collection and invokes ReviewBench's evaluator with Claude Sonnet 5. Judge checkpoints support resumption. The summary records precision across all findings, recall against known reference issues, and their respective F1 values.
+`finish.py` completes the review collection without calling a judge API. Findings are judged against the saved source revision and reference issues. A match must identify the same underlying issue; a file or line overlap alone does not count. Unsupported claims are false positives. The reference labels stay unchanged.
+
+Source-review annotations identify the candidate index, TP/FP label, matching reference indices, severity, category and reasoning. They include SHA-256 hashes of both inputs and the source revision. `score_judgments.mjs` validates these annotations and uses ReviewBench's scoring functions without model calls:
+
+```sh
+node --import ./upstream/node_modules/tsx/dist/loader.mjs score_judgments.mjs luna judgments/luna upstream
+```
+
+The score includes only fully judged PRs and states whether all 219 have been judged. Codex judgments are identified separately from official leaderboard judging.
 
 Official leaderboard submissions go through the [ReviewBench portal](https://review-bench.ai/submit).

reviewbench/adapter/review-inputs.mjs

@@ -7,9 +7,16 @@ import { listTree, openBlobReader } from '/opt/perch/src/git.js';
 import { sourceChunks } from '/opt/perch/src/chunks.js';
 import { createSystemOne } from '/opt/perch/src/systemone.js';
 import { createMeter, metered } from '/opt/perch/src/meter.js';
-import { withTokenRetries } from '/opt/perch/src/tokens.js';
+import { withTokenRetries, textTokens } from '/opt/perch/src/tokens.js';
 import { FILE_QUESTIONS, fileFindings } from './review-questions.mjs';
 const exec = promisify(execFile);
+function bounded(text, budget) {
+  if (textTokens(text) <= budget) return { text, partial: false };
+  let low = 0, high = text.length;
+  while (low < high) { const mid = Math.ceil((low + high) / 2); if (textTokens(text.slice(0, mid)) <= budget) low = mid; else high = mid - 1; }
+  if (low && /[\uD800-\uDBFF]/.test(text[low - 1])) low--;
+  return { text: text.slice(0, low), partial: true };
+}
 export const numbered = (source, first = 1) => source.split('\n').map((line, index) => `L${first + index}| ${line}`).join('\n');
 export async function mapParallel(items, parallel, work) {
   let next = 0;
@@ -58,11 +65,14 @@ export async function reviewInputs({ repo, revision, base, scan, out, producer,
         const chunks = sourceChunks(source, { path, maxTokens: Math.max(128, Math.floor(budget / 3)) });
         const flags = [];
         for (const chunk of chunks) {
-          const state = { pr: { title: metadata.title, body: metadata.body }, file: { path, source: numbered(chunk.source, chunk.line) },
-            imports: fileRecord?.imports ?? [], related: evidence,
+          const title = bounded(metadata.title ?? '', Math.max(16, Math.floor(budget / 32)));
+          const body = bounded(metadata.body ?? '', Math.max(16, Math.floor(budget / 8)));
+          const shown = evidence.map(item => { const limited = bounded(item.source, Math.max(16, Math.floor(budget / 64))); return { path: item.path, source: limited.text, partial: limited.partial }; });
+          const state = { pr: { title: title.text, body: body.text, partial: title.partial || body.partial }, file: { path, source: numbered(chunk.source, chunk.line) },
+            imports: (fileRecord?.imports ?? []).slice(0, 20), related: shown,
             reading: { start_byte: chunk.startByte, end_byte: chunk.endByte, partial: chunks.length > 1 } };
           // Keep the diff bounded separately; it is PR context, not a substitute for the complete chunked source.
-          if (diff) state.change = diff.slice(0, Math.floor(budget * 1.5));
+          if (diff) { const change = bounded(diff, Math.max(16, Math.floor(budget / 12))); state.change = { source: change.text, partial: change.partial }; }
           const reply = await client.ask(state, FILE_QUESTIONS);
           const found = fileFindings(reply.answers, { path, line: chunk.line, endLine: chunk.endLine }, producer);
           flags.push(...found);

reviewbench/finish.py

@@ -1,27 +1,24 @@
-"""Run all ReviewBench PRs, retry failures, then use the official evaluator."""
-import argparse,json,os,shutil,subprocess,sys
+"""Complete reviews and optionally aggregate supplied judgments, without paid judge calls."""
+import argparse,json,subprocess,sys
 from pathlib import Path
 ROOT=Path(__file__).resolve().parent
 
 def main():
- parser=argparse.ArgumentParser();parser.add_argument('--run',default='run');parser.add_argument('--image',default='perch-reviewbench:review');parser.add_argument('--workers',type=int,default=2);parser.add_argument('--model',choices=['jev-latest','gpt-6-luna'],default='gpt-6-luna');args=parser.parse_args()
- run=ROOT/args.run
+ p=argparse.ArgumentParser()
+ p.add_argument('--run',default='run');p.add_argument('--image',default='perch-reviewbench:review')
+ p.add_argument('--workers',type=int,default=2);p.add_argument('--model',choices=['jev-latest','gpt-6-luna'],default='gpt-6-luna')
+ p.add_argument('--judgments',type=Path)
+ args=p.parse_args();run=ROOT/args.run
  for _ in range(3):
-  code=subprocess.run([sys.executable,str(ROOT/'run.py'),'--set','full','--run',args.run,'--image',args.image,'--workers',str(args.workers),'--model',args.model],check=False).returncode
+  code=subprocess.run([sys.executable,str(ROOT/'run.py'),'--set','full','--run',args.run,'--image',args.image,'--workers',str(args.workers),'--model',args.model]).returncode
   if code==0:break
  if code:raise SystemExit(code)
  status=json.loads((run/'status.json').read_text())
  if status['completed']!=219 or status['failed']:raise RuntimeError('Review coverage is incomplete')
- config=ROOT/'upstream/.judge';config.mkdir(exist_ok=True);shutil.copyfile(ROOT/'models.json',config/'models.json')
- (run/'scoring').mkdir(parents=True,exist_ok=True)
- env=os.environ.copy();env['PI_CODING_AGENT_DIR']=str(config)
- subprocess.run(['node','--import','tsx','scripts/eval/eval.ts','--candidate',str((run/'findings').resolve()),'--provider','openrouter','--model','anthropic/claude-sonnet-5','--output',str((run/'scoring/results.json').resolve()),'--concurrency','1'],cwd=ROOT/'upstream',env=env,check=True)
- result=json.loads((run/'scoring/results.json').read_text())
- if result['pr_count']!=219:raise RuntimeError('Judge coverage is incomplete')
- for average in ['micro','macro']:
-  metrics=result[average]['overall']
-  for kind in ['grounded','augmented']:
-   p=metrics[kind+'_precision'];r=metrics[kind+'_recall'];metrics[kind+'_f1']=2*p*r/(p+r) if p is not None and r is not None and p+r else 0
- (run/'summary.json').write_text(json.dumps({'prs':219,'micro':result['micro']['overall'],'macro':result['macro']['overall'],'candidate_usage':result['candidate_usage']},indent=2))
+ if args.judgments:
+  tsx=ROOT/'upstream/node_modules/tsx/dist/loader.mjs'
+  subprocess.run(['node','--import',str(tsx),str(ROOT/'score_judgments.mjs'),str(run),str(args.judgments),str(ROOT/'upstream')],check=True)
+ else:
+  print('All 219 reviews are saved. Ready for source review; no judge API was called.')
 
 if __name__=='__main__':main()

reviewbench/manifest.json

@@ -1,7 +1,7 @@
 {
   "reviewbench_commit": "c17b05be9c90b85a1fc012ce39e455e2d09a7255",
-  "perch_commit": "1482e040bc8cfae0231e840ece6a16a7f6944e6c",
-  "image": "sha256:b8ac8a077257847d2c63e549c1d86b8cbca26c49d2b9061f67906cd10234a89a",
+  "perch_commit": "67575f846d2b0c1d912fea8e0f0e9ba8941c4a24",
+  "image": "sha256:e73b739057ed778d3095dd9a6cadce676042def6ad3222e7e28c74555e252266",
   "protocol": "perch-review-inputs-explained",
   "models": [
     "jev-latest",
@@ -17,7 +17,8 @@
     "design": 60,
     "security": 70
   },
-  "judge": "openrouter/anthropic/claude-sonnet-5",
+  "judge": "Codex source review",
   "reference_labels_available_to_review": false,
-  "explanation_effort": "low"
-}
+  "explanation_effort": "low",
+  "automatic_judge_api": false
+}

reviewbench/models.json

@@ -1 +0,0 @@
-{"providers": {"openrouter": {"baseUrl": "https://openrouter.ai/api/v1", "api": "openai-completions", "apiKey": "OPENROUTER_API_KEY", "models": [{"id": "anthropic/claude-sonnet-5", "reasoning": true, "contextWindow": 1000000, "maxTokens": 8192, "cost": {"input": 2, "output": 10, "cacheRead": 0.2, "cacheWrite": 2.5}}]}}}

reviewbench/run.py

@@ -39,7 +39,7 @@ def main():
   if cached.exists() and not destination.exists():
    destination.parent.mkdir(parents=True,exist_ok=True)
    subprocess.run(['git','clone','--local','--quiet',str(cached),str(destination)],env=env,check=True)
-  cmd=[str(ROOT/'upstream/scripts/try-agent.sh'),args.image,'--set',args.set,'--pr',str(i),'-e','TYPESAFE_API_KEY','-e','OPENAI_API_KEY','-e',f'RB_IMAGE_ID={image_id}','-e','RB_AGENT=perch','-e',f'RB_CONFIG_MODEL={args.model}','-e','RB_CONFIG_SCAN_TYPES=defect,security,refactor,docs']
+  cmd=[str(ROOT/'upstream/scripts/try-agent.sh'),args.image,'--set',args.set,'--pr',str(i),'-e','NODE_OPTIONS=--max-old-space-size=16384','-e','TYPESAFE_API_KEY','-e','OPENAI_API_KEY','-e',f'RB_IMAGE_ID={image_id}','-e','RB_AGENT=perch','-e',f'RB_CONFIG_MODEL={args.model}','-e','RB_CONFIG_SCAN_TYPES=defect,security,refactor,docs']
   captured=taskwork/'captured';prior=taskwork/'out'/key
   if args.resume_explanations:
    # Keep the original paid native and file answers; only regenerate descriptions.
@@ -53,7 +53,7 @@ def main():
     # try-agent accepts environment but not an extra mount; replay uses the exact existing input checkout directly.
     pr=taskwork/'pr'/key;newout=taskwork/'out'/key;newout.mkdir(parents=True,exist_ok=True)
     cmd=['docker','run','--rm','--platform','linux/amd64','-v',str(destination)+':/work/repo:ro','-v',str(pr)+':/work/pr:ro','-v',str(newout)+':/work/out','-v',str(captured)+':/work/captured:ro',
-     '-e','GIT_CONFIG_COUNT=1','-e','GIT_CONFIG_KEY_0=safe.directory','-e','GIT_CONFIG_VALUE_0=*','-e','OPENAI_API_KEY','-e','TYPESAFE_API_KEY',
+     '-e','GIT_CONFIG_COUNT=1','-e','GIT_CONFIG_KEY_0=safe.directory','-e','GIT_CONFIG_VALUE_0=*','-e','OPENAI_API_KEY','-e','TYPESAFE_API_KEY','-e','NODE_OPTIONS=--max-old-space-size=16384',
      '-e',f'RB_NWO={t["nwo"]}','-e',f'RB_PR_NUMBER={t["pr_number"]}','-e',f'RB_BASE={t["base"]}','-e',f'RB_HEAD={t["head"]}',
      '-e','RB_REPO=/work/repo','-e','RB_PR_JSON=/work/pr/pr.json','-e','RB_OUT=/work/out/findings.json','-e','RB_AGENT=perch','-e',f'RB_IMAGE_ID={image_id}','-e',f'RB_CONFIG_MODEL={args.model}','-e','RB_CAPTURED_OUT=/work/captured',args.image]
    if output.exists(): output.unlink()

reviewbench/score_judgments.mjs

@@ -0,0 +1,51 @@
+// Aggregate supplied source-reviewed judgments. This program makes no API calls.
+import { readFile, readdir, mkdir, writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { resolve, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const [runArg, judgmentsArg, upstreamArg = 'upstream'] = process.argv.slice(2);
+if (!runArg || !judgmentsArg) throw new Error('Usage: score_judgments.mjs RUN JUDGMENTS [UPSTREAM]');
+const run = resolve(runArg), dir = resolve(judgmentsArg), upstream = resolve(upstreamArg);
+const { scorePR, aggregate } = await import(pathToFileURL(join(upstream, 'scripts/eval/scorer.ts')));
+const { resolveForScoring } = await import(pathToFileURL(join(upstream, 'scripts/lib/match-types.ts')));
+const hash = bytes => createHash('sha256').update(bytes).digest('hex');
+const scores = [], judging = [], direct = { tp: 0, fp: 0, golden_tp: 0, covered_golden_tp: 0 };
+for (const file of (await readdir(dir)).filter(f => f.endsWith('.json')).sort()) {
+  const annotation = JSON.parse(await readFile(join(dir, file), 'utf8'));
+  const cbytes = await readFile(join(run, 'findings', file));
+  const gbytes = await readFile(join(upstream, 'golden', file));
+  if (hash(cbytes) !== annotation.candidate_sha256 || hash(gbytes) !== annotation.golden_sha256) {
+    throw new Error(`${file}: judgments refer to a different candidate or reference snapshot; review again`);
+  }
+  const candidate = JSON.parse(cbytes), golden = JSON.parse(gbytes);
+  if (candidate.pr.head !== annotation.head || golden.pr.head !== annotation.head) throw new Error(`${file}: revision mismatch`);
+  const rows = annotation.findings;
+  if (rows.length !== candidate.findings.length) throw new Error(`${file}: incomplete judgments`);
+  const classifications = new Map();
+  const raw = rows.map((row, i) => {
+    if (row.candidate_index !== i || !['tp', 'fp'].includes(row.tp_fp) || !row.reason) throw new Error(`${file}: invalid judgment ${i}`);
+    for (const index of row.matched_golden_indices) {
+      if (!Number.isInteger(index) || index < 0 || index >= golden.findings.length) throw new Error(`${file}: invalid reference index`);
+      if (candidate.findings[i].file !== golden.findings[index].file) throw new Error(`${file}: cross-file match`);
+    }
+    classifications.set(i, { ...candidate.findings[i], tp_fp: row.tp_fp, severity: row.severity, category: row.category, tp_fp_justification: row.reason });
+    direct[row.tp_fp]++;
+    return { candidate_index: i, matched_golden_indices: row.matched_golden_indices };
+  });
+  const scoring = resolveForScoring(raw, golden.findings.length);
+  scores.push(scorePR({ pr_key: annotation.pr_key, golden: golden.findings, candidate_count: candidate.findings.length,
+    matched: scoring.matchedToGolden, unmatched: scoring.unmatched, covered_golden: scoring.coveredGolden,
+    unmatched_classifications: new Map([...scoring.unmatched].map(i => [i, classifications.get(i)])) }));
+  golden.findings.forEach((g, i) => { if (g.tp_fp === 'tp') { direct.golden_tp++; if (scoring.coveredGolden.has(i)) direct.covered_golden_tp++; } });
+  judging.push({ pr_key: annotation.pr_key, judge: annotation.judge, candidate_sha256: annotation.candidate_sha256 });
+}
+if (!scores.length) throw new Error('No completed source-reviewed PR judgments');
+const result = aggregate(scores);
+result.judging = judging;
+result.direct_source_review = { ...direct, false_negatives: direct.golden_tp - direct.covered_golden_tp,
+  precision: direct.tp + direct.fp ? direct.tp / (direct.tp + direct.fp) : null,
+  recall: direct.golden_tp ? direct.covered_golden_tp / direct.golden_tp : null };
+result.judge = 'Codex'; result.complete_benchmark = result.pr_count === 219;
+await mkdir(join(run, 'codex-scoring'), { recursive: true });
+await writeFile(join(run, 'codex-scoring/results.json'), JSON.stringify(result, null, 2) + '\n');
+console.log(JSON.stringify({ run, judged_prs: result.pr_count, complete_benchmark: result.complete_benchmark, ...result.direct_source_review }));