@topy-ai/maggie 0.7.16 → 0.7.18

package/bundled-tools/runtime/maggie_head_tags.py

@@ -0,0 +1,101 @@
+"""Audit normalized head metadata across rendered shells."""
+
+from __future__ import annotations
+
+import json
+from collections import defaultdict
+from pathlib import Path
+from urllib.parse import urlparse
+from typing import Any
+
+
+SCHEMA = "maggie-head-tags.v1"
+STABLE_TAGS = ("icon", "og:image", "og:image:type", "verification", "robots", "twitter:card")
+
+
+def _extension(value: object) -> str | None:
+    path = urlparse(str(value or "")).path.lower()
+    if "." not in path.rsplit("/", 1)[-1]:
+        return None
+    return "." + path.rsplit("/", 1)[-1].rsplit(".", 1)[-1]
+
+
+def _signature(name: str, value: object, tags: dict[str, Any]) -> dict[str, Any]:
+    """Return only safe, structural metadata; never echo verification values."""
+    if name == "verification":
+        present = bool(value) if not isinstance(value, dict) else bool(value.get("present", value.get("content")))
+        return {"present": present}
+    if name == "icon":
+        data = value if isinstance(value, dict) else {"href": value}
+        return {"present": bool(value), "rel": str(data.get("rel") or "icon"), "type": str(data.get("type") or ""), "extension": _extension(data.get("href"))}
+    if name == "og:image":
+        data = value if isinstance(value, dict) else {"href": value}
+        image_type = data.get("type") or tags.get("og:image:type") or ""
+        return {"present": bool(value), "type": str(image_type), "extension": _extension(data.get("href") or data.get("content") or value), "fallback": bool(data.get("fallback", tags.get("og:image:fallback", False)))}
+    if name == "og:image:type":
+        return {"present": bool(value), "type": str(value or "")}
+    if isinstance(value, dict):
+        return {"present": bool(value), "type": str(value.get("type") or "")}
+    return {"present": bool(value), "value": str(value or "")}
+
+
+def audit_head_tags(pages: list[dict[str, Any]]) -> dict[str, Any]:
+    errors: list[dict[str, str]] = []
+    observations: list[dict[str, Any]] = []
+    for page in pages:
+        if not isinstance(page, dict) or not str(page.get("url") or "").strip():
+            errors.append({"reason": "each page requires a URL"})
+            continue
+        shell = str(page.get("shell") or "").strip()
+        if not shell:
+            errors.append({"url": str(page["url"]), "reason": "each page requires a shell"})
+            continue
+        tags = page.get("tags", {})
+        if not isinstance(tags, dict):
+            errors.append({"url": str(page["url"]), "reason": "tags must be an object"})
+            continue
+        observations.append({"url": str(page["url"]), "shell": shell, "tags": {name: _signature(name, tags.get(name), tags) for name in STABLE_TAGS}})
+
+    by_shell: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for observation in observations:
+        by_shell[observation["shell"]].append(observation)
+    disagreements: list[dict[str, Any]] = []
+
+    def compare(scope: str, label: str, entries: list[tuple[str, dict[str, Any]]]) -> None:
+        for tag in STABLE_TAGS:
+            variants: dict[str, dict[str, Any]] = {}
+            urls: dict[str, list[str]] = defaultdict(list)
+            for identifier, observation in entries:
+                signature = observation["tags"][tag]
+                key = json.dumps(signature, sort_keys=True, separators=(",", ":"))
+                variants[key] = signature
+                urls[key].append(observation["url"])
+            if len(variants) > 1:
+                disagreements.append({"scope": scope, "shell": label if scope == "shell" else None, "tag": tag, "variants": [{"signature": signature, "urls": sorted(urls[key])} for key, signature in sorted(variants.items())]})
+
+    for shell, shell_pages in sorted(by_shell.items()):
+        compare("shell", shell, [(shell, page) for page in shell_pages])
+    for tag in STABLE_TAGS:
+        entries = [(shell, page) for shell, shell_pages in sorted(by_shell.items()) for page in shell_pages]
+        shell_signatures: dict[str, dict[str, Any]] = {}
+        shell_urls: dict[str, list[str]] = defaultdict(list)
+        for shell, page in entries:
+            key = json.dumps(page["tags"][tag], sort_keys=True, separators=(",", ":"))
+            shell_signatures[shell] = page["tags"][tag]
+            shell_urls[key].append(page["url"])
+        unique = {json.dumps(value, sort_keys=True, separators=(",", ":")) for value in shell_signatures.values()}
+        if len(unique) > 1:
+            disagreements.append({"scope": "across-shells", "shell": None, "tag": tag, "variants": [{"signature": shell_signatures[shell], "shell": shell, "urls": sorted(shell_urls[json.dumps(shell_signatures[shell], sort_keys=True, separators=(",", ":"))])} for shell in sorted(shell_signatures)]})
+
+    coverage = []
+    for shell, shell_pages in sorted(by_shell.items()):
+        coverage.append({"shell": shell, "pageCount": len(shell_pages), "tags": {tag: sum(1 for page in shell_pages if page["tags"][tag]["present"]) for tag in STABLE_TAGS}})
+    return {"schemaVersion": SCHEMA, "shells": coverage, "observations": observations, "disagreements": disagreements, "errors": errors, "passed": not errors and not disagreements, "mutation": False}
+
+
+def read_pages(path: Path) -> list[dict[str, Any]]:
+    value = json.loads(path.read_text(encoding="utf-8"))
+    pages = value.get("pages") if isinstance(value, dict) else value
+    if not isinstance(pages, list):
+        raise ValueError("pages file must be a JSON array or {\"pages\": []}")
+    return pages

