agent-k2-generous-02

diff --git a/backend/lab/contract/versions/positional_v0.py b/backend/lab/contract/candidates/agent_k2_generous_02.py--- a/backend/lab/contract/versions/positional_v0.py+++ b/backend/lab/contract/candidates/agent_k2_generous_02.py@@ -1,29 +1,14 @@-"""Historical behaviour, transcribed from `origin/main`.+"""Keyed protocol parser (keyed-v2) - eliminates positional association defects. -Source: backend/app/services/openai_service.py, score_articles_batch, the-`normalized` loop. Verbatim semantics:--    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.+Each verdict must explicitly identify its article via article_id.+This allows out-of-order responses and detects mismatches unambiguously. """  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.+# project imports and no third-party dependencies.  import math as _math @@ -54,45 +39,113 @@ 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 a keyed response where each verdict contains article_id.+    +    Refuses when:+    - Response has an error+    - JSON is malformed+    - Response shape is unexpected+    - Count mismatch (fewer or more verdicts than articles)+    - Duplicate article_ids in response+    - Unknown article_ids (not in input)+    - Missing article_ids (input article not in response)+    - Invalid score values+    """+    # Handle response-level errors+    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("truncated_response", "no content returned") +    # Parse JSON     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", ""))))+    except Exception as exc:+        return refuse("malformed_json", str(exc))++    # Validate top-level shape+    if not isinstance(result, dict):+        return refuse("unexpected_shape", f"top level is {type(result).__name__}")++    results_list = result.get("results", [])+    if not isinstance(results_list, list):+        return refuse("unexpected_shape", "results is not a list")++    # Build expected article ID set+    expected_ids = {a["id"] for a in articles}+    +    # Check count first (fast path for obvious mismatches)+    if len(results_list) != len(articles):+        return refuse(+            "count_mismatch",+            f"{len(results_list)} results for {len(articles)} articles",+        )++    # Process results and validate associations+    verdicts_by_id: dict[str, dict[str, Any]] = {}+    +    for idx, entry in enumerate(results_list):+        if not isinstance(entry, dict):+            return refuse("invalid_type", f"entry at index {idx} is {type(entry).__name__}")+        +        # Extract article_id (required for keyed protocol)+        article_id = entry.get("article_id")+        if article_id is None:+            return refuse("missing_id", f"entry at index {idx} missing article_id")+        +        if not isinstance(article_id, str):+            return refuse("invalid_type", f"article_id at index {idx} is not a string")+        +        # Check for duplicates+        if article_id in verdicts_by_id:+            return refuse("duplicate_id", f"duplicate article_id: {article_id}")+        +        # Check for unknown IDs+        if article_id not in expected_ids:+            return refuse("unknown_id", f"unknown article_id: {article_id}")+        +        # Validate score+        score_raw = entry.get("score")+        if score_raw is not None:+            score = finite_unit_score(score_raw)+            if score is None:+                return refuse("score_out_of_range", f"invalid score for {article_id}")         else:-            out.append(verdict(article["id"], False, 0.0, "scoring incomplete"))-    return ok(out)+            score = 0.5  # default when missing+        +        # Validate relevant boolean+        relevant = bool(entry.get("relevant", score >= 0.5))+        +        # Extract reason+        reason = str(entry.get("reason", ""))+        +        verdicts_by_id[article_id] = verdict(article_id, relevant, score, reason)+    +    # Check for missing articles+    missing_ids = expected_ids - set(verdicts_by_id.keys())+    if missing_ids:+        return refuse("missing_id", f"missing verdicts for: {', '.join(sorted(missing_ids))}")+    +    # Build output in same order as input articles+    verdicts = []+    for article in articles:+        article_id = article["id"]+        v = verdicts_by_id.get(article_id)+        if v is None:+            # Should not happen due to missing_ids check above+            return refuse("missing_id", f"missing verdict for {article_id}")+        verdicts.append(v)+    +    return ok(verdicts) 

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