fix(capabilities): thread experiment_id through is_stale

_load_fresh_analysis passes experiment_id to is_stale, which does not
accept it, so every cache lookup that finds a stored block raises
TypeError. The durable analyzer job burns all six attempts on it and the
next poll enqueues a fresh one, so a task version that already carries a
comparison can never regenerate -- the pane polls forever and renders it
as an indefinite 'Analyzing agent behavior...' spinner.

Seen in prod on scarf-cargotracker-quarkus-to-spring-migration v2 (four
consecutive FAILED jobs, six attempts each) and 05-F3-poison-message-
recurrence v23.

The cache-lookup tests all stubbed the row out as None, which returns
before the freshness comparison, so nothing covered the hit path.

Author: stateofkate

backend/api/services/agent_capabilities.py

@@ -468,6 +468,7 @@ def is_stale(
     current_hash: str,
     schema_version: int,
     task_version_id: str,
+    experiment_id: str | None = None,
 ) -> bool:
     """Whether a stored block must be regenerated. See ``stale_reason``."""
     return (
@@ -476,6 +477,7 @@ def is_stale(
             current_hash=current_hash,
             schema_version=schema_version,
             task_version_id=task_version_id,
+            experiment_id=experiment_id,
         )
         is not None
     )

backend/tests/test_agent_capabilities_endpoint.py

@@ -220,6 +220,87 @@ async def execute(statement):
     )
 
 
+async def _load_fresh_with_stored_block(block_metadata: dict, experiment_id):
+    """``_load_fresh_analysis`` against a session that returns one stored block.
+
+    Every other cache-lookup test hands back ``None``, which never reaches the
+    freshness comparison -- the half where a hit is either served or rejected.
+    """
+
+    async def execute(statement):
+        result = MagicMock()
+        result.scalar_one_or_none.return_value = SimpleNamespace(
+            block_metadata=block_metadata, output={"summary": "stored"}
+        )
+        return result
+
+    session = MagicMock()
+    session.execute = execute
+
+    return await cc._load_fresh_analysis(
+        session,
+        task_id="t1",
+        task_version_id="v1",
+        current_hash="aaa",
+        schema_version=1,
+        experiment_id=experiment_id,
+    )
+
+
+@pytest.mark.asyncio
+async def test_experiment_scoped_cache_hit_is_served():
+    """A stored block must survive the freshness check, not raise on it.
+
+    The scoping argument is threaded from the lookup into ``is_stale``; if the
+    two signatures drift the call raises TypeError, the durable job burns all
+    six attempts, and the pane polls a job that can never succeed -- rendered
+    as an indefinite "Analyzing..." spinner rather than as an error.
+    """
+    fresh = await _load_fresh_with_stored_block(
+        {
+            "cohort_hash": "aaa",
+            "schema_version": 1,
+            "task_version_id": "v1",
+            "experiment_id": "e1",
+        },
+        experiment_id="e1",
+    )
+
+    assert fresh == {"summary": "stored"}
+
+
+@pytest.mark.asyncio
+async def test_unscoped_cache_hit_is_served():
+    fresh = await _load_fresh_with_stored_block(
+        {
+            "cohort_hash": "aaa",
+            "schema_version": 1,
+            "task_version_id": "v1",
+            "experiment_id": None,
+        },
+        experiment_id=None,
+    )
+
+    assert fresh == {"summary": "stored"}
+
+
+@pytest.mark.asyncio
+async def test_cache_hit_from_another_experiment_is_rejected():
+    """Scope is part of freshness: an experiment-scoped comparison covers a
+    different trial set than the unscoped one and must not be served for it."""
+    fresh = await _load_fresh_with_stored_block(
+        {
+            "cohort_hash": "aaa",
+            "schema_version": 1,
+            "task_version_id": "v1",
+            "experiment_id": "e1",
+        },
+        experiment_id=None,
+    )
+
+    assert fresh is None
+
+
 @pytest.mark.asyncio
 async def test_cache_lookup_filters_on_the_requested_version():
     """The newest row for a task may belong to another version.