package/bundled-tools/runtime/maggie_indexnow.py

@@ -99,6 +99,56 @@ def check_key_file(public_dir: Path, key_file: str, key: str) -> dict[str, Any]:
             "matches": served == key.strip(), "status": "pass" if served == key.strip() else "fail"}
 
 
+def _public_url(value: str, label: str) -> str:
+    parsed = urlparse(value)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc or parsed.fragment:
+        raise ValueError(f"{label} must be an absolute HTTP(S) URL without a fragment")
+    return value
+
+
+def _fetch_key(url: str, expected: str, timeout: int) -> dict[str, Any]:
+    status_code: int | None = None
+    matches = False
+    try:
+        request = Request(url, headers={"User-Agent": "Maggie-IndexNow-Key-Check/1"})
+        with urlopen(request, timeout=timeout) as response:
+            status_code = int(response.status)
+            body = response.read(4097)
+            matches = len(body) <= 4096 and body.decode("utf-8", "replace").strip() == expected
+    except HTTPError as error:
+        status_code = int(error.code)
+    except (URLError, TimeoutError, OSError):
+        pass
+    return {"statusCode": status_code, "matches": matches}
+
+
+def check_key_http(key_url: str, key: str, wrong_key_url: str | None = None,
+                   timeout: int = 15) -> dict[str, Any]:
+    """Verify the deployed key route without exposing its response body."""
+    expected = key.strip()
+    if not expected:
+        raise ValueError("key is required")
+    if timeout < 1:
+        raise ValueError("timeout must be positive")
+    correct_url = _public_url(key_url, "key-url")
+    correct = _fetch_key(correct_url, expected, timeout)
+    result: dict[str, Any] = {
+        "keyUrl": correct_url,
+        "correct": correct,
+        "wrong": None,
+        "status": "pass" if correct["statusCode"] == 200 and correct["matches"] else "fail",
+    }
+    if wrong_key_url:
+        wrong_url = _public_url(wrong_key_url, "wrong-key-url")
+        if wrong_url == correct_url:
+            raise ValueError("wrong-key-url must differ from key-url")
+        wrong = _fetch_key(wrong_url, expected, timeout)
+        result["wrong"] = {"url": wrong_url, **wrong, "is404": wrong["statusCode"] == 404}
+        if not result["wrong"]["is404"]:
+            result["status"] = "fail"
+    return result
+
+
 def submit_plan(plan: dict[str, Any], state: dict[str, Any], endpoint: str) -> dict[str, Any]:
     urls = plan.get("eligible") if isinstance(plan.get("eligible"), list) else []
     if not urls:

package/bundled-tools/runtime/maggie_social_cards.py

