fix(handler): add UNSUPPORTED_FEATURE gate and validate_platform test for sync_catalogs

- Add sync_catalogs to _OPTIONAL_PLATFORM_METHODS (specialism-gated variant)
- Call _require_platform_method("sync_catalogs") at shim entry so
  non-catalog-driven platforms surface UNSUPPORTED_FEATURE instead of
  INTERNAL_ERROR from the AttributeError wrapper
- Remove discovery-mode paragraph from _project_sync_catalogs docstring
  (belongs in shim/Protocol docstrings, not the projector helper)
- Add validate_platform boot-fail test for sales-catalog-driven missing
  sync_catalogs (pins the D12 boot-fail contract)
- Add _project_sync_catalogs unit tests: Pydantic rows, plain dict rows,
  pre-shaped passthrough, non-list passthrough
- Add UNSUPPORTED_FEATURE integration test: sync_catalogs on a
  sales-non-guaranteed handler raises UNSUPPORTED_FEATURE

https://claude.ai/code/session_01JF8GYzpYWE4swrNUhVAbMg

Author: claude

src/adcp/decisioning/handler.py

@@ -376,6 +376,8 @@
         # AudiencePlatform adopter-internal helper (not wire-served, but
         # listed here for symmetry should a future shim wire it)
         "poll_audience_statuses",
+        # Required for sales-catalog-driven; absent on all other sales-* platforms
+        "sync_catalogs",
     }
 )
 
@@ -810,10 +812,6 @@ def _project_sync_catalogs(result: Any) -> Any:
     fully-shaped :class:`SyncCatalogsSuccessResponse`. The wire envelope per
     ``schemas/cache/media-buy/sync-catalogs-response.json`` is
     ``{catalogs: [rows]}``. This helper wraps the list case.
-
-    Discovery mode (``req.catalogs is None``) returns existing synced catalogs
-    per spec — the platform method must handle ``req.catalogs is None`` as a
-    read-only path.
     """
     if isinstance(result, list):
         return {
@@ -2427,6 +2425,7 @@ async def sync_catalogs(  # type: ignore[override]
         to the wire envelope ``{catalogs: [...]}`` so adopters can return
         the ergonomic form.
         """
+        self._require_platform_method("sync_catalogs")
         tool_ctx = context or ToolContext()
         account = await self._resolve_account(getattr(params, "account", None), tool_ctx)
         ctx = self._build_ctx(tool_ctx, account)

tests/test_decisioning_dispatch.py

@@ -127,6 +127,40 @@ def update_media_buy(self, media_buy_id, patch, ctx):
     assert "get_media_buy_delivery" in missing_methods
 
 
