booking-agent-cli 0.7.0__tar.gz → 0.9.0__tar.gz

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: booking-agent-cli
-Version: 0.7.0
+Version: 0.9.0
 Summary: The Booking Agent CLI: a stateful USP booking flow with hard gates, plus its USP protocol library.
 Project-URL: Homepage, https://github.com/wix/booking-agent
 Project-URL: Documentation, https://github.com/wix/booking-agent/blob/master/booking-agent/README.md
@@ -78,7 +78,7 @@ Each release also publishes that skill at an immutable `skill-v<version>` tag an
 the release workflow, so a harness can pin and verify the exact text it follows:
 
 ```bash
-curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.55.0/booking-agent/skills/booking-agent/SKILL.md
+curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.57.0/booking-agent/skills/booking-agent/SKILL.md
 gh attestation verify SKILL.md --repo wix/booking-agent \
   --signer-workflow wix/booking-agent/.github/workflows/release.yml
 ```

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/README.md

@@ -36,7 +36,7 @@ Each release also publishes that skill at an immutable `skill-v<version>` tag an
 the release workflow, so a harness can pin and verify the exact text it follows:
 
 ```bash
-curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.55.0/booking-agent/skills/booking-agent/SKILL.md
+curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.57.0/booking-agent/skills/booking-agent/SKILL.md
 gh attestation verify SKILL.md --repo wix/booking-agent \
   --signer-workflow wix/booking-agent/.github/workflows/release.yml
 ```

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "booking-agent-cli"
-version = "0.7.0"
+version = "0.9.0"
 description = "The Booking Agent CLI: a stateful USP booking flow with hard gates, plus its USP protocol library."
 readme = "README.md"
 license = "Apache-2.0"

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/src/booking_agent/__init__.py