@@ -0,0 +1,165 @@
+"""Provider-neutral Open Graph social-card inspection."""
+
+from __future__ import annotations
+
+import json
+from collections import Counter
+from html.parser import HTMLParser
+from pathlib import Path
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.parse import urljoin, urlparse
+from urllib.request import Request, urlopen
+
+
+SCHEMA = "maggie-social-cards.v1"
+MIN_WIDTH = 300
+MIN_HEIGHT = 157
+SUPPORTED_FORMATS = {"image/jpeg", "image/png", "image/gif", "image/x-icon"}
+
+
+class OpenGraphParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__()
+        self.values: dict[str, str] = {}
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if tag != "meta":
+            return
+        data = dict(attrs)
+        key = (data.get("property") or data.get("name") or "").lower()
+        if key in {"og:image", "og:image:type"} and key not in self.values:
+            self.values[key] = str(data.get("content") or "").strip()
+
+
+def _dimensions(raw: bytes, content_type: str) -> tuple[str | None, int | None, int | None]:
+    """Read dimensions from common headers without an image dependency."""
+    if raw.startswith(b"\x89PNG\r\n\x1a\n") and len(raw) >= 24:
+        return "image/png", int.from_bytes(raw[16:20], "big"), int.from_bytes(raw[20:24], "big")
+    if raw[:3] == b"GIF" and len(raw) >= 10:
+        return "image/gif", int.from_bytes(raw[6:8], "little"), int.from_bytes(raw[8:10], "little")
+    if raw[:4] == b"\x00\x00\x01\x00" and len(raw) >= 22:
+        width = raw[6] or 256
+        height = raw[7] or 256
+        return "image/x-icon", width, height
+    if raw[:2] == b"\xff\xd8":
+        index = 2
+        while index + 9 < len(raw):
+            if raw[index] != 0xFF:
+                index += 1
+                continue
+            marker = raw[index + 1]
+            index += 2
+            if marker in {0xD8, 0xD9}:
+                continue
+            if index + 2 > len(raw):
+                break
+            segment_length = int.from_bytes(raw[index:index + 2], "big")
+            if segment_length < 2 or index + segment_length > len(raw):
+                break
+            if marker in set(range(0xC0, 0xC4)) | set(range(0xC5, 0xC8)) | set(range(0xC9, 0xCC)) | set(range(0xCD, 0xD0)):
+                if segment_length >= 7:
+                    return "image/jpeg", int.from_bytes(raw[index + 5:index + 7], "big"), int.from_bytes(raw[index + 3:index + 5], "big")
+            index += segment_length
+        return "image/jpeg", None, None
+    if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" and len(raw) >= 30:
+        if raw[12:16] == b"VP8X":
+            width = 1 + int.from_bytes(raw[24:27], "little")
+            height = 1 + int.from_bytes(raw[27:30], "little")
+            return "image/webp", width, height
+        return "image/webp", None, None
+    return (content_type.split(";", 1)[0].lower() or None), None, None
+
+
+def _fetch(url: str, timeout: int, limit: int = 8_000_000) -> tuple[int | None, str, bytes, str | None]:
+    try:
+        request = Request(url, headers={"User-Agent": "Maggie-Social-Card-Audit/1"})
+        with urlopen(request, timeout=timeout) as response:
+            raw = response.read(limit + 1)
+            return int(response.status), response.headers.get_content_type(), raw[:limit], None if len(raw) <= limit else "response exceeds size limit"
+    except HTTPError as error:
+        return int(error.code), "", b"", "HTTP error"
+    except (URLError, TimeoutError, OSError):
+        return None, "", b"", "request failed"
+
+
+def _absolute(value: str, base: str) -> str:
+    candidate = urljoin(base.rstrip("/") + "/", value)
+    parsed = urlparse(candidate)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc or parsed.fragment:
+        raise ValueError("og:image must resolve to an absolute HTTP(S) URL without a fragment")
+    return candidate
+
+
+def audit_cards(pages: list[dict[str, Any]], *, timeout: int = 15,
+                min_width: int = MIN_WIDTH, min_height: int = MIN_HEIGHT) -> dict[str, Any]:
+    if timeout < 1 or min_width < 1 or min_height < 1:
+        raise ValueError("timeout and image dimensions must be positive")
+    reports: list[dict[str, Any]] = []
+    errors: list[dict[str, str]] = []
+    sources: list[str] = []
+    for page in pages:
+        if not isinstance(page, dict) or not str(page.get("url") or "").strip():
+            errors.append({"reason": "page must contain a URL"})
+            continue
+        page_url = str(page["url"]).strip()
+        image = str(page.get("ogImage") or page.get("og:image") or "").strip()
+        record: dict[str, Any] = {"url": page_url, "ogImage": image or None, "fallback": bool(page.get("fallback", False)), "errors": []}
+        if not image:
+            record["errors"].append("missing og:image")
+            reports.append(record)
+            errors.append({"url": page_url, "reason": "missing og:image"})
+            continue
+        try:
+            image_url = _absolute(image, page_url)
+        except ValueError as exc:
+            record["errors"].append(str(exc))
+            reports.append(record)
+            errors.append({"url": page_url, "reason": str(exc)})
+            continue
+        status, header_type, raw, fetch_error = _fetch(image_url, timeout)
+        image_type, width, height = _dimensions(raw, header_type)
+        record.update({"imageUrl": image_url, "statusCode": status, "format": image_type, "width": width, "height": height})
+        if fetch_error or status != 200:
+            record["errors"].append(fetch_error or "image request did not return HTTP 200")
+        elif image_type not in SUPPORTED_FORMATS:
+            record["errors"].append("unsupported format for large social card")
+        elif width is None or height is None:
+            record["errors"].append("image dimensions could not be read")
+        else:
+            if width < min_width or height < min_height:
+                record["errors"].append(f"image is smaller than {min_width}x{min_height}")
+        reports.append(record)
+        sources.append(image_url)
+        for reason in record["errors"]:
+            errors.append({"url": page_url, "reason": reason})
+
+    warnings: list[dict[str, Any]] = []
+    if len(sources) >= 3:
+        source, count = Counter(sources).most_common(1)[0]
+        if count / len(sources) >= 0.75:
+            warnings.append({"reason": "generic fallback concentration", "imageUrl": source, "count": count, "sampleSize": len(sources), "ratio": round(count / len(sources), 3)})
+    return {"schemaVersion": SCHEMA, "threshold": {"minWidth": min_width, "minHeight": min_height, "supportedFormats": sorted(SUPPORTED_FORMATS)}, "pages": reports, "warnings": warnings, "errors": errors, "passed": not errors, "mutation": False}
+
+
+def pages_from_urls(urls: list[str], timeout: int) -> list[dict[str, Any]]:
+    pages: list[dict[str, Any]] = []
+    for page_url in urls:
+        status, content_type, raw, fetch_error = _fetch(page_url, timeout, 2_000_000)
+        if fetch_error or status != 200 or content_type != "text/html":
+            pages.append({"url": page_url, "ogImage": "", "fetchError": fetch_error or "page request did not return HTML"})
+            continue
+        parser = OpenGraphParser()
+        parser.feed(raw.decode("utf-8", "replace"))
+        pages.append({"url": page_url, "ogImage": parser.values.get("og:image", "")})
+    return pages
+
+
+def read_pages(path: Path) -> list[dict[str, Any]]:
+    value = json.loads(path.read_text(encoding="utf-8"))
+    pages = value.get("pages") if isinstance(value, dict) else value
+    if not isinstance(pages, list):
+        raise ValueError("pages file must be a JSON array or {\"pages\": []}")
+    if any(not isinstance(page, dict) for page in pages):
+        raise ValueError("pages file entries must be objects")
+    return pages

package/bundled-tools/runtime/service_variants.py

@@ -35,6 +35,16 @@ def variant_slug(kind: str, *, location: str = "", event: str = "", holiday: str
     return f"{kind}/{slug_part(value)}"
 
 
+def locale_segment(value: str) -> str:
+    """Return the stable lowercase URL segment for a BCP 47-like locale."""
+    return slug_part(value.replace("_", "-"))
+
+
+def variant_canonical_url(slug: str, locale: str, market: str) -> str:
+    """Build a collision-safe, market/language-aware service URL."""
+    return f"/services/{slug_part(market)}/{locale_segment(locale)}/{slug.strip('/')}/"
+
+
 def similarity(source: str, variant: str) -> float:
     left, right = set(re.findall(r"[a-z0-9]+", source.lower())), set(re.findall(r"[a-z0-9]+", variant.lower()))
     return 1.0 if not left and not right else len(left & right) / max(1, len(left | right))
@@ -62,6 +72,20 @@ class ServiceVariantStore:
             raise ValueError("service variant not found")
         return found
 
+    def _cluster(self, canonical_variant_id: str) -> list[dict]:
+        return [
+            item for item in self.data["variants"]
+            if item.get("id") == canonical_variant_id or item.get("canonicalVariantId") == canonical_variant_id
+        ]
+
+    def _refresh_hreflang(self, canonical_variant_id: str) -> None:
+        """Keep published locale links reciprocal and limited to published peers."""
+        cluster = self._cluster(canonical_variant_id)
+        published = [item for item in cluster if item.get("status") == "published"]
+        published_links = {item["locale"]: item["canonicalUrl"] for item in published}
+        for item in cluster:
+            item["hreflang"] = published_links if item in published else {item["locale"]: item["canonicalUrl"]}
+
     def create(self, *, service_id: str, variant_id: str, variant_type: str, locale: str, market: str,
                slug: str, title: str, facts: list[dict], source_revision: str, canonical_variant_id: str | None = None,
                cluster_links: list[str] | None = None, layout_family: str = "service-default", actor: str = "cli") -> dict:
@@ -73,15 +97,19 @@ class ServiceVariantStore:
             raise ValueError("variant requires meaningful keyed facts")
         if any(item["id"] == variant_id for item in self.data["variants"]):
             raise ValueError("variant ID already exists")
-        if any(item["slug"] == slug and item["locale"] == locale for item in self.data["variants"]):
-            raise ValueError("variant slug and locale collision")
         if canonical_variant_id and not any(item["id"] == canonical_variant_id for item in self.data["variants"]):
             raise ValueError("canonical variant does not exist")
+        canonical_url = variant_canonical_url(slug, locale, market)
+        if any(item.get("canonicalUrl") == canonical_url for item in self.data["variants"]):
+            raise ValueError("variant market, locale and slug route collision")
+        family = canonical_variant_id or variant_id
+        if any(item.get("canonicalVariantId") == family and item.get("locale") == locale for item in self.data["variants"]):
+            raise ValueError("variant locale collision in translation cluster")
         item = {"id": variant_id, "serviceId": service_id, "variantType": variant_type, "locale": locale,
                 "market": market, "slug": slug, "title": title, "facts": facts,
                 "clusterLinks": sorted(set(cluster_links or [])), "layoutFamily": layout_family,
-                "canonicalVariantId": canonical_variant_id or variant_id, "canonicalUrl": "/services/" + slug + "/",
-                "hreflang": {locale: "/services/" + slug + "/"}, "sourceRevision": source_revision,
+                "canonicalVariantId": family, "canonicalUrl": canonical_url,
+                "hreflang": {locale: canonical_url}, "sourceRevision": source_revision,
                 "provenance": {"operation": "create", "actor": actor, "sourceRevision": source_revision},
                 "status": "draft", "createdAt": now(), "updatedAt": now()}
         self.data["variants"].append(item); self._event("variant.created", variant_id, actor, "draft created"); self._save()
@@ -120,6 +148,7 @@ class ServiceVariantStore:
                 raise ValueError("canonical source must be published before a translated variant")
         old = item["status"]; item["status"] = target; item["updatedAt"] = now()
         item.setdefault("approval", []).append({"from": old, "to": target, "actor": actor, "reason": reason, "at": now()})
+        self._refresh_hreflang(item["canonicalVariantId"])
         self._event("variant." + target, variant_id, actor, reason); self._save(); return item
 
     def plan_slug_change(self, variant_id: str, new_slug: str, actor: str) -> dict:
@@ -128,17 +157,29 @@ class ServiceVariantStore:
             raise ValueError("published URL changes require owner approval")
         if not new_slug.startswith(item["variantType"] + "/") or not SLUG_WORD.fullmatch(new_slug.split("/", 1)[-1]):
             raise ValueError("new slug violates variant grammar")
-        if any(v["slug"] == new_slug and v["locale"] == item["locale"] for v in self.data["variants"] if v["id"] != variant_id):
-            raise ValueError("new slug collides with another variant")
-        redirect = {"from": item["canonicalUrl"], "to": "/services/" + new_slug + "/", "ownerApproval": actor, "status": "planned"}
+        new_url = variant_canonical_url(new_slug, item["locale"], item["market"])
+        if any(v.get("canonicalUrl") == new_url for v in self.data["variants"] if v["id"] != variant_id):
+            raise ValueError("new market, locale and slug route collides with another variant")
+        redirect = {"from": item["canonicalUrl"], "to": new_url, "ownerApproval": actor, "status": "planned"}
         self.data["redirects"].append(redirect); self._save(); return redirect
 
     def validate(self, variant_id: str, source_text: str | None = None, render_report: dict | None = None) -> dict:
         item = self._find(variant_id); errors = []
+        expected_url = variant_canonical_url(item["slug"], item["locale"], item["market"])
+        if item.get("canonicalUrl") != expected_url:
+            errors.append("canonical URL must include market, locale and variant slug")
         if not item["clusterLinks"] and item["variantType"] != "location": errors.append("cluster links required")
         if source_text is not None and similarity(source_text, item["title"] + " " + " ".join(str(f["value"]) for f in item["facts"])) < 0.1:
             errors.append("variant content has no meaningful similarity to source")
         if item["canonicalVariantId"] != item["id"] and item["canonicalVariantId"] not in {v["id"] for v in self.data["variants"]}: errors.append("canonical relation missing")
+        if item.get("status") == "published":
+            expected_hreflang = {
+                peer["locale"]: peer["canonicalUrl"]
+                for peer in self._cluster(item["canonicalVariantId"])
+                if peer.get("status") == "published"
+            }
+            if item.get("hreflang") != expected_hreflang:
+                errors.append("published hreflang links must be reciprocal published counterparts")
         if render_report is not None:
             if render_report.get("schemaVersion") != "maggie-service-variant-render.v1" or render_report.get("passed") is not True:
                 errors.append("render report is not passed")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@topy-ai/maggie",
-  "version": "0.7.16",
+  "version": "0.7.18",
   "description": "Install and manage Maggie Skills for AI coding agents",
   "license": "MIT",
   "type": "module",

package/references/universal-booking-adapter.md

@@ -25,8 +25,10 @@ when a title changes.
     "title": "Signature Scalp Ritual",
     "description": "Provider-supplied factual description.",
     "category": {"level1": "Head Spa", "level2": "Scalp Treatments"},
-    "variants": [{
+  "variants": [{
       "id": "service-123:60",
+      "idSource": "provider",
+      "variantSource": "native",
       "title": "60 minutes",
       "durationMinutes": 60,
       "price": {"amountMinor": 9500, "currency": "GBP", "display": "£95.00"}
@@ -147,3 +149,36 @@ Provider adapters may add `raw` evidence in a private local snapshot, but
 public page generation consumes only the canonical fields above. A sync must
 preserve removed records as `archived` with `removedAt` and must output a
 change report.
+
+## Provider variant capability matrix
+
+Before service pages are published, each provider declares its variant
+behavior in a project-owned JSON file. The declaration is validated against a
+sanitized fixture and emits `maggie-provider-variant-capabilities.v1`:
+
+```json
+{
+  "schemaVersion": "maggie-provider-capabilities.v1",
+  "providers": [{
+    "provider": "fresha",
+    "variantMode": "native",
+    "priceSemantics": "minor-unit-and-display",
+    "stableIdConfidence": "high"
+  }]
+}
+```
+
+`variantMode` is one of `native`, `derived-offers`, `single-fallback`, or
+`blocked`. `priceSemantics` records whether structured minor units and display
+prices are available. `stableIdConfidence` must be justified by provider or
+derived ID evidence. The audit records service/variant counts, observed source
+types, fixture name and hash, and validation errors without copying fixture
+rows or provider credentials. Run it with:
+
+```bash
+maggie service capability-audit \
+  --project . \
+  --catalogue .maggie/booking/services.json \
+  --capabilities-file .maggie/booking/provider-capabilities.json \
+  --fixture .maggie/booking/fixtures/provider.json
+```