+def test_validate_platform_raises_on_catalog_driven_without_sync_catalogs() -> None:
+    """Platform claims sales-catalog-driven but doesn't implement
+    ``sync_catalogs`` — hard-fails at server boot (D12 boot-fail rule).
+    Docstring on SalesPlatform.sync_catalogs promises this; this test
+    pins the behavior so a future refactor can't silently break it."""
+
+    class _CatalogDrivenNoMethod(DecisioningPlatform):
+        capabilities = DecisioningCapabilities(specialisms=["sales-catalog-driven"])
+        accounts = SingletonAccounts(account_id="hello")
+
+        def get_products(self, req, ctx):
+            return {"products": []}
+
+        def create_media_buy(self, req, ctx):
+            return {"media_buy_id": "mb_1"}
+
+        def update_media_buy(self, media_buy_id, patch, ctx):
+            return {"media_buy_id": media_buy_id, "status": "active"}
+
+        def sync_creatives(self, req, ctx):
+            return {"creatives": []}
+
+        def get_media_buy_delivery(self, req, ctx):
+            return {"media_buy_deliveries": []}
+
+        # Deliberately no sync_catalogs.
+
+    with pytest.raises(AdcpError) as exc_info:
+        validate_platform(_CatalogDrivenNoMethod())
+    assert exc_info.value.code == "INVALID_REQUEST"
+    missing_methods = {m["method"] for m in exc_info.value.details["missing"]}
+    assert "sync_catalogs" in missing_methods
+
+
 def test_validate_platform_warns_on_novel_specialism() -> None:
     """Truly novel specialism (no close spelling match to any known
     slug) emits UserWarning, NOT a raise. Forward-compat with v6.x+

tests/test_decisioning_handler_shims.py

@@ -40,6 +40,7 @@
     PlatformHandler,
     _project_build_creative,
     _project_sync_audiences,
+    _project_sync_catalogs,
 )
 from adcp.decisioning.webhook_emit import _BACKGROUND_WEBHOOK_TASKS
 from adcp.server.base import ToolContext
@@ -389,6 +390,92 @@ def sync_catalogs(self, req, ctx):
     }
 
 
+# ---- _project_sync_catalogs arms ----
+
+
+def test_project_sync_catalogs_wraps_pydantic_row_list() -> None:
+    """A list of Pydantic-like catalog-result rows wraps into ``{catalogs: [...]}``."""
+
+    class _Row:
+        def __init__(self, cid: str) -> None:
+            self.cid = cid
+
+        def model_dump(self, mode: str = "json") -> dict:
+            return {"catalog_id": self.cid, "action": "created"}
+
+    projected = _project_sync_catalogs([_Row("c1"), _Row("c2")])
+    assert projected == {
+        "catalogs": [
+            {"catalog_id": "c1", "action": "created"},
+            {"catalog_id": "c2", "action": "created"},
+        ]
+    }
+
+
+def test_project_sync_catalogs_wraps_plain_dict_row_list() -> None:
+    """List of plain dicts (no model_dump) — the row passthrough
+    inside the comprehension is exercised."""
+    projected = _project_sync_catalogs([{"catalog_id": "c1", "action": "updated"}])
+    assert projected == {"catalogs": [{"catalog_id": "c1", "action": "updated"}]}
+
+
+def test_project_sync_catalogs_passthrough_envelope_dict() -> None:
+    """Already-shaped envelope is unchanged."""
+    envelope = {"catalogs": [{"catalog_id": "c1"}]}
+    assert _project_sync_catalogs(envelope) is envelope
+
+
+def test_project_sync_catalogs_passthrough_non_list() -> None:
+    """Non-list, non-Pydantic shape (e.g. SyncCatalogsSuccessResponse instance
+    or unexpected sentinel) is returned unchanged so the wire validator
+    surfaces a precise mis-shape error."""
+    sentinel = "unexpected_string"
+    assert _project_sync_catalogs(sentinel) == sentinel
+
+
+# ---- sync_catalogs UNSUPPORTED_FEATURE gate ----
+
+
+@pytest.mark.asyncio
+async def test_sync_catalogs_unsupported_when_platform_lacks_method(executor) -> None:
+    """A sales-non-guaranteed platform that doesn't implement ``sync_catalogs``
+    surfaces ``UNSUPPORTED_FEATURE`` rather than ``INTERNAL_ERROR`` from the
+    AttributeError wrapper in ``_invoke_platform_method``."""
+
+    class _NoSyncCatalogs(DecisioningPlatform):
+        capabilities = DecisioningCapabilities(specialisms=["sales-non-guaranteed"])
+        accounts = SingletonAccounts(account_id="hello")
+
+        def get_products(self, req, ctx):
+            return {"products": []}
+
+        def create_media_buy(self, req, ctx):
+            return {"media_buy_id": "mb_1"}
+
+        def update_media_buy(self, media_buy_id, patch, ctx):
+            return {"media_buy_id": media_buy_id, "status": "active"}
+
+        def sync_creatives(self, req, ctx):
+            return {"creatives": []}
+
+        def get_media_buy_delivery(self, req, ctx):
+            return {"media_buy_deliveries": []}
+
+        # Deliberately no sync_catalogs.
+
+    handler = PlatformHandler(
+        _NoSyncCatalogs(),
+        executor=executor,
+        registry=InMemoryTaskRegistry(),
+    )
+    from adcp.types import SyncCatalogsRequest
+
+    with pytest.raises(AdcpError) as exc_info:
+        await handler.sync_catalogs(SyncCatalogsRequest.model_construct(), ToolContext())
+    assert exc_info.value.code == "UNSUPPORTED_FEATURE"
+    assert "sync_catalogs" in str(exc_info.value)
+
+
 @pytest.mark.asyncio
 async def test_check_governance_shim_routes_to_platform(executor) -> None:
     class _GovernanceAgent(DecisioningPlatform):