hebbrix 2.4.1__tar.gz → 2.5.0__tar.gz

{hebbrix-2.4.1 → hebbrix-2.5.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 2.5.0 — 2026-09-07
+
+- Add matching synchronous and asynchronous Evidence Loop methods: owner-managed verifiers, durable episodes, actual-execution claims, protected outcome delivery and evidence assessments.
+- Preserve scope, replay, incomplete-outcome and permission receipts without converting recommendations into execution authority or falling back to caller-reported outcomes.
+- Reject malformed, ambiguous or unknown evidence contracts before exposing unsupported synthesis; retain valid degraded evidence with its abstention signal.
+- Protected ledger methods require the connected Evidence Loop backend. Separate verifier credentials and an independent execution/outcome check remain required; these methods do not execute actions.
+
 ## 2.4.1 — 2026-08-27
 
 - Make every async and sync readiness deadline preserve the original durable

{hebbrix-2.4.1/hebbrix.egg-info → hebbrix-2.5.0}/PKG-INFO

@@ -1,10 +1,31 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.4.1
+Version: 2.5.0
 Summary: Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs
 Author-email: Hebbrix Team <support@hebbrix.com>
 Maintainer-email: Hebbrix Team <support@hebbrix.com>
-License-Expression: MIT
+License: MIT License
+        
+        Copyright (c) 2025 Hebbrix
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
 Project-URL: Homepage, https://hebbrix.com
 Project-URL: Documentation, https://docs.hebbrix.com
 Project-URL: Source, https://github.com/Hebbrix/hebbrix-python
@@ -47,7 +68,7 @@ Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs.
 ## Install
 
 ```bash
-pip install hebbrix==2.4.1
+pip install hebbrix==2.5.0
 ```
 
 Python 3.8+ is supported. `MemoryClient` is asynchronous. `SyncMemoryClient`

{hebbrix-2.4.1 → hebbrix-2.5.0}/README.md

@@ -5,7 +5,7 @@ Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs.
 ## Install
 
 ```bash
-pip install hebbrix==2.4.1
+pip install hebbrix==2.5.0
 ```
 
 Python 3.8+ is supported. `MemoryClient` is asynchronous. `SyncMemoryClient`

{hebbrix-2.4.1 → hebbrix-2.5.0}/hebbrix/__init__.py

@@ -5,7 +5,7 @@ production OpenAPI and ``GET /v1/users/me/capabilities``. The experimental
 World Model is intentionally absent from this release.
 """
 
-__version__ = "2.4.1"
+__version__ = "2.5.0"
 __author__ = "Hebbrix Team"
 __license__ = "MIT"
 

{hebbrix-2.4.1 → hebbrix-2.5.0}/hebbrix/client.py

@@ -90,7 +90,7 @@ class MemoryClient:
         """Get request headers."""
         headers = {
             "Content-Type": "application/json",
-            "User-Agent": "hebbrix-python/2.4.1",
+            "User-Agent": "hebbrix-python/2.5.0",
         }
 
         if self.api_key:

{hebbrix-2.4.1 → hebbrix-2.5.0}/hebbrix/resources.py

@@ -9,6 +9,7 @@ import json
 import time
 import uuid
 from typing import TYPE_CHECKING, Any, AsyncIterator, Dict, List, Optional
+from urllib.parse import quote
 
 from hebbrix.exceptions import IndexingTimeoutError
 from hebbrix.models import SearchSafetyEnvelope
@@ -97,9 +98,9 @@ def _canonical_search_envelope(
 ) -> Dict[str, Any]:
     """Validate API-owned evidence metadata and fail closed on contract drift."""
 
-    data = dict(response or {})
-    rows = data.get(rows_key)
-    rows = rows if isinstance(rows, list) else []
+    data = dict(response) if isinstance(response, dict) else {}
+    raw_rows = data.get(rows_key)
+    rows = raw_rows if isinstance(raw_rows, list) else []
     missing = sorted(_SEARCH_SAFETY_FIELDS.difference(data))
     reason: Optional[str] = None
     confidence = data.get("query_confidence")
@@ -117,6 +118,27 @@ def _canonical_search_envelope(
         reason = "invalid_grounding_receipt"
     elif not isinstance(data.get("evidence_ids"), list):
         reason = "invalid_evidence_ids"
+    elif data.get("safety_contract_version") != "search-safety-v1":
+        reason = "unsupported_safety_contract_version"
+    elif not isinstance(raw_rows, list):
+        reason = "invalid_evidence_rows"
+    elif any(
+        not isinstance(value, str) or not value.strip()
+        for value in data["evidence_ids"]
+    ):
+        reason = "invalid_evidence_ids"
+    elif len(set(data["evidence_ids"])) != len(data["evidence_ids"]):
+        reason = "duplicate_evidence_ids"
+    elif any(
+        not isinstance(row, dict)
+        or not isinstance(row.get("memory_id", row.get("id")), str)
+        or not row.get("memory_id", row.get("id", "")).strip()
+        or ("memory_id" in row and "id" in row and row["memory_id"] != row["id"])
+        for row in rows
+    ):
+        reason = "invalid_evidence_row_identity"
+    elif not rows and data.get("no_match") is False:
+        reason = "no_evidence_rows"
     else:
         row_ids = {
             str(row.get("memory_id") or row.get("id"))
@@ -143,6 +165,9 @@ def _canonical_search_envelope(
         data["query_confidence"] = 0.0
         data["evidence_ids"] = []
         data["evidence_claims"] = []
+        if rows_key == "sources":
+            data["answer"] = None
+            data["citations"] = []
         if reason:
             data["sdk_safety_reason"] = reason
             data["grounding"] = {
@@ -1156,6 +1181,133 @@ class ProofLoopResource(BaseResource):
             body["proof_context_token"] = token
         return await self.client.post("/v1/learning/decisions", json=body)
 
+    async def register_verifier(
+        self,
+        *,
+        policy_key: str,
+        api_key_id: str,
+        source_system: str,
+        metric_keys: List[str],
+        collection_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Owner-session administration; the agent cannot register its own verifier."""
+        return await self.client.post(
+            "/v1/learning/verifiers",
+            json={
+                "policy_key": policy_key,
+                "api_key_id": api_key_id,
+                "source_system": source_system,
+                "metric_keys": metric_keys,
+                "collection_id": collection_id,
+                "user_id": user_id,
+            },
+        )
+
+    async def revoke_verifier(self, verifier_id: str) -> Dict[str, Any]:
+        """Revoke one source without deleting historical evidence."""
+        return await self.client.post(
+            f"/v1/learning/verifiers/{quote(verifier_id, safe='')}/revoke", json={}
+        )
+
+    async def create_episode(
+        self,
+        *,
+        policy_key: str,
+        verifier_id: str,
+        idempotency_key: str,
+        collection_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a scoped durable episode; never grants execution permission."""
+        return await self.client.post(
+            "/v1/learning/episodes",
+            json={
+                "policy_key": policy_key,
+                "verifier_id": verifier_id,
+                "idempotency_key": idempotency_key,
+                "collection_id": collection_id,
+                "user_id": user_id,
+            },
+        )
+
+    async def get_episode(self, episode_id: str, *, offset: int = 0) -> Dict[str, Any]:
+        return await self.client.get(
+            f"/v1/learning/episodes/{quote(episode_id, safe='')}",
+            params={"offset": offset},
+        )
+
+    async def close_episode(self, episode_id: str, *, status: str) -> Dict[str, Any]:
+        return await self.client.post(
+            f"/v1/learning/episodes/{quote(episode_id, safe='')}/close",
+            json={"status": status},
+        )
+
+    async def record_execution(
+        self,
+        decision_id: str,
+        *,
+        attempt_id: str,
+        status: str,
+        actual_action_key: str,
+        arguments_digest: str,
+        evidence_digest: Optional[str] = None,
+        occurred_at: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Record an execution claim, not an instruction to execute."""
+        body = {
+            "attempt_id": attempt_id,
+            "status": status,
+            "actual_action_key": actual_action_key,
+            "arguments_digest": arguments_digest,
+        }
+        if evidence_digest is not None:
+            body["evidence_digest"] = evidence_digest
+        if occurred_at is not None:
+            body["occurred_at"] = occurred_at
+        return await self.client.post(
+            f"/v1/learning/decisions/{quote(decision_id, safe='')}/executions",
+            json=body,
+        )
+
+    async def assessment(
+        self, decision_id: str, *, evidence_offset: int = 0
+    ) -> Dict[str, Any]:
+        return await self.client.get(
+            f"/v1/learning/decisions/{quote(decision_id, safe='')}/assessment",
+            params={"evidence_offset": evidence_offset},
+        )
+
+    async def verifier_evidence(
+        self, verifier_id: str, decision_id: str
+    ) -> Dict[str, Any]:
+        """Call with the dedicated verifier client, never the actor's credential."""
+        return await self.client.get(
+            f"/v1/learning/verifiers/{quote(verifier_id, safe='')}/decisions/{quote(decision_id, safe='')}"
+        )
+
+    async def deliver_verified_outcomes(
+        self,
+        verifier_id: str,
+        *,
+        decision_id: str,
+        source_event_id: str,
+        evidence_digest: str,
+        execution_digest: str,
+        observations: List[Dict[str, Any]],
+    ) -> Dict[str, Any]:
+        """Deliver independently checked observations using the registered source key."""
+        return await self.client.post(
+            f"/v1/learning/verifiers/{quote(verifier_id, safe='')}/events",
+            json={
+                "decision_id": decision_id,
+                "source_event_id": source_event_id,
+                "evidence_digest": evidence_digest,
+                "execution_digest": execution_digest,
+                "observations": observations,
+            },
+        )
+
     async def get_decision(self, decision_id: str) -> Dict[str, Any]:
         return await self.client.get(f"/v1/learning/decisions/{decision_id}")
 

{hebbrix-2.4.1 → hebbrix-2.5.0}/hebbrix/sync_client.py

@@ -4,6 +4,7 @@ import json
 import os
 import time
 from typing import Any, Dict, List, Optional
+from urllib.parse import quote
 
 import httpx
 from hebbrix.exceptions import (
@@ -660,6 +661,131 @@ class SyncProofLoopResource:
             body["proof_context_token"] = token
         return self.client.post("/v1/learning/decisions", json=body)
 
+    def register_verifier(
+        self,
+        *,
+        policy_key: str,
+        api_key_id: str,
+        source_system: str,
+        metric_keys: List[str],
+        collection_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Owner-session administration; the agent cannot register its own verifier."""
+        return self.client.post(
+            "/v1/learning/verifiers",
+            json={
+                "policy_key": policy_key,
+                "api_key_id": api_key_id,
+                "source_system": source_system,
+                "metric_keys": metric_keys,
+                "collection_id": collection_id,
+                "user_id": user_id,
+            },
+        )
+
+    def revoke_verifier(self, verifier_id: str) -> Dict[str, Any]:
+        """Revoke one source without deleting historical evidence."""
+        return self.client.post(
+            f"/v1/learning/verifiers/{quote(verifier_id, safe='')}/revoke", json={}
+        )
+
+    def create_episode(
+        self,
+        *,
+        policy_key: str,
+        verifier_id: str,
+        idempotency_key: str,
+        collection_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a scoped durable episode; never grants execution permission."""
+        return self.client.post(
+            "/v1/learning/episodes",
+            json={
+                "policy_key": policy_key,
+                "verifier_id": verifier_id,
+                "idempotency_key": idempotency_key,
+                "collection_id": collection_id,
+                "user_id": user_id,
+            },
+        )
+
+    def get_episode(self, episode_id: str, *, offset: int = 0) -> Dict[str, Any]:
+        return self.client.get(
+            f"/v1/learning/episodes/{quote(episode_id, safe='')}",
+            params={"offset": offset},
+        )
+
+    def close_episode(self, episode_id: str, *, status: str) -> Dict[str, Any]:
+        return self.client.post(
+            f"/v1/learning/episodes/{quote(episode_id, safe='')}/close",
+            json={"status": status},
+        )
+
+    def record_execution(
+        self,
+        decision_id: str,
+        *,
+        attempt_id: str,
+        status: str,
+        actual_action_key: str,
+        arguments_digest: str,
+        evidence_digest: Optional[str] = None,
+        occurred_at: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Record an execution claim, not an instruction to execute."""
+        body = {
+            "attempt_id": attempt_id,
+            "status": status,
+            "actual_action_key": actual_action_key,
+            "arguments_digest": arguments_digest,
+        }
+        if evidence_digest is not None:
+            body["evidence_digest"] = evidence_digest
+        if occurred_at is not None:
+            body["occurred_at"] = occurred_at
+        return self.client.post(
+            f"/v1/learning/decisions/{quote(decision_id, safe='')}/executions",
+            json=body,
+        )
+
+    def assessment(
+        self, decision_id: str, *, evidence_offset: int = 0
+    ) -> Dict[str, Any]:
+        return self.client.get(
+            f"/v1/learning/decisions/{quote(decision_id, safe='')}/assessment",
+            params={"evidence_offset": evidence_offset},
+        )
+
+    def verifier_evidence(self, verifier_id: str, decision_id: str) -> Dict[str, Any]:
+        """Call with the dedicated verifier client, never the actor's credential."""
+        return self.client.get(
+            f"/v1/learning/verifiers/{quote(verifier_id, safe='')}/decisions/{quote(decision_id, safe='')}"
+        )
+
+    def deliver_verified_outcomes(
+        self,
+        verifier_id: str,
+        *,
+        decision_id: str,
+        source_event_id: str,
+        evidence_digest: str,
+        execution_digest: str,
+        observations: List[Dict[str, Any]],
+    ) -> Dict[str, Any]:
+        """Deliver independently checked observations using the registered source key."""
+        return self.client.post(
+            f"/v1/learning/verifiers/{quote(verifier_id, safe='')}/events",
+            json={
+                "decision_id": decision_id,
+                "source_event_id": source_event_id,
+                "evidence_digest": evidence_digest,
+                "execution_digest": execution_digest,
+                "observations": observations,
+            },
+        )
+
     def get_decision(self, decision_id: str) -> Dict[str, Any]:
         return self.client.get(f"/v1/learning/decisions/{decision_id}")
 
@@ -789,7 +915,7 @@ class SyncMemoryClient:
         self.source = source or os.getenv("HEBBRIX_SOURCE")
         headers = {
             "Content-Type": "application/json",
-            "User-Agent": "hebbrix-python/2.4.1",
+            "User-Agent": "hebbrix-python/2.5.0",
         }
         if api_key:
             headers["Authorization"] = f"Bearer {api_key}"

{hebbrix-2.4.1 → hebbrix-2.5.0/hebbrix.egg-info}/PKG-INFO

@@ -1,10 +1,31 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.4.1
+Version: 2.5.0
 Summary: Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs
 Author-email: Hebbrix Team <support@hebbrix.com>
 Maintainer-email: Hebbrix Team <support@hebbrix.com>
-License-Expression: MIT
+License: MIT License
+        
+        Copyright (c) 2025 Hebbrix
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
 Project-URL: Homepage, https://hebbrix.com
 Project-URL: Documentation, https://docs.hebbrix.com
 Project-URL: Source, https://github.com/Hebbrix/hebbrix-python
@@ -47,7 +68,7 @@ Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs.
 ## Install
 
 ```bash
-pip install hebbrix==2.4.1
+pip install hebbrix==2.5.0
 ```
 
 Python 3.8+ is supported. `MemoryClient` is asynchronous. `SyncMemoryClient`

{hebbrix-2.4.1 → hebbrix-2.5.0}/hebbrix.egg-info/SOURCES.txt

@@ -16,6 +16,8 @@ hebbrix.egg-info/dependency_links.txt
 hebbrix.egg-info/requires.txt
 hebbrix.egg-info/top_level.txt
 tests/test_advanced_resources.py
+tests/test_evidence_loop_resource.py
+tests/test_evidence_safety_boundary.py
 tests/test_memories_resource.py
 tests/test_openapi_parity.py
 tests/test_procedural_resource.py

{hebbrix-2.4.1 → hebbrix-2.5.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hebbrix"
-version = "2.4.1"
+version = "2.5.0"
 description = "Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs"
 readme = "README.md"
 requires-python = ">=3.8"
-license = "MIT"
-license-files = ["LICENSE"]
+# Keep source installation compatible with Python 3.8's setuptools release.
+license = {file = "LICENSE"}
 authors = [
     {name = "Hebbrix Team", email = "support@hebbrix.com"}
 ]

hebbrix-2.5.0/tests/test_evidence_loop_resource.py

@@ -0,0 +1,158 @@
+"""Sync/async wire parity for the protected evidence lifecycle."""
+
+import inspect
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+
+from hebbrix.resources import ProofLoopResource
+from hebbrix.sync_client import SyncProofLoopResource
+
+
+SCOPE = {
+    "policy_key": "workflow.choice",
+    "collection_id": "collection",
+    "user_id": "end-user",
+}
+DELIVERY = {
+    "decision_id": "decision",
+    "source_event_id": "source-event",
+    "evidence_digest": "a" * 64,
+    "execution_digest": "b" * 64,
+    "observations": [
+        {
+            "metric_key": "success",
+            "value": 1,
+            "is_final": False,
+            "observed_at": "2026-09-07T12:00:00Z",
+        }
+    ],
+}
+CLAIM = {
+    "attempt_id": "attempt",
+    "status": "started",
+    "actual_action_key": "baseline",
+    "arguments_digest": "c" * 64,
+}
+
+CASES = [
+    (
+        "register_verifier",
+        (),
+        {
+            **SCOPE,
+            "api_key_id": "key",
+            "source_system": "verifier",
+            "metric_keys": ["success"],
+        },
+        "post",
+        "/v1/learning/verifiers",
+    ),
+    (
+        "create_episode",
+        (),
+        {**SCOPE, "verifier_id": "verifier", "idempotency_key": "episode-key"},
+        "post",
+        "/v1/learning/episodes",
+    ),
+    (
+        "revoke_verifier",
+        ("verifier",),
+        {},
+        "post",
+        "/v1/learning/verifiers/verifier/revoke",
+    ),
+    (
+        "get_episode",
+        ("episode",),
+        {"offset": 100},
+        "get",
+        "/v1/learning/episodes/episode",
+    ),
+    (
+        "close_episode",
+        ("episode",),
+        {"status": "interrupted"},
+        "post",
+        "/v1/learning/episodes/episode/close",
+    ),
+    (
+        "record_execution",
+        ("decision",),
+        CLAIM,
+        "post",
+        "/v1/learning/decisions/decision/executions",
+    ),
+    (
+        "assessment",
+        ("decision",),
+        {"evidence_offset": 100},
+        "get",
+        "/v1/learning/decisions/decision/assessment",
+    ),
+    (
+        "verifier_evidence",
+        ("verifier", "decision"),
+        {},
+        "get",
+        "/v1/learning/verifiers/verifier/decisions/decision",
+    ),
+    (
+        "deliver_verified_outcomes",
+        ("verifier",),
+        DELIVERY,
+        "post",
+        "/v1/learning/verifiers/verifier/events",
+    ),
+]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("resource_class", [ProofLoopResource, SyncProofLoopResource])
+@pytest.mark.parametrize("name,args,kwargs,method,path", CASES)
+async def test_protected_wire_contract_preserves_server_receipt(
+    resource_class, name, args, kwargs, method, path
+):
+    receipt = {
+        "authorization_granted": False,
+        "status": "review_required",
+        "replayed": True,
+    }
+    transport = Mock()
+    call = (
+        AsyncMock(return_value=receipt)
+        if resource_class is ProofLoopResource
+        else Mock(return_value=receipt)
+    )
+    setattr(transport, method, call)
+    result = getattr(resource_class(transport), name)(*args, **kwargs)
+    if inspect.isawaitable(result):
+        result = await result
+    assert result is receipt
+    expected = (
+        {"json" if method == "post" else "params": kwargs}
+        if kwargs or method == "post"
+        else {}
+    )
+    call.assert_called_once_with(path, **expected)
+
+
+@pytest.mark.parametrize("resource_class", [ProofLoopResource, SyncProofLoopResource])
+@pytest.mark.asyncio
+async def test_source_delivery_does_not_fall_back_to_unprotected_endpoint(
+    resource_class,
+):
+    transport = Mock()
+    error = RuntimeError("verifier credential rejected")
+    transport.post = (
+        AsyncMock(side_effect=error)
+        if resource_class is ProofLoopResource
+        else Mock(side_effect=error)
+    )
+    with pytest.raises(RuntimeError, match="verifier credential rejected"):
+        result = resource_class(transport).deliver_verified_outcomes(
+            "verifier", **DELIVERY
+        )
+        if inspect.isawaitable(result):
+            await result
+    assert transport.post.call_count == 1

hebbrix-2.5.0/tests/test_evidence_safety_boundary.py

@@ -0,0 +1,42 @@
+import pytest
+from hebbrix.resources import _canonical_search_envelope
+
+
+@pytest.mark.parametrize(
+    "patch",
+    [
+        {"sources": [{"content": "unidentified"}]},
+        {"sources": [None]},
+        {"sources": ["not a row"]},
+        {"sources": [{"memory_id": 7}]},
+        {"sources": [{"memory_id": " "}]},
+        {"sources": [{"memory_id": None, "id": "m-1"}]},
+        {"sources": [{"memory_id": "m-1", "id": "m-2"}]},
+        {"sources": {}},
+        {"sources": []},
+        {"evidence_ids": [7]},
+        {"evidence_ids": [None]},
+        {"evidence_ids": ["m-1", "m-1"]},
+        {"safety_contract_version": None},
+        {"safety_contract_version": "future-version"},
+        {"no_match": True},
+    ],
+)
+def test_malformed_evidence_never_exposes_unsupported_synthesis(patch):
+    response = {
+        "sources": [{"memory_id": "m-1", "content": "fact"}],
+        "answer": "unsupported answer",
+        "citations": ["m-1"],
+        "no_match": False,
+        "abstain_recommended": False,
+        "query_confidence": 0.9,
+        "grounding": {"status": "supported"},
+        "evidence_ids": ["m-1"],
+        "safety_contract_version": "search-safety-v1",
+    }
+    result = _canonical_search_envelope(dict(response, **patch), rows_key="sources")
+    assert result["sources"] == [] and result["evidence_ids"] == []
+    assert result["answer"] is None and result["citations"] == []
+    assert result["no_match"] is True and result["abstain_recommended"] is True
+    assert result["query_confidence"] == 0
+    assert response["sources"]  # Caller-owned envelope was not mutated.