@@ -3,4 +3,4 @@
 Ships in the booking-agent-cli wheel and never imports ``booking_agent_cli``.
 """
 
-__version__ = "0.7.0"
+__version__ = "0.9.0"

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/src/booking_agent/backend/live.py

@@ -33,6 +33,7 @@ from ..rest_client import (
     USPTokenStore,
 )
 from ..headless import attach_registry_hit, mark_live_catalog_service, service_from_registry_hit
+from ..faults import record_silent_fault
 from ..authorization import BookingScopedCredential, evaluate, resolve_posture
 from ..pop import PopKey, PopKeyStore
 from ..ucp_profile import UcpNativeContext, fetch_and_resolve_business_profile
@@ -115,39 +116,41 @@ class LiveUSPBackend(USPBackend):
             decision=decision,
         )
 
+    # Discovery absorbs these failures, so they stay at debug level: a warning reaches
+    # stderr, which agent hosts merge into the stdout JSON they parse.
     @staticmethod
     def _log_profile_failure(profile_url: str, exc: BaseException) -> None:
         if is_rate_limited(exc):
-            logger.warning(
+            logger.debug(
                 "Profile resolution rate limited (HTTP 429) for %s",
                 profile_url,
             )
             return
         if isinstance(exc, httpx.HTTPStatusError):
-            logger.warning(
+            logger.debug(
                 "Profile resolution HTTP %s for %s",
                 exc.response.status_code,
                 profile_url,
             )
             return
-        logger.warning("Profile resolution failed for %s", profile_url)
+        logger.debug("Profile resolution failed for %s: %s: %s", profile_url, type(exc).__name__, exc)
 
     @staticmethod
     def _log_service_failure(service_id: str, exc: BaseException) -> None:
         if is_rate_limited(exc):
-            logger.warning(
+            logger.debug(
                 "Service catalog fetch rate limited (HTTP 429) for %s",
                 service_id,
             )
             return
         if isinstance(exc, httpx.HTTPStatusError):
-            logger.warning(
+            logger.debug(
                 "Service catalog fetch HTTP %s for %s",
                 exc.response.status_code,
                 service_id,
             )
             return
-        logger.warning("Service fetch failed: %s", service_id)
+        logger.debug("Service fetch failed: %s: %s", service_id, type(exc).__name__)
 
     # -- Registry-level ------------------------------------------------------
 
@@ -184,6 +187,9 @@ class LiveUSPBackend(USPBackend):
             self._log_profile_failure(profile_url, exc)
             if is_rate_limited(exc):
                 raise
+            record_silent_fault(
+                "profile_resolve", exc, profile_url=profile_url, business_id=biz_id,
+            )
 
     async def search_registry(self, intent: ServiceSearchIntent) -> List[USPService]:
         if not self._cfg.usp_registry_url:
@@ -289,6 +295,10 @@ class LiveUSPBackend(USPBackend):
                     if is_rate_limited(exc):
                         rate_limited_exc = exc
                         raise
+                    record_silent_fault(
+                        "catalog_enrich", exc, profile_url=profile_url,
+                        business_id=biz_id, service_id=r.service_id,
+                    )
                     return attach_registry_hit(
                         service_from_registry_hit(r), r, rank=rank,
                     )

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/src/booking_agent/defaults.env

@@ -43,6 +43,12 @@ BOOKING_AGENT_DISCOVERY_CONCURRENCY=8
 BOOKING_AGENT_PROFILE_CACHE_TTL_SECONDS=900
 # 1 writes a redacted request log to <session dir>/http_trace.log.
 BOOKING_AGENT_HTTP_TRACE=0
+# 1 writes money-path JSON event lines to stderr. Off by default because many
+# agent hosts merge stderr into the stdout JSON they parse.
+BOOKING_AGENT_STDERR_EVENTS=0
+# 0 stops automatic fault reports: faults the user never saw, about a business's
+# profile or catalog or the assistant's own code, sent with no user data.
+BOOKING_AGENT_FAULT_REPORTS=1
 
 # --- Address -------------------------------------------------------------------
 BOOKING_AGENT_GEOCODER_URL=https://nominatim.openstreetmap.org/search

booking_agent_cli-0.9.0/src/booking_agent/faults.py

@@ -0,0 +1,154 @@
+"""Faults the client absorbed, so the user never saw them.
+
+Code that catches an exception and carries on (a business profile that cannot be
+read during discovery, a catalog entry that cannot be fetched) calls
+``record_silent_fault``. Warnings logged by the allowed modules during a command are
+collected the same way. The CLI decides at the end of the command whether these
+become automatic fault reports; nothing here does I/O.
+
+Only structural facts are kept: the step, the exception type, a code-authored log
+format string, and public identifiers of the business involved. Exception messages
+and log arguments are never kept, because they can carry anything.
+"""
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any, Dict, List, Optional
+from urllib.parse import urlsplit
+
+#: Steps whose outcome never depends on the user's own accounts or data.
+STEPS = frozenset({
+    "registry_search",
+    "profile_resolve",
+    "catalog_enrich",
+    "availability_prefetch",
+    "platform_profile",
+    "cli",
+})
+#: Loggers whose warnings count as degraded results. Link, payment, identity, buyer
+#: details, and Google Calendar code is not here: their faults stay on the consented path.
+WARNING_LOGGERS = (
+    "booking_agent.backend.live",
+    "booking_agent.discovery",
+    "booking_agent.headless",
+    "booking_agent.ucp_profile",
+    "booking_agent.profile_cache",
+)
+_MAX_RECORDED = 50
+_SLUG_RE = re.compile(r"[^a-z0-9]+")
+
+_recorded: List[Dict[str, Any]] = []
+
+
+def _reason(exc: Optional[BaseException]) -> Optional[str]:
+    if exc is None:
+        return None
+    response = getattr(exc, "response", None)
+    status = getattr(response, "status_code", None)
+    if isinstance(status, int):
+        return f"http_{status}"
+    from booking_agent.ucp_profile import UcpProfileValidationError
+
+    if isinstance(exc, UcpProfileValidationError) and exc.args and isinstance(exc.args[0], str):
+        # Validation messages are written in this package and name only profile fields.
+        slug = _SLUG_RE.sub("_", exc.args[0].lower()).strip("_")
+        return slug[:64] or None
+    return None
+
+
+def _subject(profile_url: Optional[str], **ids: Any) -> Dict[str, Any]:
+    subject: Dict[str, Any] = {}
+    if profile_url:
+        try:
+            parts = urlsplit(profile_url)
+        except ValueError:
+            parts = None
+        if parts is not None and parts.scheme in ("http", "https") and parts.hostname:
+            subject["host"] = parts.hostname
+            subject["path"] = parts.path or "/"
+    for key, value in ids.items():
+        if value is not None:
+            subject[key] = value
+    return subject
+
+
+def record_silent_fault(
+    step: str,
+    exc: Optional[BaseException] = None,
+    *,
+    profile_url: Optional[str] = None,
+    business_id: Optional[str] = None,
+    service_id: Optional[str] = None,
+) -> None:
+    """Note a fault this code absorbed. Never raises."""
+    try:
+        if len(_recorded) >= _MAX_RECORDED:
+            return
+        response = getattr(exc, "response", None)
+        status = getattr(response, "status_code", None)
+        _recorded.append({
+            "fault_class": "absorbed_exception",
+            "step": step if step in STEPS else "cli",
+            "exception_type": _qualname(exc),
+            "message_template": None,
+            "reason_code": _reason(exc),
+            "subject": _subject(
+                profile_url,
+                business_id=business_id,
+                service_ids=[service_id] if service_id else None,
+                http_status=status if isinstance(status, int) else None,
+            ),
+        })
+    except Exception:
+        pass
+
+
+def _qualname(exc: Optional[BaseException]) -> Optional[str]:
+    if exc is None:
+        return None
+    cls = type(exc)
+    return f"{cls.__module__}.{cls.__qualname__}"
+
+
+class _WarningCollector(logging.Handler):
+    """Keeps the format string of each warning; the formatted text is never stored."""
+
+    def __init__(self) -> None:
+        super().__init__(level=logging.WARNING)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            if not record.name.startswith(WARNING_LOGGERS) or len(_recorded) >= _MAX_RECORDED:
+                return
+            exc = record.exc_info[1] if record.exc_info else None
+            _recorded.append({
+                "fault_class": "degraded_result",
+                "step": "cli",
+                "exception_type": _qualname(exc),
+                "message_template": record.msg if isinstance(record.msg, str) else None,
+                "reason_code": None,
+                "subject": {"logger": record.name},
+            })
+        except Exception:
+            pass
+
+
+_collector: Optional[_WarningCollector] = None
+
+
+def install_warning_collector() -> None:
+    """Collect allowed warnings instead of printing them to stderr (idempotent)."""
+    global _collector
+    if _collector is not None:
+        return
+    _collector = _WarningCollector()
+    for name in ("booking_agent", "booking_agent_cli"):
+        logging.getLogger(name).addHandler(_collector)
+
+
+def drain() -> List[Dict[str, Any]]:
+    """Every fault recorded so far, cleared."""
+    out = list(_recorded)
+    _recorded.clear()
+    return out

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/src/booking_agent/namespace.py

@@ -17,6 +17,7 @@ CAP_CATALOG = "dev.usp-protocol.services.catalog"
 CAP_AVAILABILITY = "dev.usp-protocol.services.availability"
 CAP_BOOKINGS = "dev.usp-protocol.services.bookings"
 CAP_PAID_BOOKINGS = "dev.usp-protocol.services.paid_bookings"
+CAP_PAY_AT_SERVICE = "dev.usp-protocol.services.pay_at_service"
 
 
 class NamespaceOriginError(ValueError):

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/src/booking_agent/observability.py

@@ -9,6 +9,8 @@ from typing import Any, Callable, Dict, Optional
 
 import httpx
 
+from booking_agent import settings
+
 # Wire name for the flow join key. Optional on the USP HTTP binding (Track S of
 # spec issue #160): send when bound, never require it on responses, never fail a
 # call because a peer omitted or ignored it.
@@ -35,9 +37,14 @@ _FORBIDDEN_FIELD_KEYS = frozenset({
 })
 
 _correlation_id: ContextVar[Optional[str]] = ContextVar("booking_agent_correlation_id", default=None)
-_event_sink: Callable[[Dict[str, Any]], None] = lambda record: sys.stderr.write(
-    json.dumps(record, default=str) + "\n"
-)
+
+
+def _default_sink(record: Dict[str, Any]) -> None:
+    if settings.get_bool("BOOKING_AGENT_STDERR_EVENTS"):
+        sys.stderr.write(json.dumps(record, default=str) + "\n")
+
+
+_event_sink: Callable[[Dict[str, Any]], None] = _default_sink
 
 
 def set_event_sink(sink: Callable[[Dict[str, Any]], None]) -> None:
@@ -49,7 +56,7 @@ def set_event_sink(sink: Callable[[Dict[str, Any]], None]) -> None:
 def reset_event_sink() -> None:
     """Restore the default stderr event sink."""
     global _event_sink
-    _event_sink = lambda record: sys.stderr.write(json.dumps(record, default=str) + "\n")
+    _event_sink = _default_sink
 
 
 def new_correlation_id() -> str:

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/src/booking_agent/platform_profile.py

@@ -88,6 +88,17 @@ def platform_profile_doc() -> Dict[str, Any]:
                         "extends": "dev.ucp.shopping.checkout",
                     }
                 ],
+                "dev.usp-protocol.services.pay_at_service": [
+                    {
+                        "version": "2026-08-20",
+                        "spec": (
+                            "https://usp-protocol.dev/specification"
+                            "#pay-at-service-settlement-extension"
+                        ),
+                        "schema": "https://usp-protocol.dev/schemas/services/pay_at_service.json",
+                        "extends": "dev.ucp.shopping.checkout",
+                    }
+                ],
                 "dev.ucp.common.payment.terms": [
                     {
                         "version": "2026-08-25",

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/src/booking_agent/ucp_capabilities.py

@@ -28,6 +28,7 @@ from __future__ import annotations
 from typing import Any, Callable, Dict, List
 
 from .ucp_negotiation import _capabilities_from_doc
+from .namespace import CAP_PAY_AT_SERVICE
 from .ucp_profile import CAP_PAID_BOOKINGS, UcpProfileValidationError
 
 
@@ -91,9 +92,14 @@ def _paid_bookings_handler(echoed_versions: List[str], platform_supported: List[
     _validate_versions_supported(CAP_PAID_BOOKINGS, echoed_versions, platform_supported)
 
 
+def _pay_at_service_handler(echoed_versions: List[str], platform_supported: List[str]) -> None:
+    _validate_versions_supported(CAP_PAY_AT_SERVICE, echoed_versions, platform_supported)
+
+
 # namespace -> handler. Register new capabilities (e.g. AP2) here.
 CAPABILITY_HANDLERS: Dict[str, CapabilityHandler] = {
     CAP_PAID_BOOKINGS: _paid_bookings_handler,
+    CAP_PAY_AT_SERVICE: _pay_at_service_handler,
 }
 
 

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/src/booking_agent/ucp_checkout.py

@@ -5,6 +5,7 @@ import json
 import logging
 import uuid
 from dataclasses import dataclass
+from datetime import datetime
 from enum import Enum
 from typing import Any, Dict, List, Optional
 
@@ -489,6 +490,129 @@ def immediate_schedule_amount(term: Dict[str, Any]) -> Optional[int]:
     return amount
 
 
+PAY_AT_SERVICE_CAPABILITY = "dev.usp-protocol.services.pay_at_service"
+SETTLEMENT_MODE_OFFLINE = "offline"
+#: Disclosure code the business emits for a pay-at-service checkout (USP 11.3.5 S8).
+PAYMENT_DUE_AT_SERVICE_CODE = "payment_due_at_service"
+
+
+def is_offline_settled(checkout: Any) -> bool:
+    """True when the checkout declares ``settlement.mode == "offline"`` (USP 11.3.3)."""
+    settlement = checkout.get("settlement") if isinstance(checkout, dict) else None
+    return isinstance(settlement, dict) and settlement.get("mode") == SETTLEMENT_MODE_OFFLINE
+
+
+def _instants_equal(a: Any, b: Any) -> bool:
+    """Compare two RFC 3339 instants, tolerating a differing UTC offset spelling."""
+    if a == b:
+        return True
+    try:
+        left = datetime.fromisoformat(str(a).replace("Z", "+00:00"))
+        right = datetime.fromisoformat(str(b).replace("Z", "+00:00"))
+    except ValueError:
+        return False
+    if left.tzinfo is None or right.tzinfo is None:
+        return False
+    return left == right
+
+
+def _is_at_service_term(term: Any) -> bool:
+    schedules = term.get("schedules") if isinstance(term, dict) else None
+    return (
+        isinstance(schedules, list)
+        and bool(schedules)
+        and all(isinstance(s, dict) and s.get("type") == "at_service" for s in schedules)
+    )
+
+
+def validate_offline_settlement(
+    checkout: Dict[str, Any],
+    *,
+    negotiated_capabilities: Optional[Dict[str, Any]] = None,
+    persisted_term: Optional[Dict[str, Any]] = None,
+    slot_start: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Validate a pay-at-service checkout (USP 11.3) and return its selected term.
+
+    Fails closed on anything the extension does not define: an unknown settlement
+    mode, a settlement without the terms it names (S1), more than one offline term
+    (S2), a ``due_at`` that is not the slot start (S3), or a selected term other
+    than the offline one (S4 applies only when the offline term is selected).
+    """
+    settlement = checkout.get("settlement")
+    if not isinstance(settlement, dict):
+        raise UcpProfileValidationError("Checkout settlement must be an object.")
+    if settlement.get("mode") != SETTLEMENT_MODE_OFFLINE:
+        raise UcpProfileValidationError(
+            f"Checkout settlement mode {settlement.get('mode')!r} is not supported."
+        )
+    term_id = settlement.get("term_id")
+    if not isinstance(term_id, str) or not term_id:
+        raise UcpProfileValidationError("Checkout settlement is missing term_id.")
+    caps = negotiated_capabilities or {}
+    missing = [
+        cap for cap in (PAY_AT_SERVICE_CAPABILITY, PAYMENT_TERMS_CAPABILITY) if cap not in caps
+    ]
+    if missing:
+        raise UcpProfileValidationError(
+            "Checkout declared pay-at-service settlement without negotiated capabilities "
+            f"{missing!r}."
+        )
+    payment = checkout.get("payment") if isinstance(checkout.get("payment"), dict) else {}
+    terms = payment.get("terms")
+    selected_id = payment.get("selected_term_id")
+    if not isinstance(terms, list) or not terms or not selected_id:
+        raise UcpProfileValidationError(
+            "Checkout settlement requires payment.terms and payment.selected_term_id."
+        )
+    named = [t for t in terms if isinstance(t, dict) and t.get("id") == term_id]
+    if len(named) != 1:
+        raise UcpProfileValidationError(
+            "Checkout settlement.term_id must match exactly one payment.terms[].id."
+        )
+    term = named[0]
+    offline_terms = [t for t in terms if _is_at_service_term(t)]
+    if len(offline_terms) != 1 or offline_terms[0] is not term:
+        raise UcpProfileValidationError(
+            "A pay-at-service checkout must offer exactly one pay-at-service term, "
+            "and settlement.term_id must name it."
+        )
+    if selected_id != term_id:
+        raise UcpProfileValidationError(
+            "The pay-at-service term is not the selected payment term, so the booking "
+            "cannot be completed without a payment instrument."
+        )
+    total = checkout_total_minor_units(checkout)
+    if total is None:
+        raise UcpProfileValidationError("Checkout totals must include a type=total amount.")
+    amounts: list[int] = []
+    for schedule in term["schedules"]:
+        amount = _schedule_amount(schedule)
+        if amount is None or amount <= 0:
+            raise UcpProfileValidationError(
+                "Each pay-at-service schedule must carry a positive integer amount."
+            )
+        amounts.append(amount)
+        due_at = schedule.get("due_at")
+        if not due_at:
+            raise UcpProfileValidationError(
+                "Pay-at-service schedule must set due_at to the slot start."
+            )
+        if slot_start and not _instants_equal(due_at, slot_start):
+            raise UcpProfileValidationError(
+                "Pay-at-service due_at must equal the booked slot start."
+            )
+    if sum(amounts) != int(total):
+        raise UcpProfileValidationError(
+            "Pay-at-service schedule amounts must sum to the checkout total."
+        )
+    if persisted_term is not None and persisted_term != term:
+        raise UcpProfileValidationError(
+            "The payment term changed since it was quoted. Do not complete this booking."
+        )
+    return term
+
+
 def validate_payment_terms(
     checkout: Dict[str, Any],
     *,
@@ -496,13 +620,33 @@ def validate_payment_terms(
     require_terms: bool = False,
     persisted_term: Optional[Dict[str, Any]] = None,
     slot_start: Optional[str] = None,
+    expect_offline_settlement: bool = False,
 ) -> Optional[Dict[str, Any]]:
     """Validate UCP payment terms on a checkout. Returns the selected term or None.
 
     Deposits require the negotiated terms capability, exactly one selected term,
     schedules that sum to checkout total, exactly one positive immediate amount,
     and an at-service balance with due_at.
+
+    A checkout routed as pay-at-service (``expect_offline_settlement``) must carry
+    an offline ``settlement`` and is validated by :func:`validate_offline_settlement`;
+    any other route that receives a ``settlement`` fails closed rather than being
+    treated as an ordinary charge.
     """
+    has_settlement = "settlement" in checkout
+    if has_settlement != expect_offline_settlement:
+        raise UcpProfileValidationError(
+            "Checkout carries a settlement this booking was not routed for."
+            if has_settlement
+            else "This booking was routed as pay-at-service but the checkout has no settlement."
+        )
+    if has_settlement:
+        return validate_offline_settlement(
+            checkout,
+            negotiated_capabilities=negotiated_capabilities,
+            persisted_term=persisted_term,
+            slot_start=slot_start,
+        )
     payment = checkout.get("payment") if isinstance(checkout.get("payment"), dict) else {}
     terms = payment.get("terms") if isinstance(payment, dict) else None
     has_terms = isinstance(terms, list) and len(terms) > 0

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/src/booking_agent/ucp_profile.py

@@ -20,9 +20,16 @@ from pydantic import BaseModel, ConfigDict, Field
 from pydantic.alias_generators import to_camel
 
 from .authorization import AuthorizationPolicy, parse_policy
-from .namespace import CAP_CATALOG, CAP_PAID_BOOKINGS, SVC_SERVICES, check_origin_binding
+from .namespace import (
+    CAP_CATALOG,
+    CAP_PAID_BOOKINGS,
+    CAP_PAY_AT_SERVICE,
+    SVC_SERVICES,
+    check_origin_binding,
+)
 
 CAP_CHECKOUT = "dev.ucp.shopping.checkout"
+CAP_PAYMENT_TERMS = "dev.ucp.common.payment.terms"
 
 
 class UcpTransportBinding(BaseModel):
@@ -110,6 +117,20 @@ class UcpNativeContext(BaseModel):
     def requires_paid_bookings(self) -> bool:
         return CAP_PAID_BOOKINGS in self.profile.capabilities
 
+    def declares_pay_at_service(self) -> bool:
+        """True when the business declares everything the pay-at-service checkout path needs.
+
+        USP 11.3.2: a business routing ``at_service`` through a checkout declares
+        ``pay_at_service`` *and* ``dev.ucp.common.payment.terms``; declaring the
+        first without the second is malformed, so it is not treated as declared.
+        """
+        caps = self.profile.capabilities
+        return (
+            CAP_PAY_AT_SERVICE in caps
+            and CAP_PAYMENT_TERMS in caps
+            and CAP_CHECKOUT in caps
+        )
+
     def usp_authorization(self) -> Optional[AuthorizationPolicy]:
         """The ``config.authorization`` policy on the ``dev.usp-protocol.services`` binding.
 
@@ -148,10 +169,11 @@ class UcpNativeContext(BaseModel):
                 continue
             if "authorization" in binding:
                 logger.warning(
-                    f"{SVC_SERVICES} binding declares a sibling 'authorization' member, "
+                    "%s binding declares a sibling 'authorization' member, "
                     "which USP prohibits; the policy MUST be published as "
                     "config.authorization. Treating this business as publishing no "
-                    "policy."
+                    "policy.",
+                    SVC_SERVICES,
                 )
                 misplaced = True
                 continue

{booking_agent_cli-0.7.0 → booking_agent_cli-0.9.0}/src/booking_agent_cli/__init__.py

@@ -1,3 +1,3 @@
 """booking_agent_cli: typer-based stateful CLI for USP booking flows."""
 
-__version__ = "0.7.0"
+__version__ = "0.9.0"