control-lenient-keyed

diff --git a/backend/lab/contract/versions/positional_v0.py b/backend/lab/contract/controls/lenient_keyed.py--- a/backend/lab/contract/versions/positional_v0.py+++ b/backend/lab/contract/controls/lenient_keyed.py@@ -1,18 +1,11 @@-"""Historical behaviour, transcribed from `origin/main`.+"""CONTROL — keyed parsing with last-write-wins on duplicate ids. -Source: backend/app/services/openai_service.py, score_articles_batch, the-`normalized` loop. Verbatim semantics:+Seeded defect: accepts a response containing the same article twice, keeping+the later verdict. Plausible-looking and wrong: the model has contradicted+itself and the parser has silently picked a winner. -    if len(results_list) != len(articles):-        logger.warning("... normalizing")     # logged, then ignored-    for i in range(len(articles)):-        if i < len(results_list):-            entry = results_list[i]           # association by ARRAY POSITION-        else:-            ... {"relevant": False, "score": 0.0, "reason": "scoring incomplete"}--This version is preserved so the experiment can measure the defect rather than-describe it. It is not a control: it is what production does today.+Expected outcome: REJECTED on the duplicate-id cases. If the evaluator ever+accepts this, the evaluator is broken. """  from __future__ import annotations@@ -54,45 +47,39 @@ import json from typing import Any  -VERSION_ID = "positional-v0"-PROTOCOL = "positional-v0"+VERSION_ID = "control:lenient-keyed"+PROTOCOL = "keyed-v2"   def parse(articles: list[dict[str, Any]], response: dict[str, Any]) -> dict[str, Any]:     if response.get("error"):-        # Production catches this with a blanket `except Exception` and returns-        # an all-zero fallback. Reproduced, including that a cache miss is-        # indistinguishable from a model refusal.-        return ok([verdict(a["id"], False, 0.0, "scoring unavailable") for a in articles])-+        return refuse("retries_exhausted", str(response["error"]))     content = response.get("content")     if content is None:-        return ok([verdict(a["id"], False, 0.0, "scoring unavailable") for a in articles])-+        return refuse("retries_exhausted", "no content")     try:         result = json.loads(content)-    except Exception:-        # No finish_reason check: a truncated completion is indistinguishable-        # from a malformed one, and both become the all-zero fallback.-        return ok([verdict(a["id"], False, 0.0, "scoring unavailable") for a in articles])--    results_list = result.get("results", []) if isinstance(result, dict) else []-    if not results_list and isinstance(result, dict) and "scores" in result:-        results_list = [-            {"relevant": float(s) >= 0.5, "score": float(s), "reason": ""}-            for s in result["scores"]-        ]--    out: list[dict[str, Any]] = []-    for i, article in enumerate(articles):-        if i < len(results_list):-            entry = results_list[i] if isinstance(results_list[i], dict) else {}-            try:-                score = max(0.0, min(1.0, float(entry.get("score", 0.5))))-            except Exception:-                score = 0.5-            relevant = bool(entry.get("relevant", score >= 0.5))-            out.append(verdict(article["id"], relevant, score, str(entry.get("reason", ""))))-        else:-            out.append(verdict(article["id"], False, 0.0, "scoring incomplete"))-    return ok(out)+    except Exception as exc:+        return refuse("malformed_json", str(exc))+    if not isinstance(result, dict) or not isinstance(result.get("results"), list):+        return refuse("unexpected_shape", "no results array")++    expected = {a["id"] for a in articles}+    by_id: dict[str, dict[str, Any]] = {}+    for entry in result["results"]:+        if not isinstance(entry, dict):+            continue+        article_id = entry.get("article_id", entry.get("id"))+        if article_id not in expected:+            continue  # DEFECT: silently drops unknown ids instead of refusing+        score = finite_unit_score(entry.get("score"))+        if score is None:+            score = 0.0  # DEFECT: coerces NaN / out-of-range to a real verdict+        by_id[article_id] = verdict(+            article_id, bool(entry.get("relevant", score >= 0.5)), score,+            str(entry.get("reason", "")),+        )  # DEFECT: last write wins on a duplicate id++    if len(by_id) != len(expected):+        return refuse("missing_id", f"{len(by_id)} of {len(expected)}")+    return ok([by_id[a["id"]] for a in articles]) 

Validated against the schema in web/lib/lab/artifact.ts before it was written. Download the JSON.