Rank results by recall minus false alerts and rescale charts

README.md

@@ -26,11 +26,9 @@ Pairs come from open-source projects in Rust, JavaScript, TypeScript, Python, Go
 
 ## 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 alert settings; a circle can sit off its score curve when a question has its own minimum score.
+Each line shows how many issues a model finds and what percentage of clean methods it wrongly flags as its score cutoff changes. Higher and farther left is better.
 
-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.
+The tables use each run's recorded alert settings. A value of 20% under ‘Clean methods wrongly flagged’ means one in five clean methods received an alert. Models are ranked by recall minus that percentage. Bold marks the best displayed value in each column; cost compares priced runs captured here.
 
 ## Bugs
 
@@ -40,27 +38,27 @@ Private method predictions stay private, so the curves use public predictions on
 
 ### Public — 2,220 pairs
 
-| 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 |
+| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Inference cost |
+| --- | ---: | ---: | ---: | ---: |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 33.4% | 27.1% | **6.3%** | $0.239 |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 17.7% | 12.7% | 5.0% | $0.551 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 43.0% | 39.7% | 3.3% | $0.239 |
+| [TypeLLM](https://typellm.ai/docs) | 8.3% | 5.5% | 2.7% | $0.576 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 25.3% | 22.6% | 2.7% | **$0.182** |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 4.1% | **2.5%** | 1.6% | Free tier |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | **81.9%** | 80.9% | 1.0% | ~$0.210 |
 
 ### Private — 498 pairs
 
-| Model | Recall at current cutoff | False alerts / 1,000 clean at current cutoff | TPR − FPR at current cutoff | Inference cost |
+| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | 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 |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 35.8% | 27.3% | **8.6%** | $0.054 |
+| [TypeLLM](https://typellm.ai/docs) | 11.3% | 5.8% | 5.6% | $0.129 |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 20.0% | 15.6% | 4.5% | $0.123 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 28.5% | 24.3% | 4.2% | **$0.040** |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 44.3% | 41.8% | 2.6% | $0.054 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 5.2% | **3.0%** | 2.2% | Free tier |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | **79.5%** | 80.1% | -0.6% | ~$0.047 |
 
 ## Security
 
@@ -70,27 +68,27 @@ Private method predictions stay private, so the curves use public predictions on
 
 ### Public — 1,311 pairs
 
-| 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 |
+| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Inference cost |
+| --- | ---: | ---: | ---: | ---: |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 34.6% | 23.6% | **11.0%** | $0.507 |
+| [TypeLLM](https://typellm.ai/docs) | 27.8% | 17.4% | 10.5% | $0.566 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 55.6% | 46.8% | 8.8% | Free tier |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 33.1% | 25.8% | 7.3% | **$0.208** |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 21.0% | **17.2%** | 3.9% | $0.251 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | **100.0%** | 99.9% | 0.1% | **$0.208** |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | **100.0%** | 100.0% | 0.0% | ~$1.432 |
 
 ### Private — 439 pairs
 
-| Model | Recall at current cutoff | False alerts / 1,000 clean at current cutoff | TPR − FPR at current cutoff | Inference cost |
+| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | 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 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 34.2% | 29.0% | **5.2%** | Free tier |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 20.6% | 16.7% | 3.9% | $0.182 |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 21.9% | 18.5% | 3.3% | **$0.074** |
+| [TypeLLM](https://typellm.ai/docs) | 8.8% | **6.2%** | 2.5% | $0.203 |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | **100.0%** | 100.0% | 0.0% | ~$0.528 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | **100.0%** | 100.0% | 0.0% | **$0.074** |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 8.0% | 8.1% | -0.1% | $0.091 |
 
 ## Perch Lint Bench
 
@@ -100,27 +98,27 @@ Private method predictions stay private, so the curves use public predictions on
 
 ### Public — 214 pairs
 
-| 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 |
+| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Inference cost |
+| --- | ---: | ---: | ---: | ---: |
+| [TypeLLM](https://typellm.ai/docs) | **61.7%** | 2.8% | **58.9%** | $0.050 |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 50.0% | **0.5%** | 49.5% | $0.048 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 49.1% | 0.9% | 48.1% | Free tier |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 52.8% | 5.1% | 47.7% | $0.018 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 50.0% | 11.2% | 38.8% | $0.014 |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 38.8% | 37.4% | 1.4% | **~$0.010** |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 32.2% | 31.3% | 0.9% | $0.018 |
 
 ### Private — 71 pairs
 
-| Model | Recall at current cutoff | False alerts / 1,000 clean at current cutoff | TPR − FPR at current cutoff | Inference cost |
+| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | 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 |
+| [TypeLLM](https://typellm.ai/docs) | **59.2%** | 5.6% | **53.5%** | $0.016 |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 53.5% | **1.4%** | 52.1% | $0.016 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 49.3% | **1.4%** | 47.9% | Free tier |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 53.5% | 8.5% | 45.1% | $0.006 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 45.1% | 8.5% | 36.6% | $0.005 |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 50.7% | 49.3% | 1.4% | **~$0.003** |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 42.3% | 45.1% | -2.8% | $0.006 |
 
 <!-- END TRADEOFF_RESULTS -->
 

tradeoff.py

@@ -1,9 +1,8 @@
 #!/usr/bin/env python3
-"""Rebuild public false-alert curves and benchmark result tables.
+"""Rebuild public recall/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.
+The public curves sweep saved method scores. Tables use recorded scan alerts;
+private tables use only aggregates in results-current.jsonl.
 """
 
 from __future__ import annotations
@@ -12,7 +11,7 @@ import argparse
 from collections import defaultdict
 import html
 import json
-from math import floor, isfinite
+from math import isfinite
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from urllib.request import urlopen
@@ -39,7 +38,6 @@ COLORS = {
     "semif": "#b14b39",
 }
 ORDER = tuple(NAMES)
-CAP = 0.05
 
 
 def lines(path: Path) -> list[dict]:
@@ -94,18 +92,13 @@ def curve(labels: dict[tuple[str, str], int], prediction_path: Path) -> tuple[li
     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
+    false_positive_rate = counts["fp"] / negatives
+    return recall, false_positive_rate, recall - false_positive_rate
 
 
 def money(row: dict) -> str:
@@ -125,49 +118,54 @@ 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 results_table(rows: list[dict]) -> str:
+    ordered = sorted(rows, key=lambda row: (-operating_metrics(row)[2], ORDER.index(row["model_id"])))
+    metrics = {row["model_id"]: operating_metrics(row) for row in ordered}
+    best_recall = max(round(value[0] * 100, 1) for value in metrics.values())
+    best_false_positive_rate = min(round(value[1] * 100, 1) for value in metrics.values())
+    best_net_recall = max(round(value[2] * 100, 1) for value in metrics.values())
+    priced_costs = [round(row["inference_cost_usd"], 3) for row in ordered if row.get("inference_cost_usd") is not None]
+    best_priced_cost = min(priced_costs) if priced_costs else None
 
+    def mark(value: str, winner: bool) -> str:
+        return f"**{value}**" if winner else value
 
-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 |",
+    table = ["| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | 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)} |")
+        recall, false_positive_rate, j = metrics[row["model_id"]]
+        cost = row.get("inference_cost_usd")
+        table.append("| " + " | ".join((
+            model_link(row["model_id"]),
+            mark(percent(recall), round(recall * 100, 1) == best_recall),
+            mark(percent(false_positive_rate), round(false_positive_rate * 100, 1) == best_false_positive_rate),
+            mark(percent(j), round(j * 100, 1) == best_net_recall),
+            mark(money(row), cost is not None and round(cost, 3) == best_priced_cost),
+        )) + " |")
     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:
+def svg(domain: str, curves: dict[str, tuple[list[tuple[int, int]], int, int]], 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
+    # The chart concentrates on the lower false-positive-rate region.
+    x_max = 15 if domain == "lint" else 30
+    y_max = 1.0 if domain == "lint" else 0.5
 
     def x(fp: int, negatives: int) -> float:
-        return left + (fp / negatives * 1000) / x_max * plot_w
+        return left + (fp / negatives * 100) / x_max * plot_w
 
     def y(tp: int, positives: int) -> float:
-        return top + (1 - tp / positives) * plot_h
+        return top + (1 - (tp / positives) / y_max) * 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>',
+           '<desc id="desc">Seven model score curves on the public benchmark. Higher and farther left is better.</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>']
+           f'<text x="{left}" y="70" fill="#aeb9c7" font-family="Arial,sans-serif" font-size="16">Public methods · recall versus false alerts</text>']
     for i, model in enumerate(ORDER):
         col = i % 4
         row = i // 4
@@ -175,27 +173,23 @@ def svg(domain: str, curves: dict[str, tuple[list[tuple[int, int]], int, int]],
         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):
+    x_step = 5
+    for value in range(0, x_max + 1, x_step):
         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
+                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>']
+    step = 20 if domain == "lint" else 10
+    for value in range(0, round(y_max * 100) + 1, step):
+        py = top + (1 - (value / 100) / y_max) * 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]
+        visible = [(fp, tp) for fp, tp in points if fp / negatives * 100 <= 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>',
+    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">Clean methods wrongly flagged →</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)
@@ -204,9 +198,8 @@ def svg(domain: str, curves: dict[str, tuple[list[tuple[int, int]], int, int]],
 
 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 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.", ""]
+                "Each line shows how many issues a model finds and what percentage of clean methods it wrongly flags as its score cutoff changes. Higher and farther left is better.", "",
+                "The tables use each run's recorded alert settings. A value of 20% under ‘Clean methods wrongly flagged’ means one in five clean methods received an alert. Models are ranked by recall minus that percentage. Bold marks the best displayed value in each column; cost compares priced runs captured here.", ""]
     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]
@@ -214,15 +207,14 @@ def render_sections(results: list[dict], curves_by_domain: dict[str, dict], outp
         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)
+        svg(domain, curves_by_domain[domain], 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]), "",
+                     results_table(public), "",
                      f"### Private — {private[0]['benchmark_pairs']:,} pairs", "",
-                     private_table(private), ""]
+                     results_table(private), ""]
     return "\n".join(sections)