Add GLiNER-2.5-Decide benchmark results (#33)

- feat: benchmark GLiNER-2.5-Decide (f1540c49c26f00793c43247b5e6ae6c254be9222)
- fix: size Decide benchmark requests with Perch (a5891f1d9b0f02592878a56c584e08657a2a2f44)

.gitattributes

@@ -35,6 +35,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.xz filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
+predictions/current/*/gliner25-decide.jsonl filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 # Audio files - uncompressed
 *.pcm filter=lfs diff=lfs merge=lfs -text

README.md

@@ -21,6 +21,7 @@ Pairs come from open-source projects in Rust, JavaScript, TypeScript, Python, Go
 | [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | [Respan scoring API](https://api.respan.ai/api/v1/scores) (`span-01-pro`) |
 | [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`) |
+| [GLiNER-2.5-Decide](https://huggingface.co/fastino/GLiNER2.5-Decide) | [Fastino classification API](https://api.fastino.ai/v1/chat/completions) (`fastino/GLiNER-2.5-Decide`) |
 
 <!-- BEGIN TRADEOFF_RESULTS -->
 
@@ -30,6 +31,8 @@ Each line shows how many issues a model finds and what percentage of clean metho
 
 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.
 
+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.
+
 ## Bugs
 
 [Public pairs](https://huggingface.co/datasets/perchscan/bug-pairs-public)
@@ -38,30 +41,32 @@ The tables use each run's recorded alert settings. A value of 20% under ‘Clean
 
 ### Public — 2,220 pairs
 
-| 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 |
-| [CodeQL](https://codeql.github.com/) (52 pairs) | 0.0% | 0.0% | 0.0% | — |
+| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 33.4% | 27.1% | **6.3%** | **0** | $0.239 |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 17.7% | 12.7% | 5.0% | **0** | $0.551 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 43.0% | 39.7% | 3.3% | **0** | $0.239 |
+| [TypeLLM](https://typellm.ai/docs) | 8.3% | 5.5% | 2.7% | **0** | $0.576 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 25.3% | 22.6% | 2.7% | **0** | $0.182 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 4.1% | 2.5% | 1.6% | **0** | Free tier |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | **81.9%** | 80.9% | 1.0% | **0** | ~$0.210 |
+| [GLiNER-2.5-Decide](https://huggingface.co/fastino/GLiNER2.5-Decide) | 2.3% | **2.1%** | 0.2% | **0** | **$0.175** |
+| [CodeQL](https://codeql.github.com/) (52 pairs) | 0.0% | 0.0% | 0.0% | — | — |
 
 CodeQL scored 52 of the 2,220 public pairs; other models scored all pairs. Its [method decisions](codeql-comparison/) and [evaluation protocol](CODEQL.md) are available here.
 
 ### Private — 498 pairs
 
-| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Inference cost |
-| --- | ---: | ---: | ---: | ---: |
-| [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 |
+| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 35.8% | 27.3% | **8.6%** | **0** | $0.054 |
+| [TypeLLM](https://typellm.ai/docs) | 11.3% | 5.8% | 5.6% | **0** | $0.129 |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 20.0% | 15.6% | 4.5% | **0** | $0.123 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 28.5% | 24.3% | 4.2% | **0** | $0.040 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 44.3% | 41.8% | 2.6% | **0** | $0.054 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 5.2% | 3.0% | 2.2% | **0** | Free tier |
+| [GLiNER-2.5-Decide](https://huggingface.co/fastino/GLiNER2.5-Decide) | 1.7% | **2.1%** | -0.4% | **0** | **$0.039** |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | **79.5%** | 80.1% | -0.6% | **0** | ~$0.047 |
 
 ## Security
 
@@ -71,30 +76,32 @@ CodeQL scored 52 of the 2,220 public pairs; other models scored all pairs. Its [
 
 ### Public — 1,311 pairs
 
-| 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 |
-| [CodeQL](https://codeql.github.com/) (70 pairs) | 3.7% | 0.0% | 3.7% | — |
-| [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 |
+| Model | Recall | Clean methods wrongly flagged | 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 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 55.6% | 46.8% | 8.8% | **0** | Free tier |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 33.1% | 25.8% | 7.3% | **0** | **$0.208** |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 21.0% | 17.2% | 3.9% | **0** | $0.251 |
+| [CodeQL](https://codeql.github.com/) (70 pairs) | 3.7% | 0.0% | 3.7% | — | — |
+| [GLiNER-2.5-Decide](https://huggingface.co/fastino/GLiNER2.5-Decide) | 2.1% | **1.6%** | 0.5% | 6 | $0.434 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | **100.0%** | 99.9% | 0.1% | **0** | **$0.208** |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | **100.0%** | 100.0% | 0.0% | **0** | ~$1.432 |
 
 CodeQL scored 70 of the 1,311 public pairs; other models scored all pairs. Its [method decisions](codeql-comparison/) and [evaluation protocol](CODEQL.md) are available here.
 
 ### Private — 439 pairs
 
-| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Inference cost |
-| --- | ---: | ---: | ---: | ---: |
-| [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 |
+| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 34.2% | 29.0% | **5.2%** | **0** | Free tier |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 20.6% | 16.7% | 3.9% | **0** | $0.182 |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 21.9% | 18.5% | 3.3% | **0** | **$0.074** |
+| [TypeLLM](https://typellm.ai/docs) | 8.8% | 6.2% | 2.5% | **0** | $0.203 |
+| [GLiNER-2.5-Decide](https://huggingface.co/fastino/GLiNER2.5-Decide) | 2.0% | **1.5%** | 0.6% | 1 | $0.142 |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | **100.0%** | 100.0% | 0.0% | **0** | ~$0.528 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | **100.0%** | 100.0% | 0.0% | **0** | **$0.074** |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 8.0% | 8.1% | -0.1% | **0** | $0.091 |
 
 ## Perch Lint Bench
 
@@ -104,27 +111,29 @@ CodeQL scored 70 of the 1,311 public pairs; other models scored all pairs. Its [
 
 ### Public — 214 pairs
 
-| 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 |
+| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| [TypeLLM](https://typellm.ai/docs) | **61.7%** | 2.8% | **58.9%** | **0** | $0.050 |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 50.0% | 0.5% | 49.5% | **0** | $0.048 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 49.1% | 0.9% | 48.1% | **0** | Free tier |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 52.8% | 5.1% | 47.7% | **0** | $0.018 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 50.0% | 11.2% | 38.8% | **0** | $0.014 |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 38.8% | 37.4% | 1.4% | **0** | **~$0.010** |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 32.2% | 31.3% | 0.9% | **0** | $0.018 |
+| [GLiNER-2.5-Decide](https://huggingface.co/fastino/GLiNER2.5-Decide) | 0.0% | **0.0%** | 0.0% | **0** | **$0.010** |
 
 ### Private — 71 pairs
 
-| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Inference cost |
-| --- | ---: | ---: | ---: | ---: |
-| [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 |
+| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| [TypeLLM](https://typellm.ai/docs) | **59.2%** | 5.6% | **53.5%** | **0** | $0.016 |
+| [Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) | 53.5% | 1.4% | 52.1% | **0** | $0.016 |
+| [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 49.3% | 1.4% | 47.9% | **0** | Free tier |
+| [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 53.5% | 8.5% | 45.1% | **0** | $0.006 |
+| [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 45.1% | 8.5% | 36.6% | **0** | $0.005 |
+| [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | 50.7% | 49.3% | 1.4% | **0** | **~$0.003** |
+| [GLiNER-2.5-Decide](https://huggingface.co/fastino/GLiNER2.5-Decide) | 0.0% | **0.0%** | 0.0% | **0** | $0.004 |
+| [SemiF](https://github.com/TheoLeeCJ/SemIf) | 42.3% | 45.1% | -2.8% | **0** | $0.006 |
 
 <!-- END TRADEOFF_RESULTS -->
 
@@ -134,6 +143,8 @@ Span-01 uses its [behavior-scoring API](https://www.respan.ai/docs/documentation
 
 Liquid d1 received the same Perch method state and all applicable questions in one API call per method. Semantic lint used the same compiled `ensure` rule as Jev.
 
+GLiNER-2.5-Decide scores the answer criteria as native classification labels. Perch sizes each method's context and batches its applicable questions to fit the endpoint. Large methods are read in overlapping source chunks; each question's highest issue score supplies the method decision. Returned label confidences supply the scores. Timeouts and requests that still cannot fit are recorded as failures. Costs use API-reported prompt tokens at the live catalog rate of $0.03 per million input tokens.
+
 Inference costs cover scoring the method sides in each table. Jev costs are estimated from API-reported input tokens at [TypeSafe's published rate](https://typesafe.ai/blog/introducing-system-one-models-and-jev); for semantic lint, input-token usage was measured by replaying the same 570 requests with `jev-1.13.0`. Span-01 costs use API-reported input tokens at [Respan's published rate](https://www.respan.ai/docs/documentation/span-01/concept). Beam costs are API-reported. CLM cost is an estimated share of a 38.4-minute H100 run costing $2.23 total, allocated by embedding count. Costs are not ranked. Liquid d1 was tested on the `d1:free` API tier; a paid per-token price was not published. TypeLLM cost uses API-reported input tokens at its [published rate](https://typellm.ai/pricing); no thinking tokens were used.
 
 JevLike (192-byte input), Laya (512-token input), and Kev (packed-branch limit) could not score every full-context method. NanoJev was unavailable on Beam. They are excluded rather than ranked on partial results.
@@ -148,6 +159,8 @@ JevLike (192-byte input), Laya (512-token input), and Kev (packed-branch limit)
 - [`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.
 - [`typellm.py`](https://huggingface.co/datasets/perchscan/benchmark-results/blob/main/typellm.py): scores each method independently with applicable boolean questions and saves the returned probabilities.
+- [`gliner_decide.py`](https://huggingface.co/datasets/perchscan/benchmark-results/blob/main/gliner_decide.py): runs GLiNER-2.5-Decide through its native classification endpoint, saves returned confidences and failed requests, and scores each completed track.
+- [`perch-sizing.mjs`](https://huggingface.co/datasets/perchscan/benchmark-results/blob/main/perch-sizing.mjs): uses Perch's source chunking, context sizing, and question batching. Each reading records its source-byte coverage.
 - [`perch-lint-bench-public`](https://huggingface.co/datasets/perchscan/perch-lint-bench-public): paired rules and its runnable scorer.
 
 To run Jev with the current pack, set `TYPESAFE_API_KEY` or `PERCH_API_KEY` in your environment:
@@ -163,4 +176,14 @@ To run Span-01 on the public security pairs, set `RESPAN_API_KEY` and run:
 python3 span01.py --domain security --predictions security-span01.jsonl --report security-span01.json
 ```
 
+To run GLiNER-2.5-Decide, install the npm dependencies in a [Perch source checkout](https://github.com/lakeday-org/perch), set `PERCH_SOURCE` to that checkout and `FASTINO_API_KEY` to your API key, then run:
+
+```sh
+python3 gliner_decide.py --domain lint --out gliner-lint --budget 10
+python3 gliner_decide.py --domain bug --out gliner-bug --budget 10
+python3 gliner_decide.py --domain security --out gliner-security --budget 10
+```
+
+The runner starts with a 1,200-token state budget and a 1,800-token request budget. `--state-budget`, `--request-budget`, and `--max-questions` set model limits. A size rejection splits the question batch first, then rebuilds the source readings with a smaller state budget. Perch shortens caller and callee excerpts before splitting the target source. If a leading comment outside the target prevents a reading from fitting, it is omitted and recorded. Every target-source byte must remain covered. Saved results include the Perch revision, sizing settings, question scores, and API usage. Bug and security question floors and the 70% semantic lint floor stay unchanged.
+
 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.

gliner_decide.py

@@ -0,0 +1,408 @@
+#!/usr/bin/env python3
+"""Benchmark GLiNER-2.5-Decide through its native classification API.
+
+Perch batches each method's checks and sizes source readings for the endpoint.
+Both answer-label confidences are saved; the issue-bearing label supplies the score.
+Failures are saved once and count as wrong decisions, never as model scores.
+"""
+
+from __future__ import annotations
+
+import argparse
+import atexit
+from concurrent.futures import FIRST_COMPLETED, ThreadPoolExecutor, wait
+import hashlib
+import importlib.util
+import json
+import os
+from pathlib import Path
+import subprocess
+import threading
+import time
+from urllib.error import HTTPError
+from urllib.request import Request, urlopen
+
+
+ROOT = Path(__file__).resolve().parent
+MODEL = 'fastino/GLiNER-2.5-Decide'
+API = 'https://api.fastino.ai/v1/chat/completions'
+PRICE = .03
+PROTOCOL = 'gliner25-decide-perch-sized-classification-v1'
+spec = importlib.util.spec_from_file_location('perch_benchmark', ROOT / 'benchmark.py')
+core = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(core)
+
+
+class AccountError(RuntimeError):
+    pass
+
+
+class SizeError(RuntimeError):
+    pass
+
+
+class PerchSizer:
+    def __init__(self, source, cache):
+        self.lock = threading.Lock()
+        self.closed = False
+        self.process = subprocess.Popen(['node', str(ROOT / 'perch-sizing.mjs'), str(source), str(cache)],
+                                        stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True, bufsize=1)
+        atexit.register(self.close)
+
+    def plan(self, side, checks, state_budget, request_budget, max_questions):
+        with self.lock:
+            self.process.stdin.write(json.dumps({'side': side, 'checks': checks,
+                'stateBudget': state_budget, 'requestBudget': request_budget,
+                'maxQuestions': max_questions}) + '\n')
+            self.process.stdin.flush()
+            line = self.process.stdout.readline()
+            if not line:
+                raise RuntimeError('Perch sizing process stopped')
+            result = json.loads(line)
+            if result.get('error'):
+                if result.get('name') == 'ContextLimitError':
+                    raise SizeError(result['error'])
+                raise RuntimeError(result['error'])
+            return result['readings']
+
+    def close(self):
+        if self.closed:
+            return
+        self.closed = True
+        self.process.stdin.close()
+        try:
+            self.process.wait(timeout=10)
+        except subprocess.TimeoutExpired:
+            self.process.terminate()
+            self.process.wait(timeout=5)
+
+
+def read_rows(path):
+    return [json.loads(line) for line in path.read_text().splitlines() if line.strip()] if path.exists() else []
+
+
+def questions_for(pair, domain, pack):
+    if domain == 'lint':
+        rule = ' '.join(pair['rule']['ensure'].split())
+        return [{'name': 'semantic', 'question': {
+            'instructions': 'Does this method satisfy this requirement?',
+            'criteria': {'true': rule, 'false': 'The method violates this requirement: ' + rule}},
+            'issue': {'on': False}, 'min': 70}]
+    return core.detection_questions(core.scan_questions(pack, domain, pair['language']), domain)
+
+
+def request_labels(key, state, checks, timeout):
+    tasks, task_keys = [], {}
+    for check in checks:
+        q = check['question']
+        task = check['name'] + ': ' + q['instructions']
+        labels = [q['criteria']['true'], q['criteria']['false']]
+        if len(set(labels)) != 2:
+            raise ValueError('Classification requires distinct answer labels')
+        tasks.append({'task': task, 'labels': labels, 'multi_label': True, 'top_k': 2})
+        task_keys[check['name']] = (task, labels)
+    payload = {'model': MODEL,
+               'messages': [{'role': 'user', 'content': json.dumps(state, ensure_ascii=False)}],
+               'schema': {'classifications': tasks}, 'threshold': 0,
+               'include_confidence': True, 'store': False}
+    request = Request(API, data=json.dumps(payload, ensure_ascii=False).encode(),
+                      headers={'Authorization': 'Bearer ' + key, 'Content-Type': 'application/json'})
+    start = time.monotonic()
+    try:
+        with urlopen(request, timeout=timeout) as response:
+            result = json.load(response)
+    except HTTPError as exc:
+        detail = exc.read(500).decode(errors='replace')
+        if exc.code in (401, 402, 403):
+            raise AccountError(f'Fastino HTTP {exc.code}: {detail}') from None
+        if exc.code in (400, 413, 422) and ('input_too_long' in detail or exc.code == 413):
+            raise SizeError(f'Fastino HTTP {exc.code}: {detail}') from None
+        raise RuntimeError(f'Fastino HTTP {exc.code}: {detail}') from None
+    if result['model'] != MODEL:
+        raise ValueError('API returned a different model')
+    content = json.loads(result['choices'][0]['message']['content'])
+    answers = content.get('classifications', content)
+    confidences, issue_scores = {}, {}
+    for check in checks:
+        task, labels = task_keys[check['name']]
+        answer = answers[task]
+        if not isinstance(answer, list):
+            raise ValueError('API did not return both answer-label confidences')
+        values = {item['label']: core.probability(item['confidence']) for item in answer}
+        if set(values) != set(labels):
+            raise ValueError('API returned missing or unexpected answer labels')
+        confidences[check['name']] = {'true': values[labels[0]], 'false': values[labels[1]]}
+        issue_scores[check['name']] = values[labels[1] if check['issue'].get('on') is False else labels[0]]
+    return confidences, issue_scores, result.get('usage', {}), time.monotonic() - start
+
+
+def predict(key, pair, role, domain, pack, timeout, sizer, state_budget, request_budget, max_questions):
+    checks = questions_for(pair, domain, pack)
+    by_name = {check['name']: check for check in checks}
+    usage, requests, repacks, spent_readings = {}, 0, 0, []
+    start = time.monotonic()
+    budget = state_budget
+    for attempt in range(9):
+        confidences, issue_scores, readings = {}, {}, []
+        try:
+            plans = sizer.plan(pair[role], checks, budget, request_budget, max_questions)
+            def ask_reading(plan, names):
+                nonlocal requests, repacks
+                requests += 1
+                try:
+                    values, scores, charged, latency = request_labels(key, plan['state'], [by_name[n] for n in names], timeout)
+                except SizeError:
+                    if len(names) == 1:
+                        raise
+                    repacks += 1
+                    middle = (len(names) + 1) // 2
+                    ask_reading(plan, names[:middle])
+                    ask_reading(plan, names[middle:])
+                    return
+                for name, value in charged.items():
+                    if isinstance(value, (int, float)):
+                        usage[name] = usage.get(name, 0) + value
+                for name, score in scores.items():
+                    if name not in issue_scores or score > issue_scores[name]:
+                        issue_scores[name], confidences[name] = score, values[name]
+                reading = {k: v for k, v in plan.items() if k not in ('state', 'question_names')}
+                reading.update(question_names=names, state_sha256=hashlib.sha256(json.dumps(plan['state'], sort_keys=True).encode()).hexdigest(),
+                               latency_seconds=latency, usage=charged, state_budget=budget)
+                readings.append(reading)
+                spent_readings.append(reading)
+            for plan in plans:
+                ask_reading(plan, plan['question_names'])
+            break
+        except SizeError as exc:
+            smaller = budget // 2
+            if attempt == 8 or smaller < 128:
+                exc.usage, exc.requests = usage, requests
+                raise
+            budget = smaller
+            repacks += 1
+        except Exception as exc:
+            exc.usage, exc.requests = usage, requests
+            raise
+    if set(issue_scores) != set(by_name):
+        exc = RuntimeError('Not every check received a score')
+        exc.usage, exc.requests = usage, requests
+        raise exc
+    if domain == 'lint':
+        score = issue_scores['semantic']
+        alert = score > .7
+    else:
+        score, alert = core.scan_result(issue_scores, checks, domain, .5)
+    return {'pair_id': pair['pair_id'], 'role': role, 'domain': domain,
+            'model_revision': MODEL, 'protocol_id': PROTOCOL,
+            'pack_sha256': pack['pack_sha256'] if domain != 'lint' else None,
+            'score': score, 'alert': alert, 'question_scores': issue_scores,
+            'answer_confidences': confidences, 'usage': usage, 'api_requests': requests,
+            'readings': readings, 'discarded_readings': len(spent_readings) - len(readings),
+            'size_repacks': repacks, 'final_state_budget': budget,
+            'latency_seconds': time.monotonic() - start}
+
+
+def report(pairs, predictions, failures, domain, digest, split):
+    counts = dict(tp=0, fp=0, fn=0, tn=0)
+    items, eligible, correct, ties = [], 0, 0, 0
+    for pair in pairs:
+        for role in ('before', 'after'):
+            identity = pair['pair_id'], role
+            label = pair[role]['labels'][pair['domain'] if domain == 'lint' else domain]
+            row = predictions.get(identity)
+            if row:
+                items.append((label, row['score']))
+                counts['tp' if label and row['alert'] else 'fn' if label else 'fp' if row['alert'] else 'tn'] += 1
+            elif identity in failures:
+                counts['fn' if label else 'fp'] += 1
+        if pair['before']['labels'][pair['domain']] == 1 and pair['after']['labels'][pair['domain']] == 0:
+            eligible += 1
+            before = predictions.get((pair['pair_id'], 'before'))
+            after = predictions.get((pair['pair_id'], 'after'))
+            if before and after:
+                correct += before['score'] > after['score']
+                ties += before['score'] == after['score']
+    tp, fp, fn, tn = (counts[k] for k in ('tp', 'fp', 'fn', 'tn'))
+    tokens = sum(row.get('usage', {}).get('prompt_tokens', 0) for row in [*predictions.values(), *failures.values()])
+    return {'domain': domain, 'split': split, 'model_revision': MODEL,
+            'protocol_id': PROTOCOL,
+            'benchmark_sha256': digest, 'benchmark_pairs': len(pairs),
+            'benchmark_methods': 2 * len(pairs), 'answered_methods': len(predictions),
+            'failed_methods': len(failures),
+            'complete': len(predictions) + len(failures) == 2 * len(pairs),
+            'failure_policy': 'failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering',
+            'confusion': counts, 'precision': tp / (tp + fp) if tp + fp else 0,
+            'recall': tp / (tp + fn) if tp + fn else 0,
+            'false_positive_rate': fp / (fp + tn) if fp + tn else 0,
+            'f1': 2 * tp / (2 * tp + fp + fn) if 2 * tp + fp + fn else 0,
+            'average_precision_answered_methods': core.average_precision(items) if items else None,
+            'vulnerable_or_buggy_before_above_fixed_after': {'correct': correct, 'ties': ties, 'eligible': eligible},
+            'input_tokens': tokens, 'inference_cost_usd': tokens * PRICE / 1_000_000,
+            'cost_basis': 'API-reported prompt tokens; failed requests have no returned usage'}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--manifest', type=Path, help='Suite manifest listing local datasets and their SHA-256 hashes')
+    parser.add_argument('--domain', choices=('bug', 'security', 'lint'), help='Run one public benchmark instead of a suite manifest')
+    parser.add_argument('--dataset', type=Path, help='Local benchmark.jsonl; otherwise download the public dataset')
+    parser.add_argument('--out', type=Path, required=True)
+    parser.add_argument('--question-pack', type=Path, default=ROOT / 'question-pack.json')
+    parser.add_argument('--workers', type=int, default=8)
+    parser.add_argument('--timeout', type=float, default=45)
+    parser.add_argument('--budget', type=float, default=10)
+    parser.add_argument('--limit', type=int, default=0, help='Maximum newly attempted method sides')
+    parser.add_argument('--keychain-service', default='perch-fastino-api-key')
+    parser.add_argument('--perch-source', type=Path, default=os.getenv('PERCH_SOURCE'))
+    parser.add_argument('--state-budget', type=int, default=1200)
+    parser.add_argument('--request-budget', type=int, default=1800)
+    parser.add_argument('--max-questions', type=int)
+    parser.add_argument('--score-saved', action='store_true')
+    args = parser.parse_args()
+    if bool(args.manifest) == bool(args.domain):
+        parser.error('Use either --manifest or --domain')
+    if args.workers < 1 or args.timeout <= 0 or args.budget <= 0 or args.limit < 0:
+        parser.error('Workers, timeout, and budget must be positive; limit must be nonnegative')
+    if args.state_budget < 128 or args.request_budget <= args.state_budget:
+        parser.error('State budget must be at least 128 and smaller than the request budget')
+    if args.manifest:
+        manifest = json.loads(args.manifest.read_text())
+    else:
+        path = args.dataset
+        if path is None:
+            url = ('https://huggingface.co/datasets/perchscan/perch-lint-bench-public/resolve/main/benchmark.jsonl'
+                   if args.domain == 'lint' else core.DATASET_URL[args.domain])
+            with urlopen(url, timeout=120) as response:
+                raw = response.read()
+            args.out.mkdir(parents=True, exist_ok=True)
+            path = args.out / 'benchmark.jsonl'
+            path.write_bytes(raw)
+        manifest = {'datasets': [{'split': 'public', 'domain': args.domain, 'path': str(path),
+                                 'sha256': hashlib.sha256(path.read_bytes()).hexdigest()}]}
+    pack = core.load_pack(args.question_pack)
+    sizing = {'state_budget': args.state_budget, 'request_budget': args.request_budget,
+              'max_questions': args.max_questions,
+              'adapter_sha256': hashlib.sha256((ROOT / 'perch-sizing.mjs').read_bytes()).hexdigest()}
+    if args.perch_source:
+        revision_file = args.perch_source / 'revision.json'
+        if revision_file.exists():
+            revision = json.loads(revision_file.read_text())
+            sizing['perch_revision'] = revision.get('revision', revision.get('sha'))
+        else:
+            sizing['perch_revision'] = subprocess.check_output(
+                ['git', '-C', str(args.perch_source), 'rev-parse', 'HEAD'], text=True).strip()
+    groups, pending = [], []
+    for dataset in manifest['datasets']:
+        raw = Path(dataset['path']).read_bytes()
+        digest = hashlib.sha256(raw).hexdigest()
+        if digest != dataset['sha256']:
+            raise ValueError('Dataset checksum changed')
+        pairs = [json.loads(line) for line in raw.splitlines() if line]
+        directory = args.out / dataset['split'] / dataset['domain']
+        directory.mkdir(parents=True, exist_ok=True)
+        preds = {(r['pair_id'], r['role']): r for r in read_rows(directory / 'predictions.jsonl')}
+        fails = {(r['pair_id'], r['role']): r for r in read_rows(directory / 'failures.jsonl')}
+        expected = {(p['pair_id'], role) for p in pairs for role in ('before', 'after')}
+        if set(preds) & set(fails) or not (set(preds) | set(fails)) <= expected:
+            raise ValueError('Incompatible or duplicate saved outcomes')
+        if any(r['model_revision'] != MODEL or r['dataset_sha256'] != digest or r['protocol_id'] != PROTOCOL for r in [*preds.values(), *fails.values()]):
+            raise ValueError('Saved outcomes mix models or datasets')
+        saved_sizing = {json.dumps(r['sizing'], sort_keys=True) for r in [*preds.values(), *fails.values()]}
+        if len(saved_sizing) > 1:
+            raise ValueError('Saved outcomes mix sizing configurations')
+        if saved_sizing:
+            recorded = json.loads(next(iter(saved_sizing)))
+            if args.score_saved:
+                if groups and sizing != recorded:
+                    raise ValueError('Suite outcomes mix sizing configurations')
+                sizing = recorded
+            elif sizing != recorded:
+                raise ValueError('Sizing configuration changed; use a new output directory')
+        group = dict(pairs=pairs, predictions=preds, failures=fails, directory=directory,
+                     domain=dataset['domain'], split=dataset['split'], digest=digest)
+        groups.append(group)
+        for pair in pairs:
+            for role in ('before', 'after'):
+                if (pair['pair_id'], role) not in preds and (pair['pair_id'], role) not in fails:
+                    pending.append((group, pair, role))
+    spent = sum(r.get('usage', {}).get('prompt_tokens', 0) for g in groups for r in [*g['predictions'].values(), *g['failures'].values()]) * PRICE / 1_000_000
+    def save_reports():
+        reports = []
+        for g in groups:
+            r = report(g['pairs'], g['predictions'], g['failures'], g['domain'], g['digest'], g['split'])
+            r['sizing'] = sizing
+            r['question_pack_sha256'] = pack['pack_sha256'] if g['domain'] != 'lint' else None
+            (g['directory'] / 'report.json').write_text(json.dumps(r, indent=2) + '\n')
+            reports.append(r)
+        (args.out / 'status.json').write_text(json.dumps({'model': MODEL, 'reports': reports,
+            'reported_cost_usd': sum(r['inference_cost_usd'] for r in reports),
+            'complete': all(r['complete'] for r in reports)}, indent=2) + '\n')
+    save_reports()
+    if args.score_saved or not pending:
+        return
+    if not args.perch_source:
+        parser.error('Set PERCH_SOURCE or --perch-source to the public Perch source checkout with npm dependencies installed')
+    sizer = PerchSizer(args.perch_source, args.out / '.sizing')
+    key = os.getenv('FASTINO_API_KEY') or subprocess.check_output(
+        ['security', 'find-generic-password', '-s', args.keychain_service, '-w'], text=True).strip()
+    if args.limit:
+        pending = pending[:args.limit]
+    iterator = iter(pending)
+    with ThreadPoolExecutor(max_workers=args.workers) as pool:
+        active = {}
+        def submit():
+            if spent >= args.budget:
+                return False
+            item = next(iterator, None)
+            if item is None:
+                return False
+            g, pair, role = item
+            active[pool.submit(predict, key, pair, role, g['domain'], pack, args.timeout,
+                               sizer, args.state_budget, args.request_budget, args.max_questions)] = item
+            return True
+        for _ in range(args.workers):
+            submit()
+        attempted = 0
+        try:
+            while active:
+                done, _ = wait(active, return_when=FIRST_COMPLETED)
+                for future in done:
+                    g, pair, role = active.pop(future)
+                    identity = pair['pair_id'], role
+                    try:
+                        row = future.result()
+                    except AccountError:
+                        for queued in active:
+                            queued.cancel()
+                        raise
+                    except Exception as exc:
+                        row = {'pair_id': pair['pair_id'], 'role': role, 'domain': g['domain'],
+                               'model_revision': MODEL, 'dataset_sha256': g['digest'],
+                               'protocol_id': PROTOCOL, 'status': 'failed', 'error': str(exc),
+                               'sizing': sizing,
+                               'usage': getattr(exc, 'usage', {}), 'api_requests': getattr(exc, 'requests', 0)}
+                        g['failures'][identity] = row
+                        spent += row['usage'].get('prompt_tokens', 0) * PRICE / 1_000_000
+                        with (g['directory'] / 'failures.jsonl').open('a') as stream:
+                            stream.write(json.dumps(row) + '\n')
+                        print(f"{g['split']}/{g['domain']}: failed {pair['pair_id']}:{role}: {exc}", flush=True)
+                    else:
+                        row['dataset_sha256'] = g['digest']
+                        row['sizing'] = sizing
+                        g['predictions'][identity] = row
+                        spent += row.get('usage', {}).get('prompt_tokens', 0) * PRICE / 1_000_000
+                        with (g['directory'] / 'predictions.jsonl').open('a') as stream:
+                            stream.write(json.dumps(row) + '\n')
+                    attempted += 1
+                    if attempted % 50 == 0 or not active:
+                        save_reports()
+                        print(f"Attempted {attempted}/{len(pending)} new methods; reported cost ${spent:.4f}", flush=True)
+                    submit()
+        finally:
+            save_reports()
+    print('Completed all scheduled method sides.', flush=True)
+    sizer.close()
+
+
+if __name__ == '__main__':
+    main()

perch-sizing.mjs

@@ -0,0 +1,96 @@
+/** Size saved benchmark methods with Perch's request and source-chunking code. */
+import { createRequire } from 'node:module';
+import { createInterface } from 'node:readline';
+import { mkdirSync, existsSync, symlinkSync } from 'node:fs';
+import { resolve, join, dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createHash } from 'node:crypto';
+
+const [source, cache] = process.argv.slice(2).map(value => resolve(value));
+if (!source || !cache) throw new Error('Usage: node perch-sizing.mjs PERCH_SOURCE CACHE_DIR');
+mkdirSync(cache, { recursive: true });
+if (!existsSync(join(cache, 'node_modules'))) symlinkSync(join(source, 'node_modules'), join(cache, 'node_modules'), 'dir');
+if (!existsSync(join(dirname(cache), 'scan.yaml'))) symlinkSync(join(source, 'scan.yaml'), join(dirname(cache), 'scan.yaml'));
+const require = createRequire(join(source, 'package.json'));
+const { build } = require('esbuild');
+const library = join(cache, 'perch-sizing-lib.mjs');
+await build({ stdin: {
+  contents: `export { methodSteps } from ${JSON.stringify(join(source, 'src/questions.js'))};\nexport { questionBatches, estimateTokens } from ${JSON.stringify(join(source, 'src/tokens.js'))};`,
+  resolveDir: source, sourcefile: 'benchmark-sizing.mjs', loader: 'js',
+}, outfile: library, bundle: true, packages: 'external', platform: 'node', format: 'esm', logLevel: 'silent' });
+const { methodSteps, questionBatches, estimateTokens } = await import(pathToFileURL(library));
+
+function unnumber(source) {
+  return String(source ?? '').split('\n').filter(line => !/^\.\.\. \(\d+ (?:lines above|more lines)\)$/.test(line))
+    .map(line => line.replace(/^L\d+\| ?/, '')).join('\n');
+}
+
+function methodInput(side) {
+  const state = side.state, method = state.method;
+  const body = side.source ?? unnumber(method.source);
+  const comment = method.leading_comment ?? '';
+  const prefix = comment ? comment.split('\n') : [];
+  const lines = [...prefix, ...body.split('\n')];
+  const id = method.id ?? `${method.path}::${method.name}`;
+  const node = { id, path: method.path, qualified_name: method.name, line: prefix.length + 1, end_line: lines.length, metrics: method.metrics };
+  const names = new Map([[method.name, id], [id, id]]);
+  const neighbor = item => {
+    const text = unnumber(item.source), firstLine = Number(String(item.source ?? '').match(/^L(\d+)\|/m)?.[1] ?? 1);
+    const lines = text.split('\n');
+    const id = item.id ?? `${item.path}::${item.name}`;
+    names.set(item.name, id); names.set(id, id);
+    return { node: { id, path: item.path, qualified_name: item.name, line: 1, end_line: lines.length, metrics: item.metrics },
+      lines, ...(item.calls_method_at ? { site: Math.max(1, item.calls_method_at - firstLine + 1) } : {}), handover: item.handover ?? false };
+  };
+  const callees = (state.calls ?? []).map(neighbor), callers = (state.called_by ?? []).map(neighbor);
+  const edges = (state.call_graph ?? []).map(edge => Array.isArray(edge) ? edge : String(edge).split(' -> '))
+    .filter(edge => edge.length === 2).map(edge => edge.map(name => names.get(name) ?? name));
+  return { node, lines, callees, callers, edges };
+}
+
+function plan({ side, checks, stateBudget, requestBudget, maxQuestions }) {
+  const target = side.source ?? unnumber(side.state.method.source);
+  const bytes = Buffer.byteLength(target);
+  const questions = Object.fromEntries(checks.map(check => [check.name, {
+    type: 'choice', instructions: check.name + ': ' + check.question.instructions,
+    criteria: check.question.criteria,
+  }]));
+  const limits = { state: stateBudget, single: requestBudget, request: requestBudget, questions: maxQuestions ?? Infinity, options: 2 };
+  let steps, leadingCommentOmitted = false;
+  if (estimateTokens(side.state) <= stateBudget && unnumber(side.state.method.source).includes(target.trim()))
+    steps = [{ state: side.state, covers: { start_byte: 0, end_byte: bytes } }];
+  else {
+    try { steps = methodSteps({ ...methodInput(side), budget: stateBudget, asked: [] }); }
+    catch (error) {
+      if (error.name !== 'ContextLimitError' || !side.state.method.leading_comment) throw error;
+      // The saved leading comment is surrounding context, outside the canonical target source.
+      const withoutComment = { ...side, state: { ...side.state, method: { ...side.state.method, leading_comment: null } } };
+      steps = methodSteps({ ...methodInput(withoutComment), budget: stateBudget, asked: [] });
+      leadingCommentOmitted = true;
+    }
+  }
+  let covered = 0;
+  for (const step of steps) {
+    if (step.covers.start_byte > covered) throw new Error('Source readings leave a gap in the target method');
+    covered = Math.max(covered, step.covers.end_byte);
+  }
+  if (covered !== bytes) throw new Error('Source readings do not cover the complete target method');
+  const readings = [];
+  for (let index = 0; index < steps.length; index++) {
+    const step = steps[index];
+    for (const batch of questionBatches(step.state, questions, limits)) readings.push({
+      state: step.state, question_names: Object.keys(batch),
+      source_reading: step.state.reading ?? null, covers: step.covers ?? null,
+      source_pass: index, source_passes: steps.length, estimated_state_tokens: estimateTokens(step.state),
+      target_source_bytes: bytes, target_source_sha256: createHash('sha256').update(target).digest('hex'),
+      leading_comment_omitted: leadingCommentOmitted,
+    });
+  }
+  return readings;
+}
+
+for await (const line of createInterface({ input: process.stdin, crlfDelay: Infinity })) {
+  if (!line.trim()) continue;
+  try { process.stdout.write(JSON.stringify({ readings: plan(JSON.parse(line)) }) + '\n'); }
+  catch (error) { process.stdout.write(JSON.stringify({ error: error.message, name: error.name }) + '\n'); }
+}

predictions/current/bug/gliner25-decide.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33d9f9a780c9a2de4c27a64535b3e8a8b5cffc7771922e8b4a8cc0ffb8883d89
+size 12338489

predictions/current/lint/gliner25-decide.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e737f22f09804dd314134013587b51d8b9895e303c07c4f753682f04f8d9e02
+size 727671

predictions/current/security/gliner25-decide.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:991c295fb93028a632b7b3af198ec845377f833278d7c7ba3772a1d994049f80
+size 26258297

results-current.jsonl

@@ -40,3 +40,9 @@
 {"alert_rule": "any issue score > max(run threshold, question min)", "average_precision": 0.4916331564208488, "benchmark_methods": 878, "benchmark_pairs": 439, "confusion": {"fn": 363, "fp": 30, "tn": 450, "tp": 35}, "domain": "security", "f1": 0.1511879049676026, "inference_cost_basis": "API-reported input and thinking tokens at published TypeLLM rates", "inference_cost_usd": 0.20261235, "inference_endpoint": "https://api.typellm.ai/v1/generate", "inference_host": "TypeLLM", "model_id": "typellm", "model_revision": "typellm-latest", "pair_order": 0.5025125628140703, "pair_order_correct": 200, "pair_order_eligible": 398, "precision": 0.5384615384615384, "protocol_id": "perch-scan-afe116cc8461", "question_pack_sha256": "afe116cc8461552aaca996f8f0b639cdf5e42e9d8291c59995482309b5c330dc", "recall": 0.08793969849246232, "run_id": "typellm-20260930", "threshold": 0.5, "track": "private"}
 {"alert_rule": "rule violation score > 0.7", "average_precision": 0.9489849049042018, "benchmark_methods": 428, "benchmark_pairs": 214, "confusion": {"fn": 82, "fp": 6, "tn": 208, "tp": 132}, "domain": "lint", "f1": 0.75, "inference_cost_basis": "API-reported input and thinking tokens at published TypeLLM rates", "inference_cost_usd": 0.049926450000000004, "inference_endpoint": "https://api.typellm.ai/v1/generate", "inference_host": "TypeLLM", "model_id": "typellm", "model_revision": "typellm-latest", "pair_order": 0.9532710280373832, "pair_order_correct": 204, "pair_order_eligible": 214, "precision": 0.9565217391304348, "protocol_id": "perch-semantic-ensure-v1", "question_pack_sha256": null, "recall": 0.616822429906542, "run_id": "typellm-20260930", "threshold": 0.7, "track": "public"}
 {"alert_rule": "rule violation score > 0.7", "average_precision": 0.9441042508382544, "benchmark_methods": 142, "benchmark_pairs": 71, "confusion": {"fn": 29, "fp": 4, "tn": 67, "tp": 42}, "domain": "lint", "f1": 0.717948717948718, "inference_cost_basis": "API-reported input and thinking tokens at published TypeLLM rates", "inference_cost_usd": 0.0159958, "inference_endpoint": "https://api.typellm.ai/v1/generate", "inference_host": "TypeLLM", "model_id": "typellm", "model_revision": "typellm-latest", "pair_order": 0.971830985915493, "pair_order_correct": 69, "pair_order_eligible": 71, "precision": 0.9130434782608695, "protocol_id": "perch-semantic-ensure-v1", "question_pack_sha256": null, "recall": 0.5915492957746479, "run_id": "typellm-20260930", "threshold": 0.7, "track": "private"}
+{"alert_rule": "rule violation confidence > 0.7", "answered_methods": 428, "average_precision_answered_methods": 0.5287989800050326, "benchmark_methods": 428, "benchmark_pairs": 214, "benchmark_sha256": "534f6c2abddc507c40f4597607e97e07168c544011d617b83aa39e08abb35d75", "complete": true, "confusion": {"fn": 214, "fp": 0, "tn": 214, "tp": 0}, "cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "domain": "lint", "f1": 0.0, "failed_methods": 0, "failure_counts": {}, "failure_policy": "failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering", "false_positive_rate": 0.0, "inference_cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "inference_cost_usd": 0.010324469999999999, "inference_endpoint": "https://api.fastino.ai/v1/chat/completions", "inference_host": "Fastino API", "input_tokens": 344149, "model_id": "gliner25-decide", "model_revision": "fastino/GLiNER-2.5-Decide", "pair_order": 0.5934579439252337, "pair_order_correct": 127, "pair_order_eligible": 214, "precision": 0, "protocol_id": "gliner25-decide-perch-sized-classification-v1", "question_pack_sha256": null, "recall": 0.0, "run_id": "gliner25-decide-perch-sized-20261002", "sizing": {"adapter_sha256": "6be2c1e0003b8181ea7725193c039ed21b3a86fa80bafe46f99d7759b76c6b93", "max_questions": null, "perch_revision": "3db94f007ca49433c816b4a3855253d15f7b8139", "request_budget": 1800, "state_budget": 1200}, "split": "public", "threshold": 0.7, "track": "public", "vulnerable_or_buggy_before_above_fixed_after": {"correct": 127, "eligible": 214, "ties": 7}}
+{"alert_rule": "rule violation confidence > 0.7", "answered_methods": 142, "average_precision_answered_methods": 0.5264561177710998, "benchmark_methods": 142, "benchmark_pairs": 71, "benchmark_sha256": "a6e9f2e4ee8ae77bdaf23af46920d97d1ba47375dc9ce03b950cdbe95c2777f9", "complete": true, "confusion": {"fn": 71, "fp": 0, "tn": 71, "tp": 0}, "cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "domain": "lint", "f1": 0.0, "failed_methods": 0, "failure_counts": {}, "failure_policy": "failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering", "false_positive_rate": 0.0, "inference_cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "inference_cost_usd": 0.0035382, "inference_endpoint": "https://api.fastino.ai/v1/chat/completions", "inference_host": "Fastino API", "input_tokens": 117940, "model_id": "gliner25-decide", "model_revision": "fastino/GLiNER-2.5-Decide", "pair_order": 0.6338028169014085, "pair_order_correct": 45, "pair_order_eligible": 71, "precision": 0, "protocol_id": "gliner25-decide-perch-sized-classification-v1", "question_pack_sha256": null, "recall": 0.0, "run_id": "gliner25-decide-perch-sized-20261002", "sizing": {"adapter_sha256": "6be2c1e0003b8181ea7725193c039ed21b3a86fa80bafe46f99d7759b76c6b93", "max_questions": null, "perch_revision": "3db94f007ca49433c816b4a3855253d15f7b8139", "request_budget": 1800, "state_budget": 1200}, "split": "private", "threshold": 0.7, "track": "private", "vulnerable_or_buggy_before_above_fixed_after": {"correct": 45, "eligible": 71, "ties": 1}}
+{"alert_rule": "any issue score > max(0.5, question min)", "answered_methods": 4440, "average_precision_answered_methods": 0.422300940463931, "benchmark_methods": 4440, "benchmark_pairs": 2220, "benchmark_sha256": "32bc68bc85d5535ad28e103adbfa0c09c73e09d0f53a53f7ca35ec219a96e6e2", "complete": true, "confusion": {"fn": 1818, "fp": 54, "tn": 2525, "tp": 43}, "cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "domain": "bug", "f1": 0.043922369765066395, "failed_methods": 0, "failure_counts": {}, "failure_policy": "failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering", "false_positive_rate": 0.02093834819697557, "inference_cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "inference_cost_usd": 0.17524755, "inference_endpoint": "https://api.fastino.ai/v1/chat/completions", "inference_host": "Fastino API", "input_tokens": 5841585, "model_id": "gliner25-decide", "model_revision": "fastino/GLiNER-2.5-Decide", "pair_order": 0.5173961840628507, "pair_order_correct": 922, "pair_order_eligible": 1782, "precision": 0.44329896907216493, "protocol_id": "gliner25-decide-perch-sized-classification-v1", "question_pack_sha256": "afe116cc8461552aaca996f8f0b639cdf5e42e9d8291c59995482309b5c330dc", "recall": 0.0231058570660935, "run_id": "gliner25-decide-perch-sized-20261002", "sizing": {"adapter_sha256": "6be2c1e0003b8181ea7725193c039ed21b3a86fa80bafe46f99d7759b76c6b93", "max_questions": null, "perch_revision": "3db94f007ca49433c816b4a3855253d15f7b8139", "request_budget": 1800, "state_budget": 1200}, "split": "public", "threshold": 0.5, "track": "public", "vulnerable_or_buggy_before_above_fixed_after": {"correct": 922, "eligible": 1782, "ties": 121}}
+{"alert_rule": "any issue score > max(0.5, question min)", "answered_methods": 996, "average_precision_answered_methods": 0.43547986367375113, "benchmark_methods": 996, "benchmark_pairs": 498, "benchmark_sha256": "3df4ade65fedd1128d30bc17c9c9869c8ab9bd526e666156d0e16685e78f8a73", "complete": true, "confusion": {"fn": 417, "fp": 12, "tn": 560, "tp": 7}, "cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "domain": "bug", "f1": 0.03160270880361174, "failed_methods": 0, "failure_counts": {}, "failure_policy": "failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering", "false_positive_rate": 0.02097902097902098, "inference_cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "inference_cost_usd": 0.039281729999999994, "inference_endpoint": "https://api.fastino.ai/v1/chat/completions", "inference_host": "Fastino API", "input_tokens": 1309391, "model_id": "gliner25-decide", "model_revision": "fastino/GLiNER-2.5-Decide", "pair_order": 0.5211970074812967, "pair_order_correct": 209, "pair_order_eligible": 401, "precision": 0.3684210526315789, "protocol_id": "gliner25-decide-perch-sized-classification-v1", "question_pack_sha256": "afe116cc8461552aaca996f8f0b639cdf5e42e9d8291c59995482309b5c330dc", "recall": 0.01650943396226415, "run_id": "gliner25-decide-perch-sized-20261002", "sizing": {"adapter_sha256": "6be2c1e0003b8181ea7725193c039ed21b3a86fa80bafe46f99d7759b76c6b93", "max_questions": null, "perch_revision": "3db94f007ca49433c816b4a3855253d15f7b8139", "request_budget": 1800, "state_budget": 1200}, "split": "private", "threshold": 0.5, "track": "private", "vulnerable_or_buggy_before_above_fixed_after": {"correct": 209, "eligible": 401, "ties": 28}}
+{"alert_rule": "any issue score > max(0.5, question min)", "answered_methods": 2616, "average_precision_answered_methods": 0.4560152509236216, "benchmark_methods": 2622, "benchmark_pairs": 1311, "benchmark_sha256": "2407059caa3486371749884138b997d89043eec646e548ee8f44ba3ab08514b8", "complete": true, "confusion": {"fn": 1118, "fp": 23, "tn": 1457, "tp": 24}, "cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "domain": "security", "f1": 0.040370058873002525, "failed_methods": 6, "failure_counts": {"other": 6}, "failure_policy": "failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering", "false_positive_rate": 0.015540540540540541, "inference_cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "inference_cost_usd": 0.43368182999999993, "inference_endpoint": "https://api.fastino.ai/v1/chat/completions", "inference_host": "Fastino API", "input_tokens": 14456061, "model_id": "gliner25-decide", "model_revision": "fastino/GLiNER-2.5-Decide", "pair_order": 0.45729537366548045, "pair_order_correct": 514, "pair_order_eligible": 1124, "precision": 0.5106382978723404, "protocol_id": "gliner25-decide-perch-sized-classification-v1", "question_pack_sha256": "afe116cc8461552aaca996f8f0b639cdf5e42e9d8291c59995482309b5c330dc", "recall": 0.021015761821366025, "run_id": "gliner25-decide-perch-sized-20261002", "sizing": {"adapter_sha256": "6be2c1e0003b8181ea7725193c039ed21b3a86fa80bafe46f99d7759b76c6b93", "max_questions": null, "perch_revision": "3db94f007ca49433c816b4a3855253d15f7b8139", "request_budget": 1800, "state_budget": 1200}, "split": "public", "threshold": 0.5, "track": "public", "vulnerable_or_buggy_before_above_fixed_after": {"correct": 514, "eligible": 1124, "ties": 35}}
+{"alert_rule": "any issue score > max(0.5, question min)", "answered_methods": 877, "average_precision_answered_methods": 0.44020539336977416, "benchmark_methods": 878, "benchmark_pairs": 439, "benchmark_sha256": "a4b81728e9e520cf1c6f342974bec369d72f5b7d8aabc1c9cf2aceba966f8051", "complete": true, "confusion": {"fn": 390, "fp": 7, "tn": 473, "tp": 8}, "cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "domain": "security", "f1": 0.0387409200968523, "failed_methods": 1, "failure_counts": {"other": 1}, "failure_policy": "failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering", "false_positive_rate": 0.014583333333333334, "inference_cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "inference_cost_usd": 0.14154047999999997, "inference_endpoint": "https://api.fastino.ai/v1/chat/completions", "inference_host": "Fastino API", "input_tokens": 4718016, "model_id": "gliner25-decide", "model_revision": "fastino/GLiNER-2.5-Decide", "pair_order": 0.4949748743718593, "pair_order_correct": 197, "pair_order_eligible": 398, "precision": 0.5333333333333333, "protocol_id": "gliner25-decide-perch-sized-classification-v1", "question_pack_sha256": "afe116cc8461552aaca996f8f0b639cdf5e42e9d8291c59995482309b5c330dc", "recall": 0.020100502512562814, "run_id": "gliner25-decide-perch-sized-20261002", "sizing": {"adapter_sha256": "6be2c1e0003b8181ea7725193c039ed21b3a86fa80bafe46f99d7759b76c6b93", "max_questions": null, "perch_revision": "3db94f007ca49433c816b4a3855253d15f7b8139", "request_budget": 1800, "state_budget": 1200}, "split": "private", "threshold": 0.5, "track": "private", "vulnerable_or_buggy_before_above_fixed_after": {"correct": 197, "eligible": 398, "ties": 8}}

results.jsonl

@@ -86,3 +86,9 @@
 {"alert_rule": "any issue score > max(run threshold, question min)", "average_precision": 0.4916331564208488, "benchmark_methods": 878, "benchmark_pairs": 439, "confusion": {"fn": 363, "fp": 30, "tn": 450, "tp": 35}, "domain": "security", "f1": 0.1511879049676026, "inference_cost_basis": "API-reported input and thinking tokens at published TypeLLM rates", "inference_cost_usd": 0.20261235, "inference_endpoint": "https://api.typellm.ai/v1/generate", "inference_host": "TypeLLM", "model_id": "typellm", "model_revision": "typellm-latest", "pair_order": 0.5025125628140703, "pair_order_correct": 200, "pair_order_eligible": 398, "precision": 0.5384615384615384, "protocol_id": "perch-scan-afe116cc8461", "question_pack_sha256": "afe116cc8461552aaca996f8f0b639cdf5e42e9d8291c59995482309b5c330dc", "recall": 0.08793969849246232, "run_id": "typellm-20260930", "threshold": 0.5, "track": "private"}
 {"alert_rule": "rule violation score > 0.7", "average_precision": 0.9489849049042018, "benchmark_methods": 428, "benchmark_pairs": 214, "confusion": {"fn": 82, "fp": 6, "tn": 208, "tp": 132}, "domain": "lint", "f1": 0.75, "inference_cost_basis": "API-reported input and thinking tokens at published TypeLLM rates", "inference_cost_usd": 0.049926450000000004, "inference_endpoint": "https://api.typellm.ai/v1/generate", "inference_host": "TypeLLM", "model_id": "typellm", "model_revision": "typellm-latest", "pair_order": 0.9532710280373832, "pair_order_correct": 204, "pair_order_eligible": 214, "precision": 0.9565217391304348, "protocol_id": "perch-semantic-ensure-v1", "question_pack_sha256": null, "recall": 0.616822429906542, "run_id": "typellm-20260930", "threshold": 0.7, "track": "public"}
 {"alert_rule": "rule violation score > 0.7", "average_precision": 0.9441042508382544, "benchmark_methods": 142, "benchmark_pairs": 71, "confusion": {"fn": 29, "fp": 4, "tn": 67, "tp": 42}, "domain": "lint", "f1": 0.717948717948718, "inference_cost_basis": "API-reported input and thinking tokens at published TypeLLM rates", "inference_cost_usd": 0.0159958, "inference_endpoint": "https://api.typellm.ai/v1/generate", "inference_host": "TypeLLM", "model_id": "typellm", "model_revision": "typellm-latest", "pair_order": 0.971830985915493, "pair_order_correct": 69, "pair_order_eligible": 71, "precision": 0.9130434782608695, "protocol_id": "perch-semantic-ensure-v1", "question_pack_sha256": null, "recall": 0.5915492957746479, "run_id": "typellm-20260930", "threshold": 0.7, "track": "private"}
+{"alert_rule": "rule violation confidence > 0.7", "answered_methods": 428, "average_precision_answered_methods": 0.5287989800050326, "benchmark_methods": 428, "benchmark_pairs": 214, "benchmark_sha256": "534f6c2abddc507c40f4597607e97e07168c544011d617b83aa39e08abb35d75", "complete": true, "confusion": {"fn": 214, "fp": 0, "tn": 214, "tp": 0}, "cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "domain": "lint", "f1": 0.0, "failed_methods": 0, "failure_counts": {}, "failure_policy": "failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering", "false_positive_rate": 0.0, "inference_cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "inference_cost_usd": 0.010324469999999999, "inference_endpoint": "https://api.fastino.ai/v1/chat/completions", "inference_host": "Fastino API", "input_tokens": 344149, "model_id": "gliner25-decide", "model_revision": "fastino/GLiNER-2.5-Decide", "pair_order": 0.5934579439252337, "pair_order_correct": 127, "pair_order_eligible": 214, "precision": 0, "protocol_id": "gliner25-decide-perch-sized-classification-v1", "question_pack_sha256": null, "recall": 0.0, "run_id": "gliner25-decide-perch-sized-20261002", "sizing": {"adapter_sha256": "6be2c1e0003b8181ea7725193c039ed21b3a86fa80bafe46f99d7759b76c6b93", "max_questions": null, "perch_revision": "3db94f007ca49433c816b4a3855253d15f7b8139", "request_budget": 1800, "state_budget": 1200}, "split": "public", "threshold": 0.7, "track": "public", "vulnerable_or_buggy_before_above_fixed_after": {"correct": 127, "eligible": 214, "ties": 7}}
+{"alert_rule": "rule violation confidence > 0.7", "answered_methods": 142, "average_precision_answered_methods": 0.5264561177710998, "benchmark_methods": 142, "benchmark_pairs": 71, "benchmark_sha256": "a6e9f2e4ee8ae77bdaf23af46920d97d1ba47375dc9ce03b950cdbe95c2777f9", "complete": true, "confusion": {"fn": 71, "fp": 0, "tn": 71, "tp": 0}, "cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "domain": "lint", "f1": 0.0, "failed_methods": 0, "failure_counts": {}, "failure_policy": "failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering", "false_positive_rate": 0.0, "inference_cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "inference_cost_usd": 0.0035382, "inference_endpoint": "https://api.fastino.ai/v1/chat/completions", "inference_host": "Fastino API", "input_tokens": 117940, "model_id": "gliner25-decide", "model_revision": "fastino/GLiNER-2.5-Decide", "pair_order": 0.6338028169014085, "pair_order_correct": 45, "pair_order_eligible": 71, "precision": 0, "protocol_id": "gliner25-decide-perch-sized-classification-v1", "question_pack_sha256": null, "recall": 0.0, "run_id": "gliner25-decide-perch-sized-20261002", "sizing": {"adapter_sha256": "6be2c1e0003b8181ea7725193c039ed21b3a86fa80bafe46f99d7759b76c6b93", "max_questions": null, "perch_revision": "3db94f007ca49433c816b4a3855253d15f7b8139", "request_budget": 1800, "state_budget": 1200}, "split": "private", "threshold": 0.7, "track": "private", "vulnerable_or_buggy_before_above_fixed_after": {"correct": 45, "eligible": 71, "ties": 1}}
+{"alert_rule": "any issue score > max(0.5, question min)", "answered_methods": 4440, "average_precision_answered_methods": 0.422300940463931, "benchmark_methods": 4440, "benchmark_pairs": 2220, "benchmark_sha256": "32bc68bc85d5535ad28e103adbfa0c09c73e09d0f53a53f7ca35ec219a96e6e2", "complete": true, "confusion": {"fn": 1818, "fp": 54, "tn": 2525, "tp": 43}, "cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "domain": "bug", "f1": 0.043922369765066395, "failed_methods": 0, "failure_counts": {}, "failure_policy": "failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering", "false_positive_rate": 0.02093834819697557, "inference_cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "inference_cost_usd": 0.17524755, "inference_endpoint": "https://api.fastino.ai/v1/chat/completions", "inference_host": "Fastino API", "input_tokens": 5841585, "model_id": "gliner25-decide", "model_revision": "fastino/GLiNER-2.5-Decide", "pair_order": 0.5173961840628507, "pair_order_correct": 922, "pair_order_eligible": 1782, "precision": 0.44329896907216493, "protocol_id": "gliner25-decide-perch-sized-classification-v1", "question_pack_sha256": "afe116cc8461552aaca996f8f0b639cdf5e42e9d8291c59995482309b5c330dc", "recall": 0.0231058570660935, "run_id": "gliner25-decide-perch-sized-20261002", "sizing": {"adapter_sha256": "6be2c1e0003b8181ea7725193c039ed21b3a86fa80bafe46f99d7759b76c6b93", "max_questions": null, "perch_revision": "3db94f007ca49433c816b4a3855253d15f7b8139", "request_budget": 1800, "state_budget": 1200}, "split": "public", "threshold": 0.5, "track": "public", "vulnerable_or_buggy_before_above_fixed_after": {"correct": 922, "eligible": 1782, "ties": 121}}
+{"alert_rule": "any issue score > max(0.5, question min)", "answered_methods": 996, "average_precision_answered_methods": 0.43547986367375113, "benchmark_methods": 996, "benchmark_pairs": 498, "benchmark_sha256": "3df4ade65fedd1128d30bc17c9c9869c8ab9bd526e666156d0e16685e78f8a73", "complete": true, "confusion": {"fn": 417, "fp": 12, "tn": 560, "tp": 7}, "cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "domain": "bug", "f1": 0.03160270880361174, "failed_methods": 0, "failure_counts": {}, "failure_policy": "failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering", "false_positive_rate": 0.02097902097902098, "inference_cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "inference_cost_usd": 0.039281729999999994, "inference_endpoint": "https://api.fastino.ai/v1/chat/completions", "inference_host": "Fastino API", "input_tokens": 1309391, "model_id": "gliner25-decide", "model_revision": "fastino/GLiNER-2.5-Decide", "pair_order": 0.5211970074812967, "pair_order_correct": 209, "pair_order_eligible": 401, "precision": 0.3684210526315789, "protocol_id": "gliner25-decide-perch-sized-classification-v1", "question_pack_sha256": "afe116cc8461552aaca996f8f0b639cdf5e42e9d8291c59995482309b5c330dc", "recall": 0.01650943396226415, "run_id": "gliner25-decide-perch-sized-20261002", "sizing": {"adapter_sha256": "6be2c1e0003b8181ea7725193c039ed21b3a86fa80bafe46f99d7759b76c6b93", "max_questions": null, "perch_revision": "3db94f007ca49433c816b4a3855253d15f7b8139", "request_budget": 1800, "state_budget": 1200}, "split": "private", "threshold": 0.5, "track": "private", "vulnerable_or_buggy_before_above_fixed_after": {"correct": 209, "eligible": 401, "ties": 28}}
+{"alert_rule": "any issue score > max(0.5, question min)", "answered_methods": 2616, "average_precision_answered_methods": 0.4560152509236216, "benchmark_methods": 2622, "benchmark_pairs": 1311, "benchmark_sha256": "2407059caa3486371749884138b997d89043eec646e548ee8f44ba3ab08514b8", "complete": true, "confusion": {"fn": 1118, "fp": 23, "tn": 1457, "tp": 24}, "cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "domain": "security", "f1": 0.040370058873002525, "failed_methods": 6, "failure_counts": {"other": 6}, "failure_policy": "failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering", "false_positive_rate": 0.015540540540540541, "inference_cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "inference_cost_usd": 0.43368182999999993, "inference_endpoint": "https://api.fastino.ai/v1/chat/completions", "inference_host": "Fastino API", "input_tokens": 14456061, "model_id": "gliner25-decide", "model_revision": "fastino/GLiNER-2.5-Decide", "pair_order": 0.45729537366548045, "pair_order_correct": 514, "pair_order_eligible": 1124, "precision": 0.5106382978723404, "protocol_id": "gliner25-decide-perch-sized-classification-v1", "question_pack_sha256": "afe116cc8461552aaca996f8f0b639cdf5e42e9d8291c59995482309b5c330dc", "recall": 0.021015761821366025, "run_id": "gliner25-decide-perch-sized-20261002", "sizing": {"adapter_sha256": "6be2c1e0003b8181ea7725193c039ed21b3a86fa80bafe46f99d7759b76c6b93", "max_questions": null, "perch_revision": "3db94f007ca49433c816b4a3855253d15f7b8139", "request_budget": 1800, "state_budget": 1200}, "split": "public", "threshold": 0.5, "track": "public", "vulnerable_or_buggy_before_above_fixed_after": {"correct": 514, "eligible": 1124, "ties": 35}}
+{"alert_rule": "any issue score > max(0.5, question min)", "answered_methods": 877, "average_precision_answered_methods": 0.44020539336977416, "benchmark_methods": 878, "benchmark_pairs": 439, "benchmark_sha256": "a4b81728e9e520cf1c6f342974bec369d72f5b7d8aabc1c9cf2aceba966f8051", "complete": true, "confusion": {"fn": 390, "fp": 7, "tn": 473, "tp": 8}, "cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "domain": "security", "f1": 0.0387409200968523, "failed_methods": 1, "failure_counts": {"other": 1}, "failure_policy": "failed positive counts as FN; failed negative counts as FP; failed pair counts as incorrect ordering", "false_positive_rate": 0.014583333333333334, "inference_cost_basis": "API-reported prompt tokens; failed requests have no returned usage", "inference_cost_usd": 0.14154047999999997, "inference_endpoint": "https://api.fastino.ai/v1/chat/completions", "inference_host": "Fastino API", "input_tokens": 4718016, "model_id": "gliner25-decide", "model_revision": "fastino/GLiNER-2.5-Decide", "pair_order": 0.4949748743718593, "pair_order_correct": 197, "pair_order_eligible": 398, "precision": 0.5333333333333333, "protocol_id": "gliner25-decide-perch-sized-classification-v1", "question_pack_sha256": "afe116cc8461552aaca996f8f0b639cdf5e42e9d8291c59995482309b5c330dc", "recall": 0.020100502512562814, "run_id": "gliner25-decide-perch-sized-20261002", "sizing": {"adapter_sha256": "6be2c1e0003b8181ea7725193c039ed21b3a86fa80bafe46f99d7759b76c6b93", "max_questions": null, "perch_revision": "3db94f007ca49433c816b4a3855253d15f7b8139", "request_budget": 1800, "state_budget": 1200}, "split": "private", "threshold": 0.5, "track": "private", "vulnerable_or_buggy_before_above_fixed_after": {"correct": 197, "eligible": 398, "ties": 8}}

tradeoff.py

@@ -31,11 +31,13 @@ NAMES = {
     "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"),
+    "gliner25-decide": ("GLiNER-2.5-Decide", "https://huggingface.co/fastino/GLiNER2.5-Decide"),
 }
 COLORS = {
     "jev": "#1976d2", "typellm": "#c64f81", "liquid-d1": "#7638d6",
     "diffusiongemma": "#e08a22", "span01": "#168d80", "clm": "#677586",
     "semif": "#b14b39",
+    "gliner25-decide": "#9b7a39",
 }
 ORDER = tuple(NAMES)
 
@@ -70,20 +72,26 @@ def labels_for(domain: str, pairs: list[dict]) -> dict[tuple[str, str], int]:
 
 def curve(labels: dict[tuple[str, str], int], prediction_path: Path) -> tuple[list[tuple[int, int]], int, int]:
     predictions = lines(prediction_path)
-    scores = {}
+    scores, failed = {}, set()
     for row in predictions:
         key = row["pair_id"], row["role"]
+        if row.get("status") == "failed":
+            if key in scores or key in failed or key not in labels:
+                raise ValueError(f"Invalid failure in {prediction_path}: {key}")
+            failed.add(key)
+            continue
         value = row["score"]
-        if key in scores or not isinstance(value, (int, float)) or not isfinite(value) or not 0 <= value <= 1:
+        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)
-    if scores.keys() != labels.keys():
-        raise ValueError(f"Incomplete predictions in {prediction_path}: {len(scores)} of {len(labels)}")
+    if scores.keys() | failed != labels.keys():
+        raise ValueError(f"Incomplete outcomes in {prediction_path}: {len(scores) + len(failed)} 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
+    # Failures count as wrong at every cutoff. They never receive invented scores.
+    tp, fp = 0, sum(labels[key] == 0 for key in failed)
+    points = [(fp, tp)]
     for score in sorted(groups, reverse=True):
         positive, negative = groups[score]
         tp += positive
@@ -128,14 +136,15 @@ def results_table(rows: list[dict]) -> str:
     best_recall = max(round(metrics[row["model_id"]][0] * 100, 1) for row in full_rows)
     best_false_positive_rate = min(round(metrics[row["model_id"]][1] * 100, 1) for row in full_rows)
     best_net_recall = max(round(metrics[row["model_id"]][2] * 100, 1) for row in full_rows)
+    best_failures = min(row.get("failed_methods", 0) for row in full_rows)
     priced_costs = [round(row["inference_cost_usd"], 3) for row in full_rows 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
 
-    table = ["| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Inference cost |",
-             "| --- | ---: | ---: | ---: | ---: |"]
+    table = ["| Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Failed requests | Inference cost |",
+             "| --- | ---: | ---: | ---: | ---: | ---: |"]
     for row in ordered:
         recall, false_positive_rate, j = metrics[row["model_id"]]
         cost = row.get("inference_cost_usd")
@@ -148,6 +157,7 @@ def results_table(rows: list[dict]) -> str:
             mark(percent(recall), not is_codeql and round(recall * 100, 1) == best_recall),
             mark(percent(false_positive_rate), not is_codeql and round(false_positive_rate * 100, 1) == best_false_positive_rate),
             mark(percent(j), not is_codeql and round(j * 100, 1) == best_net_recall),
+            "—" if is_codeql else mark(str(row.get("failed_methods", 0)), row.get("failed_methods", 0) == best_failures),
             "—" if is_codeql else mark(money(row), cost is not None and round(cost, 3) == best_priced_cost),
         )) + " |")
     return "\n".join(table)
@@ -170,7 +180,7 @@ def svg(domain: str, curves: dict[str, tuple[list[tuple[int, int]], int, int]],
     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.</desc>',
+           '<desc id="desc">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 · recall versus false alerts</text>']
@@ -209,6 +219,8 @@ def render_sections(results: list[dict], curves_by_domain: dict[str, dict], outp
     sections = ["## Reading the results", "",
                 "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 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.", ""]
     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]