Show recall against false positive rate

README.md

@@ -29,21 +29,21 @@ Pairs come from open-source projects in Rust, JavaScript, TypeScript, Python, Go
 
 ## Reading the results
 
-Each line shows recall minus the false-positive rate as the score cutoff changes. Higher is better; farther left means fewer clean methods flagged. The dashed zero line means issues and clean methods are flagged at equal rates.
+Each point shows a model at the same cutoff used in its table. X is the false-positive rate: the percentage of clean methods wrongly flagged. Y is recall: the percentage of labelled issues found. 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 full-set value in each column; cost compares priced runs captured here.
+The tables use each run's recorded alert settings. A value of 20% under ‘False-positive rate’ means one in five clean methods received an alert. Models are ranked by recall minus that percentage. Bold marks the best full-set value in each column; cost compares priced runs captured here.
 
-Failed requests count as incorrect decisions: a failed issue is a miss; a failed clean method is a false positive. Failed cases receive no model score and remain incorrect across the plotted cutoffs.
+Failed requests count as incorrect decisions: a failed issue is a miss; a failed clean method is a false positive. Failed cases receive no model score and are included in both the table counts and plotted points.
 
 ## Bugs
 
 [Public pairs](https://huggingface.co/datasets/perchscan/bug-pairs-public)
 
-![Bugs: recall minus false-positive rate across cutoffs](assets/bug-tradeoff.svg)
+![Bugs: recall versus false-positive rate at table cutoffs](assets/bug-tradeoff.svg)
 
 ### Public — 2,220 pairs
 
-| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |
+| Model | Recall | False-positive rate | Recall − false-positive rate | Failed requests | Inference cost |
 | --- | ---: | ---: | ---: | ---: | ---: |
 | [GPT-6 Luna Decisions](https://developers.openai.com/api/docs/guides/decisions) | 48.7% | 38.7% | **10.0%** | **0** | $1.102 |
 | [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 33.4% | 27.1% | 6.3% | **0** | $0.239 |
@@ -60,7 +60,7 @@ Failed requests count as incorrect decisions: a failed issue is a miss; a failed
 
 ### Private — 498 pairs
 
-| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |
+| Model | Recall | False-positive rate | Recall − false-positive rate | Failed requests | Inference cost |
 | --- | ---: | ---: | ---: | ---: | ---: |
 | [GPT-6 Luna Decisions](https://developers.openai.com/api/docs/guides/decisions) | 52.4% | 41.3% | **11.1%** | **0** | $0.247 |
 | [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 35.8% | 27.3% | 8.6% | **0** | $0.054 |
@@ -76,11 +76,11 @@ Failed requests count as incorrect decisions: a failed issue is a miss; a failed
 
 [Public pairs](https://huggingface.co/datasets/perchscan/security-pairs-public)
 
-![Security: recall minus false-positive rate across cutoffs](assets/security-tradeoff.svg)
+![Security: recall versus false-positive rate at table cutoffs](assets/security-tradeoff.svg)
 
 ### Public — 1,311 pairs
 
-| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |
+| Model | Recall | False-positive rate | Recall − false-positive rate | Failed requests | Inference cost |
 | --- | ---: | ---: | ---: | ---: | ---: |
 | [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 34.6% | 23.6% | **11.0%** | **0** | $0.507 |
 | [TypeLLM](https://typellm.ai/docs) | 27.8% | 17.4% | 10.5% | **0** | $0.566 |
@@ -97,7 +97,7 @@ Failed requests count as incorrect decisions: a failed issue is a miss; a failed
 
 ### Private — 439 pairs
 
-| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |
+| Model | Recall | False-positive rate | Recall − false-positive rate | Failed requests | Inference cost |
 | --- | ---: | ---: | ---: | ---: | ---: |
 | [GPT-6 Luna Decisions](https://developers.openai.com/api/docs/guides/decisions) | 40.5% | 31.5% | **9.0%** | **0** | $0.530 |
 | [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 34.2% | 29.0% | 5.2% | **0** | Free tier |
@@ -113,11 +113,11 @@ Failed requests count as incorrect decisions: a failed issue is a miss; a failed
 
 [Public pairs](https://huggingface.co/datasets/perchscan/perch-lint-bench-public)
 
-![Perch Lint Bench: recall minus false-positive rate across cutoffs](assets/lint-tradeoff.svg)
+![Perch Lint Bench: recall versus false-positive rate at table cutoffs](assets/lint-tradeoff.svg)
 
 ### Public — 214 pairs
 
-| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |
+| Model | Recall | False-positive rate | Recall − false-positive rate | Failed requests | Inference cost |
 | --- | ---: | ---: | ---: | ---: | ---: |
 | [GPT-6 Luna Decisions](https://developers.openai.com/api/docs/guides/decisions) | **76.6%** | 4.7% | **72.0%** | **0** | $0.093 |
 | [TypeLLM](https://typellm.ai/docs) | 61.7% | 2.8% | 58.9% | **0** | $0.050 |
@@ -131,7 +131,7 @@ Failed requests count as incorrect decisions: a failed issue is a miss; a failed
 
 ### Private — 71 pairs
 
-| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |
+| Model | Recall | False-positive rate | Recall − false-positive rate | Failed requests | Inference cost |
 | --- | ---: | ---: | ---: | ---: | ---: |
 | [GPT-6 Luna Decisions](https://developers.openai.com/api/docs/guides/decisions) | **84.5%** | 7.0% | **77.5%** | **0** | $0.030 |
 | [TypeLLM](https://typellm.ai/docs) | 59.2% | 5.6% | 53.5% | **0** | $0.016 |

test_tradeoff.py

@@ -7,35 +7,86 @@ import tradeoff
 
 
 class GraphTests(unittest.TestCase):
-    def test_equal_alert_rates_have_zero_margin_at_both_ends(self):
-        # Unequal class sizes prevent subtracting raw counts by mistake.
-        curves = {model: ([(0, 0), (2, 7), (20, 10)], 10, 20) for model in tradeoff.ORDER}
+    def render(self, current):
         with tempfile.TemporaryDirectory() as temp:
             output = Path(temp) / 'graph.svg'
-            tradeoff.svg('bug', curves, output)
-            root = ET.fromstring(output.read_text())
-        paths = root.findall('{http://www.w3.org/2000/svg}polyline')
-        self.assertEqual(len(paths), len(tradeoff.ORDER))
-        points = [tuple(map(float, point.split(','))) for point in paths[0].attrib['points'].split()]
-        self.assertEqual(points[0][1], points[2][1])
-        self.assertLess(points[1][1], points[0][1])
-        self.assertGreater(points[2][0], points[1][0])
+            tradeoff.svg('bug', current, output)
+            return ET.fromstring(output.read_text())
+
+    def test_points_use_recall_and_false_positive_rate_from_table(self):
+        current = {model: {'confusion': {'tp': 7, 'fn': 3, 'fp': 2, 'tn': 18}}
+                   for model in tradeoff.ORDER}
+        root = self.render(current)
+        dots = [e for e in root.findall('{http://www.w3.org/2000/svg}circle') if 'data-model' in e.attrib]
+        self.assertEqual(len(dots), len(tradeoff.ORDER))
+        self.assertAlmostEqual((float(dots[0].attrib['cx']) - 90) / 990, .1)
+        self.assertAlmostEqual((498 - float(dots[0].attrib['cy'])) / 350, .7)
+        self.assertFalse(root.findall('{http://www.w3.org/2000/svg}polyline'))
         labels = [e.text for e in root.findall('{http://www.w3.org/2000/svg}text')]
-        self.assertIn('100%', labels)
-        self.assertIn('Zero means issues and clean methods are flagged at equal rates.',
-                      root.find('{http://www.w3.org/2000/svg}desc').text)
-        self.assertIn('Recall − false-positive rate (percentage points)', labels)
+        self.assertIn('False positive rate', labels)
+        self.assertIn('Recall', labels)
+
+    def test_false_positives_do_not_change_vertical_recall_coordinate(self):
+        current = {model: {'confusion': {'tp': 7, 'fn': 3, 'fp': 2, 'tn': 18}}
+                   for model in tradeoff.ORDER}
+        current['typellm'] = {'confusion': {'tp': 7, 'fn': 3, 'fp': 10, 'tn': 10}}
+        root = self.render(current)
+        dots = {e.attrib['data-model']: e for e in root.findall('{http://www.w3.org/2000/svg}circle')
+                if 'data-model' in e.attrib}
+        self.assertEqual(dots['jev'].attrib['cy'], dots['typellm'].attrib['cy'])
+        self.assertLess(float(dots['jev'].attrib['cx']), float(dots['typellm'].attrib['cx']))
+
+
+class AlertCurveTests(unittest.TestCase):
+    def setUp(self):
+        self.pack = {'pack_sha256': 'current', 'domains': {'bug': [
+            {'name': 'first', 'min': 60, 'issue': {'type': 'defect'}},
+            {'name': 'second', 'min': 70, 'issue': {'type': 'defect'}}]}}
+        self.result = {'domain': 'bug', 'question_pack_sha256': 'current', 'threshold': .5,
+                       'confusion': {'tp': 1, 'fp': 1, 'fn': 1, 'tn': 0}}
 
-    def test_negative_margins_remain_visible(self):
-        curves = {model: ([(0, 0), (10, 2), (20, 10)], 10, 20) for model in tradeoff.ORDER}
+    def write_predictions(self, path, rows):
+        import json
+        path.write_text(''.join(json.dumps(row) + '\n' for row in rows))
+
+    def test_question_floors_remove_ineligible_alerts_at_every_cutoff(self):
+        labels = {('low', 'before'): 1, ('high', 'before'): 1, ('clean', 'after'): 0}
+        rows = [
+            {'pair_id': 'low', 'role': 'before', 'score': .68, 'alert': False,
+             'question_scores': {'first': .6, 'second': .68}},
+            {'pair_id': 'high', 'role': 'before', 'score': .9, 'alert': True,
+             'question_scores': {'first': .1, 'second': .9}},
+            {'pair_id': 'clean', 'role': 'after', 'score': .8, 'alert': True,
+             'question_scores': {'first': .8, 'second': .1}}]
         with tempfile.TemporaryDirectory() as temp:
-            output = Path(temp) / 'graph.svg'
-            tradeoff.svg('security', curves, output)
-            root = ET.fromstring(output.read_text())
-        path = root.find('{http://www.w3.org/2000/svg}polyline')
-        points = [tuple(map(float, point.split(','))) for point in path.attrib['points'].split()]
-        self.assertGreater(points[1][1], points[0][1])
-        self.assertLessEqual(points[1][1], 498)
+            path = Path(temp) / 'scores.jsonl'
+            self.write_predictions(path, rows)
+            points, positives, negatives = tradeoff.curve(labels, path, self.result, self.pack)
+            self.assertEqual((positives, negatives), (2, 1))
+            self.assertEqual(points, [(0, 0), (0, 1), (1, 1)])
+            self.assertIn((self.result['confusion']['fp'], self.result['confusion']['tp']), points)
+            # A strict threshold at .8 must exclude the clean method's .8 score.
+            stricter = {**self.result, 'threshold': .8, 'confusion': {'tp': 1, 'fp': 0, 'fn': 1, 'tn': 1}}
+            rows[2]['alert'] = False
+            self.write_predictions(path, rows)
+            strict_points, _, _ = tradeoff.curve(labels, path, stricter, self.pack)
+            self.assertEqual(strict_points, points)
+
+    def test_failure_penalty_and_table_mismatch_are_preserved(self):
+        labels = {('positive', 'before'): 1, ('negative', 'after'): 0}
+        rows = [
+            {'pair_id': 'positive', 'role': 'before', 'score': .9, 'alert': True,
+             'question_scores': {'first': .9, 'second': .1}},
+            {'pair_id': 'negative', 'role': 'after', 'status': 'failed'}]
+        result = {**self.result, 'confusion': {'tp': 1, 'fp': 1, 'fn': 0, 'tn': 0}}
+        with tempfile.TemporaryDirectory() as temp:
+            path = Path(temp) / 'scores.jsonl'
+            self.write_predictions(path, rows)
+            points, _, _ = tradeoff.curve(labels, path, result, self.pack)
+            self.assertEqual(points, [(1, 0), (1, 1)])
+            result['confusion']['fp'] = 0
+            with self.assertRaises(ValueError):
+                tradeoff.curve(labels, path, result, self.pack)
 
 
 if __name__ == '__main__':

tradeoff.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
-"""Rebuild public recall/false-alert curves and benchmark result tables.
+"""Rebuild public recall/false-positive-rate charts and benchmark result tables.
 
-The public curves sweep saved method scores. Tables use recorded scan alerts;
-private tables use only aggregates in results-current.jsonl.
+Recorded alert counts are validated against each run's question floors and failure policy.
+Private tables use only aggregates in results-current.jsonl.
 """
 
 from __future__ import annotations
@@ -11,7 +11,7 @@ import argparse
 from collections import defaultdict
 import html
 import json
-from math import ceil, floor, isfinite
+from math import isfinite
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from urllib.request import urlopen
@@ -42,6 +42,8 @@ COLORS = {
     "gliner25-decide": "#9b7a39",
 }
 ORDER = tuple(NAMES)
+OLD_PACK_SHA = "bb53c8a6ca30920140e2bf33b2905d159e7b1709b29d1ea896637905dbf9047d"
+OLD_BUG_FLOORS = {"has_bug": 0.6, "does_what_it_claims": 0.7}
 
 
 def lines(path: Path) -> list[dict]:
@@ -72,9 +74,24 @@ def labels_for(domain: str, pairs: list[dict]) -> dict[tuple[str, str], int]:
     return labels
 
 
-def curve(labels: dict[tuple[str, str], int], prediction_path: Path) -> tuple[list[tuple[int, int]], int, int]:
+def question_floors(domain: str, result: dict, pack: dict) -> dict[str, float]:
+    if domain == "lint":
+        return {}
+    revision = result["question_pack_sha256"]
+    if revision not in (OLD_PACK_SHA, pack["pack_sha256"]):
+        raise ValueError(f"Unknown question pack: {revision}")
+    if domain == "bug" and revision == OLD_PACK_SHA:
+        return OLD_BUG_FLOORS
+    return {q["name"]: (q.get("min") or 0) / 100
+            for q in pack["domains"][domain] if q.get("issue")}
+
+
+def curve(labels: dict[tuple[str, str], int], prediction_path: Path, result: dict,
+          pack: dict) -> tuple[list[tuple[int, int]], int, int]:
     predictions = lines(prediction_path)
     scores, failed = {}, set()
+    floors = question_floors(result["domain"], result, pack)
+    operating_tp = operating_fp = 0
     for row in predictions:
         key = row["pair_id"], row["role"]
         if row.get("status") == "failed":
@@ -83,13 +100,38 @@ def curve(labels: dict[tuple[str, str], int], prediction_path: Path) -> tuple[li
             failed.add(key)
             continue
         value = row["score"]
+        if floors:
+            question_scores = row["question_scores"]
+            if not question_scores or not set(question_scores) <= set(floors):
+                raise ValueError(f"Question scores differ from recorded pack: {prediction_path}: {key}")
+            for score in question_scores.values():
+                if not isinstance(score, (int, float)) or isinstance(score, bool) or not isfinite(score) or not 0 <= score <= 1:
+                    raise ValueError(f"Invalid question score in {prediction_path}: {key}")
+            value = max((score for name, score in question_scores.items()
+                         if score > floors[name]), default=0.0)
         if key in scores or key in failed 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)
+        alerted = value > result["threshold"]
+        if "alert" in row and row["alert"] != alerted:
+            raise ValueError(f"Saved alert differs from score rule: {prediction_path}: {key}")
+        if alerted:
+            if labels[key]:
+                operating_tp += 1
+            else:
+                operating_fp += 1
     if scores.keys() | failed != labels.keys():
         raise ValueError(f"Incomplete outcomes in {prediction_path}: {len(scores) + len(failed)} of {len(labels)}")
+    operating_fp += sum(labels[key] == 0 for key in failed)
+    counts = result["confusion"]
+    if (operating_tp, operating_fp) != (counts["tp"], counts["fp"]):
+        raise ValueError(f"Table counts differ from plotted score rule: {prediction_path}")
     groups = defaultdict(lambda: [0, 0])
     for key, score in scores.items():
+        # At a strict cutoff >= 0, a zero score never alerts. Methods whose
+        # questions all fail their floors must remain unalerted at every cutoff.
+        if score == 0:
+            continue
         groups[score][1 - labels[key]] += 1  # index 0 is positive; 1 is negative
     # Failures count as wrong at every cutoff. They never receive invented scores.
     tp, fp = 0, sum(labels[key] == 0 for key in failed)
@@ -99,6 +141,8 @@ def curve(labels: dict[tuple[str, str], int], prediction_path: Path) -> tuple[li
         tp += positive
         fp += negative
         points.append((fp, tp))
+    if (counts["fp"], counts["tp"]) not in points:
+        raise ValueError(f"Table operating point is not on curve: {prediction_path}")
     return points, sum(labels.values()), len(labels) - sum(labels.values())
 
 
@@ -145,7 +189,7 @@ def results_table(rows: list[dict]) -> str:
     def mark(value: str, winner: bool) -> str:
         return f"**{value}**" if winner else value
 
-    table = ["| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |",
+    table = ["| Model | Recall | False-positive rate | Recall − false-positive rate | Failed requests | Inference cost |",
              "| --- | ---: | ---: | ---: | ---: | ---: |"]
     for row in ordered:
         recall, false_positive_rate, j = metrics[row["model_id"]]
@@ -165,71 +209,53 @@ def results_table(rows: list[dict]) -> str:
     return "\n".join(table)
 
 
-def svg(domain: str, curves: dict[str, tuple[list[tuple[int, int]], int, int]], output: Path) -> None:
+def svg(domain: str, current: dict[str, dict], output: Path) -> None:
     width, height = 1120, 580
     left, right, top, bottom = 90, 40, 148, 82
     plot_w, plot_h = width - left - right, height - top - bottom
-    # Subtract the diagonal so small ranking differences remain visible.
-    # Keep every cutoff and adapt only the vertical display range.
-    x_max = 100
-    step = 10 if domain == "lint" else 5
-    margins = [100 * (tp / positives - fp / negatives)
-               for points, positives, negatives in curves.values() for fp, tp in points]
-    y_min = min(-step, floor(min(margins) / step) * step)
-    y_max = max(step, ceil(max(margins) / step) * step)
-
-    def x(fp: int, negatives: int) -> float:
-        return left + (fp / negatives * 100) / x_max * plot_w
-
-    def y(margin: float) -> float:
-        return top + (y_max - margin) / (y_max - y_min) * plot_h
-
+    models = [*ORDER, *(["codeql"] if "codeql" in current else [])]
     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 minus false-positive rate</title>',
-           '<desc id="desc">Public model curves across score cutoffs. The vertical axis subtracts the false-positive rate from recall. Zero means issues and clean methods are flagged at equal rates. Higher is better.</desc>',
+           f'<title id="title">{title}: recall versus false positive rate</title>',
+           '<desc id="desc">Each point is a model at its recorded table cutoff. X is the percentage of clean methods falsely flagged. Y is the percentage of issue-bearing methods found. Higher and farther left is better. CodeQL, where present, uses the subset documented below the table.</desc>',
            f'<rect width="{width}" height="{height}" rx="16" fill="#101318"/>',
-           f'<defs><clipPath id="plot"><rect x="{left}" y="{top}" width="{plot_w}" height="{plot_h}"/></clipPath></defs>',
            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 · recall minus false-positive rate · higher is better</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>']
-    x_step = 20
-    for value in range(0, x_max + 1, x_step):
-        px = left + value / x_max * plot_w
+           f'<text x="{left}" y="70" fill="#aeb9c7" font-family="Arial,sans-serif" font-size="16">Public methods · one point per model · upper left is better</text>']
+    for i, model in enumerate(models):
+        col, row = i % 4, i // 4
+        lx, ly = left + col * 245, 91 + row * 22
+        color = COLORS.get(model, "#cfd5df")
+        name = "CodeQL*" if model == "codeql" else NAMES[model][0]
+        out += [f'<circle cx="{lx + 12}" cy="{ly}" r="5" fill="{color}"/>',
+                f'<text x="{lx + 32}" y="{ly + 5}" fill="#e1e7ef" font-family="Arial,sans-serif" font-size="15">{html.escape(name)}</text>']
+    for value in range(0, 101, 20):
+        px = left + value / 100 * plot_w
+        py = top + (1 - value / 100) * plot_h
         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(y_min, y_max + 1, step):
-        py = y(value)
-        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>']
-    zero_y = y(0)
-    out.append(f'<line x1="{left}" y1="{zero_y:.1f}" x2="{left + plot_w}" y2="{zero_y:.1f}" stroke="#aeb9c7" stroke-width="1.5" stroke-dasharray="5 5"/>')
-    for model in ORDER:
-        points, positives, negatives = curves[model]
-        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(100 * (tp / positives - fp / negatives)):.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" clip-path="url(#plot)"/>')
-    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="14">Recall − false-positive rate (percentage points)</text>',
+                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>',
+                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>']
+    for model in models:
+        recall, fpr, _ = operating_metrics(current[model])
+        px, py = left + fpr * plot_w, top + (1 - recall) * plot_h
+        color = COLORS.get(model, "#cfd5df")
+        name = "CodeQL*" if model == "codeql" else NAMES[model][0]
+        tooltip = html.escape(f"{name}: recall {recall:.1%}; false positive rate {fpr:.1%}")
+        out.append(f'<circle data-model="{model}" cx="{px:.2f}" cy="{py:.2f}" r="6" fill="{color}" stroke="#fff" stroke-width="1.5"><title>{tooltip}</title></circle>')
+    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 positive rate</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">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,
+def render_sections(results: list[dict], output_dir: Path,
                     codeql_results: dict) -> str:
     sections = ["## Reading the results", "",
-                "Each line shows recall minus the false-positive rate as the score cutoff changes. Higher is better; farther left means fewer clean methods flagged. The dashed zero line means issues and clean methods are flagged at equal rates.", "",
-                "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 full-set value in each column; cost compares priced runs captured here.", ""]
+                "Each point shows a model at the same cutoff used in its table. X is the false-positive rate: the percentage of clean methods wrongly flagged. Y is recall: the percentage of labelled issues found. Higher and farther left is better.", "",
+                "The tables use each run's recorded alert settings. A value of 20% under ‘False-positive rate’ means one in five clean methods received an alert. Models are ranked by recall minus that percentage. Bold marks the best full-set value in each column; cost compares priced runs captured here.", ""]
     if any(r.get("failed_methods") for r in results):
-        sections += ["Failed requests count as incorrect decisions: a failed issue is a miss; a failed clean method is a false positive. Failed cases receive no model score and remain incorrect across the plotted cutoffs.", ""]
+        sections += ["Failed requests count as incorrect decisions: a failed issue is a miss; a failed clean method is a false positive. Failed cases receive no model score and are included in both the table counts and plotted points.", ""]
     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]
@@ -247,9 +273,9 @@ def render_sections(results: list[dict], curves_by_domain: dict[str, dict], outp
             public.append({"model_id": "codeql", "benchmark_pairs": comparison["pairs"],
                            "confusion": counts})
         image = output_dir / f"{domain}-tradeoff.svg"
-        svg(domain, curves_by_domain[domain], image)
+        svg(domain, {r["model_id"]: r for r in public}, image)
         sections += [f"## {title}", "", f"[Public pairs](https://huggingface.co/datasets/perchscan/{link})", "",
-                     f"![{title}: recall minus false-positive rate across cutoffs](assets/{domain}-tradeoff.svg)", "",
+                     f"![{title}: recall versus false-positive rate at table cutoffs](assets/{domain}-tradeoff.svg)", "",
                      f"### Public — {public[0]['benchmark_pairs']:,} pairs", "",
                      results_table(public), ""]
         if domain in ("bug", "security"):
@@ -268,18 +294,16 @@ def main() -> None:
     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")
+    pack = json.loads((ROOT / "question-pack.json").read_text())
     codeql_results = json.loads((ROOT / "codeql-comparison" / "results.json").read_text())
-    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")
+            points, positives, negatives = curve(labels, ROOT / "predictions" / "current" / domain / f"{model}.jsonl", result, pack)
             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 -->"
@@ -292,13 +316,13 @@ def main() -> None:
         end += len(end_marker)
     if args.check:
         with TemporaryDirectory() as temporary:
-            content = render_sections(results, curves_by_domain, Path(temporary), codeql_results)
+            content = render_sections(results, Path(temporary), codeql_results)
             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", codeql_results)
+        content = render_sections(results, ROOT / "assets", codeql_results)
     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: