agent-k2-generous-05

diff --git a/backend/lab/contract/versions/positional_v0.py b/backend/lab/contract/candidates/agent_k2_generous_05.py--- a/backend/lab/contract/versions/positional_v0.py+++ b/backend/lab/contract/candidates/agent_k2_generous_05.py@@ -1,30 +1,16 @@-"""Historical behaviour, transcribed from `origin/main`.+"""Keyed association parser - fixes the positional association defect. -Source: backend/app/services/openai_service.py, score_articles_batch, the-`normalized` loop. Verbatim semantics:+The defect: positional-v0 and count_guard_v1 both associate results[i] with articles[i].+When the model returns results in a different order, or returns a different number of them,+articles receive wrong verdicts silently. -    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.+The fix: Use keyed association where each result includes an article_id field.+This enables unambiguous association and detects duplicates, unknown IDs, and missing IDs. """  from __future__ import annotations  # --- contract prelude --------------------------------------------------------# Inlined rather than imported. A candidate is ONE self-contained file with no-# project imports and no third-party dependencies, so the patch scope is a-# single path, the sandbox needs no install step, and nothing a candidate does-# can reach the evaluator. The canonical definitions live in-# lab/contract/types.py, and tests/test_contract_prelude.py asserts that every-# copy still agrees with it.- import math as _math  @@ -54,45 +40,143 @@ import json from typing import Any  -VERSION_ID = "positional-v0"-PROTOCOL = "positional-v0"+VERSION_ID = "keyed-v2"+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])+    """Parse response using keyed association when article_id is present.+    +    Keyed association (preferred): Each result has an article_id field.+    - Validates exact match of article IDs+    - Detects duplicates, unknown IDs, missing IDs+    - Unambiguous even if results are reordered+    +    Positional fallback: Only when no article_id fields are present.+    - Requires exact count match+    - Associates by position (results[i] -> articles[i])+    """+    error = response.get("error")+    if error:+        if error in {"no_recording", "budget_exceeded"}:+            return refuse("no_recording" if error == "no_recording" else "retries_exhausted", error)+        if error in {"timeout", "cancelled"}:+            return refuse(error, error)+        return refuse("retries_exhausted", str(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 returned")      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])+    except Exception as exc:+        return refuse("malformed_json", str(exc)) -    results_list = result.get("results", []) if isinstance(result, dict) else []-    if not results_list and isinstance(result, dict) and "scores" in result:+    if not isinstance(result, dict):+        return refuse("unexpected_shape", f"top level is {type(result).__name__}")++    # Extract results list+    results_list = result.get("results", [])+    if not results_list and "scores" in result:+        # Legacy scores format - convert to results dicts         results_list = [             {"relevant": float(s) >= 0.5, "score": float(s), "reason": ""}             for s in result["scores"]         ]+    +    if not isinstance(results_list, list):+        return refuse("unexpected_shape", "results is not a list")++    # Build set of expected article IDs+    expected_ids = {a["id"] for a in articles}++    # Check if any result has article_id field+    has_keyed_results = any(+        isinstance(r, dict) and r.get("article_id") is not None +        for r in results_list+    )++    if has_keyed_results:+        # Keyed association: use article_id for unambiguous matching+        return _keyed_association(articles, expected_ids, results_list)+    else:+        # Positional fallback: only when no article_id present+        return _positional_association(articles, results_list)+++def _keyed_association(articles: list[dict[str, Any]], expected_ids: set[str], results_list: list) -> dict[str, Any]:+    """Associate results using article_id fields."""+    result_by_id: dict[str, dict] = {}+    +    for entry in results_list:+        if not isinstance(entry, dict):+            return refuse("invalid_type", f"entry is {type(entry).__name__}")+        +        article_id = entry.get("article_id")+        if article_id is None:+            # Mixed keyed/non-keyed is ambiguous - refuse+            return refuse("unexpected_shape", "mixed entries with and without article_id")+        +        if article_id in result_by_id:+            return refuse("duplicate_id", f"duplicate article_id: {article_id}")+        +        if article_id not in expected_ids:+            return refuse("unknown_id", f"unknown article_id: {article_id}")+        +        result_by_id[article_id] = entry+    +    # Check for missing IDs+    missing_ids = expected_ids - set(result_by_id.keys())+    if missing_ids:+        return refuse("missing_id", f"missing article_ids: {sorted(missing_ids)}")+    +    # Build verdicts in article order+    out: list[dict[str, Any]] = []+    for article in articles:+        article_id = article["id"]+        entry = result_by_id[article_id]+        +        # Validate and extract score+        score_raw = entry.get("score")+        score = finite_unit_score(score_raw)+        if score is None:+            return refuse("score_out_of_range", f"invalid score for {article_id}: {score_raw}")+        +        relevant = bool(entry.get("relevant", score >= 0.5))+        reason = str(entry.get("reason", ""))+        +        out.append(verdict(article_id, relevant, score, reason))+    +    return ok(out)+ +def _positional_association(articles: list[dict[str, Any]], results_list: list) -> dict[str, Any]:+    """Associate results by position - only used when no article_id present."""+    if len(results_list) != len(articles):+        return refuse(+            "count_mismatch",+            f"{len(results_list)} results for {len(articles)} articles",+        )+         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 {}+    for article, entry in zip(articles, results_list):+        if not isinstance(entry, dict):+            return refuse("invalid_type", f"entry is {type(entry).__name__}")+        +        # Validate and extract score+        score_raw = entry.get("score")+        # Use finite_unit_score if available, else clamp+        score = finite_unit_score(score_raw)+        if score is None:             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"))+            except (TypeError, ValueError):+                return refuse("invalid_type", "score is not numeric")+        +        relevant = bool(entry.get("relevant", score >= 0.5))+        reason = str(entry.get("reason", ""))+        +        out.append(verdict(article["id"], relevant, score, reason))+         return ok(out) 

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