Merge development: register La Bella Toscana; deploy wimpi bundle update.

Resolve duplicate labellatoscana manifest entry; add es/ placeholder and last-scan resync.

Author: raro42

CHANGELOG.md

@@ -10,6 +10,7 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Ver
 
 ### Added
 
+- **Marketing / La Bella Toscana:** Registered **satisfecho.de/labellatoscana/es/** — manifest entry for **`060_labellatoscana`** (slug **`labellatoscana`** matches SPA **`baseHref`**; artifact **`labellatoscana-satisfecho-deploy`**; **`deploySubpath`** **`es`**).
 - **Marketing / Pizza Luna:** Registered **satisfecho.de/pizzaluna/es/** — manifest entry for **`087_pizzalluna`** (slug **`pizzaluna`** matches SPA **`baseHref`**; artifact **`pizzaluna-satisfecho-deploy`**; **`deploySubpath`** **`es`**).
 - **Marketing / Rico Kebab:** Registered **satisfecho.de/rico-kebab/** — manifest entry for **`088_ricokebab`** (slug matches SPA **`baseHref`** `/rico-kebab/`; artifact **`rico-kebab-satisfecho-deploy`**).
 
@@ -23,6 +24,8 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Ver
 
 ### Changed
 
+- **Marketing / Wimpi:** Removed carta and booking CTAs from **satisfecho.de/wimpi/es/** per venue request after marketing build and amvara9 deploy (`083_wimpi`).
+- **Public menu API:** `GET /public/tenants/{id}/menu` groups sections by **subcategory** when set (e.g. Carta principal, Ensaladas); otherwise by the **localized** standard category label (Desserts → Postres for `lang=es`) — marketing sites and `/public-menu/:id` show restaurant-style section titles instead of raw English category keys.
 - **Marketing / Wimpi:** Updated Google reviews copy on **satisfecho.de/wimpi/es/** — **4,8 / 5 · 239 valoraciones** (was 4,7 / 102) to match the current Google listing after marketing build and amvara9 deploy (`083_wimpi` #2).
 - **Agent loop:** Per-step wall-clock limits on **`cursor-agent`** in **`agents2/pos-cursor-loop.sh`** (default **25** minutes; tester **32** minutes for deploy polling) so a hung step does not block the whole cycle — on timeout the orchestrator logs and continues; **`TESTING-`** / **`WIP-`** tasks are retried on the next pass. Disable with **`AGENT_CURSOR_TIMEOUT=0`**.
 - **Marketing / Gustazo:** Removed gallery image **`local-04`** from live **satisfecho.de/gustazo/** after **`gustazo-dist`** bundle sync (`040_gustazo` #1).

agents2/005-marketing-repos-reviewer/last-scan.json

@@ -20,18 +20,26 @@
       "last_artifact": "dist",
       "pushed_at": "2026-04-21T06:05:35Z"
     },
+    "satisfecho/060_labellatoscana": {
+      "last_artifact": "labellatoscana-satisfecho-deploy",
+      "pushed_at": "2026-06-05T11:47:20Z"
+    },
     "satisfecho/082_la_moca": {
       "last_artifact": "la-moca-dist",
       "pushed_at": "2026-05-29T09:38:56Z"
     },
     "satisfecho/083_wimpi": {
       "last_artifact": "wimpi-satisfecho-deploy",
-      "pushed_at": "2026-06-02T07:20:19Z"
+      "pushed_at": "2026-06-05T12:46:54Z"
     },
     "satisfecho/085_Bosskebabypizzeria": {
       "last_artifact": "boss-kebab-satisfecho-deploy",
       "pushed_at": "2026-06-02T07:02:46Z"
     },
+    "satisfecho/086_pitahouse": {
+      "last_artifact": "pita-house-satisfecho-deploy",
+      "pushed_at": "2026-06-05T06:54:41Z"
+    },
     "satisfecho/087_pizzalluna": {
       "last_artifact": "pizzaluna-satisfecho-deploy",
       "pushed_at": "2026-06-04T14:08:11Z"

back/app/category_codes.py

@@ -187,6 +187,111 @@ def get_category_alias_to_canonical() -> dict[str, str]:
     return merged
 
 
+_CATEGORY_DISPLAY_BY_LOCALE: dict[str, dict[str, str]] | None = None
+
+
+def _normalize_public_menu_lang(lang: str) -> str:
+    """Map API lang to a front/public/i18n filename stem."""
+    raw = (lang or "en").strip().replace("_", "-")
+    lower = raw.lower()
+    if lower.startswith("zh"):
+        return "zh-CN"
+    if lower.startswith("ca"):
+        return "ca"
+    return lower.split("-")[0] or "en"
+
+
+_BUILTIN_CATEGORY_DISPLAY: dict[str, dict[str, str]] = {
+    "en": {v: v for v in CATEGORY_CODES.values()},
+    "es": {
+        "Starters": "Entrantes",
+        "Main Course": "Plato principal",
+        "Desserts": "Postres",
+        "Beverages": "Bebidas",
+        "Sides": "Guarniciones",
+    },
+    "ca": {
+        "Starters": "Entrants",
+        "Main Course": "Plat principal",
+        "Desserts": "Postres",
+        "Beverages": "Begudes",
+        "Sides": "Amanida / Acompanyaments",
+    },
+    "de": {
+        "Starters": "Vorspeisen",
+        "Main Course": "Hauptgericht",
+        "Desserts": "Desserts",
+        "Beverages": "Getränke",
+        "Sides": "Beilagen",
+    },
+    "fr": {
+        "Starters": "Entrées",
+        "Main Course": "Plat principal",
+        "Desserts": "Desserts",
+        "Beverages": "Boissons",
+        "Sides": "Accompagnements",
+    },
+}
+
+
+def _load_category_display_by_locale() -> dict[str, dict[str, str]]:
+    """Canonical English category -> localized label per locale."""
+    out: dict[str, dict[str, str]] = {
+        locale: dict(labels) for locale, labels in _BUILTIN_CATEGORY_DISPLAY.items()
+    }
+    directory = _repo_i18n_dir()
+    if directory:
+        for path in sorted(directory.glob("*.json")):
+            locale = path.stem
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError) as exc:
+                logger.warning("Skipping i18n file %s: %s", path.name, exc)
+                continue
+            products = data.get("PRODUCTS")
+            if not isinstance(products, dict):
+                continue
+            labels: dict[str, str] = dict(out.get(locale, {}))
+            for i18n_key, code_key in _I18N_CATEGORY_KEYS:
+                label = products.get(i18n_key)
+                if not isinstance(label, str):
+                    continue
+                stripped = label.strip()
+                if not stripped:
+                    continue
+                labels[CATEGORY_CODES[code_key]] = stripped
+            if labels:
+                out[locale] = labels
+    return out
+
+
+def get_category_display_by_locale() -> dict[str, dict[str, str]]:
+    global _CATEGORY_DISPLAY_BY_LOCALE
+    if _CATEGORY_DISPLAY_BY_LOCALE is None:
+        _CATEGORY_DISPLAY_BY_LOCALE = _load_category_display_by_locale()
+    return _CATEGORY_DISPLAY_BY_LOCALE
+
+
+def get_public_category_display_label(category: str | None, lang: str = "en") -> str:
+    """
+    Localized menu section title for public APIs when grouping by category (no subcategory).
+    Unknown categories are returned stripped as-is.
+    """
+    if category is None:
+        return "Other"
+    stripped = category.strip()
+    if not stripped:
+        return "Other"
+    canonical = normalize_product_category(stripped) or stripped
+    locale = _normalize_public_menu_lang(lang)
+    labels = get_category_display_by_locale()
+    if locale in labels and canonical in labels[locale]:
+        return labels[locale][canonical]
+    if canonical in CATEGORY_CODES.values():
+        return labels.get("en", {}).get(canonical, canonical)
+    return stripped
+
+
 def normalize_product_category(category: str | None) -> str | None:
     """
     Return canonical English for known standard categories; otherwise strip and return as-is.

back/app/public_tenant_menu.py

@@ -9,6 +9,7 @@
 from sqlmodel import Session, select
 
 from . import models
+from .category_codes import get_public_category_display_label
 from .tenant_currency import normalize_tenant_currency_fields
 from .translation_service import TranslationService
 
@@ -259,20 +260,83 @@ def _load_flat_products(
     return products
 
 
-def group_products_into_categories(products: list[dict]) -> list[dict]:
-    """Group flat product dicts into categories sorted by name."""
-    by_category: dict[str, list[dict]] = {}
+def _uncategorized_section_label(lang: str) -> str:
+    """Localized title for products without category/subcategory."""
+    labels = {
+        "en": "Other",
+        "es": "Otros",
+        "ca": "Altres",
+        "de": "Sonstiges",
+        "fr": "Autres",
+    }
+    locale = (lang or "en").strip().lower().split("-")[0]
+    return labels.get(locale, labels["en"])
+
+
+def _public_menu_section_title(product: dict, lang: str) -> str:
+    """Display section: subcategory when set, else localized standard category label."""
+    sub = (product.get("subcategory") or "").strip()
+    if sub:
+        return sub
+    raw_category = (product.get("category") or "").strip()
+    if not raw_category:
+        return _uncategorized_section_label(lang)
+    return get_public_category_display_label(raw_category, lang)
+
+
+def _section_sort_key(display_name: str) -> tuple[int, str]:
+    """Prefer common restaurant section order; unknown sections sort alphabetically."""
+    hints: dict[str, int] = {
+        "carta principal": 10,
+        "especialidades": 20,
+        "entrantes": 30,
+        "ensaladas": 40,
+        "starters": 50,
+        "entrants": 50,
+        "main course": 60,
+        "plato principal": 60,
+        "plat principal": 60,
+        "beverages": 70,
+        "bebidas": 70,
+        "begudes": 70,
+        "desserts": 80,
+        "postres": 80,
+        "sides": 90,
+        "guarniciones": 90,
+        "other": 999,
+        "otros": 999,
+    }
+    rank = hints.get(display_name.strip().lower(), 500)
+    return (rank, display_name.lower())
+
+
+def group_products_into_categories(products: list[dict], lang: str = "en") -> list[dict]:
+    """
+    Group flat product dicts into menu sections for public/marketing UIs.
+
+    Uses subcategory as the section when present; otherwise the localized
+    standard category label (e.g. Desserts -> Postres for lang=es).
+    """
+    by_section: dict[str, list[dict]] = {}
+    section_titles: dict[str, str] = {}
+
     for product in products:
-        category_name = (product.get("category") or "").strip() or _UNCategorized_CATEGORY
-        by_category.setdefault(category_name, []).append(product)
+        title = _public_menu_section_title(product, lang)
+        section_id = _category_slug(title)
+        section_titles.setdefault(section_id, title)
+        by_section.setdefault(section_id, []).append(product)
 
     categories = []
-    for name in sorted(by_category.keys(), key=lambda n: n.lower()):
-        items = sorted(by_category[name], key=lambda p: (p.get("name") or "").lower())
+    for section_id in sorted(
+        by_section.keys(),
+        key=lambda sid: _section_sort_key(section_titles[sid]),
+    ):
+        title = section_titles[section_id]
+        items = sorted(by_section[section_id], key=lambda p: (p.get("name") or "").lower())
         categories.append(
             {
-                "id": _category_slug(name),
-                "name": name,
+                "id": section_id,
+                "name": title,
                 "products": items,
             }
         )
@@ -301,7 +365,7 @@ def build_public_tenant_menu(
             tenant_name = translated
 
     products = _load_flat_products(session, tenant_id, lang, currency_code)
-    categories = group_products_into_categories(products)
+    categories = group_products_into_categories(products, lang)
 
     return {
         "tenant_id": tenant_id,

back/tests/test_public_tenant_menu.py

@@ -7,7 +7,11 @@
 from pg_client_mixin import PgClientTestCase
 
 from app import models
-from app.public_tenant_menu import assert_no_sensitive_product_fields, format_public_price
+from app.public_tenant_menu import (
+    assert_no_sensitive_product_fields,
+    format_public_price,
+    group_products_into_categories,
+)
 
 
 class TestPublicTenantMenu(PgClientTestCase):
@@ -65,8 +69,10 @@ def test_happy_path_grouped_by_category(self):
 
         self.assertEqual(len(data["categories"]), 2)
         cat_ids = {c["id"] for c in data["categories"]}
-        self.assertIn("entrantes", cat_ids)
+        self.assertIn("starters", cat_ids)
         self.assertIn("principales", cat_ids)
+        by_id = {c["id"]: c for c in data["categories"]}
+        self.assertEqual(by_id["starters"]["name"], "Starters")
 
         all_products = [p for c in data["categories"] for p in c["products"]]
         self.assertEqual(len(all_products), 2)
@@ -78,6 +84,7 @@ def test_happy_path_grouped_by_category(self):
         self.assertEqual(olivas["price_formatted"], "2.50")
         self.assertEqual(olivas["description"], "Aceitunas")
         self.assertEqual(olivas["category"], "Entrantes")
+        self.assertEqual(data["categories"][0]["name"], "Starters")
         self.assertIsNone(olivas["subcategory"])
         self.assertTrue(olivas["available"])
 
@@ -106,6 +113,51 @@ def test_lang_query_es_formats_price_with_comma(self):
         self.assertEqual(data["lang"], "es")
         product = data["categories"][0]["products"][0]
         self.assertEqual(product["price_formatted"], "3,50")
+        self.assertEqual(data["categories"][0]["name"], "Entrantes")
+
+    def test_group_by_subcategory_when_present(self):
+        self.session.add(
+            models.Product(
+                tenant_id=self.tenant.id,
+                name="Margarita",
+                price_cents=900,
+                category="Main Course",
+                subcategory="Carta principal",
+            )
+        )
+        self.session.add(
+            models.Product(
+                tenant_id=self.tenant.id,
+                name="Calzone",
+                price_cents=1390,
+                category="Main Course",
+                subcategory="Especialidades",
+            )
+        )
+        self.session.add(
+            models.Product(
+                tenant_id=self.tenant.id,
+                name="Panna Cotta",
+                price_cents=595,
+                category="Desserts",
+            )
+        )
+        self.session.commit()
+
+        response = self.client.get(
+            f"/public/tenants/{self.tenant.id}/menu",
+            params={"lang": "es"},
+        )
+        self.assertEqual(response.status_code, 200, response.text)
+        data = response.json()
+        names = [c["name"] for c in data["categories"]]
+        self.assertEqual(
+            names,
+            ["Carta principal", "Especialidades", "Postres"],
+        )
+        panna = data["categories"][2]["products"][0]
+        self.assertEqual(panna["name"], "Panna Cotta")
+        self.assertIsNone(panna["subcategory"])
 
     def test_lang_from_accept_language_header(self):
         self.session.add(
@@ -228,6 +280,24 @@ def test_product_image_url_for_tenant_upload(self):
         )
 
 
+class TestGroupProductsIntoCategories(unittest.TestCase):
+    def test_unit_grouping_prefers_subcategory(self):
+        products = [
+            {
+                "name": "Sangría",
+                "category": "Beverages",
+                "subcategory": None,
+            },
+            {
+                "name": "Margarita",
+                "category": "Main Course",
+                "subcategory": "Carta principal",
+            },
+        ]
+        sections = group_products_into_categories(products, "es")
+        self.assertEqual([s["name"] for s in sections], ["Carta principal", "Bebidas"])
+
+
 class TestFormatPublicPrice(unittest.TestCase):
     def test_en_uses_dot(self):
         self.assertEqual(format_public_price(250, "en"), "2.50")