Show benchmark recall versus false-alert tradeoffs

README.md

@@ -22,113 +22,107 @@ Pairs come from open-source projects in Rust, JavaScript, TypeScript, Python, Go
 | [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | [Liquid decision API](https://api.liquid.ai/decisions/v1/systemone) (`d1:free`) |
 | [TypeLLM](https://typellm.ai/docs) | [TypeLLM API](https://api.typellm.ai/v1/generate) (`typellm-latest`) |
 
+<!-- BEGIN TRADEOFF_RESULTS -->
 
 ## Reading the results
 
-- **AP** measures how well scores rank actual issues across cutoffs.
-- **Alert floors:** A method alerts when any applicable issue score is strictly above the floor recorded for its run. Semantic lint uses a 70% run-wide floor. Per-row question packs and protocols are recorded in `results-current.jsonl`.
-- **Precision** is the share of alerts that are correct; **recall** is the share of actual issues found; **F1** combines both.
-- **TP**, **FP**, and **FN** are correct alerts, false alerts, and missed issues.
-- **Pair order** is the share of eligible repairs where the issue-bearing before method scores above the fixed after method. Ties do not count.
+Each curve shows how many labelled issues a model finds as its score cutoff changes. Moving right means more false alerts on labelled clean methods. Circles show the recorded Perch alert settings; a circle can sit off its score curve when a question has its own minimum score.
+
+The public tables rank models by **recall with no more than 5% of clean methods falsely alerted**. This is a comparison of saved score rankings, not a new deployed cutoff. The private tables show the recorded alert settings and rank by **TPR − FPR** (recall minus the false-alert rate). A model that alerts on every method scores zero on this measure. Costs are for the captured runs.
+
+Private method predictions stay private, so the curves use public predictions only. The lint public split has 214 clean methods: its 5% limit permits at most 10 false alerts. The bug and security limits permit 128 and 74 false alerts respectively.
 
 ## Bugs
 
 [Public pairs](https://huggingface.co/datasets/perchscan/bug-pairs-public)
 
-### Public — 2,220 pairs
+![Bugs recall versus false alerts](assets/bug-tradeoff.svg)
 
-| Model | AP | Precision | Recall | F1 | TP | FP | FN | Pair order | Inference cost |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | **47.3%** | 50.1% | 17.7% | 26.1% | 329 | 328 | 1,532 | 43.8% | $0.551 |
-| [TypeLLM](https://typellm.ai/docs) | 47.3% | 51.9% | 8.3% | 14.3% | 154 | 143 | 1,707 | 51.3% | $0.576 |
-| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 46.8% | 47.1% | 33.4% | 39.1% | 621 | 698 | 1,240 | **52.4%** | $0.239 |
-| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 46.6% | **53.9%** | 4.1% | 7.6% | 76 | **65** | 1,785 | 50.1% | Free tier |
-| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 44.6% | 43.9% | 43.0% | 43.4% | 800 | 1,023 | 1,061 | 44.9% | $0.239 |
-| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 43.8% | 44.7% | 25.3% | 32.3% | 471 | 583 | 1,390 | 45.0% | $0.182 |
-| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 42.1% | 42.2% | **81.9%** | **55.7%** | **1,525** | 2,087 | **336** | 45.3% | ~$0.210 |
+### Public — 2,220 pairs
 
-_Sorted by AP. Bold marks the best value in each quality column; lower FP and FN are better._
+| Model | Recall at ≤5% false alerts | Recall at current cutoff | False alerts / 1,000 clean at current cutoff | TPR − FPR at current cutoff | Inference cost |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 8.4% | 33.4% | 270.6 | 6.3% | $0.239 |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 8.1% | 17.7% | 127.2 | 5.0% | $0.551 |
+| [TypeLLM](https://typellm.ai/docs) | 7.6% | 8.3% | 55.4 | 2.7% | $0.576 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 7.2% | 4.1% | 25.2 | 1.6% | Free tier |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 6.5% | 43.0% | 396.7 | 3.3% | $0.239 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 5.3% | 25.3% | 226.1 | 2.7% | $0.182 |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 4.6% | 81.9% | 809.2 | 1.0% | ~$0.210 |
 
 ### Private — 498 pairs
 
-| Model | AP | Precision | Recall | F1 | TP | FP | FN | Pair order | Inference cost |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-| [TypeLLM](https://typellm.ai/docs) | **50.6%** | **59.3%** | 11.3% | 19.0% | 48 | 33 | 376 | **55.1%** | $0.129 |
-| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 48.7% | 56.4% | 5.2% | 9.5% | 22 | **17** | 402 | 49.6% | Free tier |
-| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 47.9% | 49.4% | 35.8% | 41.5% | 152 | 156 | 272 | 53.1% | $0.054 |
-| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 47.1% | 48.9% | 20.0% | 28.4% | 85 | 89 | 339 | 42.9% | $0.123 |
-| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 45.5% | 46.5% | 28.5% | 35.4% | 121 | 139 | 303 | 44.6% | $0.040 |
-| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 44.5% | 44.0% | 44.3% | 44.2% | 188 | 239 | 236 | 42.4% | $0.054 |
-| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 42.7% | 42.4% | **79.5%** | **55.3%** | **337** | 458 | **87** | 47.9% | ~$0.047 |
-
-_Sorted by AP. Bold marks the best value in each quality column; lower FP and FN are better._
+| Model | Recall at current cutoff | False alerts / 1,000 clean at current cutoff | TPR − FPR at current cutoff | Inference cost |
+| --- | ---: | ---: | ---: | ---: |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 35.8% | 272.7 | 8.6% | $0.054 |
+| [TypeLLM](https://typellm.ai/docs) | 11.3% | 57.7 | 5.6% | $0.129 |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 20.0% | 155.6 | 4.5% | $0.123 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 28.5% | 243.0 | 4.2% | $0.040 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 44.3% | 417.8 | 2.6% | $0.054 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 5.2% | 29.7 | 2.2% | Free tier |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 79.5% | 800.7 | -0.6% | ~$0.047 |
 
 ## Security
 
 [Public pairs](https://huggingface.co/datasets/perchscan/security-pairs-public)
 
-**Always-alert results:** CLM flags all 3,500 security methods across both splits; SemiF flags 3,499. Their 100% recall comes with 1,960 and 1,959 false alerts respectively, so their F1 scores do not indicate useful security detection.
+![Security recall versus false alerts](assets/security-tradeoff.svg)
 
 ### Public — 1,311 pairs
 
-| Model | AP | Precision | Recall | F1 | TP | FP | FN | Pair order | Inference cost |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | **51.5%** | 53.1% | 34.6% | 41.9% | 395 | 349 | 747 | 52.6% | $0.507 |
-| [TypeLLM](https://typellm.ai/docs) | 50.8% | **55.3%** | 27.8% | 37.0% | 318 | 257 | 824 | 52.0% | $0.566 |
-| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 49.4% | 47.8% | 55.6% | 51.4% | 635 | 693 | 507 | 52.2% | Free tier |
-| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 48.2% | 49.7% | 33.1% | 39.7% | 378 | 382 | 764 | **53.7%** | $0.208 |
-| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 47.6% | 48.6% | 21.0% | 29.3% | 240 | **254** | 902 | 43.7% | $0.251 |
-| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 43.9% | 43.6% | **100.0%** | **60.7%** | **1,142** | 1,479 | **0** | 46.2% | $0.208 |
-| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 42.9% | 43.6% | **100.0%** | 60.7% | **1,142** | 1,480 | **0** | 45.9% | ~$1.432 |
-
-_Sorted by AP. Bold marks the best value in each quality column; lower FP and FN are better._
+| Model | Recall at ≤5% false alerts | Recall at current cutoff | False alerts / 1,000 clean at current cutoff | TPR − FPR at current cutoff | Inference cost |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| [TypeLLM](https://typellm.ai/docs) | 9.5% | 27.8% | 173.6 | 10.5% | $0.566 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 8.8% | 21.0% | 171.6 | 3.9% | $0.251 |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 8.7% | 33.1% | 258.1 | 7.3% | $0.208 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 8.1% | 55.6% | 468.2 | 8.8% | Free tier |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 7.7% | 34.6% | 235.8 | 11.0% | $0.507 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 4.8% | 100.0% | 999.3 | 0.1% | $0.208 |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 4.6% | 100.0% | 1000.0 | 0.0% | ~$1.432 |
 
 ### Private — 439 pairs
 
-| Model | AP | Precision | Recall | F1 | TP | FP | FN | Pair order | Inference cost |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | **49.2%** | 49.4% | 21.9% | 30.3% | 87 | 89 | 311 | **51.5%** | $0.074 |
-| [TypeLLM](https://typellm.ai/docs) | 49.2% | **53.8%** | 8.8% | 15.1% | 35 | **30** | 363 | 50.3% | $0.203 |
-| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 48.9% | 50.6% | 20.6% | 29.3% | 82 | 80 | 316 | 40.2% | $0.182 |
-| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 47.8% | 49.5% | 34.2% | 40.4% | 136 | 139 | 262 | 45.5% | Free tier |
-| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 47.8% | 45.1% | 8.0% | 13.6% | 32 | 39 | 366 | 50.5% | $0.091 |
-| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 46.9% | 45.3% | **100.0%** | **62.4%** | **398** | 480 | **0** | 51.3% | ~$0.528 |
-| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 46.8% | 45.3% | **100.0%** | **62.4%** | **398** | 480 | **0** | 50.0% | $0.074 |
-
-_Sorted by AP. Bold marks the best value in each quality column; lower FP and FN are better._
+| Model | Recall at current cutoff | False alerts / 1,000 clean at current cutoff | TPR − FPR at current cutoff | Inference cost |
+| --- | ---: | ---: | ---: | ---: |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 34.2% | 289.6 | 5.2% | Free tier |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 20.6% | 166.7 | 3.9% | $0.182 |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 21.9% | 185.4 | 3.3% | $0.074 |
+| [TypeLLM](https://typellm.ai/docs) | 8.8% | 62.5 | 2.5% | $0.203 |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 100.0% | 1000.0 | 0.0% | ~$0.528 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 100.0% | 1000.0 | 0.0% | $0.074 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 8.0% | 81.2 | -0.1% | $0.091 |
 
 ## Perch Lint Bench
 
 [Public pairs](https://huggingface.co/datasets/perchscan/perch-lint-bench-public)
 
-### Public — 214 pairs
+![Perch Lint Bench recall versus false alerts](assets/lint-tradeoff.svg)
 
-| Model | AP | Precision | Recall | F1 | TP | FP | FN | Pair order | Inference cost |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | **95.0%** | **99.1%** | 50.0% | 66.5% | 107 | **1** | 107 | **96.3%** | $0.048 |
-| [TypeLLM](https://typellm.ai/docs) | 94.9% | 95.7% | **61.7%** | **75.0%** | **132** | 6 | **82** | 95.3% | $0.050 |
-| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 92.5% | 98.1% | 49.1% | 65.4% | 105 | 2 | 109 | 93.5% | Free tier |
-| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 87.0% | 91.1% | 52.8% | 66.9% | 113 | 11 | 101 | 86.4% | $0.018 |
-| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 79.6% | 81.7% | 50.0% | 62.0% | 107 | 24 | 107 | 88.3% | $0.014 |
-| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 50.5% | 50.9% | 38.8% | 44.0% | 83 | 80 | 131 | 51.4% | ~$0.010 |
-| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 50.0% | 50.7% | 32.2% | 39.4% | 69 | 67 | 145 | 56.5% | $0.018 |
+### Public — 214 pairs
 
-_Sorted by AP. Bold marks the best value in each quality column; lower FP and FN are better._
+| Model | Recall at ≤5% false alerts | Recall at current cutoff | False alerts / 1,000 clean at current cutoff | TPR − FPR at current cutoff | Inference cost |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 73.8% | 50.0% | 4.7 | 49.5% | $0.048 |
+| [TypeLLM](https://typellm.ai/docs) | 72.4% | 61.7% | 28.0 | 58.9% | $0.050 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 65.9% | 49.1% | 9.3 | 48.1% | Free tier |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 45.3% | 52.8% | 51.4 | 47.7% | $0.018 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 27.6% | 50.0% | 112.1 | 38.8% | $0.014 |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 6.1% | 38.8% | 373.8 | 1.4% | ~$0.010 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 2.3% | 32.2% | 313.1 | 0.9% | $0.018 |
 
 ### Private — 71 pairs
 
-| Model | AP | Precision | Recall | F1 | TP | FP | FN | Pair order | Inference cost |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-| [TypeLLM](https://typellm.ai/docs) | **94.4%** | 91.3% | **59.2%** | **71.8%** | **42** | 4 | **29** | **97.2%** | $0.016 |
-| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 94.3% | **97.4%** | 53.5% | 69.1% | 38 | **1** | 33 | 94.4% | $0.016 |
-| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 92.4% | 97.2% | 49.3% | 65.4% | 35 | **1** | 36 | **97.2%** | Free tier |
-| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 83.2% | 84.2% | 45.1% | 58.7% | 32 | 6 | 39 | 91.5% | $0.005 |
-| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 83.0% | 86.4% | 53.5% | 66.1% | 38 | 6 | 33 | 85.9% | $0.006 |
-| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 51.4% | 50.7% | 50.7% | 50.7% | 36 | 35 | 35 | 56.3% | ~$0.003 |
-| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 48.9% | 48.4% | 42.3% | 45.1% | 30 | 32 | 41 | 50.7% | $0.006 |
-
-_Sorted by AP. Bold marks the best value in each quality column; lower FP and FN are better._
+| Model | Recall at current cutoff | False alerts / 1,000 clean at current cutoff | TPR − FPR at current cutoff | Inference cost |
+| --- | ---: | ---: | ---: | ---: |
+| [TypeLLM](https://typellm.ai/docs) | 59.2% | 56.3 | 53.5% | $0.016 |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 53.5% | 14.1 | 52.1% | $0.016 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 49.3% | 14.1 | 47.9% | Free tier |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 53.5% | 84.5 | 45.1% | $0.006 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 45.1% | 84.5 | 36.6% | $0.005 |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 50.7% | 493.0 | 1.4% | ~$0.003 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 42.3% | 450.7 | -2.8% | $0.006 |
 
+<!-- END TRADEOFF_RESULTS -->
 
 Bug and security runs use the question floors recorded with each result. Semantic lint rules use a 70% run-wide floor.
 
@@ -145,6 +139,7 @@ JevLike (192-byte input), Laya (512-token input), and Kev (packed-branch limit)
 - [`results-current.jsonl`](https://huggingface.co/datasets/perchscan/benchmark-results/blob/main/results-current.jsonl): current-pack aggregate results for public and private splits; no private pair data.
 - [`results.jsonl`](https://huggingface.co/datasets/perchscan/benchmark-results/blob/main/results.jsonl): all recorded result versions, identified by run and protocol ID.
 - [`predictions/current/`](https://huggingface.co/datasets/perchscan/benchmark-results/tree/main/predictions/current): public method probabilities from this run. Private predictions are not published.
+- [`tradeoff.py`](https://huggingface.co/datasets/perchscan/benchmark-results/blob/main/tradeoff.py): rebuilds the public recall/false-alert curves and result tables from saved scores and labels.
 - [`benchmark.py`](https://huggingface.co/datasets/perchscan/benchmark-results/blob/main/benchmark.py) and [`question-pack.json`](https://huggingface.co/datasets/perchscan/benchmark-results/blob/main/question-pack.json): reproducible current-pack scorer and frozen questions.
 - [`span01.py`](https://huggingface.co/datasets/perchscan/benchmark-results/blob/main/span01.py): calls Span-01 with all applicable behaviors in one request per method, saves resumable predictions, and scores the completed dataset.
 - [`liquid.py`](https://huggingface.co/datasets/perchscan/benchmark-results/blob/main/liquid.py): calls Liquid d1 with the frozen Perch question pack, saves resumable predictions, and scores each track.
@@ -165,4 +160,3 @@ python3 span01.py --domain security --predictions security-span01.jsonl --report
 ```
 
 For another model, use `--scorer command --command 'python3 your_adapter.py' --model-revision YOUR_MODEL`. The adapter receives the method state and each applicable detection question and returns its true-answer probability. The runner saves predictions for resumption and reports scores only when every method side is complete.
-

tradeoff.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+"""Rebuild public false-alert curves and benchmark result tables.
+
+The public curves sweep the saved method scores. The marked operating points
+use the recorded scan alerts, which can include per-question floors. Private
+tables use only the aggregate results already published in results-current.jsonl.
+"""
+
+from __future__ import annotations
+
+import argparse
+from collections import defaultdict
+import html
+import json
+from math import floor, isfinite
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from urllib.request import urlopen
+
+
+ROOT = Path(__file__).resolve().parent
+DATASET_URLS = {
+    "bug": "https://huggingface.co/datasets/perchscan/bug-pairs-public/resolve/main/benchmark.jsonl",
+    "security": "https://huggingface.co/datasets/perchscan/security-pairs-public/resolve/main/benchmark.jsonl",
+    "lint": "https://huggingface.co/datasets/perchscan/perch-lint-bench-public/resolve/main/benchmark.jsonl",
+}
+NAMES = {
+    "jev": ("Jev", "https://typesafe.ai/blog/introducing-system-one-models-and-jev"),
+    "typellm": ("TypeLLM", "https://typellm.ai/docs"),
+    "liquid-d1": ("Liquid d1", "https://docs.liquid.ai/lfm/models/decision-models"),
+    "diffusiongemma": ("DiffusionGemma Jev", "https://github.com/razorback16/openjev"),
+    "span01": ("Span-01", "https://www.respan.ai/docs/documentation/span-01/concept"),
+    "clm": ("CLM-v0.1-8B", "https://huggingface.co/Contrastive-LM/CLM-v0.1-8B"),
+    "semif": ("SemiF", "https://github.com/TheoLeeCJ/SemIf"),
+}
+COLORS = {
+    "jev": "#1976d2", "typellm": "#c64f81", "liquid-d1": "#7638d6",
+    "diffusiongemma": "#e08a22", "span01": "#168d80", "clm": "#677586",
+    "semif": "#b14b39",
+}
+ORDER = tuple(NAMES)
+CAP = 0.05
+
+
+def lines(path: Path) -> list[dict]:
+    return [json.loads(line) for line in path.read_text().splitlines() if line]
+
+
+def dataset(domain: str, local_root: Path | None) -> list[dict]:
+    if local_root:
+        path = (local_root / "public" / domain / "benchmark.jsonl")
+        if domain == "lint":
+            path = local_root / "public" / "lint" / "benchmark.jsonl"
+        return lines(path)
+    with urlopen(DATASET_URLS[domain], timeout=120) as response:
+        return [json.loads(line) for line in response if line.strip()]
+
+
+def labels_for(domain: str, pairs: list[dict]) -> dict[tuple[str, str], int]:
+    labels = {}
+    for pair in pairs:
+        for role in ("before", "after"):
+            label = (1 if role == "before" else 0) if domain == "lint" else pair[role]["labels"][domain]
+            if label not in (0, 1):
+                raise ValueError(f"Invalid {domain} label in {pair['pair_id']}:{role}")
+            key = pair["pair_id"], role
+            if key in labels:
+                raise ValueError(f"Duplicate method side: {key}")
+            labels[key] = label
+    return labels
+
+
+def curve(labels: dict[tuple[str, str], int], prediction_path: Path) -> tuple[list[tuple[int, int]], int, int]:
+    predictions = lines(prediction_path)
+    scores = {}
+    for row in predictions:
+        key = row["pair_id"], row["role"]
+        value = row["score"]
+        if key in scores or not isinstance(value, (int, float)) or not isfinite(value) or not 0 <= value <= 1:
+            raise ValueError(f"Invalid prediction in {prediction_path}: {key}")
+        scores[key] = float(value)
+    if scores.keys() != labels.keys():
+        raise ValueError(f"Incomplete predictions in {prediction_path}: {len(scores)} of {len(labels)}")
+    groups = defaultdict(lambda: [0, 0])
+    for key, score in scores.items():
+        groups[score][1 - labels[key]] += 1  # index 0 is positive; 1 is negative
+    points = [(0, 0)]
+    tp = fp = 0
+    for score in sorted(groups, reverse=True):
+        positive, negative = groups[score]
+        tp += positive
+        fp += negative
+        points.append((fp, tp))
+    return points, sum(labels.values()), len(labels) - sum(labels.values())
+
+
+def recall_at_cap(points: list[tuple[int, int]], positives: int, negatives: int) -> float:
+    limit = floor(CAP * negatives)
+    return max(tp for fp, tp in points if fp <= limit) / positives
+
+
+def operating_metrics(row: dict) -> tuple[float, float, float]:
+    counts = row["confusion"]
+    positives = counts["tp"] + counts["fn"]
+    negatives = counts["fp"] + counts["tn"]
+    recall = counts["tp"] / positives
+    alerts_per_1000 = counts["fp"] / negatives * 1000
+    return recall, alerts_per_1000, recall - alerts_per_1000 / 1000
+
+
+def money(row: dict) -> str:
+    value = row.get("inference_cost_usd")
+    if value is None:
+        return "Free tier"
+    prefix = "~" if row["model_id"] == "clm" else ""
+    return f"{prefix}${value:.3f}"
+
+
+def model_link(model: str) -> str:
+    name, url = NAMES[model]
+    return f"[{name}]({url})"
+
+
+def percent(value: float) -> str:
+    return f"{100 * value:.1f}%"
+
+
+def public_table(rows: list[dict], curves: dict[str, tuple[list[tuple[int, int]], int, int]]) -> str:
+    ordered = sorted(rows, key=lambda row: (-recall_at_cap(*curves[row["model_id"]]), ORDER.index(row["model_id"])))
+    table = ["| Model | Recall at ≤5% false alerts | Recall at current cutoff | False alerts / 1,000 clean at current cutoff | TPR − FPR at current cutoff | Inference cost |",
+             "| --- | ---: | ---: | ---: | ---: | ---: |"]
+    for row in ordered:
+        recall, false_alerts, j = operating_metrics(row)
+        fixed_recall = recall_at_cap(*curves[row["model_id"]])
+        table.append(f"| {model_link(row['model_id'])} | {percent(fixed_recall)} | {percent(recall)} | {false_alerts:.1f} | {percent(j)} | {money(row)} |")
+    return "\n".join(table)
+
+
+def private_table(rows: list[dict]) -> str:
+    ordered = sorted(rows, key=lambda row: (-operating_metrics(row)[2], ORDER.index(row["model_id"])))
+    table = ["| Model | Recall at current cutoff | False alerts / 1,000 clean at current cutoff | TPR − FPR at current cutoff | Inference cost |",
+             "| --- | ---: | ---: | ---: | ---: |"]
+    for row in ordered:
+        recall, false_alerts, j = operating_metrics(row)
+        table.append(f"| {model_link(row['model_id'])} | {percent(recall)} | {false_alerts:.1f} | {percent(j)} | {money(row)} |")
+    return "\n".join(table)
+
+
+def svg(domain: str, curves: dict[str, tuple[list[tuple[int, int]], int, int]],
+        current: dict[str, dict], output: Path) -> None:
+    width, height = 1120, 580
+    left, right, top, bottom = 90, 40, 126, 82
+    plot_w, plot_h = width - left - right, height - top - bottom
+    # The chart concentrates on the low-false-alert region. The full sweep,
+    # including all-YES points at x=1,000, remains reproducible in tradeoff.py.
+    x_max = 150 if domain == "lint" else 300
+
+    def x(fp: int, negatives: int) -> float:
+        return left + (fp / negatives * 1000) / x_max * plot_w
+
+    def y(tp: int, positives: int) -> float:
+        return top + (1 - tp / positives) * plot_h
+
+    title = {"bug": "Bug detection", "security": "Security detection", "lint": "Perch Lint Bench"}[domain]
+    out = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" viewBox="0 0 {width} {height}" role="img" aria-labelledby="title desc">',
+           f'<title id="title">{title}: recall versus false alerts</title>',
+           '<desc id="desc">Seven model score curves on the public benchmark. Higher and farther left is better. Circles mark recorded alert cutoffs when they fall within the plotted range.</desc>',
+           f'<rect width="{width}" height="{height}" rx="16" fill="#101318"/>',
+           f'<text x="{left}" y="43" fill="#f2f5fa" font-family="Arial,sans-serif" font-weight="700" font-size="28">{html.escape(title)}</text>',
+           f'<text x="{left}" y="70" fill="#aeb9c7" font-family="Arial,sans-serif" font-size="16">Public methods · score cutoffs swept · low false-alert region</text>']
+    for i, model in enumerate(ORDER):
+        col = i % 4
+        row = i // 4
+        lx = left + col * 245
+        ly = 91 + row * 22
+        out += [f'<line x1="{lx}" y1="{ly}" x2="{lx + 24}" y2="{ly}" stroke="{COLORS[model]}" stroke-width="4"/>',
+                f'<text x="{lx + 32}" y="{ly + 5}" fill="#e1e7ef" font-family="Arial,sans-serif" font-size="15">{html.escape(NAMES[model][0])}</text>']
+    for value in range(0, x_max + 1, 50):
+        px = left + value / x_max * plot_w
+        out += [f'<line x1="{px:.1f}" y1="{top}" x2="{px:.1f}" y2="{top + plot_h}" stroke="#29303a"/>',
+                f'<text x="{px:.1f}" y="{top + plot_h + 25}" text-anchor="middle" fill="#aeb9c7" font-family="Arial,sans-serif" font-size="14">{value}</text>']
+    for value in range(0, 101, 20):
+        py = top + (1 - value / 100) * plot_h
+        out += [f'<line x1="{left}" y1="{py:.1f}" x2="{left + plot_w}" y2="{py:.1f}" stroke="#29303a"/>',
+                f'<text x="{left - 12}" y="{py + 5:.1f}" text-anchor="end" fill="#aeb9c7" font-family="Arial,sans-serif" font-size="14">{value}%</text>']
+    cap_x = left + 50 / x_max * plot_w
+    out.append(f'<line x1="{cap_x:.1f}" y1="{top}" x2="{cap_x:.1f}" y2="{top + plot_h}" stroke="#ced8e4" stroke-width="1.5" stroke-dasharray="5 6"/>')
+    out.append(f'<text x="{cap_x + 6:.1f}" y="{top + 18}" fill="#ced8e4" font-family="Arial,sans-serif" font-size="13">5% false-alert limit</text>')
+    for model in ORDER:
+        points, positives, negatives = curves[model]
+        visible = [(fp, tp) for fp, tp in points if fp / negatives * 1000 <= x_max]
+        if len(visible) > 1:
+            positions = " ".join(f"{x(fp, negatives):.2f},{y(tp, positives):.2f}" for fp, tp in visible)
+            out.append(f'<polyline points="{positions}" fill="none" stroke="{COLORS[model]}" stroke-width="2.5" stroke-linejoin="round" stroke-linecap="round"/>')
+        recall, false_alerts, _ = operating_metrics(current[model])
+        if false_alerts <= x_max:
+            out.append(f'<circle cx="{left + false_alerts / x_max * plot_w:.2f}" cy="{top + (1 - recall) * plot_h:.2f}" r="5" fill="{COLORS[model]}" stroke="#fff" stroke-width="1.5"/>')
+    out += [f'<text x="{left + plot_w / 2:.1f}" y="{height - 23}" text-anchor="middle" fill="#e1e7ef" font-family="Arial,sans-serif" font-size="17">False alerts per 1,000 clean methods →</text>',
+            f'<text transform="translate(23 {top + plot_h / 2:.1f}) rotate(-90)" text-anchor="middle" fill="#e1e7ef" font-family="Arial,sans-serif" font-size="17">Actual issues found (recall) →</text>',
+            '</svg>']
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text("\n".join(out) + "\n")
+
+
+def render_sections(results: list[dict], curves_by_domain: dict[str, dict], output_dir: Path) -> str:
+    sections = ["## Reading the results", "",
+                "Each curve shows how many labelled issues a model finds as its score cutoff changes. Moving right means more false alerts on labelled clean methods. Circles show the recorded Perch alert settings; a circle can sit off its score curve when a question has its own minimum score.", "",
+                "The public tables rank models by **recall with no more than 5% of clean methods falsely alerted**. This is a comparison of saved score rankings, not a new deployed cutoff. The private tables show the recorded alert settings and rank by **TPR − FPR** (recall minus the false-alert rate). A model that alerts on every method scores zero on this measure. Costs are for the captured runs.", "",
+                "Private method predictions stay private, so the curves use public predictions only. The lint public split has 214 clean methods: its 5% limit permits at most 10 false alerts. The bug and security limits permit 128 and 74 false alerts respectively.", ""]
+    for domain in ("bug", "security", "lint"):
+        title = {"bug": "Bugs", "security": "Security", "lint": "Perch Lint Bench"}[domain]
+        link = {"bug": "bug-pairs-public", "security": "security-pairs-public", "lint": "perch-lint-bench-public"}[domain]
+        public = [r for r in results if r["domain"] == domain and r["track"] == "public"]
+        private = [r for r in results if r["domain"] == domain and r["track"] == "private"]
+        if set(r["model_id"] for r in public) != set(ORDER) or set(r["model_id"] for r in private) != set(ORDER):
+            raise ValueError(f"Unexpected models in {domain} results")
+        current = {r["model_id"]: r for r in public}
+        image = output_dir / f"{domain}-tradeoff.svg"
+        svg(domain, curves_by_domain[domain], current, image)
+        sections += [f"## {title}", "", f"[Public pairs](https://huggingface.co/datasets/perchscan/{link})", "",
+                     f"![{title} recall versus false alerts](assets/{domain}-tradeoff.svg)", "",
+                     f"### Public — {public[0]['benchmark_pairs']:,} pairs", "",
+                     public_table(public, curves_by_domain[domain]), "",
+                     f"### Private — {private[0]['benchmark_pairs']:,} pairs", "",
+                     private_table(private), ""]
+    return "\n".join(sections)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dataset-root", type=Path, help="Directory containing public/{bug,security,lint}/benchmark.jsonl")
+    parser.add_argument("--check", action="store_true", help="Check generated card and SVGs without writing")
+    args = parser.parse_args()
+    results = lines(ROOT / "results-current.jsonl")
+    curves_by_domain = {}
+    for domain in ("bug", "security", "lint"):
+        labels = labels_for(domain, dataset(domain, args.dataset_root))
+        curves_by_domain[domain] = {}
+        for model in ORDER:
+            result = next(r for r in results if r["domain"] == domain and r["track"] == "public" and r["model_id"] == model)
+            points, positives, negatives = curve(labels, ROOT / "predictions" / "current" / domain / f"{model}.jsonl")
+            counts = result["confusion"]
+            if (positives, negatives) != (counts["tp"] + counts["fn"], counts["tn"] + counts["fp"]):
+                raise ValueError(f"Label counts differ from recorded result: {domain}/{model}")
+            curves_by_domain[domain][model] = points, positives, negatives
+    card = ROOT / "README.md"
+    original = card.read_text()
+    start_marker, end_marker = "<!-- BEGIN TRADEOFF_RESULTS -->", "<!-- END TRADEOFF_RESULTS -->"
+    start = original.find(start_marker)
+    end = original.find(end_marker)
+    if start < 0 or end < 0:
+        start = original.index("## Reading the results")
+        end = original.index("Bug and security runs use the question floors", start)
+    else:
+        end += len(end_marker)
+    if args.check:
+        with TemporaryDirectory() as temporary:
+            content = render_sections(results, curves_by_domain, Path(temporary))
+            for domain in DATASET_URLS:
+                name = f"{domain}-tradeoff.svg"
+                if (Path(temporary) / name).read_bytes() != (ROOT / "assets" / name).read_bytes():
+                    raise SystemExit(f"assets/{name} is not up to date; run python3 tradeoff.py")
+    else:
+        content = render_sections(results, curves_by_domain, ROOT / "assets")
+    updated = (original[:start].rstrip("\n") + "\n\n" + start_marker + "\n\n" + content
+               + "\n" + end_marker + "\n\n" + original[end:].lstrip("\n"))
+    if args.check and original != updated:
+        raise SystemExit("README.md is not up to date; run python3 tradeoff.py")
+    if not args.check:
+        card.write_text(updated)
+
+
+if __name__ == "__main__":
+    main()