count-guard-v1

diff --git a/backend/lab/contract/versions/positional_v0.py b/backend/lab/contract/versions/count_guard_v1.py--- a/backend/lab/contract/versions/positional_v0.py+++ b/backend/lab/contract/versions/count_guard_v1.py@@ -1,18 +1,23 @@-"""Historical behaviour, transcribed from `origin/main`.+"""The count-mismatch guard, transcribed from PR #59 (head 81b2019). -Source: backend/app/services/openai_service.py, score_articles_batch, the-`normalized` loop. Verbatim semantics:+Source: backend/app/services/openai_service.py on+`mmarufov/batch-scoring-alignment`:      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.+        logger.warning("... discarding the batch rather than assigning "+                       "verdicts by position")+        continue                              # retry, then report unscored++That commit also stops swallowing the harness's stop signals:++    except Exception as exc:+        if type(exc).__name__ in {"CacheMiss", "BudgetExceeded"}:+            raise++Both are reproduced. The guard is a real improvement over positional-v0 and+this experiment is expected to show that — and also to show its ceiling: it+compares *lengths*, so an equal-length reordered response still passes through+and is still associated by position. """  from __future__ import annotations@@ -54,45 +59,55 @@ import json from typing import Any  -VERSION_ID = "positional-v0"+VERSION_ID = "count-guard-v1" PROTOCOL = "positional-v0"   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])+    error = response.get("error")+    if error:+        # CacheMiss / BudgetExceeded propagate instead of degrading to zeros.+        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__}")++    results_list = result.get("results", [])+    if not results_list and "scores" in result:         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")++    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 {}-            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"))+    for article, entry in zip(articles, results_list):+        if not isinstance(entry, dict):+            return refuse("invalid_type", f"entry is {type(entry).__name__}")+        try:+            score = max(0.0, min(1.0, float(entry.get("score", 0.5))))+        except Exception:+            return refuse("invalid_type", "score is not numeric")+        relevant = bool(entry.get("relevant", score >= 0.5))+        out.append(verdict(article["id"], relevant, score, str(entry.get("reason", ""))))     return ok(out) 

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